unreal: deeper ready queue keeps the 8 tile workers fed (L95); SW near set 2.37 -> 1.31 s

Unreal per-tile timeline: per-tile Core work is not slower than headless (FI 11.2 vs 16.2 ms
per shared key); the gap was tick-paced admission with a small queue (FI ~5.2 of 8 slots busy).
voxel.StreamingReadyQueueDepth default 16 -> 64 (effective 32 with 8 slots, total cap 40);
result backlog cap 256 unchanged. First admission -> LOD0-2 settled: FI 2.72 -> 2.10 s,
SW 2.37 -> 1.31 s (3 of 4 runs; one 6.9 s outlier re-admitting 3 LOD0 keys, cause open).
apply_ms max 4.2 ms (14 ms budget). Frame-interval max 118-145 ms both before and after (open).
World unchanged. Fast tier PASS; Linux UE host builds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -20,6 +20,7 @@
 #include <limits>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <tuple>
@@ -100,6 +101,7 @@ namespace
         std::filesystem::path MeshExportPath;
         std::filesystem::path WorldAssemblyManifestOutputPath;
         std::filesystem::path ResolvedLayoutOutputPath;
+        std::filesystem::path CoreSnapshotInputPath;
         bool ResolvedLayoutOnly=false;
         bool AuditResolvedLayoutBoundaries=false;
         bool AuditResolvedLayoutPassages=false;
@@ -1426,6 +1428,7 @@ namespace
                     "  --mesh-export=FILE (write the exact generated tile meshes for offline rendering)\n"
                     "  --capture-skip-walkability (mesh export only; defer the owner-wide passage gate)\n"
                     "  --world-assembler-manifest-output=FILE (write the canonical Core recipe and plan)\n"
+                    "  --core-snapshot=FILE (benchmark the exact resolved Core snapshot from Unreal)\n"
                     "  --profile-column-overlap --far-horizon-lod8-step=N --force-generate\n"
                     "  --seed=N --recipe=surface-world|floating-islands|caves|lattice\n"
                     "  --lattice-strate=N (opt one Maze or VerticalShafts strate into Core.Lattice)\n"
@@ -1478,6 +1481,9 @@ namespace
             else if(arg.starts_with("--world-assembler-manifest-output="))
                 options.WorldAssemblyManifestOutputPath=std::filesystem::path(std::string(
                     arg.substr(std::string_view("--world-assembler-manifest-output=").size())));
+            else if(arg.starts_with("--core-snapshot="))
+                options.CoreSnapshotInputPath=std::filesystem::path(std::string(
+                    arg.substr(std::string_view("--core-snapshot=").size())));
             else if(arg=="--resolved-layout-only")options.ResolvedLayoutOnly=true;
             else if(arg=="--audit-resolved-layout-boundaries")options.AuditResolvedLayoutBoundaries=true;
             else if(arg=="--audit-resolved-layout-passages")options.AuditResolvedLayoutPassages=true;
@@ -2249,10 +2255,51 @@ int main(int argc,char** argv)
     std::printf("[WorldAssemblerPlanTiming] total_ms=%.3f status=PASS\n",
         std::chrono::duration<double,std::milli>(Clock::now()-planStart).count());
 
-    auto snapshot=VoxelForgeCore::MakeStandaloneSnapshotFromParsedJson(ownerJsonRoot,seed,
-        options.ClipRadius,options.MaxClipLevel,false,false,error,useExportedCorePlan);
-    if(!snapshot)
-    {std::fprintf(stderr,"Shape interval build failed: %s\n",error.c_str());return 2;}
+    VoxelForgeCore::ResolvedWorldSnapshot snapshot;
+    if (options.CoreSnapshotInputPath.empty())
+    {
+        snapshot = VoxelForgeCore::MakeStandaloneSnapshotFromParsedJson(ownerJsonRoot, seed,
+            options.ClipRadius, options.MaxClipLevel, false, false, error, useExportedCorePlan);
+        if (!snapshot)
+        {
+            std::fprintf(stderr, "Shape interval build failed: %s\n", error.c_str());
+            return 2;
+        }
+    }
+    else
+    {
+        std::ifstream snapshotFile(options.CoreSnapshotInputPath, std::ios::binary);
+        if (!snapshotFile)
+        {
+            std::fprintf(stderr, "Core snapshot load failed: cannot open %s\n",
+                options.CoreSnapshotInputPath.string().c_str());
+            return 2;
+        }
+        const std::string snapshotJson{std::istreambuf_iterator<char>(snapshotFile),
+            std::istreambuf_iterator<char>{}};
+        if (!snapshotFile && !snapshotFile.eof())
+        {
+            std::fprintf(stderr, "Core snapshot load failed: read error for %s\n",
+                options.CoreSnapshotInputPath.string().c_str());
+            return 2;
+        }
+        std::optional<VoxelForgeCore::ResolvedWorldSnapshot> ImportedSnapshot =
+            VoxelForgeCore::ResolvedWorldSnapshot::FromJson(snapshotJson, error);
+        if (!ImportedSnapshot || ImportedSnapshot->worldAssembly() == nullptr
+            || ImportedSnapshot->resolvedLayout() == nullptr)
+        {
+            std::fprintf(stderr, "Core snapshot load failed: %s\n",
+                error.empty() ? "world assembly or resolved layout is missing" : error.c_str());
+            return 2;
+        }
+        snapshot = std::move(*ImportedSnapshot);
+        worldAssembly = *snapshot.worldAssembly();
+        resolvedLayout = *snapshot.resolvedLayout();
+        std::printf("[CoreSnapshotInput] path=%s world_assembly_hash=%016llx layout_identity=%s status=PASS\n",
+            options.CoreSnapshotInputPath.string().c_str(),
+            static_cast<unsigned long long>(worldAssembly.contentHash),
+            resolvedLayout.stableIdentity.c_str());
+    }
 
     FStandaloneCoreScheduler scheduler(static_cast<std::size_t>(options.ShapeHelperLimit));
     const FVector cameraStepVoxels=options.HasCameraStep