diff --git a/PERF-SAMPLED.md b/PERF-SAMPLED.md
index 3c52d11..77a3ae8 100644
--- a/PERF-SAMPLED.md
+++ b/PERF-SAMPLED.md
@@ -1100,3 +1100,341 @@ DDC graph; retried successfully), `TakeoverFinalMovingSamplerOnHost_20260913` (c
 `...Host2` retry succeeded), `Final3MovingSamplerOn_20260913` (fatal shutdown), and
 `IsFiniteExact_20260913` (no writable DDC graph). No CrashReportClient crash occurred in the
 worm-round launches above.
+
+## Final worms round — real off switch, cheap field, and offline stacks (2026-09-14)
+
+This addendum covers the implementation and the final hardening runs after the block-skip round
+above. Existing historical measurements are retained. Scope stayed inside
+`E:\Projet Unreal\VoxelM\Plugins\VoxelForge`; no `.uasset` content was edited and nothing was
+committed, pushed, or stashed.
+
+### Final build
+
+The prescribed UE 5.7 UBT command in this report was used throughout. Three intermediate staged
+builds failed before the final game runs: the first had stale-source compile errors (`Tunnel` not
+found, missing `FGuid`, and the offline module record missing `PdbAge`); the second exposed a
+linker error from editor access to unexported tile-context TLS; the third cleanup build exposed a
+missing anonymous-namespace close after removing the in-process resolver. Each failure was fixed;
+none left an Unreal process running.
+
+The final hardening build succeeded in
+`E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\PerfSampledBuild_FinalHardening.log`
+(`Result: Succeeded`, 9.11 s). The subsequent benchmark-only force-off wiring rebuild also
+succeeded in
+`E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\PerfSampledBuild_FinalForceOff.log`
+(`Result: Succeeded`, 81.89 s). The final off/on game runs below use that latter staged build.
+Its loaded staged DLLs were verified as:
+
+- runtime: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Binaries\Win64\UnrealEditor-VoxelForge.dll`, SHA-256 `5A79B6FBDE2944D66C762EDB2D099E634B2BE84C08808D48C8CB7A3897E233FD`;
+- editor: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Binaries\Win64\UnrealEditor-VoxelForgeEditor.dll`, SHA-256 `AB20BE8A2CBAF5FA4D9D2545AA7CC9DC058085741EA18B9FEAB26669A92F9F77`.
+
+After the performance runs, the cache-key-only hardening described below was rebuilt in
+`E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\PerfSampledBuild_FinalFingerprint.log`
+(`Result: Succeeded`, 8.87 s). Its runtime hash is
+`19190CB64AB894097A49C37B8DC5D43B67018A1BD624253473D4F710FBECB532` (the editor hash is
+unchanged). `WormFinalFingerprintSmoke_20260914` then loaded that exact staged runtime, used the
+plugin DDC, and exited cleanly; the acceptance tables below remain measurements from the force-off
+build above, while this smoke verifies the final source tree after the key hardening.
+
+### Part 0 — module map and offline symbolizer
+
+`FVoxelStackSampler::StopAndWrite` now joins the sampler first, writes the bounded raw CSV, then
+enumerates the current process with PSAPI (`EnumProcessModules`, `GetModuleInformation`, and
+`GetModuleFileNameExW`). The sibling
+`VoxelStackModules_<label>_<pid>.tsv` records module path, load base, image size, file size, last
+write FILETIME, and the CodeView PDB GUID/age/path when the loaded image exposes an RSDS record.
+The image identity read is a bounded PE-header read; the measured process does not initialize or
+call DbgHelp. The raw summary explicitly says `symbolization: deferred` and
+`dbghelp_in_measured_process: no`.
+
+`-run=VoxelForgeExplore -symbolizestacks=<csv>` is now an editor-only post-exit commandlet. It
+loads the sibling module map, checks recorded file size and timestamp, maps each PC to module and
+RVA, loads only the modules needed by the CSV into DbgHelp, resolves functions and source lines,
+and queries inline frames. It writes a resolved-PC TSV and the former all-LOD, LOD0, and LOD1+
+exclusive-function, inclusive-function, and source-line tables. DbgHelp is linked by
+`VoxelForgeEditor` only.
+
+The fresh final cheap moving sampler run was
+`WormFinalForceOffBuildSamplerOnMoving_20260914`. It completed cleanly with 1,521 LOD0 samples,
+request-to-ready p50/p95 `0.062287 / 0.135633 s`, generation p50/p95 `0.054268 / 0.106542 s`,
+and `113.578722` worker seconds. Its artifacts are:
+
+- raw CSV: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\VoxelStackSamples_game_26772.csv`;
+- module map: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\VoxelStackModules_game_26772.tsv`;
+- raw summary: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\VoxelStackSummary_game_26772.txt`;
+- resolved PCs: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\VoxelStackResolved_game_26772.tsv`;
+- offline summary: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\VoxelStackSummaryOffline_game_26772.txt`.
+
+The offline pass completed with 733 recorded modules, 10 needed and loaded, zero identity
+mismatches, 109,593 samples (70,968 LOD0 and 38,625 LOD1+), 1,879,380 frame slots, 993,473
+resolved frames, 6,714 inline symbols, 7,795 mapped unique PCs, and zero unmapped PCs. The
+unknown-frame count is 885,907 and is retained as an explicit table row. The exact moving proof
+(`WormFinalMovingSamplerExactProof_20260914` plus its offline pass) independently completed with
+zero identity mismatches as well. The post-exit retry was
+`WormFinalForceOffBuildSamplerOfflineRetry_20260914`; its first direct attempt is recorded as a
+failed launch below because it omitted the writable local DDC arguments.
+
+The LOD0 exclusive identities in the fresh offline table match the old in-process exact
+configuration: `GetDensityWithParams`, `GetDensityAt`, `Sqrt`, `SmoothMin`,
+`FChunkSDFSpatialIndex::GetRange`, `VF_ProjectNativePassageFloorUncached`,
+`VF_ProjectTunnelSegmentXY`, `VF_EvaluateSweptTunnelChain`, `EvaluateTunnelCoreWorld`, and
+`ProjectWalkableTunnelFloor`. Counts differ because these are separate moving reservoirs; the
+function/source identities and table shape are the comparison.
+
+The planted-cost proof used `WormSamplerPlantGenerator_20260914` and
+`WormSamplerPlantGeneratorOffline_20260914`. The post-exit map for `game_22152` contained five
+resolved `VoxelWormField::RunSampleStacksPlant()` rows, all module identities matched, and all
+planted PCs mapped. The two earlier plant attempts (`WormSamplerPlantOffline_20260914` and
+`WormSamplerPlantLongOffline_20260914`) completed but were inconclusive because the hook was
+placed where it was optimized away from the captured stack. The plant was then removed; a source
+and harness search has no `RunSampleStacksPlant` or `SampleStacksPlant` match.
+
+The final disabled sampler proof used `WormFinalOffSampler_20260914` followed by
+`WormFinalOffSymbolize_20260914`. It produced 1,992 untagged commandlet samples (the commandlet
+has no generation-task LOD tag) and zero resolved rows containing `Worm`, which is the required
+zero-worm-frame result for the disabled configuration.
+
+### Part 1 — asset-owned off switch
+
+`UVoxelStrateDefinition` now has `bEnableWorms`, defaulting to `true`, so existing assets retain
+their current behavior. It is deliberately not a member of `FStrateGenerationParams`; the
+`VF_STRATE_PARAM_FIELDS` list and its static assertions remain at 83 fields plus 8 bytes of
+padding. The manager resolves the asset switch after composer candidates, season vectors, and
+boundary blending, and the generation-parameter fingerprint includes the switch. Composer
+runtime overrides are also clamped before publication, so a roll cannot re-enable a disabled
+asset.
+
+`voxel.WormsForceOff=1` is present only as a development measurement override for the game
+harness: `0` uses the asset-owned value and `1` forces all resolved worm strengths to zero. It is
+resolved once per process, included in the generation fingerprint, and explicitly documented as
+world-changing; it is not the per-strate switch and must never vary between multiplayer peers or
+world regenerations.
+
+With the resolved strength at zero, the fused evaluator does not enter the worm block or its
+timer; the op-stack builder omits the worm source, an already-materialized source returns exact
+identity and zero carve bounds, and the interval/classifier paths do no worm evaluation. The
+same gate is applied to the recipe materializer and the composer override path.
+
+The final post-hardening geometry proof is exact:
+
+| configuration | geometry hash | triangles | player-fit | walk-reachable | connectivity |
+|---|---:|---:|---:|---:|---|
+| `WormPostHardeningOff_20260914` (`-wormsenabled=0`) | `70D310A4` | 74,672 | 20,856 | 10,917 | Connected |
+| `WormPostHardeningZeroed_20260914` (`-wormstrength=0`) | `70D310A4` | 74,672 | 20,856 | 10,917 | Connected |
+
+Both runs also reported `canonical_repeat_equal=true`. The disabled asset path therefore matches
+the hand-zeroed control byte-for-byte at the exported geometry hash, while exceeding the required
+20,830 / 10,909 capability gate.
+
+### Part 2 — measured cheap field
+
+The selected field is `voxel.WormNoiseMode=1`: a deterministic scalar value-noise evaluation
+using the same worm coordinate mapping, threshold, N1 short-circuit, N2 offset, and strength
+contract. The code default is mode 1. Mode 0 remains the legacy gradient-Perlin exact control.
+`voxel.WormNoiseMode` and `voxel.WormLatticeStep` are documented development-only,
+world-changing experiments; they are not the multiplayer off switch and must be identical on
+all peers and on every regeneration of a world.
+
+The coarser lattice was measured rather than assumed. The first lattice implementation was much
+slower because of cache churn; after the fixed tile-window cache, it returned to roughly the
+exact cost but did not improve it. Representative static worker seconds were exact 33.10,
+lattice-2 initial 160.86, lattice-2 cache-fixed 33.78, lattice-4 cache-fixed 33.25, and exact
+block-skip 33.10. The lattice path is retained as a bounded experiment, but is not the selected
+production mode. The exact block skip is also retained as a fail-closed exact-mode diagnostic;
+it is not used as a correctness or performance claim for value noise because its Perlin proof
+does not cover the changed field.
+
+The capability and geometry candidates were:
+
+| candidate | mode | geometry hash | triangles | player-fit / reach | result |
+|---|---|---:|---:|---:|---|
+| `WormExactCurrentExplore_20260914` | exact, lattice 0 | `311CA42C` | 75,482 | 20,830 / 10,909 | accepted control |
+| `WormLedgerLattice2_20260914` | exact, lattice 2 | `5C9E0858` | 74,932 | 20,856 / 10,917 | capability pass; no speed gain |
+| `WormLedgerLattice4_20260914` | exact, lattice 4 | `E3EC3FAF` | 74,708 | 20,857 / 10,917 | capability pass; no speed gain |
+| `WormCheapValue_20260914` | value, lattice 0 | — | — | 20,826 / 10,917 | rejected: fit short by 4 |
+| `WormCheapValueLattice2Explore_20260914` | value, lattice 2 | `C47567A2` | 75,132 | 20,857 / 10,917 | pass; no speed gain |
+| `WormCheapFastHashExplore_20260914` | value, lattice 0 | `6204C7E6` | 75,956 | 20,851 / 10,917 | selected |
+
+The selected mode changes the field, but the measured full-game gain is small rather than a
+claim of a dramatic speedup. In two interleaved static pairs, exact averaged 0.087128 / 0.148415
+s request-to-ready p50/p95, 0.063042 / 0.105080 s generation p50/p95, and 33.213871 worker s;
+cheap averaged 0.087761 / 0.145897 s, 0.062863 / 0.106258 s, and 33.083774 worker s. In two
+interleaved moving pairs at 800 cm/s, exact averaged 0.060116 / 0.131752 s request-to-ready,
+0.050910 / 0.104262 s generation, and 109.165600 worker s; cheap averaged 0.061533 /
+0.133272 s, 0.052125 / 0.105495 s, and 111.492032 worker s. Thus cheap is a small static worker
+improvement and within noise there, but approximately 2.1% worse in moving worker seconds. That
+is the measured tradeoff for the field change, not an overclaim.
+
+The explicit game-path switch-off/on measurement requested for Part 2 used the force-off override,
+with value-noise mode and no sampler. Static on averaged 0.085736 / 0.143135 s request-to-ready
+p50/p95, 0.062793 / 0.104333 s generation p50/p95, and 33.022549 worker s. Static off averaged
+0.084559 / 0.136829 s, 0.061727 / 0.099843 s, and 32.218070 worker s. Moving on averaged
+0.059974 / 0.132163 s request-to-ready, 0.051983 / 0.102972 s generation, and 109.244366
+worker s; moving off averaged 0.058397 / 0.126581 s, 0.050210 / 0.098518 s, and 105.648779
+worker s. These are two interleaved A/B runs per side, 343 static and 1,521 moving LOD0 samples
+per run, and all four had zero obsolete-tile aborts. Enabled worms therefore cost about 2.5%
+static and 3.4% moving worker time in this harness, while the selected cheap field's exact-versus-
+cheap comparison above measures the cost of changing the enabled field itself.
+
+The final deterministic tile ledger used 64 tiles in `z_then_y_then_x` order. Exact A/B and cheap
+A/B each had zero per-tile triangle-count/hash differences. Exact versus selected cheap changed
+29/64 tile hashes/counts (45.3125%); the changed tiles contained 69,625/75,482 exact triangles
+(92.2405%) and 70,099/75,956 cheap triangles (92.2890%), with a signed total of +474 triangles
+and an absolute per-tile triangle-count delta of 1,822. The triangle percentages are explicitly
+changed-tile coverage, not an assertion that individual triangles were matched across changed
+topologies.
+
+The four final deterministic/acceptance exports were:
+
+| run pair | per-tile differences | hash / triangles | player-fit / reach | connectivity |
+|---|---:|---|---:|---|
+| `WormFinalExactDetA_20260914` / `WormFinalExactDetB_20260914` | 0 / 64 | `311CA42C` / 75,482 | 20,830 / 10,909 | Connected |
+| `WormFinalCheapDetA_20260914` / `WormFinalCheapDetB_20260914` | 0 / 64 | `6204C7E6` / 75,956 | 20,851 / 10,917 | Connected |
+
+The final fixed-camera LOD0 renders are 512×288 at
+`-89.4815216,-104.9037323,-163.272038`:
+
+- exact before: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\WormPostHardeningRenderBefore_20260914Out\render_02.png`;
+- cheap after: `E:\Projet Unreal\VoxelM\Plugins\VoxelForge\Saved\BuildHost\HostProject\Plugins\VoxelForge\Saved\WormPostHardeningRenderAfter_20260914Out\render_02.png`.
+
+They show the same worm-rich passage with only small local wall/relief changes, consistent with
+the tile ledger. The preliminary final static pair
+`WormFinalPerfStaticOffA_20260914` / `WormFinalPerfStaticOnA_20260914` also completed, but both
+were accidentally launched with mode 1 and are excluded from the exact-versus-cheap averages.
+
+### Fresh moving sampler LOD0 top 20
+
+The final post-hardening moving cheap run had 1,521 LOD0 samples, no obsolete tile aborts, and
+the following offline-resolved exclusive leaf table. Percentages use the 71,427 LOD0 samples in
+the offline reservoir:
+
+| # | samples | percent | function |
+|---:|---:|---:|---|
+| 1 | 13,250 | 18.6704 | `GetDensityWithParams` |
+| 2 | 3,632 | 5.1178 | `GetDensityAt` |
+| 3 | 3,351 | 4.7218 | unknown |
+| 4 | 2,750 | 3.8750 | `Sqrt` |
+| 5 | 2,266 | 3.1930 | `SmoothMin` |
+| 6 | 2,066 | 2.9112 | `FChunkSDFSpatialIndex::GetRange` |
+| 7 | 1,708 | 2.4067 | `VF_ProjectNativePassageFloorUncached` |
+| 8 | 1,678 | 2.3644 | `VF_ProjectTunnelSegmentXY` |
+| 9 | 1,540 | 2.1700 | `VF_EvaluateSweptTunnelChain` |
+| 10 | 1,360 | 1.9164 | `EvaluateTunnelCoreWorld` lambda |
+| 11 | 1,267 | 1.7853 | `ProjectWalkableTunnelFloor` |
+| 12 | 1,120 | 1.5782 | `EvaluateSDFCached` lambda |
+| 13 | 1,116 | 1.5725 | swept-chain lambda |
+| 14 | 1,035 | 1.4584 | `IsFiniteFast` |
+| 15 | 875 | 1.2330 | `IsFinite` |
+| 16 | 874 | 1.2315 | `GenerateMesh` |
+| 17 | 842 | 1.1865 | `EvaluateModifierSDF` |
+| 18 | 832 | 1.1724 | `DistanceSquaredToAabb` |
+| 19 | 819 | 1.1540 | `FScopedTimer::End` |
+| 20 | 789 | 1.1118 | `UsesOperatorStackForChunk` |
+
+### Complete current-round launch ledger
+
+The existing block-skip ledger above remains the record for the earlier `WormSkip*` launches.
+This table adds the harness validation and every launch made for this off-switch/cheap-field
+round, including invalidated, inconclusive, failed, and retried launches. A `PASS` here means the
+process exited cleanly and produced its stated artifact; a candidate can still be rejected by a
+capability or comparison gate.
+
+| launch | outcome |
+|---|---|
+| `HarnessFixBuild_20260914` | PASS; harness/build validation completed. |
+| `HarnessFixSamplerSmoke_20260914` | PASS; sampler-on static smoke, clean exit. |
+| `HarnessFixSamplerSmokeRetry_20260914` | PASS; sampler-on static retry, clean exit. |
+| `HarnessFixSamplerSmokeFinal_20260914` | PASS; sampler-on static final smoke, clean exit. |
+| `HarnessFix01SamplerOnStatic.log` | PASS; sampler-on static. |
+| `HarnessFix02SamplerOnMoving.log` | PASS; sampler-on moving, 64 m movement. |
+| `HarnessFix03SamplerOnStatic.log` | PASS; sampler-on static. |
+| `HarnessFix04SamplerOnMoving.log` | PASS; sampler-on moving, 64 m movement. |
+| `HarnessFix05SamplerOnStatic.log` | PASS; sampler-on static. |
+| `HarnessFix06SamplerOffMoving.log` | PASS; sampler-off moving; one obsolete-tile abort was recorded by the stress session. |
+| `HarnessFix07SamplerOffStatic.log` | PASS; sampler-off static. |
+| `HarnessFix08SamplerOnMoving.log` | PASS; sampler-on moving. |
+| `HarnessFix09SamplerOffMoving.log` | PASS; sampler-off moving; nine obsolete-tile aborts were recorded by the stress session. |
+| `HarnessFix10SamplerOnStatic.log` | PASS; sampler-on static. |
+| `HarnessFixExport_20260914` | PASS; export commandlet exited 0. |
+| `WormOnExact_20260914` | PASS; exact export-only baseline, hash `07C14005`, 153,346 triangles. |
+| `WormOffSwitch_20260914` | PASS; disabled switch, hash `70D310A4`, 74,672 triangles, 20,856 / 10,917, Connected. |
+| `WormZeroedControl_20260914` | PASS; hand-zeroed control, same hash `70D310A4`, 74,672 triangles. |
+| `WormOfflineSamplerOn_20260914` | PASS; fresh exact sampler-on game run. |
+| `OfflineSymbolizeWormSampler_20260914` | PASS; post-exit exact CSV resolved; 733 modules, zero identity mismatches. |
+| `WormLedgerExact_20260914` | PASS; exact ledger candidate, 20,830 / 10,909, Connected. |
+| `WormLedgerLattice2_20260914` | PASS; exact lattice-2 candidate. |
+| `WormLedgerLattice4_20260914` | PASS; exact lattice-4 candidate. |
+| `WormLatticeExactStaticA_20260914` | PASS; 343 LOD0 samples, worker 33.102516 s. |
+| `WormLattice2StaticA_20260914` | PASS process; invalidated as a candidate after 160.860434 worker s and p95 generation 1.036767 s. |
+| `WormLattice2StaticCacheFixA_20260914` | PASS process; invalidated partial cache experiment, 189 samples and 209.142420 worker s. |
+| `WormLattice2StaticCacheFixB_20260914` | PASS; cache-fixed lattice-2 rerun, worker 33.779886 s. |
+| `WormLattice4StaticCacheFixA_20260914` | PASS; cache-fixed lattice-4, worker 33.252895 s. |
+| `WormLattice2StaticN2CacheA_20260914` | PASS; N2-cache experiment, worker 33.226479 s. |
+| `WormBlockSkipStaticProbe_20260914` | PASS; exact block-skip probe, worker 33.099186 s. |
+| `WormLattice2StaticN1CacheA_20260914` | PASS; N1-cache experiment, worker 33.618430 s. |
+| `WormLedgerN1Exact_20260914` | PASS; exact N1 ledger candidate. |
+| `WormLedgerN1Lattice2_20260914` | PASS; lattice-2 N1 ledger candidate. |
+| `WormCheapValue_20260914` | PASS process; candidate rejected because player-fit was 20,826. |
+| `WormCheapValueStaticA_20260914` | PASS; value-noise static profile, worker 32.551710 s. |
+| `WormCheapValueLattice2StaticA_20260914` | PASS; value-noise lattice-2 profile, worker 33.814655 s. |
+| `WormCheapValueLattice2Explore_20260914` | PASS; capability 20,857 / 10,917, Connected. |
+| `WormCheapValue098Explore_20260914` | PASS process; candidate fit 20,821, rejected. |
+| `WormCheapValue102Explore_20260914` | PASS process; candidate fit 20,827, rejected. |
+| `WormCheapValue110Explore_20260914` | PASS process; candidate fit 20,828, rejected. |
+| `WormCheapFastHashExplore_20260914` | PASS; selected cheap field, hash `6204C7E6`, 75,956 triangles, 20,851 / 10,917, Connected. |
+| `WormExactCurrentExplore_20260914` | PASS; selected exact control, hash `311CA42C`, 75,482 triangles, 20,830 / 10,909, Connected. |
+| `WormPerfStaticExactA_20260914` | PASS; preliminary exact static A. |
+| `WormPerfStaticCheapA_20260914` | PASS; preliminary cheap static A. |
+| `WormPerfStaticExactB_20260914` | PASS; preliminary exact static B. |
+| `WormPerfStaticCheapB_20260914` | PASS; preliminary cheap static B. |
+| `WormSamplerPlant_20260914` | PASS process; first planted profile, proof inconclusive. |
+| `WormSamplerPlantOffline_20260914` | PASS process; first offline planted pass, no named plant row. |
+| `WormSamplerPlantLong_20260914` | PASS process; longer planted profile, proof inconclusive. |
+| `WormSamplerPlantLongOffline_20260914` | PASS process; longer offline pass, no named plant row. |
+| `WormSamplerPlantGenerator_20260914` | PASS; generator-level planted profile. |
+| `WormSamplerPlantGeneratorOffline_20260914` | PASS; five named plant rows resolved; proof accepted before plant removal. |
+| `WormFinalOffSampler_20260914` | PASS; disabled sampler-on commandlet, zero worm rows after symbolization. |
+| `WormFinalOffSymbolize_20260914` | PASS; post-exit disabled CSV resolved. |
+| `WormFinalOffSwitch_20260914` | PASS; disabled geometry/capability proof. |
+| `WormFinalZeroedControl_20260914` | PASS; zeroed-parameter control, exact geometry match. |
+| `WormFinalExactDetA_20260914` | PASS; exact determinism A. |
+| `WormFinalExactDetB_20260914` | PASS; exact determinism B. |
+| `WormFinalCheapDetA_20260914` | PASS; cheap determinism A. |
+| `WormFinalCheapDetB_20260914` | PASS; cheap determinism B. |
+| `WormFinalPerfStaticOffA_20260914` | PASS process; preliminary pair member, but launched with cheap mode. |
+| `WormFinalPerfStaticOnA_20260914` | PASS process; preliminary pair member, also cheap mode, excluded from comparison. |
+| `WormFinalPerfStaticWormsOnA_20260914` | PASS; explicit game-path worms-on static A (`WormsForceOff=0`). |
+| `WormFinalPerfStaticWormsOffA_20260914` | PASS; explicit game-path worms-off static A (`WormsForceOff=1`). |
+| `WormFinalPerfStaticWormsOnB_20260914` | PASS; explicit game-path worms-on static B (`WormsForceOff=0`). |
+| `WormFinalPerfStaticWormsOffB_20260914` | PASS; explicit game-path worms-off static B (`WormsForceOff=1`). |
+| `WormFinalPerfStaticExactA_20260914` | PASS; final exact static A. |
+| `WormFinalPerfStaticCheapA_20260914` | PASS; final cheap static A. |
+| `WormFinalPerfStaticExactB_20260914` | PASS; final exact static B. |
+| `WormFinalPerfStaticCheapB_20260914` | PASS; final cheap static B. |
+| initial `WormFinalPerfMovingExactA_20260914` wrapper launch | FAILED harness shutdown after the graceful-close timeout; no crash folder or reporter, and the preserved backup log is `WormFinalPerfMovingExactA_20260914-backup-2026.09.14-05.14.32.log`. |
+| retried `WormFinalPerfMovingExactA_20260914` | PASS; rerun used the runtime movement/exit path, 1,521 LOD0 samples. |
+| `WormFinalPerfMovingCheapA_20260914` | PASS; final cheap moving A. |
+| `WormFinalPerfMovingExactB_20260914` | PASS; final exact moving B. |
+| `WormFinalPerfMovingCheapB_20260914` | PASS; final cheap moving B. |
+| `WormFinalPerfMovingWormsOnA_20260914` | PASS; explicit game-path worms-on moving A (`WormsForceOff=0`). |
+| `WormFinalPerfMovingWormsOffA_20260914` | PASS; explicit game-path worms-off moving A (`WormsForceOff=1`). |
+| `WormFinalPerfMovingWormsOnB_20260914` | PASS; explicit game-path worms-on moving B (`WormsForceOff=0`). |
+| `WormFinalPerfMovingWormsOffB_20260914` | PASS; explicit game-path worms-off moving B (`WormsForceOff=1`). |
+| `WormFinalMovingSamplerOn_20260914` | PASS; pre-hardening cheap sampler-on moving profile. |
+| `WormFinalMovingSamplerOffline_20260914` | PASS; pre-hardening post-exit symbolization. |
+| `WormFinalRenderBefore_20260914` | PASS; exact fixed-camera render. |
+| `WormFinalRenderAfter_20260914` | PASS; cheap fixed-camera render. |
+| `WormPostHardeningOff_20260914` | PASS; final disabled geometry proof. |
+| `WormPostHardeningZeroed_20260914` | PASS; final zeroed-control geometry proof. |
+| `WormFinalMovingSamplerOnPostHardening_20260914` | PASS; final cheap sampler-on moving profile, 1,521 LOD0 samples, 800 cm/s, no obsolete aborts. |
+| `WormFinalMovingSamplerOfflinePostHardening_20260914` | PASS; final cheap offline symbolization, zero module identity mismatches. |
+| `WormFinalMovingSamplerExactProof_20260914` | PASS; final exact sampler-on comparison profile. |
+| `WormFinalMovingSamplerExactProofOffline_20260914` | PASS; final exact offline symbolization, zero module identity mismatches. |
+| `WormPostHardeningRenderBefore_20260914` | PASS; final exact render refresh. |
+| `WormPostHardeningRenderAfter_20260914` | PASS; final cheap render refresh. |
+| `PerfSampledBuild_FinalForceOff.log` | PASS; final force-off wiring build, Result: Succeeded. |
+| `WormFinalForceOffBuildSamplerOnMoving_20260914` | PASS; final sampler-on moving run on the force-off build, 1,521 LOD0 samples, no obsolete aborts. |
+| `WormFinalForceOffBuildSamplerOffline_20260914` | FAILED; first direct post-exit symbolizer attempt stopped on UE 5.7's fatal no-writable-cache-graph DDC configuration; preserved log/output, no code failure. |
+| `WormFinalForceOffBuildSamplerOfflineRetry_20260914` | PASS; retried with writable `Saved\ZenData`/`Saved\DDC`, 733 modules, 10 loaded, zero identity mismatches, all 7,795 unique PCs mapped. |
+| `PerfSampledBuild_FinalFingerprint.log` | PASS; final cache-key hardening rebuild, Result: Succeeded. |
+| `WormFinalFingerprintSmoke_20260914` | PASS; post-hardening clean game smoke, exact staged runtime verified, writable DDC, zero crash folders/reporters. |
diff --git a/Source/VoxelForge/Private/VoxelDensityOpStack.cpp b/Source/VoxelForge/Private/VoxelDensityOpStack.cpp
index eef1a7c..4b322eb 100644
--- a/Source/VoxelForge/Private/VoxelDensityOpStack.cpp
+++ b/Source/VoxelForge/Private/VoxelDensityOpStack.cpp
@@ -26,6 +26,7 @@
 #include "VoxelGenerator.h"           // VoxelGenLOD::Eff
 #include "VoxelHeightOp.h"            // FVoxelHeightStack — SurfaceWorld's two height stacks
 #include "VoxelNoise.h"               // VoxelNoise::FBM
+#include "VoxelWormField.h"
 #include "VoxelStrateDefinition.h"    // TerrainOperations — le pool que BuildChunkCache tire par salle
 #include "VoxelTerrainOpDefinition.h" // ApplyTo — l'override d'op PAR SALLE (étape C1)
 #include "VoxelStrateManager.h"       // EvaluateModifierSDF / AnyPassageNearBox
@@ -8540,7 +8541,12 @@ namespace
     {
     public:
         FWormFieldSource(const FStrateGenerationParams& InP, int32 Seed)
-            : P(InP), SeedU((uint32)Seed) {}
+            : P(InP)
+            , SeedU((uint32)Seed)
+            , WormLatticeStep(
+                InP.WormStrength > 0.0f && InP.WormThreshold > 0.0f
+                    ? VoxelWormField::GetLatticeStep() : 0)
+        {}
 
         EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
         EVoxelOpChannelMask ChannelReads() const override
@@ -8555,8 +8561,6 @@ namespace
         {
             if (!(P.WormStrength > 0.0f && P.WormThreshold > 0.0f)) { return; }
 
-            const float EffectiveZ = (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f)
-                                   ? (WorldZ / P.VerticalScale) : WorldZ;
             const float CaveSDF = InOut.Sdf;
 
             float NetworkMask = 1.0f;
@@ -8574,25 +8578,14 @@ namespace
 
             if (NetworkMask <= 0.0f) { return; }
 
-            const float WormZFreq = P.WormFrequency * P.WormHorizontalBias;
-
-            const float N1 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
-                WorldX * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f),
-                WorldY * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f),
-                EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f)
-            )) * VOXEL_NOISE_SCALE);
-
-            // N2 ≥ 0, donc si N1 dépasse déjà le seuil la somme ne peut plus creuser — on saute le
-            // second Perlin (le cas courant ; sortie bit-identique). Transcrit tel quel.
-            if (N1 >= P.WormThreshold) { return; }
-
-            const float N2 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
-                WorldX * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f) + 137.0f,
-                WorldY * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f) + 259.0f,
-                EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f) + 431.0f
-            )) * VOXEL_NOISE_SCALE);
-
-            const float WormValue = N1 + N2;
+            const VoxelWormField::FParameters WormParameters{
+                P.WormFrequency,
+                P.WormHorizontalBias,
+                P.VerticalScale,
+                SeedU};
+            const float WormValue = VoxelWormField::Evaluate(
+                WorldX, WorldY, WorldZ, P.WormThreshold,
+                WormParameters, WormLatticeStep);
             if (WormValue < P.WormThreshold)
             {
                 const float t = 1.0f - (WormValue / P.WormThreshold);
@@ -8663,7 +8656,9 @@ namespace
             // explicit count cap keeps this check bounded.  The network mask still uses the SDF
             // interval's worst case, so this never assumes a room value that the preceding source
             // did not prove.
-            if (Ctx.bUseLatticeProof && Ctx.bTightenWarpProof && Ctx.Step >= 1
+            if (VoxelWormField::GetNoiseMode() == 0
+                && WormLatticeStep <= 1
+                && Ctx.bUseLatticeProof && Ctx.bTightenWarpProof && Ctx.Step >= 1
                 && VoxelMath::IsFinite(P.WormFrequency)
                 && VoxelMath::IsFinite(P.WormHorizontalBias)
                 && VoxelMath::IsFinite(P.WormThreshold)
@@ -8783,6 +8778,7 @@ namespace
     private:
         FStrateGenerationParams P;
         uint32 SeedU;
+        int32 WormLatticeStep = 0;
     };
 
 #if WITH_EDITOR
@@ -9738,7 +9734,10 @@ namespace VoxelDensityOps
         OutStack.Add(MakeUnique<FDomeMod>(P, RoomPtr));                  // 4g — dômes
         OutStack.Add(MakeUnique<FPinchMod>(P, RoomPtr));                 // 4h — pincement
         OutStack.Add(MakeUnique<FFloorBiasMod>(P, RoomPtr));             // fin 4h — biais de sol
-        OutStack.Add(MakeUnique<FWormFieldSource>(P, Seed));
+        if (P.WormStrength > 0.0f && P.WormThreshold > 0.0f)
+        {
+            OutStack.Add(MakeUnique<FWormFieldSource>(P, Seed));
+        }
 
         if (bAppendStructuralPosts)
         {
@@ -10324,6 +10323,14 @@ bool VF_BuildStackFromRecipe(const FVoxelOpStackRecipe& Recipe,
 
     for (const FVoxelOpRecipeEntry& Entry : Recipe.Modifiers)
     {
+        if (Entry.OpClass == EVoxelStrateOpClass::WormFieldSource
+            && !(Params.TunnelNetworkParams.WormStrength > 0.0f
+                 && Params.TunnelNetworkParams.WormThreshold > 0.0f))
+        {
+            // A disabled strate has no worm operator at all. This makes the off switch cheap on
+            // the interpreted path as well as exact in its interval/classifier fold.
+            continue;
+        }
         TUniquePtr<IVoxelDensityOp> Modifier =
             VoxelStrateRecipePrivate::BuildRecipeOp(Entry, Params, Seed, SpineRadius,
                                                     StrateManager, RoomPtr, ShaftPtr);
diff --git a/Source/VoxelForge/Private/VoxelGenerator.cpp b/Source/VoxelForge/Private/VoxelGenerator.cpp
index baa0002..cae4a69 100644
--- a/Source/VoxelForge/Private/VoxelGenerator.cpp
+++ b/Source/VoxelForge/Private/VoxelGenerator.cpp
@@ -13,6 +13,7 @@
 #include "VoxelDiffLayer.h"
 #include "VoxelBiomeDefinition.h"
 #include "VoxelNoise.h"   // T2.a: float, SIMD-batched gradient-noise core
+#include "VoxelWormField.h"
 #include "VoxelDensityPrimitives.h"   // spine / seals / passage — shared with the operator stack
 #include "VoxelDensityOpStack.h"      // OPSTACK Phase 1: the opt-in per-strate operator stack
 #include "VoxelHeightOp.h"            // IVoxelBiomeField — the adapter below implements it
@@ -858,6 +859,14 @@ bool VoxelGenLOD::GetThreadTileCacheWindow(
         && Extent <= static_cast<int64>(CHUNK_SIZE) * 64;
 }
 
+void VoxelGenLOD::SetThreadTileContext(
+    const FIntVector& OriginVoxels,
+    int32 CellsPerAxis)
+{
+    TileOriginVoxels = OriginVoxels;
+    TileCellsPerAxis = CellsPerAxis;
+}
+
 bool VoxelGenLOD::ShouldUseSpatialIndex(bool bFusedPath)
 {
     VF_ParseSpatialIndexSwitch();
@@ -4239,10 +4248,10 @@ float UVoxelGenerator::GetDensityWithParams(float WorldX, float WorldY, float Wo
     // already computed by Step 4 — free): full strength at the network, smooth fade to zero
     // at Range. Worms become braids/shortcuts hugging the cave system; no isolated speckle.
     // Range = 0 → unmasked legacy behaviour. Bonus: fully-masked voxels skip both Perlins.
-    VoxelDensityProfile::FScopedTimer FusedWormTimer(
-        VoxelDensityProfile::EBucket::FusedWorm);
     if (Params.WormStrength > 0.0f && Params.WormThreshold > 0.0f)
     {
+        VoxelDensityProfile::FScopedTimer FusedWormTimer(
+            VoxelDensityProfile::EBucket::FusedWorm);
         float NetworkMask = 1.0f;
         if (Params.WormNetworkRange > 0.0f)
         {
@@ -4267,7 +4276,10 @@ float UVoxelGenerator::GetDensityWithParams(float WorldX, float WorldY, float Wo
             }
 
             bool bWormBlockProofComputed = false;
-            const bool bSkipWormBlock = GVoxelForgeWormBlockSkip != 0
+            const int32 WormLatticeStep = VoxelWormField::GetLatticeStep();
+            const bool bSkipWormBlock = VoxelWormField::GetNoiseMode() == 0
+                && WormLatticeStep <= 1
+                && GVoxelForgeWormBlockSkip != 0
                 && VF_TryGetWormBlockSkip(
                     DensityCacheOwnerId, SeedU, ParamsFingerprint, LayoutVersion,
                     WorldX, WorldY, WorldZ, Params, bWormBlockProofComputed);
@@ -4286,37 +4298,25 @@ float UVoxelGenerator::GetDensityWithParams(float WorldX, float WorldY, float Wo
             }
             else
             {
-                const float WormZFreq = Params.WormFrequency * Params.WormHorizontalBias;
-                const float N1 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
-                    WorldX * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f),
-                    WorldY * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f),
-                    EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f)
-                )) * VOXEL_NOISE_SCALE);
+                const VoxelWormField::FParameters WormParameters{
+                    Params.WormFrequency,
+                    Params.WormHorizontalBias,
+                    Params.VerticalScale,
+                    SeedU};
+                const float WormValue = VoxelWormField::Evaluate(
+                    WorldX, WorldY, WorldZ, Params.WormThreshold,
+                    WormParameters, WormLatticeStep);
 
-                // N2 >= 0, so if N1 alone already clears the threshold the sum can't carve —
-                // skip the second Perlin entirely (most voxels; bit-identical output).
-                if (N1 < Params.WormThreshold)
+                if (WormValue < Params.WormThreshold)
                 {
-                    const float N2 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
-                        WorldX * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f) + 137.0f,
-                        WorldY * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f) + 259.0f,
-                        EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f) + 431.0f
-                    )) * VOXEL_NOISE_SCALE);
-
-                    const float WormValue = N1 + N2;
-
-                    if (WormValue < Params.WormThreshold)
-                    {
-                        const float t = 1.0f - (WormValue / Params.WormThreshold);
-                        Density -= t * Params.WormStrength * NetworkMask;
-                    }
+                    const float t = 1.0f - (WormValue / Params.WormThreshold);
+                    Density -= t * Params.WormStrength * NetworkMask;
                 }
             }
         }
+        FusedWormTimer.End();
     }
 
-    FusedWormTimer.End();
-
     //=========================================================================
     // STEP 6: STRATE BOUNDARY SEAL (haut + bas)
     //=========================================================================
diff --git a/Source/VoxelForge/Private/VoxelStackSampler.cpp b/Source/VoxelForge/Private/VoxelStackSampler.cpp
index f2badcc..1f49c85 100644
--- a/Source/VoxelForge/Private/VoxelStackSampler.cpp
+++ b/Source/VoxelForge/Private/VoxelStackSampler.cpp
@@ -4,8 +4,6 @@
 #include "VoxelStackSampler.h"
 
 #include "Containers/Array.h"
-#include "Containers/Map.h"
-#include "Containers/Set.h"
 #include "HAL/FileManager.h"
 #include "HAL/PlatformProcess.h"
 #include "HAL/PlatformStackWalk.h"
@@ -17,6 +15,7 @@
 #include "Math/UnrealMathUtility.h"
 #include "Containers/StringConv.h"
 #include "Misc/FileHelper.h"
+#include "Misc/Guid.h"
 #include "Misc/Paths.h"
 #include "Misc/ScopeLock.h"
 #include "Serialization/Archive.h"
@@ -24,6 +23,11 @@
 
 #if PLATFORM_WINDOWS
 #include "Windows/WindowsPlatformStackWalk.h"
+#include "Windows/AllowWindowsPlatformTypes.h"
+THIRD_PARTY_INCLUDES_START
+#include <Psapi.h>
+THIRD_PARTY_INCLUDES_END
+#include "Windows/HideWindowsPlatformTypes.h"
 #endif
 
 #include <atomic>
@@ -89,221 +93,219 @@ void WriteUtf8(FArchive& Archive, const FString& Text)
     }
 }
 
-FString NormalizedForClassification(const FString& InValue)
+#if PLATFORM_WINDOWS
+struct FModuleMapRecord
+{
+    FString Path;
+    uint64 LoadBase = 0;
+    uint32 ImageSize = 0;
+    uint64 FileSize = 0;
+    uint64 LastWriteFileTime = 0;
+    FString PdbGuid;
+    uint32 PdbAge = 0;
+    FString PdbPath;
+};
+
+FString ModuleMapField(const FString& InValue)
 {
     FString Result = InValue;
-    Result.ToLowerInline();
-    Result.ReplaceInline(TEXT("\\"), TEXT("/"));
+    Result.ReplaceInline(TEXT("\t"), TEXT(" "));
+    Result.ReplaceInline(TEXT("\r"), TEXT(" "));
+    Result.ReplaceInline(TEXT("\n"), TEXT(" "));
     return Result;
 }
 
-struct FResolvedSymbol
+bool IsModuleImageRangeValid(uint32 Offset, uint64 Size, uint32 ImageSize)
 {
-    FString Module;
-    FString Function;
-    FString File;
-    int32 Line = 0;
-    bool bInline = false;
-};
-
-struct FResolvedProgramCounter
-{
-    bool bAttempted = false;
-    TArray<FResolvedSymbol> Symbols;
-};
-
-struct FProfileRow
-{
-    FString Key;
-    FString Function;
-    FString Module;
-    FString File;
-    FString Label;
-    int32 Line = 0;
-    uint64 Samples = 0;
-};
-
-struct FProfileAggregateSet
-{
-    TMap<FString, FProfileRow> ExclusiveFunctions;
-    TMap<FString, FProfileRow> InclusiveFunctions;
-    TMap<FString, FProfileRow> ExclusiveLines;
-    uint64 SamplesWithStack = 0;
-};
-
-const FResolvedSymbol* FirstFunctionSymbol(const FResolvedProgramCounter& Entry)
-{
-    for (const FResolvedSymbol& Symbol : Entry.Symbols)
-    {
-        if (!Symbol.Function.IsEmpty())
-        {
-            return &Symbol;
-        }
-    }
-    return nullptr;
+    return Offset <= ImageSize && Size <= static_cast<uint64>(ImageSize - Offset);
 }
 
-const FResolvedSymbol* FirstSourceSymbol(const FResolvedProgramCounter& Entry)
+void ReadModuleCodeViewIdentity(
+    FModuleMapRecord& Record, const uint8* ModuleBase, uint32 ImageSize)
 {
-    for (const FResolvedSymbol& Symbol : Entry.Symbols)
-    {
-        if (!Symbol.File.IsEmpty() && Symbol.Line > 0)
-        {
-            return &Symbol;
-        }
-    }
-    return nullptr;
-}
-
-FString SymbolLabel(const FResolvedSymbol& Symbol)
-{
-    if (Symbol.Function.IsEmpty())
-    {
-        return TEXT("unknown");
-    }
-
-    const FString FunctionLower = NormalizedForClassification(Symbol.Function);
-    if (FunctionLower.Contains(TEXT("std::")))
-    {
-        return TEXT("std");
-    }
-
-    const FString ModuleLower = NormalizedForClassification(Symbol.Module);
-    const FString FileLower = NormalizedForClassification(Symbol.File);
-    const bool bFileIsEngine = FileLower.Contains(TEXT("/engine/"));
-    if (bFileIsEngine)
-    {
-        return TEXT("engine");
-    }
-
-    const bool bVoxelForge = FunctionLower.Contains(TEXT("voxelforge"))
-        || FileLower.Contains(TEXT("/voxelforge/"))
-        || ModuleLower.Contains(TEXT("voxelforge"));
-    if (bVoxelForge)
-    {
-        return TEXT("plugin");
-    }
-
-    const bool bModuleIsEngine = ModuleLower.StartsWith(TEXT("unrealeditor-"))
-        || ModuleLower.StartsWith(TEXT("ue5-"));
-    return bModuleIsEngine ? TEXT("engine") : TEXT("other");
-}
-
-bool IsWaitLike(const FResolvedSymbol& Symbol)
-{
-    const FString FunctionLower = NormalizedForClassification(Symbol.Function);
-    return FunctionLower.Contains(TEXT("wait"))
-        || FunctionLower.Contains(TEXT("sleep"))
-        || FunctionLower.Contains(TEXT("semaphore"))
-        || FunctionLower.Contains(TEXT("fevent"));
-}
-
-FString FunctionKey(const FResolvedSymbol& Symbol)
-{
-    return SymbolLabel(Symbol) + TEXT("\x1f") + Symbol.Function;
-}
-
-FString SourceKey(const FResolvedSymbol* Symbol)
-{
-    if (Symbol == nullptr || Symbol->File.IsEmpty() || Symbol->Line <= 0)
-    {
-        return TEXT("unknown\x1f<unknown>");
-    }
-    return SymbolLabel(*Symbol) + TEXT("\x1f")
-        + FString::Printf(TEXT("%s:%d"), *Symbol->File, Symbol->Line);
-}
-
-void AddFunctionRow(
-    TMap<FString, FProfileRow>& Rows,
-    const FResolvedSymbol* Symbol,
-    uint64 SampleCount)
-{
-    if (Symbol == nullptr || Symbol->Function.IsEmpty())
+    if (ModuleBase == nullptr || ImageSize < sizeof(IMAGE_DOS_HEADER))
     {
         return;
     }
-    const FString Key = FunctionKey(*Symbol);
-    FProfileRow& Row = Rows.FindOrAdd(Key);
-    if (Row.Key.IsEmpty())
+
+    const IMAGE_DOS_HEADER* DosHeader = reinterpret_cast<const IMAGE_DOS_HEADER*>(ModuleBase);
+    if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE || DosHeader->e_lfanew < 0)
     {
-        Row.Key = Key;
-        Row.Function = Symbol->Function;
-        Row.Module = Symbol->Module;
-        Row.File = Symbol->File;
-        Row.Line = Symbol->Line;
-        Row.Label = SymbolLabel(*Symbol);
+        return;
+    }
+
+    const uint32 NtOffset = static_cast<uint32>(DosHeader->e_lfanew);
+    if (!IsModuleImageRangeValid(NtOffset, sizeof(IMAGE_NT_HEADERS), ImageSize))
+    {
+        return;
+    }
+    const IMAGE_NT_HEADERS* NtHeaders = reinterpret_cast<const IMAGE_NT_HEADERS*>(
+        ModuleBase + NtOffset);
+    if (NtHeaders->Signature != IMAGE_NT_SIGNATURE
+        || NtHeaders->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_DEBUG)
+    {
+        return;
+    }
+
+    const IMAGE_DATA_DIRECTORY& DebugDirectory =
+        NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
+    if (DebugDirectory.VirtualAddress == 0
+        || DebugDirectory.Size < sizeof(IMAGE_DEBUG_DIRECTORY)
+        || !IsModuleImageRangeValid(
+            DebugDirectory.VirtualAddress, DebugDirectory.Size, ImageSize))
+    {
+        return;
+    }
+
+    const IMAGE_DEBUG_DIRECTORY* Entries = reinterpret_cast<const IMAGE_DEBUG_DIRECTORY*>(
+        ModuleBase + DebugDirectory.VirtualAddress);
+    const uint32 EntryCount = DebugDirectory.Size / sizeof(IMAGE_DEBUG_DIRECTORY);
+    for (uint32 Index = 0; Index < EntryCount; ++Index)
+    {
+        const IMAGE_DEBUG_DIRECTORY& Entry = Entries[Index];
+        if (Entry.Type != IMAGE_DEBUG_TYPE_CODEVIEW || Entry.SizeOfData < 24
+            || Entry.AddressOfRawData == 0
+            || !IsModuleImageRangeValid(
+                Entry.AddressOfRawData, Entry.SizeOfData, ImageSize))
+        {
+            continue;
+        }
+
+        const uint8* CodeView = ModuleBase + Entry.AddressOfRawData;
+        if (CodeView[0] != 'R' || CodeView[1] != 'S'
+            || CodeView[2] != 'D' || CodeView[3] != 'S')
+        {
+            continue;
+        }
+
+        FGuid Guid;
+        FMemory::Memcpy(&Guid, CodeView + 4, sizeof(Guid));
+        Record.PdbGuid = Guid.ToString();
+        FMemory::Memcpy(&Record.PdbAge, CodeView + 20, sizeof(Record.PdbAge));
+
+        const uint32 PdbPathBytes = Entry.SizeOfData - 24;
+        if (PdbPathBytes > 0)
+        {
+            const ANSICHAR* PdbPathAnsi = reinterpret_cast<const ANSICHAR*>(CodeView + 24);
+            int32 Length = 0;
+            while (Length < static_cast<int32>(PdbPathBytes) && PdbPathAnsi[Length] != '\0')
+            {
+                ++Length;
+            }
+            if (Length > 0)
+            {
+                FUTF8ToTCHAR PdbPathUtf8(PdbPathAnsi, Length);
+                Record.PdbPath = FString(PdbPathUtf8.Get());
+            }
+        }
+        return;
     }
-    Row.Samples += SampleCount;
 }
 
-void AddSourceRow(
-    TMap<FString, FProfileRow>& Rows,
-    const FResolvedSymbol* FunctionSymbol,
-    const FResolvedSymbol* SourceSymbol)
+bool CollectProcessModuleMap(TArray<FModuleMapRecord>& OutRecords, FString& OutError)
 {
-    const FString Key = SourceKey(SourceSymbol);
-    FProfileRow& Row = Rows.FindOrAdd(Key);
-    if (Row.Key.IsEmpty())
-    {
-        Row.Key = Key;
-        Row.Label = SourceSymbol != nullptr ? SymbolLabel(*SourceSymbol) : TEXT("unknown");
-        Row.File = SourceSymbol != nullptr ? SourceSymbol->File : TEXT("<unknown>");
-        Row.Line = SourceSymbol != nullptr ? SourceSymbol->Line : 0;
-        Row.Function = FunctionSymbol != nullptr ? FunctionSymbol->Function : TEXT("<unknown>");
-        Row.Module = FunctionSymbol != nullptr ? FunctionSymbol->Module : TEXT("<unknown>");
-    }
-    ++Row.Samples;
-}
+    OutRecords.Reset();
+    OutError.Reset();
 
-TArray<FProfileRow> SortedRows(const TMap<FString, FProfileRow>& InRows)
-{
-    TArray<FProfileRow> Rows;
-    Rows.Reserve(InRows.Num());
-    for (const TPair<FString, FProfileRow>& Pair : InRows)
+    // Keep PSAPI dynamic, like the engine stack-walk implementation. This records module state
+    // without touching DbgHelp or the process-global symbol engine.
+    void* PsapiHandle = FPlatformProcess::GetDllHandle(TEXT("PSAPI.DLL"));
+    if (PsapiHandle == nullptr)
     {
-        Rows.Add(Pair.Value);
+        OutError = TEXT("PSAPI.DLL could not be loaded");
+        return false;
     }
-    Rows.Sort([](const FProfileRow& A, const FProfileRow& B)
+
+    using FEnumProcessModules = BOOL (WINAPI*)(HANDLE, HMODULE*, DWORD, LPDWORD);
+    using FGetModuleFileNameExW = DWORD (WINAPI*)(HANDLE, HMODULE, LPWSTR, DWORD);
+    using FGetModuleInformation = BOOL (WINAPI*)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
+
+    const FEnumProcessModules EnumModules = reinterpret_cast<FEnumProcessModules>(
+        FPlatformProcess::GetDllExport(PsapiHandle, TEXT("EnumProcessModules")));
+    const FGetModuleFileNameExW GetModuleFileNameEx = reinterpret_cast<FGetModuleFileNameExW>(
+        FPlatformProcess::GetDllExport(PsapiHandle, TEXT("GetModuleFileNameExW")));
+    const FGetModuleInformation GetModuleInformation = reinterpret_cast<FGetModuleInformation>(
+        FPlatformProcess::GetDllExport(PsapiHandle, TEXT("GetModuleInformation")));
+    if (EnumModules == nullptr || GetModuleFileNameEx == nullptr || GetModuleInformation == nullptr)
     {
-        return A.Samples != B.Samples ? A.Samples > B.Samples : A.Key < B.Key;
+        OutError = TEXT("PSAPI exports needed for module enumeration are unavailable");
+        FPlatformProcess::FreeDllHandle(PsapiHandle);
+        return false;
+    }
+
+    DWORD BytesRequired = 0;
+    EnumModules(GetCurrentProcess(), nullptr, 0, &BytesRequired);
+    if (BytesRequired == 0)
+    {
+        OutError = TEXT("EnumProcessModules returned no module bytes");
+        FPlatformProcess::FreeDllHandle(PsapiHandle);
+        return false;
+    }
+
+    TArray<HMODULE> Modules;
+    Modules.SetNumUninitialized(
+        FMath::Max<int32>(1, static_cast<int32>(BytesRequired / sizeof(HMODULE) + 1)));
+    DWORD BytesWritten = 0;
+    if (!EnumModules(
+            GetCurrentProcess(), Modules.GetData(),
+            static_cast<DWORD>(Modules.Num() * sizeof(HMODULE)), &BytesWritten))
+    {
+        OutError = TEXT("EnumProcessModules failed");
+        FPlatformProcess::FreeDllHandle(PsapiHandle);
+        return false;
+    }
+
+    const int32 ModuleCount = FMath::Min<int32>(
+        Modules.Num(), static_cast<int32>(BytesWritten / sizeof(HMODULE)));
+    for (int32 Index = 0; Index < ModuleCount; ++Index)
+    {
+        MODULEINFO ModuleInfo{};
+        if (!GetModuleInformation(
+                GetCurrentProcess(), Modules[Index], &ModuleInfo, sizeof(ModuleInfo)))
+        {
+            continue;
+        }
+
+        WCHAR ImagePath[32768] = {};
+        const DWORD PathLength = GetModuleFileNameEx(
+            GetCurrentProcess(), Modules[Index], ImagePath, UE_ARRAY_COUNT(ImagePath));
+        if (PathLength == 0)
+        {
+            continue;
+        }
+
+        FModuleMapRecord Record;
+        Record.Path = FString(ImagePath, static_cast<int32>(PathLength));
+        Record.LoadBase = reinterpret_cast<uint64>(ModuleInfo.lpBaseOfDll);
+        Record.ImageSize = static_cast<uint32>(ModuleInfo.SizeOfImage);
+
+        WIN32_FILE_ATTRIBUTE_DATA FileData{};
+        if (GetFileAttributesExW(*Record.Path, GetFileExInfoStandard, &FileData))
+        {
+            ULARGE_INTEGER FileSize;
+            FileSize.HighPart = FileData.nFileSizeHigh;
+            FileSize.LowPart = FileData.nFileSizeLow;
+            Record.FileSize = FileSize.QuadPart;
+            ULARGE_INTEGER LastWrite;
+            LastWrite.HighPart = FileData.ftLastWriteTime.dwHighDateTime;
+            LastWrite.LowPart = FileData.ftLastWriteTime.dwLowDateTime;
+            Record.LastWriteFileTime = LastWrite.QuadPart;
+        }
+
+        ReadModuleCodeViewIdentity(
+            Record, reinterpret_cast<const uint8*>(ModuleInfo.lpBaseOfDll), Record.ImageSize);
+        OutRecords.Add(MoveTemp(Record));
+    }
+
+    OutRecords.Sort([](const FModuleMapRecord& A, const FModuleMapRecord& B)
+    {
+        return A.LoadBase < B.LoadBase;
     });
-    return Rows;
+    FPlatformProcess::FreeDllHandle(PsapiHandle);
+    return OutRecords.Num() > 0;
 }
+#endif
 
-void AppendRows(
-    FString& Out,
-    const TCHAR* Title,
-    const TMap<FString, FProfileRow>& InRows,
-    uint64 Denominator,
-    int32 MaxRows)
-{
-    Out += TEXT("\n");
-    Out += Title;
-    Out += TEXT("\nrank\tsamples\tpercent\tlabel\tfunction\tmodule\tfile\tline\n");
-    const TArray<FProfileRow> Rows = SortedRows(InRows);
-    const int32 Count = FMath::Min(MaxRows, Rows.Num());
-    for (int32 Index = 0; Index < Count; ++Index)
-    {
-        const FProfileRow& Row = Rows[Index];
-        const double Percent = Denominator > 0
-            ? static_cast<double>(Row.Samples) * 100.0 / static_cast<double>(Denominator)
-            : 0.0;
-        Out.Appendf(
-            TEXT("%d\t%llu\t%.4f\t%s\t%s\t%s\t%s\t%d\n"),
-            Index + 1,
-            static_cast<unsigned long long>(Row.Samples),
-            Percent,
-            *Row.Label,
-            *Row.Function,
-            *Row.Module,
-            *Row.File,
-            Row.Line);
-    }
-    if (Rows.Num() == 0)
-    {
-        Out += TEXT("(no rows)\n");
-    }
-}
 }
 
 struct FVoxelStackSampler::FImpl final : public FRunnable
@@ -322,6 +324,7 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
     FString RunLabel;
     FString OutputDirectory;
     FString RawSamplesPath;
+    FString ModuleMapPath;
     FString SummaryPath;
     double StartSeconds = 0.0;
     std::atomic<bool> bStop{false};
@@ -360,6 +363,9 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
         RawSamplesPath = FPaths::Combine(
             OutputDirectory,
             FString::Printf(TEXT("VoxelStackSamples_%s_%u.csv"), *SafeLabel, ProcessId));
+        ModuleMapPath = FPaths::Combine(
+            OutputDirectory,
+            FString::Printf(TEXT("VoxelStackModules_%s_%u.tsv"), *SafeLabel, ProcessId));
         SummaryPath = FPaths::Combine(
             OutputDirectory,
             FString::Printf(TEXT("VoxelStackSummary_%s_%u.txt"), *SafeLabel, ProcessId));
@@ -622,10 +628,12 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
         Result.MaxActiveRegisteredThreads = MaxActiveRegisteredThreads;
         Result.RunLabel = RunLabel;
         Result.RawSamplesPath = RawSamplesPath;
+        Result.ModuleMapPath = ModuleMapPath;
         Result.SummaryPath = SummaryPath;
         Result.RunSeconds = FPlatformTime::Seconds() - StartSeconds;
 
         WriteRawSamples(Result);
+        WriteModuleMap(Result);
         // Do not call the DbgHelp-backed symbolizer from the measured process. DbgHelp is a
         // process-global state machine and can fault during shutdown even after the sampler
         // thread has joined. The raw PCs remain available for a separate offline pass.
@@ -672,6 +680,48 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
         Result.bOutputWritten = true;
     }
 
+    void WriteModuleMap(FSummary& Result)
+    {
+#if PLATFORM_WINDOWS
+        TArray<FModuleMapRecord> Records;
+        FString CollectionError;
+        const bool bCollected = CollectProcessModuleMap(Records, CollectionError);
+
+        FArchive* Archive = IFileManager::Get().CreateFileWriter(*ModuleMapPath);
+        if (Archive == nullptr)
+        {
+            return;
+        }
+
+        WriteUtf8(*Archive, TEXT("# VoxelForge module map v1\n"));
+        WriteUtf8(*Archive, TEXT("# DbgHelp is not initialized by this artifact writer.\n"));
+        WriteUtf8(*Archive, TEXT("module_path\tload_base_hex\timage_size\tfile_size\tfile_last_write_filetime\tpdb_guid\tpdb_age\tpdb_path\n"));
+        if (!bCollected)
+        {
+            WriteUtf8(*Archive, FString::Printf(TEXT("# collection_error\t%s\n"), *CollectionError));
+        }
+        for (const FModuleMapRecord& Record : Records)
+        {
+            const FString Line = FString::Printf(
+                TEXT("%s\t0x%016llX\t%u\t%llu\t%llu\t%s\t%u\t%s\n"),
+                *ModuleMapField(Record.Path),
+                static_cast<unsigned long long>(Record.LoadBase),
+                Record.ImageSize,
+                static_cast<unsigned long long>(Record.FileSize),
+                static_cast<unsigned long long>(Record.LastWriteFileTime),
+                *ModuleMapField(Record.PdbGuid),
+                Record.PdbAge,
+                *ModuleMapField(Record.PdbPath));
+            WriteUtf8(*Archive, Line);
+        }
+        delete Archive;
+        Result.ModuleCount = static_cast<uint64>(Records.Num());
+        Result.bModuleMapWritten = true;
+#else
+        (void)Result;
+#endif
+    }
+
     void WriteRawOnlySummary(FSummary& Result)
     {
         uint64 SamplesWithStack = 0;
@@ -691,6 +741,10 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
         Summary += TEXT("raw_only: yes\n");
         Summary += TEXT("symbolization: deferred\n");
         Summary += TEXT("dbghelp_in_measured_process: no\n");
+        Summary.Appendf(TEXT("module_map_written: %s\n"),
+            Result.bModuleMapWritten ? TEXT("yes") : TEXT("no"));
+        Summary.Appendf(TEXT("module_count: %llu\n"),
+            static_cast<unsigned long long>(Result.ModuleCount));
         Summary.Appendf(TEXT("interval_us: %u\n"), IntervalUs);
         Summary.Appendf(TEXT("max_stack_depth: %u\n"), MaxStackDepth);
         Summary.Appendf(TEXT("max_stored_samples: %u\n"), MaxStoredSamples);
@@ -716,6 +770,7 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
             static_cast<unsigned long long>(MaxActiveRegisteredThreads));
         Summary.Appendf(TEXT("run_seconds: %.6f\n"), Result.RunSeconds);
         Summary.Appendf(TEXT("raw_samples_path: %s\n"), *RawSamplesPath);
+        Summary.Appendf(TEXT("module_map_path: %s\n"), *ModuleMapPath);
         Summary += TEXT("\nThe target process records bounded raw PCs only; resolve symbols after the process exits.\n");
 
         if (FFileHelper::SaveStringToFile(
@@ -727,300 +782,7 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
         }
     }
 
-    void ResolveProgramCounter(
-        uint64 ProgramCounter,
-        TMap<uint64, FResolvedProgramCounter>& SymbolCache,
-        FSummary& Result)
-    {
-        FResolvedProgramCounter& Entry = SymbolCache.FindOrAdd(ProgramCounter);
-        if (Entry.bAttempted)
-        {
-            return;
-        }
-        Entry.bAttempted = true;
 
-#if PLATFORM_WINDOWS
-        FPlatformStackWalk::EnumerateSymbolInfosForProgramCounter(
-            ProgramCounter,
-            true,
-            [&Entry, &Result](FProgramCounterSymbolInfo& Info)
-            {
-                FResolvedSymbol Symbol;
-                Symbol.Module = FString(ANSI_TO_TCHAR(Info.ModuleName));
-                Symbol.Function = FString(ANSI_TO_TCHAR(Info.FunctionName));
-                Symbol.File = FString(ANSI_TO_TCHAR(Info.Filename));
-                Symbol.Line = Info.LineNumber;
-                Symbol.bInline = Symbol.Function.StartsWith(TEXT("[Inline Frame]"));
-                if (Symbol.bInline)
-                {
-                    ++Result.InlineSymbols;
-                }
-                Entry.Symbols.Add(MoveTemp(Symbol));
-            });
-        // DbgHelp can return source-only inline records for a PC. Ask the ordinary resolver as
-        // well when none of the enumerated records has a function name, so an unresolved frame
-        // does not hide an available outer function symbol.
-        if (Entry.Symbols.Num() == 0 || FirstFunctionSymbol(Entry) == nullptr)
-        {
-            FProgramCounterSymbolInfo Info;
-            FPlatformStackWalk::ProgramCounterToSymbolInfo(ProgramCounter, Info);
-            FResolvedSymbol Symbol;
-            Symbol.Module = FString(ANSI_TO_TCHAR(Info.ModuleName));
-            Symbol.Function = FString(ANSI_TO_TCHAR(Info.FunctionName));
-            Symbol.File = FString(ANSI_TO_TCHAR(Info.Filename));
-            Symbol.Line = Info.LineNumber;
-            Entry.Symbols.Add(MoveTemp(Symbol));
-        }
-#else
-        (void)ProgramCounter;
-        (void)Result;
-#endif
-    }
-
-    void SymbolizeAndWriteSummary(FSummary& Result)
-    {
-        TMap<uint64, FResolvedProgramCounter> SymbolCache;
-        FProfileAggregateSet AllAggregates;
-        FProfileAggregateSet Lod0Aggregates;
-        FProfileAggregateSet Lod1PlusAggregates;
-        TSet<FString> SeenFunctions;
-        uint64 ResolvedFrames = 0;
-        uint64 UnknownFrames = 0;
-        uint64 WaitLikeFrames = 0;
-        uint64 SamplesWithResolvedLeaf = 0;
-        uint64 SamplesWithWaitLikeFrame = 0;
-        uint64 SamplesWithStack = 0;
-        uint64 UntaggedSamples = 0;
-
-        auto AddUnknownExclusiveRow = [](FProfileAggregateSet& Aggregate)
-        {
-            const FString UnknownKey = TEXT("unknown\x1f<unknown>");
-            FProfileRow& UnknownRow = Aggregate.ExclusiveFunctions.FindOrAdd(UnknownKey);
-            if (UnknownRow.Key.IsEmpty())
-            {
-                UnknownRow.Key = UnknownKey;
-                UnknownRow.Function = TEXT("<unknown>");
-                UnknownRow.Module = TEXT("<unknown>");
-                UnknownRow.File = TEXT("<unknown>");
-                UnknownRow.Label = TEXT("unknown");
-            }
-            ++UnknownRow.Samples;
-        };
-
-        for (uint32 SampleIndex = 0; SampleIndex < StoredSampleCount; ++SampleIndex)
-        {
-            const FStoredSample& Sample = Samples[SampleIndex];
-            if (Sample.Depth == 0)
-            {
-                continue;
-            }
-            ++SamplesWithStack;
-            SeenFunctions.Reset();
-            TArray<FResolvedSymbol> SampleFunctions;
-
-            const FResolvedProgramCounter* LeafEntry = nullptr;
-            const FResolvedSymbol* LeafFunction = nullptr;
-            const FResolvedSymbol* LeafSource = nullptr;
-            uint64 LeafProgramCounter = 0;
-            bool bHasLeafProgramCounter = false;
-            bool bSampleHasResolvedLeaf = false;
-            bool bSampleHasWaitLike = false;
-
-            for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
-            {
-                const uint64 ProgramCounter = Sample.ProgramCounters[FrameIndex];
-                ResolveProgramCounter(ProgramCounter, SymbolCache, Result);
-                const FResolvedProgramCounter* Entry = SymbolCache.Find(ProgramCounter);
-                const FResolvedSymbol* FrameFunction = Entry != nullptr
-                    ? FirstFunctionSymbol(*Entry) : nullptr;
-                if (FrameFunction != nullptr)
-                {
-                    ++ResolvedFrames;
-                    if (IsWaitLike(*FrameFunction))
-                    {
-                        ++WaitLikeFrames;
-                        bSampleHasWaitLike = true;
-                    }
-                    if (FrameIndex == 0)
-                    {
-                        LeafProgramCounter = ProgramCounter;
-                        bHasLeafProgramCounter = true;
-                        bSampleHasResolvedLeaf = true;
-                    }
-                }
-                else
-                {
-                    ++UnknownFrames;
-                }
-
-                if (Entry != nullptr)
-                {
-                    if (FrameIndex == 0)
-                    {
-                        LeafProgramCounter = ProgramCounter;
-                        bHasLeafProgramCounter = true;
-                    }
-                    for (const FResolvedSymbol& Symbol : Entry->Symbols)
-                    {
-                        if (Symbol.Function.IsEmpty())
-                        {
-                            continue;
-                        }
-                        const FString Key = FunctionKey(Symbol);
-                        if (!SeenFunctions.Contains(Key))
-                        {
-                            SeenFunctions.Add(Key);
-                            SampleFunctions.Add(Symbol);
-                        }
-                    }
-                }
-            }
-
-            // SymbolCache is a TMap. FindOrAdd while resolving later frames may rehash it, so
-            // pointers captured during the loop are not stable. Re-find the leaf only after all
-            // PCs for this sample have been inserted.
-            if (bHasLeafProgramCounter)
-            {
-                LeafEntry = SymbolCache.Find(LeafProgramCounter);
-                if (LeafEntry != nullptr)
-                {
-                    LeafFunction = FirstFunctionSymbol(*LeafEntry);
-                    LeafSource = FirstSourceSymbol(*LeafEntry);
-                }
-            }
-
-            auto AddToAggregate = [&](FProfileAggregateSet& Aggregate)
-            {
-                ++Aggregate.SamplesWithStack;
-                if (bSampleHasResolvedLeaf)
-                {
-                    AddFunctionRow(Aggregate.ExclusiveFunctions, LeafFunction, 1);
-                }
-                else
-                {
-                    AddUnknownExclusiveRow(Aggregate);
-                }
-                for (const FResolvedSymbol& Symbol : SampleFunctions)
-                {
-                    AddFunctionRow(Aggregate.InclusiveFunctions, &Symbol, 1);
-                }
-                AddSourceRow(Aggregate.ExclusiveLines, LeafFunction, LeafSource);
-            };
-
-            AddToAggregate(AllAggregates);
-            if (Sample.LODLevel == 0)
-            {
-                AddToAggregate(Lod0Aggregates);
-            }
-            else if (Sample.LODLevel >= 1)
-            {
-                AddToAggregate(Lod1PlusAggregates);
-            }
-            else
-            {
-                ++UntaggedSamples;
-            }
-
-            if (bSampleHasResolvedLeaf)
-            {
-                ++SamplesWithResolvedLeaf;
-            }
-            if (bSampleHasWaitLike)
-            {
-                ++SamplesWithWaitLikeFrame;
-            }
-        }
-
-        Result.UniqueProgramCounters = SymbolCache.Num();
-        Result.ResolvedFrames = ResolvedFrames;
-        Result.UnknownFrames = UnknownFrames;
-        Result.WaitLikeFrames = WaitLikeFrames;
-        Result.SamplesWithResolvedLeaf = SamplesWithResolvedLeaf;
-        Result.SamplesWithWaitLikeFrame = SamplesWithWaitLikeFrame;
-
-        FString Summary;
-        Summary += TEXT("VoxelForge in-process stack sampler\n");
-        Summary += TEXT("==================================\n");
-        Summary.Appendf(TEXT("run_label: %s\n"), *RunLabel);
-        Summary.Appendf(TEXT("supported: %s\n"), Result.bSupported ? TEXT("yes") : TEXT("no"));
-        Summary.Appendf(TEXT("stack_walking_initialized: %s\n"),
-            Result.bStackWalkingInitialized ? TEXT("yes") : TEXT("no"));
-        Summary.Appendf(TEXT("interval_us: %u\n"), IntervalUs);
-        Summary.Appendf(TEXT("max_stack_depth: %u\n"), MaxStackDepth);
-        Summary.Appendf(TEXT("max_stored_samples: %u\n"), MaxStoredSamples);
-        Summary.Appendf(TEXT("sampler_ticks: %llu\n"),
-            static_cast<unsigned long long>(SamplerTicks));
-        Summary.Appendf(TEXT("capture_attempts: %llu\n"),
-            static_cast<unsigned long long>(CaptureAttempts));
-        Summary.Appendf(TEXT("registered_thread_samples: %llu\n"),
-            static_cast<unsigned long long>(RegisteredThreadSamples));
-        Summary.Appendf(TEXT("registration_race_drops: %llu\n"),
-            static_cast<unsigned long long>(RegistrationRaceDrops));
-        Summary.Appendf(TEXT("capture_failures: %llu\n"),
-            static_cast<unsigned long long>(CaptureFailures));
-        Summary.Appendf(TEXT("retained_samples: %llu\n"),
-            static_cast<unsigned long long>(StoredSampleCount));
-        Summary.Appendf(TEXT("dropped_samples_after_bound: %llu\n"),
-            static_cast<unsigned long long>(DroppedSamples));
-        Summary.Appendf(TEXT("samples_with_stack: %llu\n"),
-            static_cast<unsigned long long>(SamplesWithStack));
-        Summary.Appendf(TEXT("lod0_samples_with_stack: %llu\n"),
-            static_cast<unsigned long long>(Lod0Aggregates.SamplesWithStack));
-        Summary.Appendf(TEXT("lod1plus_samples_with_stack: %llu\n"),
-            static_cast<unsigned long long>(Lod1PlusAggregates.SamplesWithStack));
-        Summary.Appendf(TEXT("untagged_samples: %llu\n"),
-            static_cast<unsigned long long>(UntaggedSamples));
-        Summary.Appendf(TEXT("total_frames: %llu\n"),
-            static_cast<unsigned long long>(TotalFrames));
-        Summary.Appendf(TEXT("resolved_frames: %llu\n"),
-            static_cast<unsigned long long>(ResolvedFrames));
-        Summary.Appendf(TEXT("unknown_frames: %llu\n"),
-            static_cast<unsigned long long>(UnknownFrames));
-        Summary.Appendf(TEXT("wait_like_frames: %llu\n"),
-            static_cast<unsigned long long>(WaitLikeFrames));
-        Summary.Appendf(TEXT("samples_with_resolved_leaf: %llu\n"),
-            static_cast<unsigned long long>(SamplesWithResolvedLeaf));
-        Summary.Appendf(TEXT("samples_with_wait_like_frame: %llu\n"),
-            static_cast<unsigned long long>(SamplesWithWaitLikeFrame));
-        Summary.Appendf(TEXT("unique_program_counters: %llu\n"),
-            static_cast<unsigned long long>(Result.UniqueProgramCounters));
-        Summary.Appendf(TEXT("inline_symbols: %llu\n"),
-            static_cast<unsigned long long>(Result.InlineSymbols));
-        Summary.Appendf(TEXT("max_active_registered_threads: %llu\n"),
-            static_cast<unsigned long long>(MaxActiveRegisteredThreads));
-        Summary.Appendf(TEXT("run_seconds: %.6f\n"), Result.RunSeconds);
-        Summary += TEXT("\nClosure uses stable registration snapshots. Top-table percentages use retained samples with a non-empty stack; the raw CSV includes zero-depth captures.\n");
-        Summary.Appendf(TEXT("resolved_frame_fraction: %.6f\n"), TotalFrames > 0
-            ? static_cast<double>(ResolvedFrames) / static_cast<double>(TotalFrames) : 0.0);
-        Summary.Appendf(TEXT("unknown_frame_fraction: %.6f\n"), TotalFrames > 0
-            ? static_cast<double>(UnknownFrames) / static_cast<double>(TotalFrames) : 0.0);
-        Summary.Appendf(TEXT("wait_like_frame_fraction: %.6f\n"), TotalFrames > 0
-            ? static_cast<double>(WaitLikeFrames) / static_cast<double>(TotalFrames) : 0.0);
-        Summary.Appendf(TEXT("resolved_leaf_fraction: %.6f\n"), SamplesWithStack > 0
-            ? static_cast<double>(SamplesWithResolvedLeaf) / static_cast<double>(SamplesWithStack) : 0.0);
-        Summary.Appendf(TEXT("wait_like_sample_fraction: %.6f\n"), SamplesWithStack > 0
-            ? static_cast<double>(SamplesWithWaitLikeFrame) / static_cast<double>(SamplesWithStack) : 0.0);
-        Summary += TEXT("\nLabels: plugin = VoxelForge, engine = Unreal/Engine, std = std:: frames, other = other resolved modules, unknown = no function symbol. Inline symbol callbacks were requested through DbgHelp when available.\n");
-        AppendRows(Summary, TEXT("Top 30 exclusive functions (leaf)"), AllAggregates.ExclusiveFunctions, SamplesWithStack, 30);
-        AppendRows(Summary, TEXT("Top 30 inclusive functions (once per sample)"), AllAggregates.InclusiveFunctions, SamplesWithStack, 30);
-        AppendRows(Summary, TEXT("Top 30 exclusive source lines (leaf source)"), AllAggregates.ExclusiveLines, SamplesWithStack, 30);
-        Summary += TEXT("\nLOD0 tables (floor)\n");
-        AppendRows(Summary, TEXT("LOD0 top 30 exclusive functions (leaf)"), Lod0Aggregates.ExclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
-        AppendRows(Summary, TEXT("LOD0 top 30 inclusive functions (once per sample)"), Lod0Aggregates.InclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
-        AppendRows(Summary, TEXT("LOD0 top 30 exclusive source lines (leaf source)"), Lod0Aggregates.ExclusiveLines, Lod0Aggregates.SamplesWithStack, 30);
-        Summary += TEXT("\nLOD1+ tables (coarse/background)\n");
-        AppendRows(Summary, TEXT("LOD1+ top 30 exclusive functions (leaf)"), Lod1PlusAggregates.ExclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
-        AppendRows(Summary, TEXT("LOD1+ top 30 inclusive functions (once per sample)"), Lod1PlusAggregates.InclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
-        AppendRows(Summary, TEXT("LOD1+ top 30 exclusive source lines (leaf source)"), Lod1PlusAggregates.ExclusiveLines, Lod1PlusAggregates.SamplesWithStack, 30);
-
-        if (FFileHelper::SaveStringToFile(
-                Summary,
-                *SummaryPath,
-                FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
-        {
-            Result.bOutputWritten = true;
-        }
-    }
 };
 
 FVoxelStackSampler& FVoxelStackSampler::Get()
@@ -1060,8 +822,9 @@ bool FVoxelStackSampler::Start(
     Impl = NewImpl;
     GVoxelStackSamplerEnabled.store(true, std::memory_order_release);
     UE_LOG(LogTemp, Display,
-        TEXT("[VoxelStackSampler] started label=%s interval_us=%u raw=%s summary=%s"),
-        *RunLabel, NewImpl->IntervalUs, *NewImpl->RawSamplesPath, *NewImpl->SummaryPath);
+        TEXT("[VoxelStackSampler] started label=%s interval_us=%u raw=%s modules=%s summary=%s"),
+        *RunLabel, NewImpl->IntervalUs, *NewImpl->RawSamplesPath,
+        *NewImpl->ModuleMapPath, *NewImpl->SummaryPath);
     return true;
 #endif
 }
@@ -1081,16 +844,14 @@ FVoxelStackSampler::FSummary FVoxelStackSampler::StopAndWrite()
     Result = StoppedImpl->Finalize();
     UE_LOG(LogTemp, Display,
         TEXT("[VoxelStackSampler] stopped label=%s ticks=%llu registered_samples=%llu "
-             "retained=%llu dropped=%llu resolved_fraction=%.4f raw=%s summary=%s"),
+             "retained=%llu dropped=%llu raw=%s module_map=%s summary=%s"),
         *Result.RunLabel,
         static_cast<unsigned long long>(Result.SamplerTicks),
         static_cast<unsigned long long>(Result.RegisteredThreadSamples),
         static_cast<unsigned long long>(Result.RetainedSamples),
         static_cast<unsigned long long>(Result.DroppedSamples),
-        Result.TotalFrames > 0
-            ? static_cast<double>(Result.ResolvedFrames) / static_cast<double>(Result.TotalFrames)
-            : 0.0,
         *Result.RawSamplesPath,
+        *Result.ModuleMapPath,
         *Result.SummaryPath);
     delete StoppedImpl;
     Impl = nullptr;
diff --git a/Source/VoxelForge/Private/VoxelStrateManager.cpp b/Source/VoxelForge/Private/VoxelStrateManager.cpp
index ae90865..498ee91 100644
--- a/Source/VoxelForge/Private/VoxelStrateManager.cpp
+++ b/Source/VoxelForge/Private/VoxelStrateManager.cpp
@@ -12,6 +12,7 @@
 #include "VoxelStartupTrace.h"
 #include "VoxelTerrainOpDefinition.h"  // For UVoxelTerrainOpDefinition::ApplyTo
 #include "VoxelBiomeDefinition.h"  // For UVoxelBiomeDefinition (biome context flatten)
+#include "VoxelWormField.h"  // World-changing worm evaluator mode/lattice identity
 #include "HAL/IConsoleManager.h"
 #include "Misc/CommandLine.h"
 #include "Misc/Crc.h"
@@ -33,6 +34,42 @@ namespace
         GVoxelForgeFloorRound1PassageProjectionCache,
         TEXT("Reuse exact passage floor projections within one density sample; 0 disables the A/B cache."));
 
+    // This is a measurement override only. The asset-owned bEnableWorms field remains the real
+    // per-strate contract; this process-wide switch exists so the game harness can measure the
+    // cost of enabled versus disabled worms without editing an owner's asset. It is resolved once
+    // before generation params are published so workers cannot disagree mid-world.
+    int32 GVoxelForgeWormsForceOff = 0;
+    std::atomic<int32> GResolvedWormsForceOff(-1);
+    FAutoConsoleVariableRef CVarVoxelForgeWormsForceOff(
+        TEXT("voxel.WormsForceOff"),
+        GVoxelForgeWormsForceOff,
+        TEXT("WORLD-CHANGING DEVELOPMENT-ONLY measurement override. 0=asset behavior, 1=force "
+             "all worm strengths to zero. Never vary this between multiplayer peers or world "
+             "regenerations; it is not the per-strate off switch."),
+        ECVF_Default);
+
+    bool VF_WormsForceOff()
+    {
+        int32 Existing = GResolvedWormsForceOff.load(std::memory_order_acquire);
+        if (Existing >= 0)
+        {
+            return Existing != 0;
+        }
+
+        int32 CommandLineValue = GVoxelForgeWormsForceOff;
+        FParse::Value(
+            FCommandLine::Get(), TEXT("voxel.WormsForceOff="), CommandLineValue);
+        const int32 Resolved = CommandLineValue != 0 ? 1 : 0;
+        int32 Expected = -1;
+        if (!GResolvedWormsForceOff.compare_exchange_strong(
+                Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
+        {
+            return Expected != 0;
+        }
+        GVoxelForgeWormsForceOff = Resolved;
+        return Resolved != 0;
+    }
+
     struct FRuntimeRoughnessOverrides
     {
         bool bSurfaceRoughness = false;
@@ -1429,6 +1466,15 @@ bool UVoxelStrateManager::SetComposerOverrideForStrate(
     Override->CandidateSeed = CandidateSeed;
     Override->Archetype = Archetype;
     Override->Params = Params;
+    if ((VF_WormsForceOff() || !TargetSlot->Definition->bEnableWorms)
+        && (Archetype == ECaveGeneratorType::TunnelNetwork
+            || Archetype == ECaveGeneratorType::Underwater))
+    {
+        // The composer is allowed to roll a complete candidate, but a disabled asset must never
+        // retain a worm-enabled candidate in its runtime override, even for code that inspects
+        // the override before GetGenerationParams applies the final resolution gate.
+        Override->Params.TunnelNetworkParams.WormStrength = 0.0f;
+    }
     VF_SetComposerRuntimeBounds(
         Override->Params,
         (float)(TargetSlot->TopChunkZ + 1) * CHUNK_SIZE,
@@ -5474,6 +5520,19 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
 
     const FStrateSlot& Slot = StrateLayout[SlotIdx];
 
+    // This is the one final resolution gate for the asset-owned worm switch. It is deliberately
+    // applied after composer/season replacements and after boundary blending: a disabled current
+    // strate can never be re-enabled by a rolled candidate or by an enabled neighbour.
+    const auto ResolveFinalParams = [&Slot](FStrateGenerationParams Result)
+    {
+        if (VF_WormsForceOff()
+            || (Slot.Definition != nullptr && !Slot.Definition->bEnableWorms))
+        {
+            Result.WormStrength = 0.0f;
+        }
+        return VF_ApplyRuntimeRoughnessOverrides(Result);
+    };
+
 #if WITH_EDITOR
     if (const FVoxelStrateComposerSlotOverride* Override =
         FindComposerOverride(Slot.StrateIndex))
@@ -5483,7 +5542,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
         Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
         // A candidate is a hard replacement of this slot. Do not blend its rolled vector with an
         // authored neighbour at a boundary; this is also how the offline fixture measures it.
-        return VF_ApplyRuntimeRoughnessOverrides(Result);
+        return ResolveFinalParams(Result);
     }
 #endif
 
@@ -5494,7 +5553,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
         Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
         // Season vectors are already final, measured slot records. Vertical structural posts own
         // their boundary; blending them with another selected recipe would describe neither one.
-        return VF_ApplyRuntimeRoughnessOverrides(Result);
+        return ResolveFinalParams(Result);
     }
 
     FStrateGenerationParams BaseParams = BuildParamsFromDefinition(Slot.Definition);
@@ -5589,7 +5648,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
                 float Alpha = 1.0f - ((float)DistFromBottom / (float)EffectiveBlend);
                 Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
 
-                return VF_ApplyRuntimeRoughnessOverrides(
+                return ResolveFinalParams(
                     FStrateGenerationParams::Lerp(BaseParams, BelowParams, Alpha));
             }
             break;
@@ -5643,7 +5702,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
                 // Only blend if alpha > 0 (we're inside the warped transition zone)
                 if (Alpha > 0.0f)
                 {
-                    return VF_ApplyRuntimeRoughnessOverrides(
+                    return ResolveFinalParams(
                         FStrateGenerationParams::Lerp(BaseParams, BelowParams, Alpha));
                 }
             }
@@ -5685,7 +5744,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
                 float Alpha = 1.0f - ((float)DistFromTop / (float)EffectiveBlend);
                 Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
 
-                return VF_ApplyRuntimeRoughnessOverrides(
+                return ResolveFinalParams(
                     FStrateGenerationParams::Lerp(BaseParams, AboveParams, Alpha));
             }
             break;
@@ -5715,7 +5774,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
 
                 if (Alpha > 0.0f)
                 {
-                    return VF_ApplyRuntimeRoughnessOverrides(
+                    return ResolveFinalParams(
                         FStrateGenerationParams::Lerp(BaseParams, AboveParams, Alpha));
                 }
             }
@@ -5725,7 +5784,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
     }
 
     // Not near any boundary (or Hard transition) — use this strate's params directly
-    return VF_ApplyRuntimeRoughnessOverrides(BaseParams);
+    return ResolveFinalParams(BaseParams);
 }
 
 //=============================================================================
@@ -5745,8 +5804,15 @@ FStrateGenerationParams UVoxelStrateManager::BuildParamsFromDefinition(const UVo
 {
     if (!Definition) return FStrateGenerationParams();
 
-    // Base params only — terrain op fields stay 0 until per-room assignment.
-    return Definition->GenerationParams;
+    // Base params only — terrain op fields stay 0 until per-room assignment. Resolve the asset
+    // switch here as well as at the final return so a disabled neighbour cannot leak worm strength
+    // back through a boundary blend.
+    FStrateGenerationParams Result = Definition->GenerationParams;
+    if (VF_WormsForceOff() || !Definition->bEnableWorms)
+    {
+        Result.WormStrength = 0.0f;
+    }
+    return Result;
 }
 
 uint64 UVoxelStrateManager::GetGenerationParamsFingerprint() const
@@ -5817,6 +5883,13 @@ uint64 UVoxelStrateManager::GetGenerationParamsFingerprint() const
         HashValue(Slot.HeightInChunks);
         HashValue(Slot.Definition->GeneratorType);
         HashValue(Slot.Definition->bUseOperatorStack);
+        HashValue(Slot.Definition->bEnableWorms);
+        HashValue(VF_WormsForceOff());
+        // The selected evaluator is a world input even though it is deliberately not part of
+        // FStrateGenerationParams (the fixed 83-field memo key). Keep persistent/verdict keys
+        // from crossing an explicit WormNoiseMode/WormLatticeStep experiment.
+        HashValue(VoxelWormField::GetNoiseMode());
+        HashValue(VoxelWormField::GetLatticeStep());
         HashValue(Slot.Definition->StrateHeightInChunks);
         HashValue(Slot.Definition->TransitionType);
         HashValue(Slot.Definition->TransitionBlendChunks);
diff --git a/Source/VoxelForge/Private/VoxelWormField.cpp b/Source/VoxelForge/Private/VoxelWormField.cpp
new file mode 100644
index 0000000..1fbfb99
--- /dev/null
+++ b/Source/VoxelForge/Private/VoxelWormField.cpp
@@ -0,0 +1,471 @@
+// VoxelWormField.cpp
+// Shared deterministic worm-field evaluation and the measured lattice experiment.
+
+#include "VoxelWormField.h"
+
+#include "VoxelCaveMorphology.h" // VoxelHash::SeedOffset
+#include "VoxelGenerator.h"       // per-worker canonical tile window
+#include "VoxelNoise.h"
+#include "VoxelTypes.h"           // VOXEL_NOISE_SCALE
+
+#include "HAL/IConsoleManager.h"
+#include "Misc/CommandLine.h"
+#include "Misc/Parse.h"
+
+#include <atomic>
+#include <cfloat>
+#include <cstring>
+
+namespace
+{
+    // The selected production mode is resolved once, before a generation stack is allowed to
+    // observe it, so all workers in a process use one world definition. Mode 0 remains the exact
+    // legacy control for measurements and compatibility investigations.
+    int32 GVoxelForgeWormLatticeStep = 0;
+    std::atomic<int32> GResolvedWormLatticeStep(-1);
+    int32 GVoxelForgeWormNoiseMode = 1;
+    std::atomic<int32> GResolvedWormNoiseMode(-1);
+
+    // The value field has the same threshold/strength contract as legacy Perlin.  This small
+    // amplitude retune keeps the authored TunnelNetwork player-fit margin after replacing the
+    // gradient evaluation with the cheaper scalar hash.  It is a code default, not a CVar, so a
+    // client cannot silently choose a different world.
+    constexpr float CheapWormNoiseAmplitude = 1.0f;
+
+    FAutoConsoleVariableRef CVarVoxelForgeWormLatticeStep(
+        TEXT("voxel.WormLatticeStep"),
+        GVoxelForgeWormLatticeStep,
+        TEXT("WORLD-CHANGING development experiment. 0=exact, 2/4=coarse worm lattice with "
+             "trilinear interpolation. All multiplayer peers and regenerated worlds must use "
+             "the same value. Default 0 until measured."),
+        ECVF_Default);
+
+    FAutoConsoleVariableRef CVarVoxelForgeWormNoiseMode(
+        TEXT("voxel.WormNoiseMode"),
+        GVoxelForgeWormNoiseMode,
+        TEXT("WORLD-CHANGING development experiment. 0=legacy gradient Perlin, 1=cheap "
+             "deterministic value-noise worm fields. All multiplayer peers and regenerated "
+             "worlds must use the same value. Default 1 (the measured production mode)."),
+        ECVF_Default);
+
+    int32 ResolveLatticeStep()
+    {
+        int32 Existing = GResolvedWormLatticeStep.load(std::memory_order_acquire);
+        if (Existing >= 0)
+        {
+            return Existing;
+        }
+
+        int32 CommandLineValue = GVoxelForgeWormLatticeStep;
+        FParse::Value(
+            FCommandLine::Get(), TEXT("voxel.WormLatticeStep="), CommandLineValue);
+        const int32 Resolved = CommandLineValue == 2 || CommandLineValue == 4
+            ? CommandLineValue : 0;
+        int32 Expected = -1;
+        if (!GResolvedWormLatticeStep.compare_exchange_strong(
+                Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
+        {
+            return Expected;
+        }
+        GVoxelForgeWormLatticeStep = Resolved;
+        return Resolved;
+    }
+
+    int32 ResolveNoiseMode()
+    {
+        int32 Existing = GResolvedWormNoiseMode.load(std::memory_order_acquire);
+        if (Existing >= 0)
+        {
+            return Existing;
+        }
+
+        int32 CommandLineValue = GVoxelForgeWormNoiseMode;
+        FParse::Value(
+            FCommandLine::Get(), TEXT("voxel.WormNoiseMode="), CommandLineValue);
+        const int32 Resolved = CommandLineValue == 1 ? 1 : 0;
+        int32 Expected = -1;
+        if (!GResolvedWormNoiseMode.compare_exchange_strong(
+                Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
+        {
+            return Expected;
+        }
+        GVoxelForgeWormNoiseMode = Resolved;
+        return Resolved;
+    }
+
+    FORCEINLINE FVector3f MakeWormNoiseBase(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        const VoxelWormField::FParameters& Parameters)
+    {
+        const float EffectiveZ = (Parameters.VerticalScale != 1.0f
+                                  && Parameters.VerticalScale > 0.0f)
+            ? WorldZ / Parameters.VerticalScale : WorldZ;
+        const float WormZFrequency = Parameters.Frequency * Parameters.HorizontalBias;
+        return FVector3f(
+            WorldX * Parameters.Frequency
+                + VoxelHash::SeedOffset(Parameters.Seed, 1.0f),
+            WorldY * Parameters.Frequency
+                + VoxelHash::SeedOffset(Parameters.Seed, 1.7f),
+            EffectiveZ * WormZFrequency
+                + VoxelHash::SeedOffset(Parameters.Seed, 2.3f));
+    }
+
+    FORCEINLINE float EvaluateN1Field(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        const VoxelWormField::FParameters& Parameters,
+        int32 NoiseMode,
+        float NoiseScale)
+    {
+        const FVector3f NoiseBase = MakeWormNoiseBase(
+            WorldX, WorldY, WorldZ, Parameters);
+        return FMath::Abs(
+            (NoiseMode == 0
+                ? VoxelNoise::Perlin3D(NoiseBase)
+                : VoxelNoise::ValueNoise3D(NoiseBase, Parameters.Seed, 0x4D3A2F19u))
+            * NoiseScale);
+    }
+
+    FORCEINLINE float EvaluateN2Field(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        const VoxelWormField::FParameters& Parameters,
+        int32 NoiseMode,
+        float NoiseScale)
+    {
+        const FVector3f NoiseBase = MakeWormNoiseBase(
+            WorldX, WorldY, WorldZ, Parameters);
+        const FVector3f N2Position = NoiseBase + FVector3f(137.0f, 259.0f, 431.0f);
+        return FMath::Abs(
+            (NoiseMode == 0
+                ? VoxelNoise::Perlin3D(N2Position)
+                : VoxelNoise::ValueNoise3D(N2Position, Parameters.Seed, 0xA7C15E2Du))
+            * NoiseScale);
+    }
+
+    FORCEINLINE float EvaluateExactField(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        float Threshold,
+        const VoxelWormField::FParameters& Parameters)
+    {
+        const int32 NoiseMode = ResolveNoiseMode();
+        const float NoiseScale = VOXEL_NOISE_SCALE
+            * (NoiseMode == 1 ? CheapWormNoiseAmplitude : 1.0f);
+        const float N1 = EvaluateN1Field(
+            WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
+
+        // N2 is non-negative, so this preserves the old exact evaluator's short-circuit.
+        if (N1 >= Threshold)
+        {
+            return N1;
+        }
+        return N1 + EvaluateN2Field(
+            WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
+    }
+
+    struct FLatticeNode
+    {
+        int32 X = 0;
+        int32 Y = 0;
+        int32 Z = 0;
+        float Value = 0.0f;
+        bool bValid = false;
+    };
+
+    // The shared density grid is traversed z/y/x. Retaining two adjacent lattice planes is
+    // necessary for the z transition; 2048 entries evicted the previous plane and made the
+    // experiment slower than exact evaluation.  This is fixed storage, not a heap allocation, and
+    // remains deterministic on every worker.
+    constexpr uint32 LatticeCacheSize = 32768;
+    static_assert((LatticeCacheSize & (LatticeCacheSize - 1u)) == 0,
+        "The lattice cache size must remain a power of two for the mask lookup.");
+    constexpr int32 TileLatticeAxis = 32;
+    static_assert(static_cast<uint32>(TileLatticeAxis * TileLatticeAxis * TileLatticeAxis)
+                      == LatticeCacheSize,
+        "The direct tile lattice must use the fixed cache storage exactly.");
+
+    struct FLatticeCache
+    {
+        uint32 Seed = 0;
+        uint32 FrequencyBits = 0;
+        uint32 HorizontalBiasBits = 0;
+        uint32 VerticalScaleBits = 0;
+        int32 Step = 0;
+        bool bUseTileWindow = false;
+        FIntVector TileBaseGrid = FIntVector::ZeroValue;
+        int32 TileSampleStep = 0;
+        int32 TileCellsPerAxis = 0;
+        bool bContextValid = false;
+        FLatticeNode Nodes[LatticeCacheSize];
+
+        void SetContext(
+            const VoxelWormField::FParameters& Parameters,
+            int32 InStep,
+            bool InUseTileWindow,
+            const FIntVector& InTileOrigin,
+            int32 InTileSampleStep,
+            int32 InTileCellsPerAxis)
+        {
+            uint32 FrequencyBitsIn = 0;
+            uint32 HorizontalBiasBitsIn = 0;
+            uint32 VerticalScaleBitsIn = 0;
+            FMemory::Memcpy(&FrequencyBitsIn, &Parameters.Frequency, sizeof(uint32));
+            FMemory::Memcpy(&HorizontalBiasBitsIn, &Parameters.HorizontalBias, sizeof(uint32));
+            FMemory::Memcpy(&VerticalScaleBitsIn, &Parameters.VerticalScale, sizeof(uint32));
+            const double WormStepD = static_cast<double>(InStep);
+            const FIntVector InTileBaseGrid(
+                FMath::FloorToInt(static_cast<double>(InTileOrigin.X) / WormStepD) - 2,
+                FMath::FloorToInt(static_cast<double>(InTileOrigin.Y) / WormStepD) - 2,
+                FMath::FloorToInt(static_cast<double>(InTileOrigin.Z) / WormStepD) - 2);
+            if (bContextValid
+                && Seed == Parameters.Seed
+                && FrequencyBits == FrequencyBitsIn
+                && HorizontalBiasBits == HorizontalBiasBitsIn
+                && VerticalScaleBits == VerticalScaleBitsIn
+                && Step == InStep
+                && bUseTileWindow == InUseTileWindow
+                && TileBaseGrid == InTileBaseGrid
+                && TileSampleStep == InTileSampleStep
+                && TileCellsPerAxis == InTileCellsPerAxis)
+            {
+                return;
+            }
+
+            Seed = Parameters.Seed;
+            FrequencyBits = FrequencyBitsIn;
+            HorizontalBiasBits = HorizontalBiasBitsIn;
+            VerticalScaleBits = VerticalScaleBitsIn;
+            Step = InStep;
+            bUseTileWindow = InUseTileWindow;
+            TileBaseGrid = InTileBaseGrid;
+            TileSampleStep = InTileSampleStep;
+            TileCellsPerAxis = InTileCellsPerAxis;
+            bContextValid = true;
+            for (FLatticeNode& Node : Nodes)
+            {
+                Node.bValid = false;
+            }
+        }
+
+        static uint32 Hash(int32 X, int32 Y, int32 Z)
+        {
+            uint32 H = static_cast<uint32>(X) * 0x9E3779B1u;
+            H ^= static_cast<uint32>(Y) * 0x85EBCA77u;
+            H ^= static_cast<uint32>(Z) * 0xC2B2AE3Du;
+            H ^= H >> 16;
+            H *= 0x7FEB352Du;
+            H ^= H >> 15;
+            return H;
+        }
+
+        float Get(int32 X, int32 Y, int32 Z,
+                  const VoxelWormField::FParameters& Parameters,
+                  int32 NoiseMode,
+                  float NoiseScale)
+        {
+            const auto EvaluateNode = [this, &Parameters, NoiseMode, NoiseScale](FLatticeNode& Node,
+                                                            int32 NodeX, int32 NodeY,
+                                                            int32 NodeZ) -> float
+            {
+                if (Node.bValid && Node.X == NodeX && Node.Y == NodeY && Node.Z == NodeZ)
+                {
+                    return Node.Value;
+                }
+                Node.X = NodeX;
+                Node.Y = NodeY;
+                Node.Z = NodeZ;
+                const double StepD = static_cast<double>(Step);
+                const float WorldX = static_cast<float>(static_cast<double>(NodeX) * StepD);
+                const float WorldY = static_cast<float>(static_cast<double>(NodeY) * StepD);
+                const float WorldZ = static_cast<float>(static_cast<double>(NodeZ) * StepD);
+                // The lattice stores N1 only. The requested voxel uses this interpolated N1 for
+                // the threshold decision; N2 remains an exact point query only in the carve
+                // region. This removes the first noise call on the hot above-threshold majority
+                // without making the second noise unconditional.
+                Node.Value = EvaluateN1Field(
+                    WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
+                Node.bValid = true;
+                return Node.Value;
+            };
+
+            if (bUseTileWindow)
+            {
+                const int32 LocalX = X - TileBaseGrid.X;
+                const int32 LocalY = Y - TileBaseGrid.Y;
+                const int32 LocalZ = Z - TileBaseGrid.Z;
+                if (LocalX >= 0 && LocalX < TileLatticeAxis
+                    && LocalY >= 0 && LocalY < TileLatticeAxis
+                    && LocalZ >= 0 && LocalZ < TileLatticeAxis)
+                {
+                    FLatticeNode& Node = Nodes[
+                        (LocalZ * TileLatticeAxis + LocalY) * TileLatticeAxis + LocalX];
+                    return EvaluateNode(Node, X, Y, Z);
+                }
+
+                // A malformed or unusually large tile window must not alter the field's finite
+                // fallback semantics. It is outside the fixed direct table, so evaluate N1 once
+                // for this sample rather than attempting an unbounded allocation.
+                const double StepD = static_cast<double>(Step);
+                return EvaluateN1Field(
+                    static_cast<float>(static_cast<double>(X) * StepD),
+                    static_cast<float>(static_cast<double>(Y) * StepD),
+                    static_cast<float>(static_cast<double>(Z) * StepD),
+                    Parameters, NoiseMode, NoiseScale);
+            }
+
+            const uint32 Start = Hash(X, Y, Z) & (LatticeCacheSize - 1u);
+            for (uint32 Probe = 0; Probe < LatticeCacheSize; ++Probe)
+            {
+                FLatticeNode& Node = Nodes[(Start + Probe) & (LatticeCacheSize - 1u)];
+                if (Node.bValid)
+                {
+                    if (Node.X == X && Node.Y == Y && Node.Z == Z)
+                    {
+                        return Node.Value;
+                    }
+                    continue;
+                }
+
+                Node.X = X;
+                Node.Y = Y;
+                Node.Z = Z;
+                return EvaluateNode(Node, X, Y, Z);
+            }
+
+            // A saturated cache is exceptionally unlikely for one density block. Falling back to
+            // a direct N1 evaluation keeps the result bounded if a caller exceeds it.
+            const double StepD = static_cast<double>(Step);
+            return EvaluateN1Field(
+                static_cast<float>(static_cast<double>(X) * StepD),
+                static_cast<float>(static_cast<double>(Y) * StepD),
+                static_cast<float>(static_cast<double>(Z) * StepD),
+                Parameters, NoiseMode, NoiseScale);
+        }
+    };
+
+    thread_local FLatticeCache GLatticeCache;
+
+    FORCEINLINE bool CanUseLattice(float WorldX, float WorldY, float WorldZ, int32 Step)
+    {
+        if (Step <= 1 || !FMath::IsFinite(WorldX) || !FMath::IsFinite(WorldY)
+            || !FMath::IsFinite(WorldZ))
+        {
+            return false;
+        }
+
+        // The integer grid indices must survive the conversion back to a finite float world
+        // coordinate. Normal VoxelForge worlds are far inside this envelope; pathological input
+        // takes the exact path rather than changing overflow behaviour.
+        constexpr double MaxGridCoordinate = 1000000000.0;
+        return FMath::Abs(static_cast<double>(WorldX) / static_cast<double>(Step))
+                   <= MaxGridCoordinate
+            && FMath::Abs(static_cast<double>(WorldY) / static_cast<double>(Step))
+                   <= MaxGridCoordinate
+            && FMath::Abs(static_cast<double>(WorldZ) / static_cast<double>(Step))
+                   <= MaxGridCoordinate;
+    }
+
+    FORCEINLINE float Lerp(float A, float B, float Alpha)
+    {
+        return A + (B - A) * Alpha;
+    }
+
+    float EvaluateLattice(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        const VoxelWormField::FParameters& Parameters,
+        int32 Step,
+        float NoiseScale)
+    {
+        const int32 NoiseMode = ResolveNoiseMode();
+        const bool bUseTileWindow = VoxelGenLOD::TileCellsPerAxis > 0
+            && VoxelGenLOD::TileCellsPerAxis <= CHUNK_SIZE
+            && VoxelGenLOD::SampleStep > 0;
+        GLatticeCache.SetContext(
+            Parameters,
+            Step,
+            bUseTileWindow,
+            VoxelGenLOD::TileOriginVoxels,
+            VoxelGenLOD::SampleStep,
+            VoxelGenLOD::TileCellsPerAxis);
+
+        const double StepD = static_cast<double>(Step);
+        const double GX = static_cast<double>(WorldX) / StepD;
+        const double GY = static_cast<double>(WorldY) / StepD;
+        const double GZ = static_cast<double>(WorldZ) / StepD;
+        const int32 X0 = FMath::FloorToInt(GX);
+        const int32 Y0 = FMath::FloorToInt(GY);
+        const int32 Z0 = FMath::FloorToInt(GZ);
+        const float Tx = static_cast<float>(GX - static_cast<double>(X0));
+        const float Ty = static_cast<float>(GY - static_cast<double>(Y0));
+        const float Tz = static_cast<float>(GZ - static_cast<double>(Z0));
+
+        const float V000 = GLatticeCache.Get(X0, Y0, Z0, Parameters, NoiseMode, NoiseScale);
+        const float V100 = GLatticeCache.Get(X0 + 1, Y0, Z0, Parameters, NoiseMode, NoiseScale);
+        const float V010 = GLatticeCache.Get(X0, Y0 + 1, Z0, Parameters, NoiseMode, NoiseScale);
+        const float V110 = GLatticeCache.Get(X0 + 1, Y0 + 1, Z0, Parameters, NoiseMode, NoiseScale);
+        const float V001 = GLatticeCache.Get(X0, Y0, Z0 + 1, Parameters, NoiseMode, NoiseScale);
+        const float V101 = GLatticeCache.Get(X0 + 1, Y0, Z0 + 1, Parameters, NoiseMode, NoiseScale);
+        const float V011 = GLatticeCache.Get(X0, Y0 + 1, Z0 + 1, Parameters, NoiseMode, NoiseScale);
+        const float V111 = GLatticeCache.Get(X0 + 1, Y0 + 1, Z0 + 1, Parameters, NoiseMode, NoiseScale);
+
+        const float X00 = Lerp(V000, V100, Tx);
+        const float X10 = Lerp(V010, V110, Tx);
+        const float X01 = Lerp(V001, V101, Tx);
+        const float X11 = Lerp(V011, V111, Tx);
+        return Lerp(Lerp(X00, X10, Ty), Lerp(X01, X11, Ty), Tz);
+    }
+}
+
+namespace VoxelWormField
+{
+    int32 GetLatticeStep()
+    {
+        return ResolveLatticeStep();
+    }
+
+    int32 GetNoiseMode()
+    {
+        return ResolveNoiseMode();
+    }
+
+    float EvaluateExact(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        float Threshold,
+        const FParameters& Parameters)
+    {
+        return EvaluateExactField(WorldX, WorldY, WorldZ, Threshold, Parameters);
+    }
+
+    float Evaluate(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        float Threshold,
+        const FParameters& Parameters,
+        int32 LatticeStep)
+    {
+        const int32 NoiseMode = ResolveNoiseMode();
+        const bool bUseLattice = CanUseLattice(WorldX, WorldY, WorldZ, LatticeStep);
+        const float NoiseScale = VOXEL_NOISE_SCALE
+            * (NoiseMode == 1 ? CheapWormNoiseAmplitude : 1.0f);
+        const float N1 = bUseLattice
+            ? EvaluateLattice(WorldX, WorldY, WorldZ, Parameters, LatticeStep, NoiseScale)
+            : EvaluateN1Field(WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
+        if (N1 >= Threshold)
+        {
+            return N1;
+        }
+        return N1 + EvaluateN2Field(
+            WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
+    }
+}
diff --git a/Source/VoxelForge/Public/VoxelGenerator.h b/Source/VoxelForge/Public/VoxelGenerator.h
index cd5a0c4..0aa1219 100644
--- a/Source/VoxelForge/Public/VoxelGenerator.h
+++ b/Source/VoxelForge/Public/VoxelGenerator.h
@@ -66,6 +66,8 @@ namespace VoxelGenLOD
     VOXELFORGE_API bool IsTileCacheWindowEnabled(bool bFusedPath = true);
     VOXELFORGE_API bool GetThreadTileCacheWindow(
         FIntVector& OutOriginVoxels, int32& OutStep, int32& OutCellsPerAxis);
+    VOXELFORGE_API void SetThreadTileContext(
+        const FIntVector& OriginVoxels, int32 CellsPerAxis);
 
     // Effective octave count for a per-voxel noise call site.
     // At least 1 octave always survives (the coarse base shape).
diff --git a/Source/VoxelForge/Public/VoxelNoise.h b/Source/VoxelForge/Public/VoxelNoise.h
index ecaaa3a..b75ff0d 100644
--- a/Source/VoxelForge/Public/VoxelNoise.h
+++ b/Source/VoxelForge/Public/VoxelNoise.h
@@ -142,6 +142,56 @@ FORCEINLINE float Perlin3D(const FVector3f& P)
     return Perlin3D(P.X, P.Y, P.Z);
 }
 
+// A smooth, deterministic value-noise sample for the worm-only cost experiment. It keeps the
+// same unit lattice and quintic interpolation as Perlin3D, but uses one seeded scalar hash per
+// corner instead of the eight gradient selections and dot products. It is intentionally not used
+// by the terrain's other noise fields; WormNoiseMode gates it as an explicit world-changing test.
+FORCEINLINE uint32 ValueNoiseHash(int32 X, int32 Y, int32 Z, uint32 Seed, uint32 Salt)
+{
+    uint32 H = Detail::HashCorner(X, Y, Z) ^ Seed ^ Salt;
+    H ^= H >> 16;
+    H *= 0x7FEB352Du;
+    H ^= H >> 15;
+    return H;
+}
+
+FORCEINLINE float ValueNoise3D(const FVector3f& P, uint32 Seed, uint32 Salt)
+{
+    const float XFloor = FMath::FloorToFloat(P.X);
+    const float YFloor = FMath::FloorToFloat(P.Y);
+    const float ZFloor = FMath::FloorToFloat(P.Z);
+    const int32 X = static_cast<int32>(XFloor);
+    const int32 Y = static_cast<int32>(YFloor);
+    const int32 Z = static_cast<int32>(ZFloor);
+    const float Fx = P.X - XFloor;
+    const float Fy = P.Y - YFloor;
+    const float Fz = P.Z - ZFloor;
+    const float Sx = Detail::Fade(Fx);
+    const float Sy = Detail::Fade(Fy);
+    const float Sz = Detail::Fade(Fz);
+    constexpr float HashToSigned = 2.0f / 16777216.0f;
+    const auto Sample = [Seed, Salt, HashToSigned](int32 IX, int32 IY, int32 IZ) -> float
+    {
+        return static_cast<float>(ValueNoiseHash(IX, IY, IZ, Seed, Salt) & 0x00FFFFFFu)
+            * HashToSigned - 1.0f;
+    };
+    const float V000 = Sample(X, Y, Z);
+    const float V100 = Sample(X + 1, Y, Z);
+    const float V010 = Sample(X, Y + 1, Z);
+    const float V110 = Sample(X + 1, Y + 1, Z);
+    const float V001 = Sample(X, Y, Z + 1);
+    const float V101 = Sample(X + 1, Y, Z + 1);
+    const float V011 = Sample(X, Y + 1, Z + 1);
+    const float V111 = Sample(X + 1, Y + 1, Z + 1);
+    const float X00 = Detail::Lerp(V000, V100, Sx);
+    const float X10 = Detail::Lerp(V010, V110, Sx);
+    const float X01 = Detail::Lerp(V001, V101, Sx);
+    const float X11 = Detail::Lerp(V011, V111, Sx);
+    const float Y0 = Detail::Lerp(X00, X10, Sy);
+    const float Y1 = Detail::Lerp(X01, X11, Sy);
+    return Detail::Lerp(Y0, Y1, Sz);
+}
+
 //=============================================================================
 // LIPSCHITZ BOUND FOR THE ACTUAL 3D FIELD
 //=============================================================================
diff --git a/Source/VoxelForge/Public/VoxelStackSampler.h b/Source/VoxelForge/Public/VoxelStackSampler.h
index 621e561..c6dfe5b 100644
--- a/Source/VoxelForge/Public/VoxelStackSampler.h
+++ b/Source/VoxelForge/Public/VoxelStackSampler.h
@@ -34,6 +34,7 @@ public:
         bool bSupported = false;
         bool bStarted = false;
         bool bOutputWritten = false;
+        bool bModuleMapWritten = false;
         bool bStackWalkingInitialized = false;
         uint32 IntervalUs = 0;
         uint32 MaxDepth = 0;
@@ -47,6 +48,8 @@ public:
         uint64 RetainedSamples = 0;
         uint64 DroppedSamples = 0;
         uint64 TotalFrames = 0;
+        // Kept for source compatibility with the earlier in-process summary.  Raw sessions leave
+        // these zero; the offline summary owns all resolved-frame counts and tables.
         uint64 ResolvedFrames = 0;
         uint64 UnknownFrames = 0;
         uint64 WaitLikeFrames = 0;
@@ -55,10 +58,12 @@ public:
         uint64 UniqueProgramCounters = 0;
         uint64 InlineSymbols = 0;
         uint64 MaxActiveRegisteredThreads = 0;
+        uint64 ModuleCount = 0;
         double RunSeconds = 0.0;
 
         FString RunLabel;
         FString RawSamplesPath;
+        FString ModuleMapPath;
         FString SummaryPath;
     };
 
diff --git a/Source/VoxelForge/Public/VoxelStrateDefinition.h b/Source/VoxelForge/Public/VoxelStrateDefinition.h
index d638ea7..69d18a2 100644
--- a/Source/VoxelForge/Public/VoxelStrateDefinition.h
+++ b/Source/VoxelForge/Public/VoxelStrateDefinition.h
@@ -136,6 +136,15 @@ public:
         meta = (DisplayName = "Use Operator Stack (experimental)"))
     bool bUseOperatorStack = false;
 
+    /**
+     * Authoritative per-strate worm switch. Existing assets default to enabled. The manager
+     * resolves a disabled strate to WormStrength == 0 before any fused, stack, composer, or
+     * interval path sees its parameters, so this is a geometry switch rather than a local CVar.
+     */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Generation",
+        meta = (DisplayName = "Enable Worms"))
+    bool bEnableWorms = true;
+
     //=========================================================================
     // TUNNEL NETWORK PARAMS (shown only for TunnelNetwork generator type)
     //=========================================================================
diff --git a/Source/VoxelForge/Public/VoxelWormField.h b/Source/VoxelForge/Public/VoxelWormField.h
new file mode 100644
index 0000000..b2e23cf
--- /dev/null
+++ b/Source/VoxelForge/Public/VoxelWormField.h
@@ -0,0 +1,45 @@
+// VoxelWormField.h
+// Shared deterministic evaluation for the TunnelNetwork worm field.
+
+#pragma once
+
+#include "CoreMinimal.h"
+
+namespace VoxelWormField
+{
+    /** The scalar inputs used by both the fused and operator-stack evaluators. */
+    struct FParameters
+    {
+        float Frequency = 0.0f;
+        float HorizontalBias = 0.0f;
+        float VerticalScale = 1.0f;
+        uint32 Seed = 0;
+    };
+
+    /**
+     * Return the selected development experiment mode.
+     *
+     * 0 is the exact field.  2 and 4 evaluate the exact field on that many-voxel lattice and
+     * trilinearly interpolate it.  This is intentionally a WORLD-CHANGING development switch:
+     * it must not be changed between multiplayer peers or for an already generated world.
+     */
+    VOXELFORGE_API int32 GetLatticeStep();
+    VOXELFORGE_API int32 GetNoiseMode();
+
+    /** Evaluate the exact two-noise field, retaining the N1 threshold short-circuit. */
+    VOXELFORGE_API float EvaluateExact(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        float Threshold,
+        const FParameters& Parameters);
+
+    /** Evaluate the exact field or its selected cached lattice approximation. */
+    VOXELFORGE_API float Evaluate(
+        float WorldX,
+        float WorldY,
+        float WorldZ,
+        float Threshold,
+        const FParameters& Parameters,
+        int32 LatticeStep);
+}
diff --git a/Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp b/Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp
index af28123..28383f2 100644
--- a/Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp
+++ b/Source/VoxelForgeEditor/Private/VoxelForgeExploreCommandlet.cpp
@@ -1,4 +1,5 @@
 #include "VoxelForgeExploreCommandlet.h"
+#include "VoxelStackOfflineSymbolizer.h"
 
 #include "CoreMinimal.h"
 #include "Async/ParallelFor.h"
@@ -32,6 +33,7 @@
 #include "VoxelGenerator.h"
 #include "VoxelMarchingCubesMesher.h"
 #include "VoxelNoise.h"
+#include "VoxelWormField.h"
 #include "VoxelSettings.h"
 #include "VoxelStackSampler.h"
 #include "VoxelStrateDefinition.h"
@@ -265,6 +267,10 @@ struct FExploreArguments
     bool bWalk = true;
     bool bExport = true;
     bool bUseOperatorStack = true;
+    bool bWormsEnabledOverride = false;
+    bool bWormsEnabled = true;
+    bool bWormStrengthOverride = false;
+    float WormStrength = 0.0f;
     bool bProfileDensity = false;
     bool bProfileDensityFull = false;
     bool bPerfAttribution = false;
@@ -364,6 +370,17 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
     int32 UseOperatorStack = 1;
     FParse::Value(*Params, TEXT("opstack="), UseOperatorStack);
     OutArguments.bUseOperatorStack = UseOperatorStack != 0;
+    int32 WormsEnabled = 1;
+    if (FParse::Value(*Params, TEXT("wormsenabled="), WormsEnabled))
+    {
+        OutArguments.bWormsEnabledOverride = true;
+        OutArguments.bWormsEnabled = WormsEnabled != 0;
+    }
+    if (Params.Contains(TEXT("wormstrength="), ESearchCase::IgnoreCase)
+        && FParse::Value(*Params, TEXT("wormstrength="), OutArguments.WormStrength))
+    {
+        OutArguments.bWormStrengthOverride = true;
+    }
     OutArguments.bProfileDensity = FParse::Param(*Params, TEXT("profiledensity"));
     OutArguments.bProfileDensityFull = FParse::Param(*Params, TEXT("profiledensityfull"));
     OutArguments.bProfileDensity |= OutArguments.bProfileDensityFull;
@@ -881,6 +898,10 @@ struct FExploreWorld
     int32 ExploreMeshSize = 0;
     int32 ExploreMeshTileCount = 0;
     int32 ExploreMeshTilesCompleted = 0;
+    // Per-tile geometry identity is retained in canonical Z/Y/X order so an optimization can be
+    // compared without treating one aggregate hash or triangle total as a shape measurement.
+    TArray<int32> ExploreTileTriangleCounts;
+    TArray<FString> ExploreTileGeometryHashes;
     double ExploreMeshSeconds = 0.0;
     // Exact wall-clock partition of ExploreMeshSeconds.  The first three fields end at the
     // parallel tile launch; merge closes the mesh clock.  Remainder is intentionally retained
@@ -966,6 +987,16 @@ struct FExploreWorld
             // Explicitly select the production switch so the same synthetic layout, seed and
             // mesher invocation can be measured through both density branches.
             Definition->bUseOperatorStack = Arguments.bUseOperatorStack;
+            if (Arguments.bWormsEnabledOverride)
+            {
+                Definition->bEnableWorms = Arguments.bWormsEnabled;
+            }
+            if (Arguments.bWormStrengthOverride
+                && (Definition->GeneratorType == ECaveGeneratorType::TunnelNetwork
+                    || Definition->GeneratorType == ECaveGeneratorType::Underwater))
+            {
+                Definition->GenerationParams.WormStrength = Arguments.WormStrength;
+            }
 
             const TSoftObjectPtr<UVoxelStrateDefinition> SoftDefinition(Definition);
             Settings->FixedStrates.Add(Index, SoftDefinition);
@@ -1702,6 +1733,8 @@ bool EnsureExploreMesh(
     const int32 TilesPerAxis = Arguments.ExportSize / CHUNK_SIZE;
     World.ExploreMeshTileCount = TilesPerAxis * TilesPerAxis * TilesPerAxis;
     World.ExploreMeshTilesCompleted = 0;
+    World.ExploreTileTriangleCounts.Init(0, World.ExploreMeshTileCount);
+    World.ExploreTileGeometryHashes.SetNum(World.ExploreMeshTileCount);
     World.ExploreMeshOrigin = ChooseExploreMeshOrigin(
         Arguments,
         CameraSeedWalk,
@@ -1812,6 +1845,15 @@ bool EnsureExploreMesh(
                 const int32 OwnerX = LinearOwnerIndex % GridTileCount;
                 const int32 OwnerY = (LinearOwnerIndex / GridTileCount) % GridTileCount;
                 const int32 OwnerZ = LinearOwnerIndex / (GridTileCount * GridTileCount);
+                FIntVector PreviousTileOrigin = FIntVector::ZeroValue;
+                int32 IgnoredPreviousTileStep = 1;
+                int32 PreviousTileCells = 0;
+                VoxelGenLOD::GetThreadTileCacheWindow(
+                    PreviousTileOrigin, IgnoredPreviousTileStep, PreviousTileCells);
+                VoxelGenLOD::SetThreadTileContext(
+                    World.ExploreMeshOrigin
+                        + FIntVector(OwnerX * CHUNK_SIZE, OwnerY * CHUNK_SIZE, OwnerZ * CHUNK_SIZE),
+                    CellsPerTile);
                 // Partition the shared lattice into disjoint rectangular owner regions.  A
                 // boundary sample belongs to exactly one owner; tile windows may read it from
                 // either side.  This keeps the generator's spatial locality while guaranteeing
@@ -1849,6 +1891,7 @@ bool EnsureExploreMesh(
                 }
                 VoxelGenLOD::SetThreadOctaveBias(PreviousOctaveBias);
                 VoxelGenLOD::SetThreadSampleStep(PreviousSampleStep);
+                VoxelGenLOD::SetThreadTileContext(PreviousTileOrigin, PreviousTileCells);
             },
             EParallelForFlags::None);
         World.ExploreDensityGridSeconds = FPlatformTime::Seconds() - DensityGridStartSeconds;
@@ -1988,6 +2031,10 @@ bool EnsureExploreMesh(
             World.ExploreMeshSeconds = FPlatformTime::Seconds() - MeshStartSeconds;
             return false;
         }
+        World.ExploreTileTriangleCounts[CompletedTiles] =
+            TileMeshes[CompletedTiles].Triangles.Num() / 3;
+        World.ExploreTileGeometryHashes[CompletedTiles] =
+            ComputeGeometryHash(TileMeshes[CompletedTiles]);
         World.ExploreMeshTilesCompleted = CompletedTiles + 1;
     }
 
@@ -4145,6 +4192,18 @@ FString BuildManifestJson(
     Writer->WriteValue(TEXT("archetype"), ArchetypeName(Arguments.Archetype));
     Writer->WriteValue(TEXT("slot"), Arguments.Slot);
     Writer->WriteValue(TEXT("operator_stack"), Arguments.bUseOperatorStack);
+    Writer->WriteValue(TEXT("worms_enabled_override"), Arguments.bWormsEnabledOverride);
+    if (Arguments.bWormsEnabledOverride)
+    {
+        Writer->WriteValue(TEXT("worms_enabled"), Arguments.bWormsEnabled);
+    }
+    Writer->WriteValue(TEXT("worm_strength_override"), Arguments.bWormStrengthOverride);
+    if (Arguments.bWormStrengthOverride)
+    {
+        Writer->WriteValue(TEXT("worm_strength"), static_cast<double>(Arguments.WormStrength));
+    }
+    Writer->WriteValue(TEXT("worm_lattice_step"), VoxelWormField::GetLatticeStep());
+    Writer->WriteValue(TEXT("worm_noise_mode"), VoxelWormField::GetNoiseMode());
     WriteTunnelFloorOverrides(*Writer, Arguments);
     Writer->WriteValue(TEXT("room_mouth_rise_override"), Arguments.bRoomMouthRiseOverride);
     if (Arguments.bRoomMouthRiseOverride)
@@ -4409,6 +4468,18 @@ FString BuildExploreJson(
     Writer->WriteValue(TEXT("archetype"), ArchetypeName(Arguments.Archetype));
     Writer->WriteValue(TEXT("slot"), Arguments.Slot);
     Writer->WriteValue(TEXT("operator_stack"), Arguments.bUseOperatorStack);
+    Writer->WriteValue(TEXT("worms_enabled_override"), Arguments.bWormsEnabledOverride);
+    if (Arguments.bWormsEnabledOverride)
+    {
+        Writer->WriteValue(TEXT("worms_enabled"), Arguments.bWormsEnabled);
+    }
+    Writer->WriteValue(TEXT("worm_strength_override"), Arguments.bWormStrengthOverride);
+    if (Arguments.bWormStrengthOverride)
+    {
+        Writer->WriteValue(TEXT("worm_strength"), static_cast<double>(Arguments.WormStrength));
+    }
+    Writer->WriteValue(TEXT("worm_lattice_step"), VoxelWormField::GetLatticeStep());
+    Writer->WriteValue(TEXT("worm_noise_mode"), VoxelWormField::GetNoiseMode());
     WriteTunnelFloorOverrides(*Writer, Arguments);
     Writer->WriteValue(TEXT("room_mouth_rise_override"), Arguments.bRoomMouthRiseOverride);
     if (Arguments.bRoomMouthRiseOverride)
@@ -4541,6 +4612,29 @@ FString BuildExploreJson(
     Writer->WriteValue(TEXT("estimated_launch_overhead_seconds"),
         World.ExploreMeshTaskLaunchOverheadSeconds);
     Writer->WriteObjectEnd();
+    Writer->WriteObjectStart(TEXT("tile_ledger"));
+    Writer->WriteValue(TEXT("order"), TEXT("z_then_y_then_x"));
+    Writer->WriteValue(TEXT("tile_cells"), CHUNK_SIZE);
+    Writer->WriteValue(TEXT("tile_count"), World.ExploreMeshTileCount);
+    Writer->WriteValue(TEXT("completed_tiles"), World.ExploreMeshTilesCompleted);
+    Writer->WriteArrayStart(TEXT("tiles"));
+    for (int32 TileIndex = 0; TileIndex < World.ExploreMeshTilesCompleted; ++TileIndex)
+    {
+        const int32 TilesPerAxis = Arguments.ExportSize / CHUNK_SIZE;
+        const int32 TileX = TileIndex % TilesPerAxis;
+        const int32 TileY = (TileIndex / TilesPerAxis) % TilesPerAxis;
+        const int32 TileZ = TileIndex / (TilesPerAxis * TilesPerAxis);
+        Writer->WriteObjectStart();
+        Writer->WriteValue(TEXT("index"), TileIndex);
+        Writer->WriteValue(TEXT("x"), TileX);
+        Writer->WriteValue(TEXT("y"), TileY);
+        Writer->WriteValue(TEXT("z"), TileZ);
+        Writer->WriteValue(TEXT("triangle_count"), World.ExploreTileTriangleCounts[TileIndex]);
+        Writer->WriteValue(TEXT("geometry_hash"), World.ExploreTileGeometryHashes[TileIndex]);
+        Writer->WriteObjectEnd();
+    }
+    Writer->WriteArrayEnd();
+    Writer->WriteObjectEnd();
     Writer->WriteObjectStart(TEXT("counters"));
     for (int32 Index = 0; Index < VoxelDensityProfile::CounterCount; ++Index)
     {
@@ -6676,6 +6770,29 @@ int32 RunBatch(const FString& Params)
 
 int32 UVoxelForgeExploreCommandlet::Main(const FString& Params)
 {
+    FString SymbolizeCsvPath;
+    if (FParse::Value(*Params, TEXT("symbolizestacks="), SymbolizeCsvPath))
+    {
+        FString SymbolizedOutputPath;
+        FString SymbolPath;
+        FParse::Value(*Params, TEXT("symbolizedout="), SymbolizedOutputPath);
+        FParse::Value(*Params, TEXT("symbolpath="), SymbolPath);
+
+        FString SummaryPath;
+        FString Error;
+        if (!VoxelForgeOfflineStackSymbolizer::Run(
+                SymbolizeCsvPath, SymbolizedOutputPath, SymbolPath, SummaryPath, Error))
+        {
+            UE_LOG(LogTemp, Error, TEXT("[VoxelForgeExplore] offline stack symbolization failed: %s"),
+                *Error);
+            return 2;
+        }
+        UE_LOG(LogTemp, Display,
+            TEXT("[VoxelForgeExplore] offline stack symbolization completed summary=%s"),
+            *SummaryPath);
+        return 0;
+    }
+
     FString BatchPath;
     if (FParse::Value(*Params, TEXT("batch="), BatchPath))
     {
diff --git a/Source/VoxelForgeEditor/Private/VoxelStackOfflineSymbolizer.cpp b/Source/VoxelForgeEditor/Private/VoxelStackOfflineSymbolizer.cpp
new file mode 100644
index 0000000..93486e7
--- /dev/null
+++ b/Source/VoxelForgeEditor/Private/VoxelStackOfflineSymbolizer.cpp
@@ -0,0 +1,953 @@
+// VoxelStackOfflineSymbolizer.cpp
+// Post-exit PC -> module/RVA -> function/source/inline resolution.
+
+#include "VoxelStackOfflineSymbolizer.h"
+
+#include "Containers/Array.h"
+#include "Containers/Map.h"
+#include "Containers/Set.h"
+#include "HAL/FileManager.h"
+#include "HAL/PlatformProcess.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+#include "Misc/Parse.h"
+#include "Serialization/Archive.h"
+#include "Containers/StringConv.h"
+
+#if PLATFORM_WINDOWS
+#include "Windows/AllowWindowsPlatformTypes.h"
+THIRD_PARTY_INCLUDES_START
+#include <Windows.h>
+#include <DbgHelp.h>
+THIRD_PARTY_INCLUDES_END
+#include "Windows/HideWindowsPlatformTypes.h"
+#endif
+
+namespace
+{
+    void WriteUtf8(FArchive& Archive, const FString& Text)
+    {
+        FTCHARToUTF8 Utf8(*Text);
+        if (Utf8.Length() > 0)
+        {
+            Archive.Serialize(const_cast<ANSICHAR*>(Utf8.Get()), Utf8.Length());
+        }
+    }
+
+    FString SanitizeField(const FString& InValue)
+    {
+        FString Result = InValue;
+        Result.ReplaceInline(TEXT("\t"), TEXT(" "));
+        Result.ReplaceInline(TEXT("\r"), TEXT(" "));
+        Result.ReplaceInline(TEXT("\n"), TEXT(" "));
+        return Result;
+    }
+
+    FString NormalizedForClassification(const FString& InValue)
+    {
+        FString Result = InValue;
+        Result.ToLowerInline();
+        Result.ReplaceInline(TEXT("\\"), TEXT("/"));
+        return Result;
+    }
+
+    struct FOfflineModule
+    {
+        FString Path;
+        FString PdbGuid;
+        FString PdbPath;
+        uint32 PdbAge = 0;
+        uint64 LoadBase = 0;
+        uint32 ImageSize = 0;
+        uint64 FileSize = 0;
+        uint64 LastWriteFileTime = 0;
+        bool bNeeded = false;
+        bool bLoaded = false;
+        bool bCurrentIdentityMatches = true;
+    };
+
+    struct FOfflineSample
+    {
+        uint64 SampleIndex = 0;
+        uint64 ElapsedUs = 0;
+        uint64 ThreadId = 0;
+        int32 LODLevel = INDEX_NONE;
+        uint32 Depth = 0;
+        uint64 ProgramCounters[64]{};
+    };
+
+    struct FResolvedSymbol
+    {
+        FString Module;
+        FString Function;
+        FString File;
+        int32 Line = 0;
+        bool bInline = false;
+    };
+
+    struct FResolvedProgramCounter
+    {
+        bool bAttempted = false;
+        int32 ModuleIndex = INDEX_NONE;
+        uint64 Rva = 0;
+        TArray<FResolvedSymbol> Symbols;
+    };
+
+    struct FProfileRow
+    {
+        FString Key;
+        FString Function;
+        FString Module;
+        FString File;
+        FString Label;
+        int32 Line = 0;
+        uint64 Samples = 0;
+    };
+
+    struct FProfileAggregateSet
+    {
+        TMap<FString, FProfileRow> ExclusiveFunctions;
+        TMap<FString, FProfileRow> InclusiveFunctions;
+        TMap<FString, FProfileRow> ExclusiveLines;
+        uint64 SamplesWithStack = 0;
+    };
+
+    const FResolvedSymbol* FirstFunctionSymbol(const FResolvedProgramCounter& Entry)
+    {
+        for (const FResolvedSymbol& Symbol : Entry.Symbols)
+        {
+            if (!Symbol.Function.IsEmpty())
+            {
+                return &Symbol;
+            }
+        }
+        return nullptr;
+    }
+
+    const FResolvedSymbol* FirstSourceSymbol(const FResolvedProgramCounter& Entry)
+    {
+        for (const FResolvedSymbol& Symbol : Entry.Symbols)
+        {
+            if (!Symbol.File.IsEmpty() && Symbol.Line > 0)
+            {
+                return &Symbol;
+            }
+        }
+        return nullptr;
+    }
+
+    FString SymbolLabel(const FResolvedSymbol& Symbol)
+    {
+        if (Symbol.Function.IsEmpty())
+        {
+            return TEXT("unknown");
+        }
+
+        const FString FunctionLower = NormalizedForClassification(Symbol.Function);
+        if (FunctionLower.Contains(TEXT("std::")))
+        {
+            return TEXT("std");
+        }
+
+        const FString ModuleLower = NormalizedForClassification(Symbol.Module);
+        const FString FileLower = NormalizedForClassification(Symbol.File);
+        if (FileLower.Contains(TEXT("/engine/")))
+        {
+            return TEXT("engine");
+        }
+
+        const bool bVoxelForge = FunctionLower.Contains(TEXT("voxelforge"))
+            || FileLower.Contains(TEXT("/voxelforge/"))
+            || ModuleLower.Contains(TEXT("voxelforge"));
+        if (bVoxelForge)
+        {
+            return TEXT("plugin");
+        }
+
+        const bool bModuleIsEngine = ModuleLower.StartsWith(TEXT("unrealeditor-"))
+            || ModuleLower.StartsWith(TEXT("ue5-"));
+        return bModuleIsEngine ? TEXT("engine") : TEXT("other");
+    }
+
+    bool IsWaitLike(const FResolvedSymbol& Symbol)
+    {
+        const FString FunctionLower = NormalizedForClassification(Symbol.Function);
+        return FunctionLower.Contains(TEXT("wait"))
+            || FunctionLower.Contains(TEXT("sleep"))
+            || FunctionLower.Contains(TEXT("semaphore"))
+            || FunctionLower.Contains(TEXT("fevent"));
+    }
+
+    FString FunctionKey(const FResolvedSymbol& Symbol)
+    {
+        return SymbolLabel(Symbol) + TEXT("\x1f") + Symbol.Function;
+    }
+
+    FString SourceKey(const FResolvedSymbol* Symbol)
+    {
+        if (Symbol == nullptr || Symbol->File.IsEmpty() || Symbol->Line <= 0)
+        {
+            return TEXT("unknown\x1f<unknown>");
+        }
+        return SymbolLabel(*Symbol) + TEXT("\x1f")
+            + FString::Printf(TEXT("%s:%d"), *Symbol->File, Symbol->Line);
+    }
+
+    void AddFunctionRow(
+        TMap<FString, FProfileRow>& Rows,
+        const FResolvedSymbol* Symbol,
+        uint64 SampleCount)
+    {
+        if (Symbol == nullptr || Symbol->Function.IsEmpty())
+        {
+            return;
+        }
+        const FString Key = FunctionKey(*Symbol);
+        FProfileRow& Row = Rows.FindOrAdd(Key);
+        if (Row.Key.IsEmpty())
+        {
+            Row.Key = Key;
+            Row.Function = Symbol->Function;
+            Row.Module = Symbol->Module;
+            Row.File = Symbol->File;
+            Row.Line = Symbol->Line;
+            Row.Label = SymbolLabel(*Symbol);
+        }
+        Row.Samples += SampleCount;
+    }
+
+    void AddSourceRow(
+        TMap<FString, FProfileRow>& Rows,
+        const FResolvedSymbol* FunctionSymbol,
+        const FResolvedSymbol* SourceSymbol)
+    {
+        const FString Key = SourceKey(SourceSymbol);
+        FProfileRow& Row = Rows.FindOrAdd(Key);
+        if (Row.Key.IsEmpty())
+        {
+            Row.Key = Key;
+            Row.Label = SourceSymbol != nullptr ? SymbolLabel(*SourceSymbol) : TEXT("unknown");
+            Row.File = SourceSymbol != nullptr ? SourceSymbol->File : TEXT("<unknown>");
+            Row.Line = SourceSymbol != nullptr ? SourceSymbol->Line : 0;
+            Row.Function = FunctionSymbol != nullptr ? FunctionSymbol->Function : TEXT("<unknown>");
+            Row.Module = FunctionSymbol != nullptr ? FunctionSymbol->Module : TEXT("<unknown>");
+        }
+        ++Row.Samples;
+    }
+
+    TArray<FProfileRow> SortedRows(const TMap<FString, FProfileRow>& InRows)
+    {
+        TArray<FProfileRow> Rows;
+        Rows.Reserve(InRows.Num());
+        for (const TPair<FString, FProfileRow>& Pair : InRows)
+        {
+            Rows.Add(Pair.Value);
+        }
+        Rows.Sort([](const FProfileRow& A, const FProfileRow& B)
+        {
+            return A.Samples != B.Samples ? A.Samples > B.Samples : A.Key < B.Key;
+        });
+        return Rows;
+    }
+
+    void AppendRows(
+        FString& Out,
+        const TCHAR* Title,
+        const TMap<FString, FProfileRow>& InRows,
+        uint64 Denominator,
+        int32 MaxRows)
+    {
+        Out += TEXT("\n");
+        Out += Title;
+        Out += TEXT("\nrank\tsamples\tpercent\tlabel\tfunction\tmodule\tfile\tline\n");
+        const TArray<FProfileRow> Rows = SortedRows(InRows);
+        const int32 Count = FMath::Min(MaxRows, Rows.Num());
+        for (int32 Index = 0; Index < Count; ++Index)
+        {
+            const FProfileRow& Row = Rows[Index];
+            const double Percent = Denominator > 0
+                ? static_cast<double>(Row.Samples) * 100.0 / static_cast<double>(Denominator)
+                : 0.0;
+            Out.Appendf(
+                TEXT("%d\t%llu\t%.4f\t%s\t%s\t%s\t%s\t%d\n"),
+                Index + 1,
+                static_cast<unsigned long long>(Row.Samples),
+                Percent,
+                *Row.Label,
+                *Row.Function,
+                *Row.Module,
+                *Row.File,
+                Row.Line);
+        }
+        if (Rows.Num() == 0)
+        {
+            Out += TEXT("(no rows)\n");
+        }
+    }
+
+    FString DeriveSiblingPath(const FString& CsvPath, const TCHAR* OldToken, const TCHAR* NewToken,
+                              const TCHAR* Extension)
+    {
+        const FString FullPath = FPaths::ConvertRelativePathToFull(CsvPath);
+        FString BaseName = FPaths::GetBaseFilename(FullPath);
+        if (BaseName.StartsWith(OldToken, ESearchCase::IgnoreCase))
+        {
+            BaseName = FString(NewToken) + BaseName.RightChop(FCString::Strlen(OldToken));
+        }
+        else
+        {
+            BaseName += FString(TEXT(".")) + NewToken;
+        }
+        return FPaths::Combine(FPaths::GetPath(FullPath), BaseName + Extension);
+    }
+
+    bool ParseUint64(const FString& Text, uint64& OutValue)
+    {
+        if (Text.IsEmpty())
+        {
+            return false;
+        }
+        TCHAR* End = nullptr;
+        OutValue = FCString::Strtoui64(*Text, &End, 0);
+        return End != nullptr && End != *Text;
+    }
+
+    bool ReadModuleMap(
+        const FString& ModuleMapPath,
+        TArray<FOfflineModule>& OutModules,
+        FString& OutError)
+    {
+        FString Text;
+        if (!FFileHelper::LoadFileToString(Text, *ModuleMapPath))
+        {
+            OutError = FString::Printf(TEXT("module map is not readable: %s"), *ModuleMapPath);
+            return false;
+        }
+
+        OutModules.Reset();
+        TArray<FString> Lines;
+        Text.ParseIntoArrayLines(Lines, false);
+        for (const FString& Line : Lines)
+        {
+            if (Line.IsEmpty() || Line.StartsWith(TEXT("#"))
+                || Line.StartsWith(TEXT("module_path\t")))
+            {
+                continue;
+            }
+
+            TArray<FString> Fields;
+            Line.ParseIntoArray(Fields, TEXT("\t"), false);
+            if (Fields.Num() < 7)
+            {
+                continue;
+            }
+
+            FOfflineModule Module;
+            Module.Path = Fields[0];
+            uint64 ParsedImageSize = 0;
+            uint64 ParsedPdbAge = 0;
+            if (!ParseUint64(Fields[1], Module.LoadBase)
+                || !ParseUint64(Fields[2], ParsedImageSize)
+                || !ParseUint64(Fields[3], Module.FileSize)
+                || !ParseUint64(Fields[4], Module.LastWriteFileTime)
+                || !ParseUint64(Fields[6], ParsedPdbAge))
+            {
+                continue;
+            }
+            Module.ImageSize = static_cast<uint32>(ParsedImageSize);
+            Module.PdbAge = static_cast<uint32>(ParsedPdbAge);
+            Module.PdbGuid = Fields[5];
+            Module.PdbPath = Fields.Num() > 7 ? Fields[7] : FString();
+            OutModules.Add(MoveTemp(Module));
+        }
+
+        if (OutModules.Num() == 0)
+        {
+            OutError = FString::Printf(TEXT("module map has no module records: %s"), *ModuleMapPath);
+            return false;
+        }
+        return true;
+    }
+
+#if PLATFORM_WINDOWS
+    bool ReadCurrentFileIdentity(const FString& Path, uint64& OutSize, uint64& OutLastWrite)
+    {
+        WIN32_FILE_ATTRIBUTE_DATA FileData{};
+        if (!GetFileAttributesExW(*Path, GetFileExInfoStandard, &FileData))
+        {
+            return false;
+        }
+        ULARGE_INTEGER Size;
+        Size.HighPart = FileData.nFileSizeHigh;
+        Size.LowPart = FileData.nFileSizeLow;
+        OutSize = Size.QuadPart;
+        ULARGE_INTEGER LastWrite;
+        LastWrite.HighPart = FileData.ftLastWriteTime.dwHighDateTime;
+        LastWrite.LowPart = FileData.ftLastWriteTime.dwLowDateTime;
+        OutLastWrite = LastWrite.QuadPart;
+        return true;
+    }
+
+    int32 FindModuleForPc(const TArray<FOfflineModule>& Modules, uint64 ProgramCounter)
+    {
+        for (int32 Index = 0; Index < Modules.Num(); ++Index)
+        {
+            const FOfflineModule& Module = Modules[Index];
+            if (Module.ImageSize > 0 && ProgramCounter >= Module.LoadBase
+                && ProgramCounter - Module.LoadBase < Module.ImageSize)
+            {
+                return Index;
+            }
+        }
+        return INDEX_NONE;
+    }
+
+    FString DbgHelpFunctionName(const SYMBOL_INFO* Symbol, bool bInline)
+    {
+        if (Symbol == nullptr || Symbol->Name[0] == '\0')
+        {
+            return FString();
+        }
+        int32 Offset = 0;
+        while (Symbol->Name[Offset] != '\0'
+            && (Symbol->Name[Offset] < 32 || Symbol->Name[Offset] > 127))
+        {
+            ++Offset;
+        }
+        const FString Name = FString(ANSI_TO_TCHAR(Symbol->Name + Offset));
+        return bInline
+            ? FString::Printf(TEXT("[Inline Frame] %s()"), *Name)
+            : FString::Printf(TEXT("%s()"), *Name);
+    }
+
+    void ResolveProgramCounter(
+        HANDLE Process,
+        uint64 ProgramCounter,
+        const TArray<FOfflineModule>& Modules,
+        TMap<uint64, FResolvedProgramCounter>& Cache,
+        uint64& InOutInlineSymbols,
+        TSet<uint64>& MappedPcs,
+        TSet<uint64>& UnmappedPcs)
+    {
+        FResolvedProgramCounter& Entry = Cache.FindOrAdd(ProgramCounter);
+        if (Entry.bAttempted)
+        {
+            return;
+        }
+        Entry.bAttempted = true;
+        Entry.ModuleIndex = FindModuleForPc(Modules, ProgramCounter);
+        if (Entry.ModuleIndex == INDEX_NONE)
+        {
+            UnmappedPcs.Add(ProgramCounter);
+            return;
+        }
+
+        const FOfflineModule& Module = Modules[Entry.ModuleIndex];
+        Entry.Rva = ProgramCounter - Module.LoadBase;
+        MappedPcs.Add(ProgramCounter);
+        const FString ModuleName = FPaths::GetCleanFilename(Module.Path);
+
+        // The buffer shape and inline query match UE's Windows stack walker, but this resolver is
+        // called only in the post-exit commandlet process.
+        ANSICHAR SymbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME] = {};
+        SYMBOL_INFO* Symbol = reinterpret_cast<SYMBOL_INFO*>(SymbolBuffer);
+        Symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+        Symbol->MaxNameLen = MAX_SYM_NAME;
+
+        const DWORD InlineCount = SymAddrIncludeInlineTrace(Process, ProgramCounter);
+        if (InlineCount > 0)
+        {
+            DWORD InlineContext = 0;
+            DWORD FrameIndex = 0;
+            if (SymQueryInlineTrace(
+                    Process, ProgramCounter, 0, ProgramCounter, ProgramCounter,
+                    &InlineContext, &FrameIndex))
+            {
+                for (DWORD Index = 0; Index < InlineCount; ++Index, ++InlineContext)
+                {
+                    DWORD64 Displacement = 0;
+                    if (!SymFromInlineContext(
+                            Process, ProgramCounter, InlineContext, &Displacement, Symbol))
+                    {
+                        continue;
+                    }
+
+                    FResolvedSymbol Resolved;
+                    Resolved.Module = ModuleName;
+                    Resolved.Function = DbgHelpFunctionName(Symbol, true);
+                    Resolved.bInline = true;
+
+                    IMAGEHLP_LINE64 Line{};
+                    Line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+                    DWORD LineDisplacement = 0;
+                    if (SymGetLineFromInlineContext(
+                            Process, ProgramCounter, InlineContext, 0,
+                            &LineDisplacement, &Line))
+                    {
+                        Resolved.File = Line.FileName != nullptr
+                            ? FString(ANSI_TO_TCHAR(Line.FileName)) : FString();
+                        Resolved.Line = static_cast<int32>(Line.LineNumber);
+                    }
+                    Entry.Symbols.Add(MoveTemp(Resolved));
+                    ++InOutInlineSymbols;
+                }
+            }
+        }
+
+        DWORD64 Displacement = 0;
+        if (SymFromAddr(Process, ProgramCounter, &Displacement, Symbol))
+        {
+            FResolvedSymbol Resolved;
+            Resolved.Module = ModuleName;
+            Resolved.Function = DbgHelpFunctionName(Symbol, false);
+            IMAGEHLP_LINE64 Line{};
+            Line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+            DWORD LineDisplacement = 0;
+            if (SymGetLineFromAddr64(Process, ProgramCounter, &LineDisplacement, &Line))
+            {
+                Resolved.File = Line.FileName != nullptr
+                    ? FString(ANSI_TO_TCHAR(Line.FileName)) : FString();
+                Resolved.Line = static_cast<int32>(Line.LineNumber);
+            }
+            Entry.Symbols.Add(MoveTemp(Resolved));
+        }
+    }
+
+    void WritePcMap(
+        const FString& PcMapPath,
+        const TArray<FOfflineModule>& Modules,
+        const TMap<uint64, FResolvedProgramCounter>& Cache)
+    {
+        FArchive* Archive = IFileManager::Get().CreateFileWriter(*PcMapPath);
+        if (Archive == nullptr)
+        {
+            return;
+        }
+        WriteUtf8(*Archive, TEXT("# VoxelForge resolved PC map v1\n"));
+        WriteUtf8(*Archive, TEXT("pc_hex\tmodule_path\tload_base_hex\trva_hex\tinline\tfunction\tfile\tline\n"));
+
+        TArray<uint64> Pcs;
+        Pcs.Reserve(Cache.Num());
+        for (const TPair<uint64, FResolvedProgramCounter>& Pair : Cache)
+        {
+            Pcs.Add(Pair.Key);
+        }
+        Pcs.Sort();
+        for (const uint64 Pc : Pcs)
+        {
+            const FResolvedProgramCounter* Entry = Cache.Find(Pc);
+            if (Entry == nullptr)
+            {
+                continue;
+            }
+            const FOfflineModule* Module = Modules.IsValidIndex(Entry->ModuleIndex)
+                ? &Modules[Entry->ModuleIndex] : nullptr;
+            const FString ModulePath = Module != nullptr ? Module->Path : TEXT("<unmapped>");
+            const uint64 LoadBase = Module != nullptr ? Module->LoadBase : 0;
+            const FString ModuleLine = FString::Printf(
+                TEXT("0x%016llX\t%s\t0x%016llX\t0x%llX\t"),
+                static_cast<unsigned long long>(Pc),
+                *SanitizeField(ModulePath),
+                static_cast<unsigned long long>(LoadBase),
+                static_cast<unsigned long long>(Entry->Rva));
+            if (Entry->Symbols.Num() == 0)
+            {
+                WriteUtf8(*Archive, ModuleLine + TEXT("0\t<unknown>\t<unknown>\t0\n"));
+                continue;
+            }
+            for (const FResolvedSymbol& Symbol : Entry->Symbols)
+            {
+                WriteUtf8(*Archive, ModuleLine + FString::Printf(
+                    TEXT("%d\t%s\t%s\t%d\n"),
+                    Symbol.bInline ? 1 : 0,
+                    *SanitizeField(Symbol.Function),
+                    *SanitizeField(Symbol.File),
+                    Symbol.Line));
+            }
+        }
+        delete Archive;
+    }
+#endif
+}
+
+namespace VoxelForgeOfflineStackSymbolizer
+{
+    bool Run(
+        const FString& CsvPath,
+        const FString& OptionalOutputPath,
+        const FString& OptionalSymbolPath,
+        FString& OutSummaryPath,
+        FString& OutError)
+    {
+        OutSummaryPath.Reset();
+        OutError.Reset();
+
+#if !PLATFORM_WINDOWS
+        OutError = TEXT("offline stack symbolization currently requires Windows DbgHelp");
+        return false;
+#else
+        const FString FullCsvPath = FPaths::ConvertRelativePathToFull(CsvPath);
+        if (!FPaths::FileExists(FullCsvPath))
+        {
+            OutError = FString::Printf(TEXT("CSV is not readable: %s"), *FullCsvPath);
+            return false;
+        }
+
+        const FString ModuleMapPath = DeriveSiblingPath(
+            FullCsvPath, TEXT("VoxelStackSamples_"), TEXT("VoxelStackModules_"), TEXT(".tsv"));
+        const FString DefaultSummaryPath = DeriveSiblingPath(
+            FullCsvPath, TEXT("VoxelStackSamples_"), TEXT("VoxelStackSummaryOffline_"), TEXT(".txt"));
+        OutSummaryPath = OptionalOutputPath.IsEmpty()
+            ? DefaultSummaryPath : FPaths::ConvertRelativePathToFull(OptionalOutputPath);
+        const FString PcMapPath = DeriveSiblingPath(
+            FullCsvPath, TEXT("VoxelStackSamples_"), TEXT("VoxelStackResolved_"), TEXT(".tsv"));
+
+        TArray<FOfflineModule> Modules;
+        if (!ReadModuleMap(ModuleMapPath, Modules, OutError))
+        {
+            return false;
+        }
+
+        for (FOfflineModule& Module : Modules)
+        {
+            uint64 CurrentSize = 0;
+            uint64 CurrentLastWrite = 0;
+            Module.bCurrentIdentityMatches =
+                ReadCurrentFileIdentity(Module.Path, CurrentSize, CurrentLastWrite)
+                && CurrentSize == Module.FileSize
+                && CurrentLastWrite == Module.LastWriteFileTime;
+        }
+
+        FString CsvText;
+        if (!FFileHelper::LoadFileToString(CsvText, *FullCsvPath))
+        {
+            OutError = FString::Printf(TEXT("CSV could not be loaded: %s"), *FullCsvPath);
+            return false;
+        }
+
+        TArray<FOfflineSample> Samples;
+        TArray<FString> Lines;
+        CsvText.ParseIntoArrayLines(Lines, false);
+        Samples.Reserve(Lines.Num());
+        uint64 TotalFrames = 0;
+        for (const FString& Line : Lines)
+        {
+            if (Line.IsEmpty() || Line.StartsWith(TEXT("sample_index,")))
+            {
+                continue;
+            }
+            TArray<FString> Fields;
+            Line.ParseIntoArray(Fields, TEXT(","), false);
+            if (Fields.Num() < 5)
+            {
+                continue;
+            }
+
+            FOfflineSample Sample;
+            uint64 Parsed = 0;
+            if (!ParseUint64(Fields[0], Sample.SampleIndex)
+                || !ParseUint64(Fields[1], Sample.ElapsedUs)
+                || !ParseUint64(Fields[2], Sample.ThreadId)
+                || !ParseUint64(Fields[4], Parsed))
+            {
+                continue;
+            }
+            Sample.LODLevel = FCString::Atoi(*Fields[3]);
+            Sample.Depth = static_cast<uint32>(FMath::Min<uint64>(
+                Parsed, UE_ARRAY_COUNT(Sample.ProgramCounters)));
+            for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
+            {
+                if (5 + FrameIndex >= static_cast<uint32>(Fields.Num()))
+                {
+                    Sample.Depth = FrameIndex;
+                    break;
+                }
+                uint64 ProgramCounter = 0;
+                if (!ParseUint64(Fields[5 + FrameIndex], ProgramCounter))
+                {
+                    Sample.Depth = FrameIndex;
+                    break;
+                }
+                Sample.ProgramCounters[FrameIndex] = ProgramCounter;
+            }
+            TotalFrames += Sample.Depth;
+            Samples.Add(MoveTemp(Sample));
+        }
+
+        HANDLE Process = GetCurrentProcess();
+        const DWORD OldOptions = SymGetOptions();
+        SymSetOptions(OldOptions
+            | SYMOPT_LOAD_LINES
+            | SYMOPT_UNDNAME
+            | SYMOPT_DEFERRED_LOADS
+            | SYMOPT_EXACT_SYMBOLS
+            | SYMOPT_FAIL_CRITICAL_ERRORS);
+
+        FString SearchPath = OptionalSymbolPath;
+        for (const FOfflineModule& Module : Modules)
+        {
+            const FString ModuleDirectory = FPaths::GetPath(Module.Path);
+            const FString PdbDirectory = FPaths::GetPath(Module.PdbPath);
+            if (!ModuleDirectory.IsEmpty())
+            {
+                if (!SearchPath.IsEmpty()) SearchPath += TEXT(";");
+                SearchPath += ModuleDirectory;
+            }
+            if (!PdbDirectory.IsEmpty() && !SearchPath.Contains(PdbDirectory))
+            {
+                if (!SearchPath.IsEmpty()) SearchPath += TEXT(";");
+                SearchPath += PdbDirectory;
+            }
+        }
+
+        if (!SymInitializeW(Process, *SearchPath, 0))
+        {
+            const DWORD Error = GetLastError();
+            SymSetOptions(OldOptions);
+            OutError = FString::Printf(TEXT("SymInitializeW failed with error %u"), Error);
+            return false;
+        }
+
+        TSet<int32> NeededModuleIndices;
+        for (const FOfflineSample& Sample : Samples)
+        {
+            for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
+            {
+                const int32 ModuleIndex = FindModuleForPc(Modules, Sample.ProgramCounters[FrameIndex]);
+                if (ModuleIndex != INDEX_NONE)
+                {
+                    NeededModuleIndices.Add(ModuleIndex);
+                }
+            }
+        }
+
+        int32 LoadedModules = 0;
+        int32 NeededModules = NeededModuleIndices.Num();
+        for (FOfflineModule& Module : Modules)
+        {
+            Module.bNeeded = NeededModuleIndices.Contains(static_cast<int32>(&Module - Modules.GetData()));
+            if (!Module.bNeeded) continue;
+            const DWORD64 LoadedBase = SymLoadModuleExW(
+                Process, nullptr, *Module.Path, *Module.Path,
+                static_cast<DWORD64>(Module.LoadBase), Module.ImageSize, nullptr, 0);
+            if (LoadedBase != 0)
+            {
+                Module.bLoaded = true;
+                ++LoadedModules;
+            }
+        }
+
+        TMap<uint64, FResolvedProgramCounter> SymbolCache;
+        TSet<uint64> MappedPcs;
+        TSet<uint64> UnmappedPcs;
+        FProfileAggregateSet AllAggregates;
+        FProfileAggregateSet Lod0Aggregates;
+        FProfileAggregateSet Lod1PlusAggregates;
+        uint64 ResolvedFrames = 0;
+        uint64 UnknownFrames = 0;
+        uint64 WaitLikeFrames = 0;
+        uint64 SamplesWithResolvedLeaf = 0;
+        uint64 SamplesWithWaitLikeFrame = 0;
+        uint64 SamplesWithStack = 0;
+        uint64 UntaggedSamples = 0;
+        uint64 InlineSymbols = 0;
+
+        auto AddUnknownExclusiveRow = [](FProfileAggregateSet& Aggregate)
+        {
+            const FString UnknownKey = TEXT("unknown\x1f<unknown>");
+            FProfileRow& UnknownRow = Aggregate.ExclusiveFunctions.FindOrAdd(UnknownKey);
+            if (UnknownRow.Key.IsEmpty())
+            {
+                UnknownRow.Key = UnknownKey;
+                UnknownRow.Function = TEXT("<unknown>");
+                UnknownRow.Module = TEXT("<unknown>");
+                UnknownRow.File = TEXT("<unknown>");
+                UnknownRow.Label = TEXT("unknown");
+            }
+            ++UnknownRow.Samples;
+        };
+
+        for (const FOfflineSample& Sample : Samples)
+        {
+            if (Sample.Depth == 0)
+            {
+                continue;
+            }
+            ++SamplesWithStack;
+            TSet<FString> SeenFunctions;
+            TArray<FResolvedSymbol> SampleFunctions;
+            uint64 LeafProgramCounter = 0;
+            bool bHasLeafProgramCounter = false;
+            bool bSampleHasResolvedLeaf = false;
+            bool bSampleHasWaitLike = false;
+
+            for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
+            {
+                const uint64 ProgramCounter = Sample.ProgramCounters[FrameIndex];
+                ResolveProgramCounter(
+                    Process, ProgramCounter, Modules, SymbolCache, InlineSymbols,
+                    MappedPcs, UnmappedPcs);
+                const FResolvedProgramCounter* Entry = SymbolCache.Find(ProgramCounter);
+                const FResolvedSymbol* FrameFunction = Entry != nullptr
+                    ? FirstFunctionSymbol(*Entry) : nullptr;
+                if (FrameFunction != nullptr)
+                {
+                    ++ResolvedFrames;
+                    if (IsWaitLike(*FrameFunction))
+                    {
+                        ++WaitLikeFrames;
+                        bSampleHasWaitLike = true;
+                    }
+                    if (FrameIndex == 0)
+                    {
+                        bSampleHasResolvedLeaf = true;
+                    }
+                }
+                else
+                {
+                    ++UnknownFrames;
+                }
+
+                if (FrameIndex == 0)
+                {
+                    LeafProgramCounter = ProgramCounter;
+                    bHasLeafProgramCounter = true;
+                }
+                if (Entry != nullptr)
+                {
+                    for (const FResolvedSymbol& Symbol : Entry->Symbols)
+                    {
+                        if (Symbol.Function.IsEmpty()) continue;
+                        const FString Key = FunctionKey(Symbol);
+                        if (!SeenFunctions.Contains(Key))
+                        {
+                            SeenFunctions.Add(Key);
+                            SampleFunctions.Add(Symbol);
+                        }
+                    }
+                }
+            }
+
+            const FResolvedProgramCounter* LeafEntry = bHasLeafProgramCounter
+                ? SymbolCache.Find(LeafProgramCounter) : nullptr;
+            const FResolvedSymbol* LeafFunction = LeafEntry != nullptr
+                ? FirstFunctionSymbol(*LeafEntry) : nullptr;
+            const FResolvedSymbol* LeafSource = LeafEntry != nullptr
+                ? FirstSourceSymbol(*LeafEntry) : nullptr;
+
+            auto AddToAggregate = [&](FProfileAggregateSet& Aggregate)
+            {
+                ++Aggregate.SamplesWithStack;
+                if (bSampleHasResolvedLeaf)
+                {
+                    AddFunctionRow(Aggregate.ExclusiveFunctions, LeafFunction, 1);
+                }
+                else
+                {
+                    AddUnknownExclusiveRow(Aggregate);
+                }
+                for (const FResolvedSymbol& Symbol : SampleFunctions)
+                {
+                    AddFunctionRow(Aggregate.InclusiveFunctions, &Symbol, 1);
+                }
+                AddSourceRow(Aggregate.ExclusiveLines, LeafFunction, LeafSource);
+            };
+
+            AddToAggregate(AllAggregates);
+            if (Sample.LODLevel == 0)
+            {
+                AddToAggregate(Lod0Aggregates);
+            }
+            else if (Sample.LODLevel >= 1)
+            {
+                AddToAggregate(Lod1PlusAggregates);
+            }
+            else
+            {
+                ++UntaggedSamples;
+            }
+
+            if (bSampleHasResolvedLeaf) ++SamplesWithResolvedLeaf;
+            if (bSampleHasWaitLike) ++SamplesWithWaitLikeFrame;
+        }
+
+        const int32 IdentityMismatches = [&Modules]()
+        {
+            int32 Count = 0;
+            for (const FOfflineModule& Module : Modules)
+            {
+                if (!Module.bCurrentIdentityMatches) ++Count;
+            }
+            return Count;
+        }();
+
+        WritePcMap(PcMapPath, Modules, SymbolCache);
+        SymCleanup(Process);
+        SymSetOptions(OldOptions);
+
+        FString Summary;
+        Summary += TEXT("VoxelForge offline stack symbolizer\n");
+        Summary += TEXT("==================================\n");
+        Summary.Appendf(TEXT("csv_path: %s\n"), *FullCsvPath);
+        Summary.Appendf(TEXT("module_map_path: %s\n"), *ModuleMapPath);
+        Summary.Appendf(TEXT("resolved_pc_map_path: %s\n"), *PcMapPath);
+        Summary += TEXT("symbolization: offline\n");
+        Summary.Appendf(TEXT("dbghelp_in_measured_process: no\n"));
+        Summary.Appendf(TEXT("dbghelp_in_symbolizer_process: yes\n"));
+        Summary.Appendf(TEXT("module_count: %d\n"), Modules.Num());
+        Summary.Appendf(TEXT("needed_module_count: %d\n"), NeededModules);
+        Summary.Appendf(TEXT("loaded_module_count: %d\n"), LoadedModules);
+        Summary.Appendf(TEXT("module_identity_mismatches: %d\n"), IdentityMismatches);
+        Summary.Appendf(TEXT("samples: %d\n"), Samples.Num());
+        Summary.Appendf(TEXT("samples_with_stack: %llu\n"), static_cast<unsigned long long>(SamplesWithStack));
+        Summary.Appendf(TEXT("lod0_samples_with_stack: %llu\n"),
+            static_cast<unsigned long long>(Lod0Aggregates.SamplesWithStack));
+        Summary.Appendf(TEXT("lod1plus_samples_with_stack: %llu\n"),
+            static_cast<unsigned long long>(Lod1PlusAggregates.SamplesWithStack));
+        Summary.Appendf(TEXT("untagged_samples: %llu\n"), static_cast<unsigned long long>(UntaggedSamples));
+        Summary.Appendf(TEXT("total_frames: %llu\n"), static_cast<unsigned long long>(TotalFrames));
+        Summary.Appendf(TEXT("resolved_frames: %llu\n"), static_cast<unsigned long long>(ResolvedFrames));
+        Summary.Appendf(TEXT("unknown_frames: %llu\n"), static_cast<unsigned long long>(UnknownFrames));
+        Summary.Appendf(TEXT("wait_like_frames: %llu\n"), static_cast<unsigned long long>(WaitLikeFrames));
+        Summary.Appendf(TEXT("samples_with_resolved_leaf: %llu\n"),
+            static_cast<unsigned long long>(SamplesWithResolvedLeaf));
+        Summary.Appendf(TEXT("samples_with_wait_like_frame: %llu\n"),
+            static_cast<unsigned long long>(SamplesWithWaitLikeFrame));
+        Summary.Appendf(TEXT("unique_program_counters: %d\n"), SymbolCache.Num());
+        Summary.Appendf(TEXT("mapped_program_counters: %d\n"), MappedPcs.Num());
+        Summary.Appendf(TEXT("unmapped_program_counters: %d\n"), UnmappedPcs.Num());
+        Summary.Appendf(TEXT("inline_symbols: %llu\n"), static_cast<unsigned long long>(InlineSymbols));
+        Summary.Appendf(TEXT("resolved_frame_fraction: %.6f\n"), TotalFrames > 0
+            ? static_cast<double>(ResolvedFrames) / static_cast<double>(TotalFrames) : 0.0);
+        Summary.Appendf(TEXT("unknown_frame_fraction: %.6f\n"), TotalFrames > 0
+            ? static_cast<double>(UnknownFrames) / static_cast<double>(TotalFrames) : 0.0);
+        Summary.Appendf(TEXT("wait_like_frame_fraction: %.6f\n"), TotalFrames > 0
+            ? static_cast<double>(WaitLikeFrames) / static_cast<double>(TotalFrames) : 0.0);
+        Summary.Appendf(TEXT("resolved_leaf_fraction: %.6f\n"), SamplesWithStack > 0
+            ? static_cast<double>(SamplesWithResolvedLeaf) / static_cast<double>(SamplesWithStack) : 0.0);
+        Summary.Appendf(TEXT("wait_like_sample_fraction: %.6f\n"), SamplesWithStack > 0
+            ? static_cast<double>(SamplesWithWaitLikeFrame) / static_cast<double>(SamplesWithStack) : 0.0);
+        Summary += TEXT("\nLabels: plugin = VoxelForge, engine = Unreal/Engine, std = std:: frames, other = other resolved modules, unknown = no function symbol. Inline callbacks are resolved only in this offline process.\n");
+        AppendRows(Summary, TEXT("Top 30 exclusive functions (leaf)"), AllAggregates.ExclusiveFunctions, SamplesWithStack, 30);
+        AppendRows(Summary, TEXT("Top 30 inclusive functions (once per sample)"), AllAggregates.InclusiveFunctions, SamplesWithStack, 30);
+        AppendRows(Summary, TEXT("Top 30 exclusive source lines (leaf source)"), AllAggregates.ExclusiveLines, SamplesWithStack, 30);
+        Summary += TEXT("\nLOD0 tables (floor)\n");
+        AppendRows(Summary, TEXT("LOD0 top 30 exclusive functions (leaf)"), Lod0Aggregates.ExclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
+        AppendRows(Summary, TEXT("LOD0 top 30 inclusive functions (once per sample)"), Lod0Aggregates.InclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
+        AppendRows(Summary, TEXT("LOD0 top 30 exclusive source lines (leaf source)"), Lod0Aggregates.ExclusiveLines, Lod0Aggregates.SamplesWithStack, 30);
+        Summary += TEXT("\nLOD1+ tables (coarse/background)\n");
+        AppendRows(Summary, TEXT("LOD1+ top 30 exclusive functions (leaf)"), Lod1PlusAggregates.ExclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
+        AppendRows(Summary, TEXT("LOD1+ top 30 inclusive functions (once per sample)"), Lod1PlusAggregates.InclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
+        AppendRows(Summary, TEXT("LOD1+ top 30 exclusive source lines (leaf source)"), Lod1PlusAggregates.ExclusiveLines, Lod1PlusAggregates.SamplesWithStack, 30);
+
+        IFileManager::Get().MakeDirectory(*FPaths::GetPath(OutSummaryPath), true);
+        if (!FFileHelper::SaveStringToFile(
+                Summary, *OutSummaryPath, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
+        {
+            OutError = FString::Printf(TEXT("could not write offline summary: %s"), *OutSummaryPath);
+            return false;
+        }
+        return true;
+#endif
+    }
+}
diff --git a/Source/VoxelForgeEditor/Private/VoxelStackOfflineSymbolizer.h b/Source/VoxelForgeEditor/Private/VoxelStackOfflineSymbolizer.h
new file mode 100644
index 0000000..c61bcce
--- /dev/null
+++ b/Source/VoxelForgeEditor/Private/VoxelStackOfflineSymbolizer.h
@@ -0,0 +1,16 @@
+// VoxelStackOfflineSymbolizer.h
+
+#pragma once
+
+#include "CoreMinimal.h"
+
+namespace VoxelForgeOfflineStackSymbolizer
+{
+    /** Resolve one sampler CSV after the measured process has exited. */
+    bool Run(
+        const FString& CsvPath,
+        const FString& OptionalOutputPath,
+        const FString& OptionalSymbolPath,
+        FString& OutSummaryPath,
+        FString& OutError);
+}
diff --git a/Source/VoxelForgeEditor/VoxelForgeEditor.Build.cs b/Source/VoxelForgeEditor/VoxelForgeEditor.Build.cs
index c9d9321..7209807 100644
--- a/Source/VoxelForgeEditor/VoxelForgeEditor.Build.cs
+++ b/Source/VoxelForgeEditor/VoxelForgeEditor.Build.cs
@@ -25,5 +25,12 @@ public class VoxelForgeEditor : ModuleRules
 			"ImageWrapper",
 			"VoxelForge",
 		});
+
+		if (Target.Platform == UnrealTargetPlatform.Win64)
+		{
+			// DbgHelp is intentionally editor-only: the measured game/sampler process never links
+			// or initializes it. VoxelForgeExplore uses it only in its post-exit symbolizer mode.
+			PublicSystemLibraries.Add("Dbghelp.lib");
+		}
 	}
 }