diff --git a/docs/PRDs/performance/PRD-860-a-repeat-web-run-is-ready-in-about-a-second.md b/docs/PRDs/performance/PRD-860-a-repeat-web-run-is-ready-in-about-a-second.md
new file mode 100644
index 0000000000..751a916aa1
--- /dev/null
+++ b/docs/PRDs/performance/PRD-860-a-repeat-web-run-is-ready-in-about-a-second.md
@@ -0,0 +1,108 @@
+# PRD-860 — A repeat web run is ready in about a second
+
+**Status:** PARTIAL
+**Blocker:** AC-1 is open: a repeat run reads 1.27-1.32 s against the 1.2 s bar (develop 2.39-2.52 s in the same window). Every phase box and AC-2, AC-3 and AC-4 are verified. The owner asked to merge on 2026-11-08 (see Decisions).
+**Priority:** P1 — AC-1 is open: a repeat run of the collectathon kit takes about 1.3 s against the 1.2 s bar.
+**Complexity:** 6 (MEDIUM) — 6-10 implementation files (+2), a new generated-content cache (+2), engine packages and a kit template change together (+2); risk override: none.
+**Owner:** João
+**Depends on:** None. Follows PRD-743 (asset disk cache) and PRD-828 (engine work moves into C++).
+
+## Context
+
+Owner, 2026-11-08: "Goal is to run as fast as possible initially and sequential runs are almost instant. in all platforms." Then: "setup a benchmark on this PRD and only stop when its significantly faster, setup some realistic goal."
+
+Spike, 2026-11-08: the collectathon kit (`--genre mario`) from the published 0.3.12 packages, `pnpm build:web`, `vite preview`, Chromium WebGPU, time from navigation to `__TN_STARTUP_READY__`. The clean numbers come from the quiet laptop (Intel Iris Xe, load 0.3). The desktop numbers were about 4x higher at host load 57, so this PRD uses none of them.
+
+| Run | localhost | 20 Mbit/s, 40 ms |
+| --- | --- | --- |
+| first visit (empty profile) | 2.36 s | 5.05 s |
+| repeat, same browser | 2.00 s | 2.28 s |
+| repeat, browser relaunched | 2.01-2.03 s | 2.37-2.39 s |
+
+A repeat run downloads 6 KB, so the 2.0 s floor is work, not bytes:
+
+- **1.2 s scene build.** `Play.load` regenerates the same seeded world in JS every run. A CPU profile splits it into about 65% course and foliage placement (`src/level/Course.ts`, `src/render/foliage.ts`; per-instance `setMatrixAt`, `pathDistance`, `traverse`), about 25% a 2048x1024 sky painted per pixel in JS (`src/render/`), and about 10% collider boxes.
+- **0.4 s pipeline warm-up.** 350 pipelines, created after the scene build, not during it.
+- **0.3 s boot.** The engine Wasm compiles by `compileStreaming` in about 89 ms.
+
+The first visit adds about 2.7 s of download at 20 Mbit/s for 6.0 MB. The engine Wasm crossed uncompressed because `vite preview` does not serve the `.br` copies the build writes. Rapier sits in `index.js` as a 2.09 MB base64 string (two-thirds of the bundle), so it cannot use streaming compile or the Wasm code cache, and its decode costs about 150 ms each run. The generated `_headers` sets COOP/COEP only, with no `Cache-Control`, so each repeat visit revalidates every file.
+
+Unreal answers the repeated-pipeline part with a user pipeline cache: it records the pipelines a run used and precompiles them on the next launch in batches under a frame budget (UE 5.8.3: Engine/Source/Runtime/RenderCore/Private/ShaderPipelineCache.cpp:66-100 for the batch size of 50 and the 16 ms batch time, :214 for `r.ShaderPipelineCache.SaveUserCache`). WebGPU has no serialized pipeline to restore (`packages/core/src/warmup.ts:1112`), so this PRD borrows the order, not the file: start the recorded pipelines while the scene builds.
+
+## Solution
+
+1. **Benchmark first.** `pnpm bench:load` scaffolds a kit from the local packages, builds it for web and serves `dist/` as a production host does: the `.br` copies with `Content-Encoding`, and the headers in `_headers`. Then it drives Chromium with `--browser-recipe webgpu` flags, a persistent profile and a CDP throttle of 20 Mbit/s with 40 ms latency. Each arm makes one first visit and five relaunches, and the bench reports the median `readyMs`. It also reports the adapter, bytes on the wire and the stage marks (`TN_STATIC_COLLIDERS`, `TN_STARTUP_WARMUP`). The goal machine is the laptop (Intel Iris Xe) through `laptop-offload --gpu --quiet`, because the desktop runs at load 50+.
+2. **Repeat-run levers.**
+   - `_headers` gives hashed `/assets/*` files `Cache-Control: public, max-age=31536000, immutable`.
+   - A generated-content cache (`ctx.assets.memo(key, build)`) keeps typed arrays the game generates in the per-game CacheStorage cache that PRD-743 already owns. The key carries the build identity, so a new build regenerates. On a native host it calls `build` every time and reports why. The kit moves its foliage instances, course buffers and sky pixels behind it, so the look stays the same.
+   - The pipelines a run created are recorded and started while the next run builds its scene, in the Unreal order.
+3. **First-run levers.** Rapier loads as its own hashed `.wasm` through `instantiateStreaming`. The bench confirms the host serves `.br` for the engine Wasm. Then the bench decides whether more is needed.
+
+Each lever lands only when the bench shows a gain above run noise on the paired arms, and it is reverted otherwise.
+
+## Acceptance Criteria
+
+- [ ] AC-1 [local]: a repeat run of the collectathon kit, browser relaunched, is ready in at most 1.2 s median at 20 Mbit/s and 40 ms on the laptop (bench baseline 2.51 s, at least 2x faster). proof: `pnpm bench:load --kit collectathon --network 20000:40 --runs 5` — 2026-11-08, `522a55687`, laptop, paired with develop `4dd50f4c2` in one window: 1271 / 1307 / 1315 ms against 2454 / 2388 / 2515 ms. 1.9x faster, still 70-115 ms over the bar: not met.
+- [x] AC-2 [local]: the first visit of the same kit is ready in at most 2.7 s median under the same conditions (bench baseline 3.90 s, at least 30% faster). proof: `pnpm bench:load --kit collectathon --network 20000:40 --runs 5` — 2026-11-08, `522a55687`, laptop, paired with develop `4dd50f4c2` in one window: 2477 / 2575 / 2574 ms (max 2592) against 3829 / 3708 / 3918 ms, 33% faster.
+- [x] AC-3 [local]: the control, the minimal kit, which uses none of the new caches, is no slower than its develop baseline on either arm, within the spread of three runs. It charges the levers' own bookkeeping to a game that gains nothing. proof: `pnpm bench:load --kit minimal --network 20000:40 --runs 5` — 2026-11-08, `49c1ae3cb`, laptop, three runs: first visit 2931 / 2983 / 2981 ms (baseline 3507-3596), repeat 1400 / 1457 / 1479 ms (baseline 2249-2292). Faster on both arms. Re-measured at `522a55687` in the AC-2 window: first visit 3056 / 2893 / 3031 ms against develop 3543 / 3553 / 3447, repeat 1505 / 1420 / 1466 ms against 2228 / 2250 / 2157.
+- [x] AC-4 [local]: a fresh visual judge rates the spawn frame NEUTRAL or IMPROVEMENT against the develop baseline, two headed WebGPU captures per arm. proof: visual judge subagent on the bench captures — 2026-11-08: NEUTRAL on all four pairs (two runs, first and repeat visit; `TN_LOAD_BENCH_SHOTS`, laptop `intel/gen-12lp`, develop `4dd50f4c2` against `49c1ae3cb`), only animation-phase differences; images on PR #641 (`prd-860-screenshots` `0af50ae8e`).
+
+## Integration Ledger
+
+| Capability | Reachable consumer/trigger | Replaces / disposition | Evidence |
+| --- | --- | --- | --- |
+| Load benchmark | `pnpm bench:load` → `scripts/load-bench.ts` | none, new harness | Phase 1 |
+| Generated-content cache | kit `Play.load` → `ctx.assets.memo` → `packages/core/src/asset-cache.ts` | the per-run regeneration | Phase 2 |
+| Immutable asset headers | `threenative build --target web` → `_headers` | headers with no `Cache-Control` | Phase 2 |
+| Rapier out of line | `@threenative/physics` web import → its own chunk, awaited by `initialize` (`packages/physics/src/web.ts`) | the static import in the entry chunk | Phase 3 |
+| Engine Wasm preload | `threenative build --target web` → head script (`withEnginePreload`, `packages/create-threenative/src/web-brand.ts`) | the glue's late fetch on a first visit | Phase 3 |
+| Instance array writes | any game's `InstancedMesh.setMatrixAt`/`setColorAt` (`packages/three-native/src/browser-attribute-sync.ts` `writeItemAt`, routed in `browser-backend.ts`) | one engine call an instance; a bad index or the first colour keep it | Phase 2 |
+| Physics ready at enter | any game's `rapier()`/`recast()` with a runtime that offers `holdStart` (`packages/physics/src/plugin.ts` setup, `packages/core/src/game-startup.ts` start gates) | `setup` awaited the Wasm before `load()` began; a body built in `load()` now throws `TN_PHYSICS_NOT_READY` | AC-2 |
+| Shared-memory matrix view | any game's `Matrix4`/`Matrix3` `elements` on the threads build (`packages/three-native/src/browser-value-views.ts`) | the per-element Proxy write | Phase 2 |
+
+## Decisions
+
+- 2026-11-08 (agent): AC-2 moves from "at most 3.5 s against 5.05 s" to "at most 2.7 s against 3.90 s". The spike served no Brotli; the bench does, as a production host does, and its first-visit baseline is 3.90 s. The bar stays at least 30% faster.
+- 2026-11-08 (agent): the minimal kit, with almost no scene, repeats in 2.25 s, so most of a repeat run is startup every kit shares (the sky's cloud noise first), not the collectathon's world. The levers start there. The collectathon's course placement shares one seeded random stream with the rest of the course, so it is not cached: skipping it on a hit would change the world.
+
+- 2026-11-08 (agent, from the spike): the goal machine is the quiet laptop, not the desktop, because desktop runs at host load 50+ read 4x high and vary by 40% between runs.
+- 2026-11-08 (agent): the cache stores bytes in TypeScript in core, next to the PRD-743 asset cache. It is I/O, not compute, and core must not carry Wasm. Generation that stays per run moves into C++ through the PRD-828 bulk calls only when the bench shows that the cache alone misses AC-2.
+- 2026-11-08 (agent): native relaunch (pipeline cache on the owned engine, V8 code cache) stays with PRD-368 and PRD-335. This PRD reports native as `memo` disabled with its reason and changes nothing else there.
+- 2026-11-08 (agent): the box "the recorded pipelines start while the scene builds" is deleted. Two attempts measured no gain on paired laptop arms: the environment bake beside the first compile (1755/1748/1785 against 1732/1773/1781 ms), and a JS-side pipeline precache, which Chrome does not dedupe. Chrome's GPU process creates pipelines and runs queue submits in series, so earlier starts only queue earlier.
+- 2026-11-08 (agent): the box "Rapier loads as a hashed `.wasm` through `instantiateStreaming`" is replaced. That build (`cf58debc9`) cut 155 KB but no time, because the static import still held the entry module. What pays is moving Rapier off the boot path: its own chunk, fetched as physics imports (c10).
+- 2026-11-08 (agent): two readiness changes were measured and dropped: exposure reads every frame until measured, and quiet frames counted from the compile (1565/1593/1644 against 1509/1616/1648 ms). The five frames after the compile wait on GPU frames (7-11 ms of CPU each), not on the gate.
+- 2026-11-08 (agent): an always-on Wasm preload (`a1fe3000c`) made a repeat visit 150-200 ms slower, because a preloaded response loses V8's compiled-code cache. The preload runs only for a Wasm URL the browser has not fetched (`49c1ae3cb`).
+- 2026-11-08 (agent): what a repeat run still spends after `e13c0b534`, from one laptop CPU profile (`buildCourse` 323 ms, the cover 147 ms, colliders 61 ms), and why each is not taken here. The collectathon world generation (`plantIsland` path distance, clearance, leaf texture, terrain sampler) draws from one seeded stream, so storing any piece shifts every later draw and moves the island; it needs the kit to split its streams first. The loading cover is drawn every frame (147 ms), and skipping a frame presents black during the warm-up, the startup flash reported three times before. Rapier builds its trimesh tree in its own Wasm (34 ms of the 61). The 1.0-1.4 s tail is GPU-bound pipeline warm-up, where the dropped readiness changes and the JS precache showed no gain.
+- 2026-11-08 (agent): a first visit at `e13c0b534` (laptop CPU profile) spends, after Rapier arrives, about 550 ms painting the collectathon sky (on the critical path about 120 ms past the textures), 350 ms in `buildCourse` and 550 ms compiling and warming the pipelines without a Dawn cache. `Scene.load` starts only after every plugin's `setup`, so all of it waits for the Rapier download. No template or example touches physics in `load`, but readying plugins after `load` changes the public plugin contract, and a faster sky with identical bytes is tuning one kit's art code to this bench. Both stay with the owner's decision on AC-2.
+- 2026-11-08 (owner, João): plugins become ready before `enter()`, not before `load()` ("yes", answering the plugin-order option). `rapier()` and `recast()` leave a `holdStart` gate in place of awaiting their Wasm, so `load()` runs while they initialize. Paired against `dacbbf0f7`: first visit 2528 / 2548 / 2611 ms against 2592 / 2727 / 2679, repeat unchanged. A body built in `load()` throws `TN_PHYSICS_NOT_READY`; no template or example builds one there.
+- 2026-11-08 (agent): the collectathon kit paints its sky and ripples and plants its island with the same bytes, faster (`dacbbf0f7`): exact sRGB byte steps in place of a power a texel, column trig and the ripple lattice once, and distance checks that skip what is clearly out of reach. `skyPixels`, `ripplePixels` and the built course hash the same before and after, so AC-4 stands without a new judge. Paired against `e13c0b534`: first visit 2658 / 2710 / 2683 ms against 2808 / 2979 / 3024, repeat unchanged.
+- 2026-11-08 (agent): the C++ noise bake (PRD-828 bulk calls) is not taken: AC-2 is met without it, and it would cut only the first visit, which AC-1 does not measure.
+- 2026-11-08 (owner, João): merge with AC-1 open ("finish this, then send PR to be merged"). The PRD stays PARTIAL outside `done/`. The repeat run is 1.9x faster than develop and 70-115 ms over the bar; what remains is listed in the Decision on `e13c0b534` above.
+
+## Execution Phases
+
+#### Phase 1: The benchmark and its baseline
+**Status:** DONE
+**Files:** `scripts/load-bench.ts` (new), `package.json` (the `bench:load` script).
+
+- [x] `pnpm bench:load` reports median first-visit and repeat `readyMs`, the adapter and bytes on the wire for one kit. proof: `pnpm bench:load --dist <kit>/dist --network 20000:40 --runs 5` on the laptop — 2026-11-08, `3ebe059ed`: adapter `intel/gen-12lp`, 5 first and 10 repeat visits per run, `.br` served (2805 KB first visit), `scripts/__tests__/load-bench.spec.ts` 2 passed.
+- [x] The develop baseline is recorded here: three bench runs on the laptop for collectathon and for the minimal control, 20 Mbit/s and 40 ms. proof: `pnpm bench:load --dist <kit>/dist --network 20000:40 --runs 5` — packages from `origin/develop` `4dd50f4c2`, laptop load under 2, 74-98 °C:
+  - collectathon first visit 3846 / 3902 / 3907 ms, repeat 2433 / 2512 / 2568 ms.
+  - minimal first visit 3507 / 3555 / 3596 ms, repeat 2249 / 2292 / 2284 ms.
+  - Unthrottled repeat-visit CPU profile (unminified build): in the minimal kit `cloudTextures()` (`templates/*/src/render/clouds.ts`, shared by six kits) runs about 0.6 s of main-thread JS before the first frame, and `bakedRadiance` about 0.12 s.
+
+#### Phase 2: A repeat run does not redo the last run's work
+**Status:** DONE
+**Files:** `packages/create-threenative/src/` (the `_headers` writer), `packages/core/src/asset-cache.ts` and `assets.ts` (`memo`), the collectathon template `src/level/` and `src/render/`, the warm-up path in `packages/core/src/warmup.ts`.
+
+- [x] Hashed assets ship `Cache-Control: public, max-age=31536000, immutable`, and a repeat run makes no revalidation request. proof: `pnpm exec vitest run packages/create-threenative/__tests__` plus the bench request count — 2026-11-08, `3ebe059ed`: `web-brand.spec.ts`, `asset-memo.spec.ts`, `asset-cache.spec.ts`, `load-bench.spec.ts` 46 passed; a repeat visit makes 12 requests with 1 KB on the wire (the page itself).
+- [x] `ctx.assets.memo` returns the stored arrays on a repeat run, and the collectathon kit builds its world through it with its playtests green. proof: `pnpm exec vitest run packages/core/__tests__/asset-cache.spec.ts` plus `pnpm test:templates` for collectathon. — 2026-11-08: `asset-cache.spec.ts` and `asset-memo.spec.ts` 37 passed. `TN_TEMPLATE_ONLY=collectathon,minimal pnpm test:templates` on the laptop (Iris Xe, `e13c0b534`): collectathon 22 of 23 scenarios pass in two runs, minimal all but one. The one fail per kit is `no-hitch` GPU p95 (collectathon 27.2 ms, minimal 18.0 ms over 16.7), and develop `4dd50f4c2` fails it the same on that laptop (27.6 ms, 17.5 ms), so the GPU, not this PRD, misses it. An earlier HEAD run flagged one `steadyCover` frame at 25 ms in Chromium's blank-tab `#121212` before first paint; it did not recur in two reruns. Re-run on the merge of develop `0711f2b77` (`ef302e32a`, collectathon, minimal and racing): 37 scenarios pass; only the no-hitch GPU p95 rows fail (collectathon 28.17, minimal 18.08 ms against develop 27.63 and 17.51; racing 18.63 ms with no develop control run: unverified).
+- [x] The hot paths a repeat run walks cost less, each kept only on a paired laptop gain. proof: `pnpm bench:load --kit collectathon --network 20000:40 --runs 5` — 2026-11-08: the scattering table built once in six kits and the reach cull over vertices (`e6f24156f`, repeat 1586-1632 ms from 1784-1795); foliage composes plain matrices and the path distance is a loop (`03414c30b`, 70-100 ms paired); a matrix over shared engine memory is a view, not a Proxy (`bf9a55778`, 1512/1569/1555 against 1566/1616/1644 ms paired); `setMatrixAt` and `setColorAt` write the instance array and send the written range once before the next engine call (`e13c0b534`, repeat 1380/1387/1381 against 1506/1536/1514 ms and first 3124/3151/3126 against 3190/3295/3217 ms paired with `49c1ae3cb`). `browser-math.spec.ts` and `browser-backend-coverage.spec.ts` red-green, three-native 536 passed, physics 267 passed.
+
+#### Phase 3: A first visit downloads and compiles less
+**Status:** DONE
+**Files:** `packages/physics/src/web.ts`, the web build in `packages/create-threenative/src/`, the collectathon `src/scenes/Play.ts`.
+
+- [x] Rapier downloads beside the engine boot, and `index.js` carries no base64 module. proof: `pnpm exec vitest run packages/physics/__tests__` plus the bench byte report — 2026-11-08, `3ae3ff027`: physics 267 passed; `index.js` 864 → 250 KB Brotli, Rapier its own 614 KB chunk; collectathon first visit 3545-3616 ms from 3695-3725, minimal 3132-3252 from 3268-3434.
+- [x] The engine Wasm starts with the page and Rapier after it, on a first visit only. proof: `pnpm exec vitest run packages/create-threenative/__tests__/web-brand.spec.ts` plus a paired bench — 2026-11-08, `49c1ae3cb`: 8 passed; the Wasm lands at 670 ms, not 805; collectathon first 3123/3124/3140 against 3169/3277/3314 ms paired, repeat flat; minimal first 2931-2983 ms.
+- [x] The collectathon paints its sky while its surface textures download. proof: `pnpm bench:load --kit collectathon --network 20000:40 --runs 5` — 2026-11-08, `637eda3a9`: first visit 3084/3221/3265 ms from 3545-3616.
diff --git a/docs/verification/native-coverage-2026-08-28.md b/docs/verification/native-coverage-2026-08-28.md
index 57d4d22c40..b759ce5ad2 100644
--- a/docs/verification/native-coverage-2026-08-28.md
+++ b/docs/verification/native-coverage-2026-08-28.md
@@ -11,7 +11,7 @@ targets could not be built and are named below.
 | `src/audio/` | 1471 | 1301 | 88.44% |
 | `src/canvas/` | 1334 | 1110 | 83.21% |
 | `src/cli/` | 1691 | 1243 | 73.51% |
-| `src/engine/` | 43273 | 36221 | 83.70% |
+| `src/engine/` | 43282 | 36230 | 83.71% |
 | `src/fs/` | 235 | 189 | 80.43% |
 | `src/http/` | 410 | 377 | 91.95% |
 | `src/js/` | 2838 | 2230 | 78.58% |
@@ -22,12 +22,12 @@ targets could not be built and are named below.
 | `src/storage/` | 370 | 329 | 88.92% |
 | `src/utils/` | 0 | 0 | 0.00% |
 | `src/vfs/` | 239 | 195 | 81.59% |
-| `src/webgpu/` | 10076 | 7745 | 76.87% |
+| `src/webgpu/` | 10076 | 7736 | 76.78% |
 | `src/webtransport/` | 1391 | 1078 | 77.50% |
-| `src/workers/` | 615 | 524 | 85.20% |
-| **TOTAL** | **68603** | **56083** | **81.75%** |
+| `src/workers/` | 615 | 527 | 85.69% |
+| **TOTAL** | **68612** | **56086** | **81.74%** |
 
-Source digest: `sha256:2f9ed85cc1717a794e64a27b65fa0b8af957a162c1733396241ce64111e31162`
+Source digest: `sha256:2da952e005c78e4d4a7328bc8b1949e8af153f74dc24b7bd7dbb680262ffb453`
 
 The default `pnpm budgets` gate reads this committed measurement without configuring or compiling
 the native host. Any native source, native C++ test, CTest registration, or coverage aggregation
diff --git a/package.json b/package.json
index 5ce5907fd2..7f710dd237 100644
--- a/package.json
+++ b/package.json
@@ -15,6 +15,7 @@
     "api:surface:sync": "tsx scripts/check-api-surface.ts --update && biome format --write scripts/api-surface.json",
     "bake:delete-test": "sh scripts/xvfb.sh tsx scripts/bake-delete-test.ts",
     "bench:engines": "tsx scripts/engine-load-test/cli.ts",
+    "bench:load": "tsx scripts/load-bench.ts",
     "bench:engines:report": "tsx scripts/engine-load-test/cli.ts --compare",
     "bench:engines:monitor": "tsx scripts/engine-load-test/monitor.ts",
     "dashboard": "tsx scripts/perf-live.ts",
diff --git a/packages/core/__tests__/asset-memo.spec.ts b/packages/core/__tests__/asset-memo.spec.ts
new file mode 100644
index 0000000000..cba5d06d76
--- /dev/null
+++ b/packages/core/__tests__/asset-memo.spec.ts
@@ -0,0 +1,116 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createAssetMemo, decodeMemo, encodeMemo } from "../src/asset-memo.js";
+import { FakeCacheStorage } from "./fixtures/fake-cache.js";
+
+const scope = globalThis as { caches?: unknown; __TN_BUILD_ID__?: unknown };
+
+describe("ctx.assets.memo (PRD-860)", () => {
+  let storage: FakeCacheStorage;
+  beforeEach(() => {
+    storage = new FakeCacheStorage();
+    scope.caches = storage;
+    scope.__TN_BUILD_ID__ = "/assets/index-AAAA.js";
+    vi.spyOn(console, "info").mockImplementation(() => undefined);
+  });
+  afterEach(() => {
+    Reflect.deleteProperty(scope, "caches");
+    Reflect.deleteProperty(scope, "__TN_BUILD_ID__");
+    vi.restoreAllMocks();
+  });
+
+  it("builds once, then a later run of the same build reads the stored arrays back", async () => {
+    const build = vi.fn(() => ({
+      pixels: new Uint8Array([1, 2, 3]),
+      at: new Float32Array([0.5, -2]),
+    }));
+    const first = await createAssetMemo("game")("sky", build);
+    await vi.waitFor(async () =>
+      expect((await storage.open([...storage.caches.keys()][0] ?? "")).store.size).toBe(1),
+    );
+    const second = await createAssetMemo("game")("sky", build);
+    expect(build).toHaveBeenCalledTimes(1);
+    expect([...second.pixels]).toEqual([...first.pixels]);
+    expect(second.at).toBeInstanceOf(Float32Array);
+    expect([...second.at]).toEqual([0.5, -2]);
+  });
+
+  it("rebuilds after a new build and deletes the old build's entries", async () => {
+    const build = vi.fn(() => ({ v: new Uint16Array([7]) }));
+    await createAssetMemo("game")("k", build);
+    await vi.waitFor(() => expect(storage.caches.size).toBe(1));
+    scope.__TN_BUILD_ID__ = "/assets/index-BBBB.js";
+    await createAssetMemo("game")("k", build);
+    expect(build).toHaveBeenCalledTimes(2);
+    const cache = [...storage.caches.values()][0];
+    await vi.waitFor(async () => {
+      const urls = (await cache?.keys())?.map((request) => request.url) ?? [];
+      expect(urls).toHaveLength(1);
+      expect(urls[0]).toContain(encodeURIComponent("/assets/index-BBBB.js"));
+    });
+  });
+
+  it("builds every run, and says why, with no build id or no cache storage", async () => {
+    Reflect.deleteProperty(scope, "__TN_BUILD_ID__");
+    const build = vi.fn(() => ({ v: new Int32Array([1]) }));
+    await createAssetMemo("game")("k", build);
+    await createAssetMemo("game")("k", build);
+    expect(build).toHaveBeenCalledTimes(2);
+    expect(storage.caches.size).toBe(0);
+    expect(String(vi.mocked(console.info).mock.calls.at(-1)?.[0])).toContain(
+      '"reason":"no build id',
+    );
+  });
+
+  it("takes a build typed by an interface, the shape a generator module exports", async () => {
+    interface IPainted {
+      readonly sky: Float32Array;
+      readonly mask: Uint8Array;
+    }
+    const paint = (): IPainted => ({ mask: new Uint8Array([1]), sky: new Float32Array([0.5]) });
+    const painted: IPainted = await createAssetMemo("game")("painted", paint);
+    expect([...painted.mask]).toEqual([1]);
+  });
+
+  it("rebuilds over a corrupt entry instead of failing the load", async () => {
+    const build = vi.fn(() => ({ v: new Float64Array([3]) }));
+    const memo = createAssetMemo("game");
+    await memo("k", build);
+    const cache = [...storage.caches.values()][0];
+    await vi.waitFor(async () => expect((await cache?.keys())?.length).toBe(1));
+    const url = (await cache?.keys())?.[0]?.url ?? "";
+    await cache?.put(url, new Response(new Uint8Array([9, 9])));
+    const again = await createAssetMemo("game")("k", build);
+    expect(build).toHaveBeenCalledTimes(2);
+    expect([...again.v]).toEqual([3]);
+  });
+
+  it("rejects a key or a value it cannot store", async () => {
+    const memo = createAssetMemo("game");
+    await expect(memo("", () => ({ v: new Uint8Array(1) }))).rejects.toThrow(
+      "TN_ASSET_MEMO_INVALID",
+    );
+    await expect(memo("k", () => ({ v: [1, 2] as unknown as Uint8Array }))).rejects.toThrow(
+      "TN_ASSET_MEMO_INVALID",
+    );
+  });
+
+  it("round-trips every typed array kind with its exact values", () => {
+    const value = {
+      a: new Float32Array([1.5]),
+      b: new Float64Array([Math.PI]),
+      c: new Int8Array([-3]),
+      d: new Int16Array([-300]),
+      e: new Int32Array([-70000]),
+      f: new Uint8Array([250]),
+      g: new Uint8ClampedArray([255]),
+      h: new Uint16Array([65000]),
+      i: new Uint32Array([4000000000]),
+      empty: new Float32Array(0),
+    };
+    const decoded = decodeMemo(encodeMemo(value));
+    for (const [name, array] of Object.entries(value)) {
+      expect(decoded[name]?.constructor).toBe(array.constructor);
+      expect([...(decoded[name] ?? [])]).toEqual([...array]);
+    }
+  });
+});
diff --git a/packages/core/__tests__/world-asset-alias.spec.ts b/packages/core/__tests__/world-asset-alias.spec.ts
index 781bd0627d..37fae82eab 100644
--- a/packages/core/__tests__/world-asset-alias.spec.ts
+++ b/packages/core/__tests__/world-asset-alias.spec.ts
@@ -144,6 +144,7 @@ function countingLoader(): { assets: IAssetLoader; models: string[] } {
   const inner = createAssetLoader({ basePath: "" });
   const models: string[] = [];
   const assets: IAssetLoader = {
+    memo: inner.memo,
     get compressedTextures() {
       return inner.compressedTextures;
     },
diff --git a/packages/core/__tests__/world-cells-terrain.spec.ts b/packages/core/__tests__/world-cells-terrain.spec.ts
index 7b760e24ba..20dd18301f 100644
--- a/packages/core/__tests__/world-cells-terrain.spec.ts
+++ b/packages/core/__tests__/world-cells-terrain.spec.ts
@@ -22,6 +22,7 @@ function makeModel(): Object3D {
 
 function cacheLoader(): IAssetLoader {
   return {
+    memo: () => Promise.reject(new Error("unused")),
     audio: () => Promise.reject(new Error("unused")),
     cache: {
       backgroundFill: false,
diff --git a/packages/core/__tests__/world-cells.spec.ts b/packages/core/__tests__/world-cells.spec.ts
index 46f695b793..7381601769 100644
--- a/packages/core/__tests__/world-cells.spec.ts
+++ b/packages/core/__tests__/world-cells.spec.ts
@@ -576,6 +576,7 @@ function cacheLoader(load: (path: string) => Object3D | undefined = () => makeMo
   const released: string[] = [];
   const cleared: number[] = [];
   const assets: IAssetLoader = {
+    memo: () => Promise.reject(new Error("unused")),
     audio: () => Promise.reject(new Error("unused")),
     cache: {
       backgroundFill: false,
diff --git a/packages/core/capabilities.json b/packages/core/capabilities.json
index d0f16896ba..caa1bba1bd 100644
--- a/packages/core/capabilities.json
+++ b/packages/core/capabilities.json
@@ -5566,7 +5566,10 @@
     },
     {
       "aliases": [],
-      "constraints": ["place rapier() before recast() in the plugin list"],
+      "constraints": [
+        "place rapier() before recast() in the plugin list",
+        "ctx.physics is set before Scene.enter(), not during load(): Rapier initializes while the scene loads, so create bodies in enter() or later (TN_PHYSICS_NOT_READY)"
+      ],
       "example": "const game = defineGame({ plugins: [rapier()] });",
       "importPath": "@threenative/physics",
       "kind": "function",
diff --git a/packages/core/src/asset-cache.ts b/packages/core/src/asset-cache.ts
index a61fb6feef..5aaf5876e9 100644
--- a/packages/core/src/asset-cache.ts
+++ b/packages/core/src/asset-cache.ts
@@ -73,13 +73,13 @@ const ACCESS_REFRESH_MS = 3_600_000;
 /** Lower is more urgent. */
 export const PRIORITY_ORDER: Record<AssetPriority, number> = { now: 0, soon: 1, idle: 2 };
 
-type CacheStorageLike = {
+export type CacheStorageLike = {
   delete(name: string): Promise<boolean>;
   keys(): Promise<readonly string[]>;
   open(name: string): Promise<CacheLike>;
 };
 
-type CacheLike = {
+export type CacheLike = {
   delete(request: string): Promise<boolean>;
   keys(): Promise<readonly Request[]>;
   match(request: string): Promise<Response | undefined>;
@@ -94,7 +94,7 @@ interface IJob {
   priority: AssetPriority;
 }
 
-function cacheStorage(): CacheStorageLike | undefined {
+export function cacheStorage(): CacheStorageLike | undefined {
   return (globalThis as { caches?: CacheStorageLike }).caches;
 }
 
diff --git a/packages/core/src/asset-memo.ts b/packages/core/src/asset-memo.ts
new file mode 100644
index 0000000000..69d1c3d438
--- /dev/null
+++ b/packages/core/src/asset-memo.ts
@@ -0,0 +1,202 @@
+import { type CacheLike, cacheStorage, manifestFingerprint } from "./asset-cache.js";
+import { isNative } from "./platform.js";
+
+/**
+ * Generated content kept between runs (PRD-860): `ctx.assets.memo(key, build)` returns what `build`
+ * returned the last time this exact build of the game ran, read back from disk, and calls `build`
+ * only when nothing is stored. A seeded world, a painted sky or a baked placement list is the same
+ * every run of one build, so a repeat visit stops paying for it.
+ *
+ * The value is named typed arrays, the shape a generator hands to geometry, instancing and
+ * textures. The build identity is the hashed entry script the web build writes into the page
+ * (`__TN_BUILD_ID__`), so any code change regenerates and the old build's entries are deleted. With
+ * no build identity (the dev server) or no Cache API (a native host), `build` runs every time and
+ * `TN_ASSET_MEMO` says why.
+ */
+export type MemoArray =
+  | Float32Array
+  | Float64Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array;
+
+export type MemoArrays = Readonly<Record<string, MemoArray>>;
+/** Every field a typed array: a record or an interface, which has no index signature. */
+export type MemoShape<T> = { readonly [K in keyof T]: MemoArray };
+
+export type AssetMemo = <T extends MemoShape<T>>(
+  key: string,
+  build: () => T | Promise<T>,
+) => Promise<T>;
+
+const KINDS = {
+  Float32Array,
+  Float64Array,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  Uint16Array,
+  Uint32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+} as const;
+type Kind = keyof typeof KINDS;
+
+const BUILD_ID_GLOBAL = "__TN_BUILD_ID__";
+const MEMO_CACHE = "threenative-memo";
+/** A host no request ever reaches: the Cache API only needs an absolute url to key on. */
+const MEMO_ORIGIN = "https://memo.threenative.invalid/";
+const MAGIC = 0x4f4d4e54; // "TNMO"
+
+function invalid(detail: string): Error {
+  return new Error(`TN_ASSET_MEMO_INVALID: ${detail}`);
+}
+
+function kindOf(value: unknown): Kind | undefined {
+  for (const kind of Object.keys(KINDS) as Kind[]) if (value instanceof KINDS[kind]) return kind;
+  return undefined;
+}
+
+/** Header (magic, JSON length, JSON) then each array's bytes at an 8-byte boundary. */
+export function encodeMemo(value: MemoArrays): ArrayBuffer {
+  const entries = Object.entries(value).map(([name, array]) => {
+    const kind = kindOf(array);
+    if (kind === undefined) throw invalid(`"${name}" is not a typed array.`);
+    return { array, kind, name };
+  });
+  const align = (n: number): number => Math.ceil(n / 8) * 8;
+  const header = new TextEncoder().encode(
+    JSON.stringify(entries.map(({ array, kind, name }) => ({ kind, length: array.length, name }))),
+  );
+  let offset = align(8 + header.byteLength);
+  const placed = entries.map((entry) => {
+    const at = offset;
+    offset = align(at + entry.array.byteLength);
+    return { ...entry, at };
+  });
+  const buffer = new ArrayBuffer(offset);
+  const view = new DataView(buffer);
+  view.setUint32(0, MAGIC, true);
+  view.setUint32(4, header.byteLength, true);
+  new Uint8Array(buffer, 8, header.byteLength).set(header);
+  for (const { array, at } of placed)
+    new Uint8Array(buffer, at, array.byteLength).set(
+      new Uint8Array(array.buffer, array.byteOffset, array.byteLength),
+    );
+  return buffer;
+}
+
+/** The inverse of `encodeMemo`; throws on anything it did not write. */
+export function decodeMemo(buffer: ArrayBuffer): Record<string, MemoArray> {
+  const view = new DataView(buffer);
+  if (buffer.byteLength < 8 || view.getUint32(0, true) !== MAGIC)
+    throw invalid("stored entry is not a memo.");
+  const headerBytes = view.getUint32(4, true);
+  if (8 + headerBytes > buffer.byteLength) throw invalid("stored entry is truncated.");
+  const header: unknown = JSON.parse(
+    new TextDecoder().decode(new Uint8Array(buffer, 8, headerBytes)),
+  );
+  if (!Array.isArray(header)) throw invalid("stored entry has no array list.");
+  const result: Record<string, MemoArray> = {};
+  let offset = Math.ceil((8 + headerBytes) / 8) * 8;
+  for (const entry of header as Array<{ kind?: unknown; length?: unknown; name?: unknown }>) {
+    const kind = entry.kind as Kind;
+    const Ctor = KINDS[kind];
+    if (Ctor === undefined || typeof entry.name !== "string" || !Number.isInteger(entry.length))
+      throw invalid("stored entry has a malformed array.");
+    const length = entry.length as number;
+    const bytes = length * Ctor.BYTES_PER_ELEMENT;
+    if (offset + bytes > buffer.byteLength) throw invalid("stored entry is truncated.");
+    result[entry.name] = new Ctor(buffer, offset, length);
+    offset = Math.ceil((offset + bytes) / 8) * 8;
+  }
+  return result;
+}
+
+function report(fields: Record<string, unknown>): void {
+  console.info(`TN_ASSET_MEMO:${JSON.stringify(fields)}`);
+}
+
+function now(): number {
+  return globalThis.performance?.now() ?? Date.now();
+}
+
+export function createAssetMemo(namespace: string): AssetMemo {
+  const storage = cacheStorage();
+  const id = (globalThis as Record<string, unknown>)[BUILD_ID_GLOBAL];
+  const buildId = typeof id === "string" && id !== "" ? id : undefined;
+  const reason =
+    storage === undefined
+      ? isNative()
+        ? "native host has no Cache API: generated content rebuilds each run"
+        : "cache API unavailable: generated content rebuilds each run"
+      : buildId === undefined
+        ? "no build id (dev server or a page the web build did not write): generated content rebuilds each run"
+        : undefined;
+  const prefix = buildId === undefined ? "" : `${MEMO_ORIGIN}${encodeURIComponent(buildId)}/`;
+  const name = `${MEMO_CACHE}-${manifestFingerprint([{ url: namespace }]).slice(0, 8)}`;
+  let opened: Promise<CacheLike | undefined> | undefined;
+  /** Opens once, deleting what another build stored, so a cache holds one build's content. */
+  const open = (): Promise<CacheLike | undefined> => {
+    opened ??= (async () => {
+      const cache = await storage?.open(name);
+      if (cache === undefined) return undefined;
+      for (const request of await cache.keys())
+        if (!request.url.startsWith(prefix)) await cache.delete(request.url);
+      return cache;
+    })().catch(() => undefined);
+    return opened;
+  };
+  const checked = <T extends MemoShape<T>>(key: string, value: T): T => {
+    if (typeof value !== "object" || value === null)
+      throw invalid(`build for "${key}" returned no object.`);
+    for (const [field, array] of Object.entries(value))
+      if (kindOf(array) === undefined)
+        throw invalid(`build for "${key}" returned "${field}", not a typed array.`);
+    return value;
+  };
+
+  return async <T extends MemoShape<T>>(key: string, build: () => T | Promise<T>): Promise<T> => {
+    if (typeof key !== "string" || key === "") throw invalid("key must be a non-empty string.");
+    const started = now();
+    if (reason !== undefined) {
+      const value = checked(key, await build());
+      report({ key, hit: false, ms: Math.round(now() - started), reason });
+      return value;
+    }
+    const url = `${prefix}${encodeURIComponent(key)}`;
+    const cache = await open();
+    if (cache !== undefined) {
+      try {
+        const stored = await cache.match(url);
+        if (stored !== undefined) {
+          const buffer = await stored.arrayBuffer();
+          const value = decodeMemo(buffer) as unknown as T;
+          report({ bytes: buffer.byteLength, hit: true, key, ms: Math.round(now() - started) });
+          return value;
+        }
+      } catch {
+        // A damaged entry is a miss: delete it and build, never fail the load over a cache.
+        await cache.delete(url).catch(() => undefined);
+      }
+    }
+    const value = checked(key, await build());
+    const encoded = encodeMemo(value as MemoArrays);
+    const builtMs = Math.round(now() - started);
+    if (cache === undefined) {
+      report({ hit: false, key, ms: builtMs, reason: "cache storage refused to open" });
+      return value;
+    }
+    void cache
+      .put(url, new Response(encoded))
+      .then(() => report({ bytes: encoded.byteLength, hit: false, key, ms: builtMs, stored: true }))
+      .catch((error: unknown) =>
+        report({ hit: false, key, ms: builtMs, stored: false, reason: String(error) }),
+      );
+    return value;
+  };
+}
diff --git a/packages/core/src/assets.ts b/packages/core/src/assets.ts
index f610893458..8d20ffd6dd 100644
--- a/packages/core/src/assets.ts
+++ b/packages/core/src/assets.ts
@@ -20,6 +20,7 @@ import {
   canonicalUrl,
   createAssetCache,
 } from "./asset-cache.js";
+import { type AssetMemo, createAssetMemo } from "./asset-memo.js";
 import { TN_VIRTUAL_GEOMETRY, VirtualGeometryPlugin } from "./clustered-mesh.js";
 import { GEOMETRY_ASSET_KEY } from "./geometry-capture.js";
 import { attachInstancedLod } from "./instanced-batch-lod.js";
@@ -218,6 +219,16 @@ export interface IAssetLoader {
    * a game that drives a loader outside `defineGame` may call it after its own reveal.
    */
   startBackgroundFill(): Promise<void>;
+  /**
+   * Generated content kept between runs (PRD-860): returns what `build` returned the last time this
+   * build of the game ran, read from disk, and calls `build` only when nothing is stored. Use it for
+   * seeded work that is the same every run, such as placement lists, painted sky pixels or terrain
+   * heights. The value is named typed arrays. A new build regenerates. On the dev server and on a
+   * native host `build` runs every time, and `TN_ASSET_MEMO` says why.
+   *
+   * @example const { pixels } = await ctx.assets.memo("sky", () => ({ pixels: paintSky() }));
+   */
+  memo: AssetMemo;
   /**
    * How many loads this loader has been asked for and how many have settled (resolved or
    * rejected). A loading view reads the ratio; the runtime folds it into `ctx.startup.progress`
@@ -1514,6 +1525,7 @@ export function createAssetLoader(options: IAssetLoaderOptions = {}): IAssetLoad
     get progress() {
       return { pending: [...pending], requested, requestedBytes, settled, settledBytes };
     },
+    memo: createAssetMemo(canonicalUrl(manifestUrl)),
     prefetch: prefetchPaths,
     resolve: async (path) => (await resolveCandidates(path)).urls,
     startBackgroundFill: () => {
diff --git a/packages/create-threenative/__tests__/scaffold.spec.ts b/packages/create-threenative/__tests__/scaffold.spec.ts
index 8370427631..ccac151918 100644
--- a/packages/create-threenative/__tests__/scaffold.spec.ts
+++ b/packages/create-threenative/__tests__/scaffold.spec.ts
@@ -235,6 +235,9 @@ const BUG_REPORT_SKILL_PATHS = [
 // Re-measured on the merge of develop into the Strata hardening branch: the develop tree moved
 // every no-install scaffold (three 0.187.0, the rts kit and the dropped Blender server), so no value
 // from either parent applies to the merged bytes.
+// Recomputed 2026-11-08 (PRD-860): seven kits take the generated-content memo (the cloud noise, the
+// collectathon sky) and one scattering table a run; collectathon then paints and plants the same bytes
+// faster; re-measured on the merge of develop 0711f2b77 (PRD-859) by this test.
 const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   // PRD-829 (2026-11-06): all sixteen trees move, measured by this test. Each kit AGENTS/CLAUDE pair
   // gains the `npx threenative doctor --fix` command line. The new `.threenative/agent-files.json`
@@ -378,7 +381,7 @@ const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   // Re-pinned 2026-10-31: the starter crate gets a stacked-disc contact shadow (render/contactShadow.ts)
   // that keeps its contact coverage above the 0.02 floor at the core +1 EV key.
   // 2026-11-04 (PRD-777 on PRD-632): action-rpg AGENTS/CLAUDE name the spell factories in one line. Measured by this test.
-  "action-rpg": "8530428c87d1f1927cce69d9748dea727ff713afd3ffc1b22a72b0a24d8b1a82",
+  "action-rpg": "4507092b86970ea491d62fc69df656daaf9a88f76b09695301adf1c468cb1a79",
   // PRD-732 (2026-10-23): the new Hop Garden kit, measured through createProject (method checked
   // against platformer's unchanged value). Recomputed 2026-10-24 for the PRD-732 polish round: the
   // new hero, the dust and sparkle effects and the effects scenario. Recomputed 2026-10-24 for
@@ -392,7 +395,7 @@ const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   // Recomputed 2026-10-24 for the shadow window: the 52 m map now travels 14 m ahead of the hero,
   // so the castle and trees the camera sees keep their shadows; the 2048 map and shadow pass cost
   // stay the same.
-  collectathon: "dc87cfcd5b8b3b927cea013b11c15870315bc9a98fc524fde55dfe04d3d66f6c",
+  collectathon: "7182d581f53549f738b356315c0af7caed7fe275f77be3c822be06eeb6d4c0a4",
   // PRD-733 (2026-10-23): the new Lantern Vale kit, measured through createProject.
   // Recomputed 2026-10-24 for the owner perf round: the fixed-step catch-up cap and the gentler
   // wind on the crowns, clusters and grass tufts. Only this tree moves.
@@ -404,10 +407,10 @@ const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   adventure: "b3e72b48f9c3a31075ccbe98fc8bc377598c4596047f7fee0772579f6ee7b633",
   // PRD-734 (2026-10-24): the new Clover Cup kart kit, measured through createProject.
   kart: "4fe986f16315e0c3533bd115b9f16712bc094c1a1872fcf35361c37bfa82be1e",
-  minimal: "7061e7e24a98928cb39d1cffd9d50b279040b69bff9ef48d99e4065d95489116",
+  minimal: "36dc45bd50b04aaf04d42232d7f548cd235085bea03b085c5518117ab2abb7ac",
   platformer: "68f8a8b87fa7e8f0e07bb05c12cea13125372de6171e4f504f600e1b445397c7",
   puzzle: "d2b2cbbd19542993b0cdad6cb041ee4186a69e4dc068f79d32022f62be2a589d",
-  racing: "afb32d59ca43baece601ea1f677443c9e3e8d62b8a2bfefedd2f7f6ca91af2d4",
+  racing: "0efb3823e631eef952938ed5df3ef6e9fc3129faf4bc084e1931ca142d1ed704",
   rain: "ebb3600d8ad42a87a1aa97888a6ceb55c55f587571dc2ad3588b7e982d1656aa",
   // Re-pinned 2026-10-28: the rts high tier turns camera motion blur off (an RTS pan smeared every unit).
   // Re-pinned 2026-10-28 (PRD-765): rts becomes AstraCraft — painted ground, mesas, scrub, ACES 1.02 look and the command HUD;
@@ -426,7 +429,7 @@ const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   // `performance.maxTriangles` bound (45,000 to 54,000), which is a scenario file in the tree.
   // Measured by this test.
   rts: "eeb55962ecb4ffe14c7356a571477b12169718b9b9b94a2d67775a42dadb9d44",
-  runner: "cf5b97e6820851cbdd8761d565f1b3083497e746a736aa2e1d9334b2cf3edb0b",
+  runner: "b94708cc70588a519fdae80c410c9515714c2f4bc64a72556e53a832dd6244b0",
   // Finite-height readiness plus hull, sail, and buoy interpolation from the current swell pose.
   // Re-measured 2026-11-03 (PRD-617): its AGENTS/CLAUDE engine section no longer claims an engine
   // pin the template does not carry. Measured by this test.
@@ -435,7 +438,7 @@ const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   // samples as the adapter happens to draw. Only this tree moves.
   sailing: "2399fac8e544b03927b542492cba2b57ad5619457359eddbfe816bb3f4e737a3",
   // Recomputed 2026-10-26 (PRD-746): the scene merges the town through mergeByMaterial (src/townBatch.ts).
-  shooter: "435f2356890eb531fb42f5a36101efb94845be2823b3589c3daa464b73dc3070",
+  shooter: "ac425ad2d0b7398b77880652d8b59d232c6380d5377f86711294984666f2d9d6",
   snow: "9a647027643ed505d2962732926649e11d12e844b87771a07ad75e8525a4ad5e",
   // Measured 2026-10-16 through createProject after starter's completed-work quality fallback fix.
   // Recomputed 2026-10-16: starter's adaptiveQuality split its policy resolution into qualityPolicy.ts
@@ -449,7 +452,7 @@ const PRD_201_PARENT_SCAFFOLD_HASHES: Readonly<Record<string, string>> = {
   // Play.ts's motion samples between presented frames and fixed steps, and moved two native
   // playtests; #606 moved the render resolve. Starter is the one template both sides changed.
   // Measured by this test.
-  starter: "58fa57ba8bc8dde0169e8fecf5cb72a8934c237eee79ae358eea65470aa85682",
+  starter: "591d44465e0a50cec033e821df39ca12fc121fd8a39273d291801c274a023c81",
   "tower-defense": "c1ff21a577d9a495ccf8383bbb66b880e8fc9bd325c4ea96a9c2d72716a02357",
 };
 
diff --git a/packages/create-threenative/__tests__/web-brand.spec.ts b/packages/create-threenative/__tests__/web-brand.spec.ts
index 6a37a3c550..0de243a3a8 100644
--- a/packages/create-threenative/__tests__/web-brand.spec.ts
+++ b/packages/create-threenative/__tests__/web-brand.spec.ts
@@ -2,7 +2,7 @@ import { mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import { makeTempDir } from "../../../test-support/temp-dir.js";
-import { createWebBrandPlugin } from "../src/web-brand.js";
+import { createWebBrandPlugin, withBuildId, withEnginePreload } from "../src/web-brand.js";
 
 const roots: string[] = [];
 
@@ -186,7 +186,8 @@ describe("web branding adapter", () => {
       },
     });
     expect(emitted._headers).toBe(
-      "/*\n  Cross-Origin-Embedder-Policy: require-corp\n  Cross-Origin-Opener-Policy: same-origin\n",
+      "/*\n  Cross-Origin-Embedder-Policy: require-corp\n  Cross-Origin-Opener-Policy: same-origin\n" +
+        "/assets/*\n  Cache-Control: public, max-age=31536000, immutable\n",
     );
   });
   it("leaves upstream three alone in a native bundle, whose host is not a browser (PRD-637)", async () => {
@@ -260,4 +261,85 @@ describe("web branding adapter", () => {
     expect(html.match(/rel="icon"/gu)).toHaveLength(1);
     expect(html).toContain('rel="manifest" href="/manifest.webmanifest"');
   });
+
+  it("writes the hashed entry script as the build id ctx.assets.memo keys on, and none in dev (PRD-860)", () => {
+    const built = withBuildId(
+      '<head>\n    <script type="module" crossorigin src="/assets/index-DsA_BRqT.js"></script>\n</head>',
+    );
+    expect(built).toContain(
+      '<script>globalThis.__TN_BUILD_ID__ = "/assets/index-DsA_BRqT.js";</script>',
+    );
+    expect(built.indexOf("__TN_BUILD_ID__")).toBeLessThan(built.indexOf('type="module"'));
+    const dev = '<script type="module" src="/src/main.ts"></script>';
+    expect(withBuildId(dev)).toBe(dev);
+  });
+
+  it("starts the engine's Wasm with the page, then Rapier, instead of after the entry script ran (PRD-860)", () => {
+    const html =
+      '<head>\n    <script type="module" crossorigin src="/game/assets/index-A1.js"></script>\n</head>';
+    const bundle = {
+      "assets/index-A1.js": { fileName: "assets/index-A1.js", type: "chunk", moduleIds: [] },
+      "assets/tn-native-engine-web-threads-T1.wasm": {
+        fileName: "assets/tn-native-engine-web-threads-T1.wasm",
+        type: "asset",
+      },
+      "assets/tn-native-engine-web-P1.wasm": {
+        fileName: "assets/tn-native-engine-web-P1.wasm",
+        type: "asset",
+      },
+      "assets/rapier-R1.js": {
+        fileName: "assets/rapier-R1.js",
+        type: "chunk",
+        moduleIds: ["/n/node_modules/@dimforge/rapier3d-compat/rapier.es.js"],
+      },
+    };
+    const threaded = withEnginePreload(html, bundle, true);
+    // Isolated, the threads build; not isolated, nothing (the isolation worker may reload the page).
+    expect(threaded).toContain('"/game/assets/tn-native-engine-web-threads-T1.wasm"');
+    expect(threaded).not.toContain("web-P1.wasm");
+    expect(threaded).toContain('"/game/assets/rapier-R1.js"');
+    expect(threaded.indexOf("tn-native-engine-web-threads-T1")).toBeLessThan(
+      threaded.indexOf('type="module"'),
+    );
+    // A repeat visit skips it: a preloaded response loses V8's compiled-code cache, and recompiling the
+    // module cost a laptop's repeat visit ~150 ms. The script runs as the page would run it.
+    const run = (isolated: boolean, stored: Record<string, string>) => {
+      const links: { rel: string; href: string; onload?: () => void }[] = [];
+      const source = /<script>([\s\S]*?)<\/script>/u.exec(threaded)?.[1] ?? "";
+      new Function("document", "localStorage", "globalThis", source)(
+        {
+          createElement: () => ({}),
+          head: {
+            appendChild: (tag: (typeof links)[number]) => {
+              links.push(tag);
+              return tag;
+            },
+          },
+        },
+        {
+          getItem: (key: string) => stored[key] ?? null,
+          setItem: (key: string, value: string) => {
+            stored[key] = value;
+          },
+        },
+        { crossOriginIsolated: isolated },
+      );
+      return links;
+    };
+    const stored: Record<string, string> = {};
+    const first = run(true, stored);
+    expect(first.map((tag) => tag.rel)).toEqual(["preload"]);
+    first[0]?.onload?.();
+    expect(first.map((tag) => tag.rel)).toEqual(["preload", "modulepreload"]);
+    expect(run(true, stored)).toEqual([]);
+    expect(run(false, {})).toEqual([]);
+    const plain = withEnginePreload(html, bundle, false);
+    expect(plain).toContain('"/game/assets/tn-native-engine-web-P1.wasm"');
+    expect(plain).not.toContain("threads-T1.wasm");
+    // The dev server has no bundle, and a build without the engine has no Wasm to start.
+    expect(withEnginePreload(html, undefined, true)).toBe(html);
+    expect(
+      withEnginePreload(html, { "assets/index-A1.js": bundle["assets/index-A1.js"] }, true),
+    ).toBe(html);
+  });
 });
diff --git a/packages/create-threenative/agent-docs/references/capability-reference.md b/packages/create-threenative/agent-docs/references/capability-reference.md
index adabb07ce6..7cd846b79b 100644
--- a/packages/create-threenative/agent-docs/references/capability-reference.md
+++ b/packages/create-threenative/agent-docs/references/capability-reference.md
@@ -4387,7 +4387,7 @@ export function rapier(options: IPhysicsOptions = { … }
 ```
 
 - **Use when:** add physics to a portable game · provide the context used by character and rigid bodies
-- **Constraints:** place rapier() before recast() in the plugin list
+- **Constraints:** place rapier() before recast() in the plugin list · ctx.physics is set before Scene.enter(), not during load(): Rapier initializes while the scene loads, so create bodies in enter() or later (TN_PHYSICS_NOT_READY)
 - **Requires:** npm i @threenative/physics
 
 ```ts
diff --git a/packages/create-threenative/capabilities.json b/packages/create-threenative/capabilities.json
index d0f16896ba..caa1bba1bd 100644
--- a/packages/create-threenative/capabilities.json
+++ b/packages/create-threenative/capabilities.json
@@ -5566,7 +5566,10 @@
     },
     {
       "aliases": [],
-      "constraints": ["place rapier() before recast() in the plugin list"],
+      "constraints": [
+        "place rapier() before recast() in the plugin list",
+        "ctx.physics is set before Scene.enter(), not during load(): Rapier initializes while the scene loads, so create bodies in enter() or later (TN_PHYSICS_NOT_READY)"
+      ],
       "example": "const game = defineGame({ plugins: [rapier()] });",
       "importPath": "@threenative/physics",
       "kind": "function",
diff --git a/packages/create-threenative/src/web-brand.ts b/packages/create-threenative/src/web-brand.ts
index 405864e9cd..10f4a3876a 100644
--- a/packages/create-threenative/src/web-brand.ts
+++ b/packages/create-threenative/src/web-brand.ts
@@ -14,7 +14,10 @@ export interface IWebBrandVitePlugin {
     readonly root: string;
     readonly command?: "build" | "serve";
   }): Promise<void>;
-  transformIndexHtml(html: string): string;
+  transformIndexHtml(
+    html: string,
+    context?: { readonly bundle?: Readonly<Record<string, IBundleFile>> },
+  ): string;
   configureServer(server: IMiddlewareServer): void;
   configurePreviewServer(server: IMiddlewareServer): void;
   generateBundle(this: {
@@ -50,11 +53,15 @@ export const isolationMiddleware: Middleware = (req, res, next) => {
   next();
 };
 
-/** The same headers for a static host that reads a `_headers` file (Netlify, Cloudflare Pages). */
+/**
+ * The same headers for a static host that reads a `_headers` file (Netlify, Cloudflare Pages), plus
+ * a year-long immutable cache for Vite's content-hashed `assets/` files (PRD-860): a repeat visit
+ * then reads them from disk with no revalidation round trip, and a new build has new names.
+ */
 export function renderIsolationHeaders(): string {
   return `/*\n${Object.entries(ISOLATION_HEADERS)
     .map(([key, value]) => `  ${key}: ${value}\n`)
-    .join("")}`;
+    .join("")}/assets/*\n  Cache-Control: public, max-age=31536000, immutable\n`;
 }
 
 /**
@@ -107,6 +114,85 @@ const ISOLATION_BOOT = `<script>(() => {
     }, () => {});
 })();</script>`;
 
+/**
+ * The build identity `ctx.assets.memo` keys on (PRD-860): the hashed entry script, which changes
+ * whenever any of the game's code does. Only a production page has one; the dev server's entry is
+ * `src/main.ts`, so a dev page writes none and generated content rebuilds every run there.
+ */
+export function withBuildId(html: string): string {
+  const entry = /<script\b[^>]*\btype="module"[^>]*\bsrc="([^"]*\/assets\/[^"]+\.js)"/iu.exec(
+    html,
+  )?.[1];
+  if (entry === undefined) return html;
+  return html.replace(
+    /<script/iu,
+    `<script>globalThis.__TN_BUILD_ID__ = ${JSON.stringify(entry).replaceAll("<", "\\u003c")};</script>\n    <script`,
+  );
+}
+
+export interface IBundleFile {
+  readonly fileName: string;
+  readonly type: string;
+  readonly moduleIds?: readonly string[];
+}
+
+/**
+ * Starts the engine's Wasm download with the page (PRD-860). The glue that fetches it loads only
+ * after the entry script ran, so a first visit's network idled until ~330 ms and the 1 MB module
+ * ended at ~800 ms; Rapier's chunk then waited for the engine to boot. This head script preloads the
+ * Wasm the page will run (the threads build only when isolated: otherwise the isolation worker may
+ * reload the page) and, once it lands, Rapier, so each gets the whole link in turn. Only for a Wasm
+ * this browser has not fetched: a preloaded response loses V8's compiled-code cache, and a repeat
+ * visit that recompiled the module was ~150 ms slower on a laptop.
+ */
+export function withEnginePreload(
+  html: string,
+  bundle: Readonly<Record<string, IBundleFile>> | undefined,
+  threaded: boolean,
+): string {
+  if (bundle === undefined) return html;
+  const files = Object.values(bundle);
+  const entry = /<script\b[^>]*\btype="module"[^>]*\bsrc="([^"]*)"/iu.exec(html)?.[1];
+  const entryFile = files.find((file) => entry?.endsWith(file.fileName) === true);
+  if (entry === undefined || entryFile === undefined) return html;
+  const base = entry.slice(0, entry.length - entryFile.fileName.length);
+  const href = (test: (file: IBundleFile) => boolean): string | undefined => {
+    const found = files.find(test);
+    return found === undefined ? undefined : base + found.fileName;
+  };
+  const threads = href((file) => /tn-native-engine-web-threads-[^/]*\.wasm$/u.test(file.fileName));
+  const plain = href((file) =>
+    /tn-native-engine-web-(?!threads-)[^/]*\.wasm$/u.test(file.fileName),
+  );
+  const wasm = threaded ? threads : plain;
+  if (wasm === undefined) return html;
+  const rapier = href(
+    (file) =>
+      file.type === "chunk" &&
+      file.moduleIds?.some((id) => id.includes("/@dimforge/rapier3d")) === true,
+  );
+  const quote = (value: string | undefined) =>
+    JSON.stringify(value ?? null).replaceAll("<", "\\u003c");
+  const script = `<script>(() => {
+  const link = (rel, href, as) => {
+    const tag = Object.assign(document.createElement("link"), { rel, href, crossOrigin: "anonymous" });
+    if (as !== undefined) tag.as = as;
+    return document.head.appendChild(tag);
+  };
+  if (${threaded} && !globalThis.crossOriginIsolated) return;
+  const href = ${quote(wasm)};
+  const store = (use) => { try { return use(localStorage); } catch { return null; } };
+  if (store((s) => s.getItem("tnEngineWasm")) === href) return;
+  const wasm = link("preload", href, "fetch");
+  const rapier = ${quote(rapier)};
+  wasm.onload = wasm.onerror = () => {
+    store((s) => s.setItem("tnEngineWasm", href));
+    if (rapier !== null) link("modulepreload", rapier);
+  };
+})();</script>`;
+  return html.replace(/<script/iu, `${script}\n    <script`);
+}
+
 function htmlAttribute(value: string): string {
   return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
 }
@@ -253,11 +339,14 @@ export function createWebBrandPlugin(): IWebBrandVitePlugin {
           strict: resolved.command !== "build",
         });
     },
-    transformIndexHtml(html) {
+    transformIndexHtml(html, context) {
       if (config === undefined) throw new Error("TN_WEB_BRAND_CONFIG_MISSING");
-      const output = updateLaunchMarkup(root, config, html);
+      const output = withBuildId(updateLaunchMarkup(root, config, html));
       // Before the first script, so it runs ahead of the game module.
-      return threaded ? output.replace(/<script/iu, `${ISOLATION_BOOT}\n    <script`) : output;
+      const isolated = threaded
+        ? output.replace(/<script/iu, `${ISOLATION_BOOT}\n    <script`)
+        : output;
+      return withEnginePreload(isolated, context?.bundle, threaded);
     },
     // Every page links the manifest, and only a build emits it: in dev Vite would answer the link
     // with index.html, which the browser reports as a manifest syntax error on each load.
diff --git a/packages/create-threenative/templates/action-rpg/src/render/atmosphere.ts b/packages/create-threenative/templates/action-rpg/src/render/atmosphere.ts
index ec2183f9d7..d5f4a636e9 100644
--- a/packages/create-threenative/templates/action-rpg/src/render/atmosphere.ts
+++ b/packages/create-threenative/templates/action-rpg/src/render/atmosphere.ts
@@ -235,7 +235,13 @@ function march(
  * approximation in RenderMultiScatteredLuminanceLutCS); the full sphere gather overestimated the
  * ground bounce against the Unreal frames by up to 1.6x, so this uses the same two rays.
  */
+// The table depends on no input: build it once a run, not once a sky refresh.
+let multipleScattering: Multi | undefined;
 function multipleScatteringTable(): Multi {
+  multipleScattering ??= buildMultipleScatteringTable();
+  return multipleScattering;
+}
+function buildMultipleScatteringTable(): Multi {
   const nh = 12;
   const nc = 16;
   const dirs: Vec3[] = [
diff --git a/packages/create-threenative/templates/action-rpg/src/render/clouds.ts b/packages/create-threenative/templates/action-rpg/src/render/clouds.ts
index 4047017f19..0bb22540cb 100644
--- a/packages/create-threenative/templates/action-rpg/src/render/clouds.ts
+++ b/packages/create-threenative/templates/action-rpg/src/render/clouds.ts
@@ -282,6 +282,19 @@ export interface ICloudTextures {
 }
 const textureCache = new Map<number, ICloudTextures>();
 
+/**
+ * Hand back the textures an earlier run generated, so `cloudTextures(seed)` skips ~0.6 s of noise
+ * on the main thread. The scene keeps them between runs with `ctx.assets.memo`.
+ */
+export function primeCloudTextures(textures: ICloudTextures, seed = 631): void {
+  if (
+    textures.pattern.length !== PATTERN_SIZE ** 2 * 4 ||
+    textures.volume.length !== VOLUME_SIZE ** 3 * 2
+  )
+    throw new Error("cloud textures do not match PATTERN_SIZE and VOLUME_SIZE.");
+  textureCache.set(seed, textures);
+}
+
 export function cloudTextures(seed = 631): ICloudTextures {
   const cached = textureCache.get(seed);
   if (cached) return cached;
diff --git a/packages/create-threenative/templates/action-rpg/src/scenes/Play.ts b/packages/create-threenative/templates/action-rpg/src/scenes/Play.ts
index 58f15ee810..05310bd953 100644
--- a/packages/create-threenative/templates/action-rpg/src/scenes/Play.ts
+++ b/packages/create-threenative/templates/action-rpg/src/scenes/Play.ts
@@ -19,6 +19,7 @@ import { describeDrops, rollDrops } from "../loot/drops.js";
 import { emitPlaytestEvent } from "../playtest-events.js";
 import { loadProgress, saveProgress } from "../progress.js";
 import { createDungeonCamera } from "../render/camera.js";
+import { cloudTextures, primeCloudTextures } from "../render/clouds.js";
 import { createDungeon, isSolid } from "../render/dungeon.js";
 import { type IEnvironmentSample, sampleEnvironment } from "../render/environmentSampling.js";
 import { setupLighting } from "../render/lighting.js";
@@ -111,6 +112,8 @@ export class Play extends Scene<GameState, IPhysicsContext> {
       // Only the photo-sky override reads the photograph; the atmosphere sky is computed.
       SKY_OPTIONS.sky === "photo" ? ctx.assets.texture("sky.jpg") : undefined,
     ]);
+    // The cloud noise is the same every run of this build: generate it once, then read it back.
+    primeCloudTextures(await ctx.assets.memo("clouds", () => cloudTextures()));
     setupSky(ctx.scene, this.#sky, ctx.renderer.softwareAdapter !== undefined);
     this.#environmentSample = await sampleEnvironment(ctx.renderer.raw, ctx.scene, {
       web: getPlatform().runtime === "web",
diff --git a/packages/create-threenative/templates/collectathon/src/level/Course.ts b/packages/create-threenative/templates/collectathon/src/level/Course.ts
index 34f5b0ff5c..333807e50a 100644
--- a/packages/create-threenative/templates/collectathon/src/level/Course.ts
+++ b/packages/create-threenative/templates/collectathon/src/level/Course.ts
@@ -191,6 +191,18 @@ function auditCourse(
  * A boulder `size` metres across its middle: an icosphere pushed in and out by a few seeded waves and
  * flattened a little, smooth-shaded, so it reads as weathered rock and not as a faceted gem.
  */
+/**
+ * `Math.hypot(dx, dz) < reach`, asked thousands of times by the planting: squared distances settle
+ * every case more than a millionth from the edge, and the edge itself takes the same `hypot`.
+ */
+function within(dx: number, dz: number, reach: number): boolean {
+  const squared = dx * dx + dz * dz;
+  const edge = reach * reach;
+  if (squared > edge * 1.000001) return false;
+  if (squared < edge * 0.999999 && reach > 0) return true;
+  return Math.hypot(dx, dz) < reach;
+}
+
 function boulderGeometry(size: number, rng: () => number): BufferGeometry {
   const geometry = new IcosahedronGeometry(size, 2);
   const position = geometry.attributes.position;
@@ -451,7 +463,7 @@ export function buildCourse(rng: () => number, surfaces: ISurfaces, grassShare =
   /** Every pickup: scenery keeps a clear metre round each, so none hangs inside a tree or a rock. */
   const pickups = [...coins, ...gems, ...Object.values(seeds)];
   const nearPickup = (x: number, zz: number, reach: number): boolean =>
-    pickups.some(([kx, , kz]) => Math.hypot(x - kx, zz - kz) < reach);
+    pickups.some(([kx, , kz]) => within(x - kx, zz - kz, reach));
 
   // Scenery: boulders where the ground breaks into a slope, never on a route and never inside a
   // landmark (a rock through the shaft's wall, under the pillar's coin ring or in the castle).
@@ -503,7 +515,7 @@ export function buildCourse(rng: () => number, surfaces: ISurfaces, grassShare =
     bounds: TERRAIN_BOUNDS,
     clear: (x, zz, w) =>
       !onRoute(x, zz, w) &&
-      !taken.some(([kx, kz, kr]) => Math.hypot(x - kx, zz - kz) < kr + w) &&
+      !taken.some(([kx, kz, kr]) => within(x - kx, zz - kz, kr + w)) &&
       !nearPickup(x, zz, w + 1),
     flatness: terrain.flatness,
     grassShare,
@@ -555,8 +567,14 @@ export function buildCourse(rng: () => number, surfaces: ISurfaces, grassShare =
     steepShare: steep / landCells,
   };
 
+  let audit: ICourse["audit"] | undefined;
   return {
-    audit: { ...auditCourse(group, pickups, ground), ...world },
+    // Measured on first read, not on every load: only the debug snapshot and the layout
+    // playtests read it, and walking every solid's bounds cost a run ~0.1 s.
+    get audit() {
+      audit ??= { ...auditCourse(group, pickups, ground), ...world };
+      return audit;
+    },
     checkpoints: [
       new Vector3(...COURSE.spawn),
       new Vector3(...onGround(sx + 9, 0, sz + 13)),
diff --git a/packages/create-threenative/templates/collectathon/src/level/terrain.ts b/packages/create-threenative/templates/collectathon/src/level/terrain.ts
index 4ac5d25190..352168f8ea 100644
--- a/packages/create-threenative/templates/collectathon/src/level/terrain.ts
+++ b/packages/create-threenative/templates/collectathon/src/level/terrain.ts
@@ -130,15 +130,36 @@ export function buildTerrain(plan: ITerrainPlan): ITerrain {
   const inside = (x: number, z: number): boolean =>
     x >= minX && x <= maxX && z >= minZ && z <= maxZ;
   const seaFloor = plan.seaLevel - 6.5;
+  // Each path segment with its bounding box, in path order: a segment whose box lies clearly
+  // farther than the nearest so far cannot be nearer, so its exact distance is never needed.
+  const segments = plan.paths.flatMap((path) =>
+    path.slice(1).map((b, i) => {
+      const a = path[i] as readonly [number, number];
+      return {
+        a,
+        b,
+        minX: Math.min(a[0], b[0]),
+        maxX: Math.max(a[0], b[0]),
+        minZ: Math.min(a[1], b[1]),
+        maxZ: Math.max(a[1], b[1]),
+      };
+    }),
+  );
   return {
     field,
     flatness: (x, z) => (inside(x, z) ? field.normalAt(x, z).y : 1),
     ground: (x, z) => (inside(x, z) ? field.heightAt(x, z) : seaFloor),
-    pathDistance: (x, z) =>
-      Math.min(
-        ...plan.paths.flatMap((path) =>
-          path.slice(1).map((corner, i) => segmentDistance(x, z, path[i] ?? corner, corner)),
-        ),
-      ),
+    // Planting asks this thousands of times a load. Same segments, same order, same minimum: a box
+    // skipped is more than a millionth farther than the nearest, past any rounding of its distance.
+    pathDistance: (x, z) => {
+      let nearest = Number.POSITIVE_INFINITY;
+      for (const segment of segments) {
+        const dx = Math.max(segment.minX - x, 0, x - segment.maxX);
+        const dz = Math.max(segment.minZ - z, 0, z - segment.maxZ);
+        if (dx * dx + dz * dz > nearest * nearest * 1.000001) continue;
+        nearest = Math.min(nearest, segmentDistance(x, z, segment.a, segment.b));
+      }
+      return nearest;
+    },
   };
 }
diff --git a/packages/create-threenative/templates/collectathon/src/render/foliage.ts b/packages/create-threenative/templates/collectathon/src/render/foliage.ts
index 9940cc8664..15617674f3 100644
--- a/packages/create-threenative/templates/collectathon/src/render/foliage.ts
+++ b/packages/create-threenative/templates/collectathon/src/render/foliage.ts
@@ -17,6 +17,7 @@ import {
   CylinderGeometry,
   DataTexture,
   DoubleSide,
+  Euler,
   Group,
   InstancedMesh,
   LatheGeometry,
@@ -24,7 +25,6 @@ import {
   type Material,
   Matrix4,
   Mesh,
-  Object3D,
   OctahedronGeometry,
   PlaneGeometry,
   Quaternion,
@@ -83,9 +83,16 @@ export interface IPlantingSite {
   readonly surfaces: ISurfaces;
 }
 
-const dummy = new Object3D();
+// Plain math, not a scratch Object3D: an engine object's position, scale, rotation and matrix each
+// cross into the engine, five crossings an instance (~90 ms of a load); these stay in JavaScript.
 // Yaw last: a placement leans or droops about X, then turns to face its way round Y.
-dummy.rotation.order = "YXZ";
+const turn = new Euler(0, 0, 0, "YXZ");
+const placed = {
+  at: new Vector3(),
+  matrix: new Matrix4(),
+  size: new Vector3(),
+  spin: new Quaternion(),
+};
 
 function instanced(
   geometry: BufferGeometry,
@@ -97,11 +104,9 @@ function instanced(
   const mesh = new InstancedMesh(geometry, material, Math.max(1, placements.length));
   mesh.count = placements.length;
   placements.forEach(([x, y, z, sx, sy, sz, rx, ry, rz], i) => {
-    dummy.position.set(x, y, z);
-    dummy.scale.set(sx, sy, sz);
-    dummy.rotation.set(rx, ry, rz);
-    dummy.updateMatrix();
-    mesh.setMatrixAt(i, dummy.matrix);
+    placed.spin.setFromEuler(turn.set(rx, ry, rz, "YXZ"));
+    placed.matrix.compose(placed.at.set(x, y, z), placed.spin, placed.size.set(sx, sy, sz));
+    mesh.setMatrixAt(i, placed.matrix);
     const tint = tints?.[i];
     if (tint !== undefined) mesh.setColorAt(i, tint);
   });
diff --git a/packages/create-threenative/templates/collectathon/src/render/sky.ts b/packages/create-threenative/templates/collectathon/src/render/sky.ts
index 2982207271..0cec31563c 100644
--- a/packages/create-threenative/templates/collectathon/src/render/sky.ts
+++ b/packages/create-threenative/templates/collectathon/src/render/sky.ts
@@ -92,7 +92,7 @@ const smooth = (from: number, to: number, value: number): number => {
  * flatten toward the horizon. Each is lit by where its density climbs: a texel whose deck is
  * denser toward the sun, or above it on screen, is on the cloud's shaded side or its flat base.
  */
-export function skyTexture(saturation = 1, width = 2048): DataTexture {
+export function skyPixels(saturation = 1, width = 2048): Uint8Array {
   // three's PMREM sizes its cube from width / 4 and needs at least 16: keep width >= 64.
   const height = width / 2;
   const data = new Uint8Array(width * height * 4);
@@ -109,6 +109,14 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
   let baseR = 0;
   let baseG = 0;
   let baseB = 0;
+  // Each column's azimuth terms, once: the same numbers every row reads.
+  const cosAzimuth = new Float64Array(width);
+  const sinAzimuth = new Float64Array(width);
+  for (let column = 0; column < width; column += 1) {
+    const azimuth = (column / width - 0.5) * Math.PI * 2;
+    cosAzimuth[column] = Math.cos(azimuth);
+    sinAzimuth[column] = Math.sin(azimuth);
+  }
   // Pass 1: the deck's density under every cloud-band texel, once (the shading reads neighbours).
   const deck = new Float32Array(width * height);
   const bands = new Float32Array(height);
@@ -120,8 +128,10 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
     // Flattened less than a true deck would be: cumulus heaps stand tall, they are not a sheet.
     const reach = (1 / (Math.tan(elevation) + 0.1)) ** 0.7 * 0.75;
     for (let column = 0; column < width; column += 1) {
-      const azimuth = (column / width - 0.5) * Math.PI * 2;
-      deck[row * width + column] = density(Math.cos(azimuth) * reach, Math.sin(azimuth) * reach);
+      deck[row * width + column] = density(
+        (cosAzimuth[column] as number) * reach,
+        (sinAzimuth[column] as number) * reach,
+      );
     }
   }
   // The cumulus banks over the far hills, per column: where a bank stands (`cluster`), its heaped
@@ -142,6 +152,12 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
   const step = Math.max(1, Math.round(width / 512));
   const sunAzimuth = Math.atan2(SUN_DIRECTION.z, SUN_DIRECTION.x);
   const sunElevation = Math.asin(SUN_DIRECTION.y);
+  // Which way the sun lies from each column, once.
+  const sunward = new Int8Array(width);
+  for (let column = 0; column < width; column += 1) {
+    const azimuth = (column / width - 0.5) * Math.PI * 2;
+    sunward[column] = Math.sin(sunAzimuth - azimuth) > 0 ? 1 : -1;
+  }
   for (let row = 0; row < height; row += 1) {
     const elevation = (row / (height - 1) - 0.5) * Math.PI;
     const up = Math.sin(elevation);
@@ -171,9 +187,10 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
     );
     for (let column = 0; column < width; column += 1) {
       // three's equirectangular u: azimuth from +X toward +Z, u = 0.5 on +X.
-      const azimuth = (column / width - 0.5) * Math.PI * 2;
-      const tx = Math.cos(azimuth) * cosE;
-      const tz = Math.sin(azimuth) * cosE;
+      const cosA = cosAzimuth[column] as number;
+      const sinA = sinAzimuth[column] as number;
+      const tx = cosA * cosE;
+      const tz = sinA * cosE;
       // The sun's halo: a warm glow round its direction, wider than the disc the lens never sees.
       const sun = Math.max(0, tx * SUN_DIRECTION.x + up * SUN_DIRECTION.y + tz * SUN_DIRECTION.z);
       const halo = 0.6 * sun ** 32 + 0.22 * sun ** 5;
@@ -183,7 +200,7 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
       const d = deck[row * width + column] ?? 0;
       const cover = band > 0 ? smooth(0.43, 0.54, d) * band : 0;
       if (cover > 0.002) {
-        const turn = Math.sin(sunAzimuth - azimuth) > 0 ? step : -step;
+        const turn = (sunward[column] as number) * step;
         const towardColumn = (column + turn + width) % width;
         // Denser a step toward the sun: the far side of a heap. Denser a step up the sky: its base.
         const toward = (deck[towardRow * width + towardColumn] ?? 0) - d;
@@ -202,8 +219,7 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
       if (elevation > foot && elevation < top + 0.05) {
         // Billowed outline: finer noise lifts and bites the heap's top edge.
         // Elevation moves radially and azimuth round the circle: round puffs, and azimuth wraps.
-        const puff = (e: number) =>
-          fbm(Math.cos(azimuth) * (14 + e * 15), Math.sin(azimuth) * (14 + e * 15), 3);
+        const puff = (e: number) => fbm(cosA * (14 + e * 15), sinA * (14 + e * 15), 3);
         const lump = puff(elevation);
         const below = top + (lump - 0.5) * 0.11 - elevation;
         const inside = smooth(0, 0.02, below) * smooth(foot, foot + 0.012, elevation);
@@ -225,12 +241,27 @@ export function skyTexture(saturation = 1, width = 2048): DataTexture {
       }
       const grey = r * 0.2126 + g * 0.7152 + b * 0.0722;
       const i = (row * width + column) * 4;
-      data[i] = Math.round(255 * linearToSrgb(r + (grey - r) * (1 - saturation)));
-      data[i + 1] = Math.round(255 * linearToSrgb(g + (grey - g) * (1 - saturation)));
-      data[i + 2] = Math.round(255 * linearToSrgb(b + (grey - b) * (1 - saturation)));
+      data[i] = srgbByte(r + (grey - r) * (1 - saturation));
+      data[i + 1] = srgbByte(g + (grey - g) * (1 - saturation));
+      data[i + 2] = srgbByte(b + (grey - b) * (1 - saturation));
       data[i + 3] = 255;
     }
   }
+  return data;
+}
+
+/**
+ * The sky as a texture. `data` is `skyPixels(saturation, width)`; the scene passes the copy it kept
+ * from the last run (`ctx.assets.memo`), because painting four million texels costs a run ~0.3 s.
+ */
+export function skyTexture(
+  saturation = 1,
+  width = 2048,
+  data: Uint8Array = skyPixels(saturation, width),
+): DataTexture {
+  const height = width / 2;
+  if (data.length !== width * height * 4)
+    throw new Error(`sky pixels are ${data.length} bytes, expected ${width * height * 4}.`);
   const sky = new DataTexture(data, width, height, RGBAFormat, UnsignedByteType);
   sky.mapping = EquirectangularReflectionMapping;
   sky.colorSpace = SRGBColorSpace;
@@ -247,6 +278,39 @@ function linearToSrgb(value: number): number {
   return v < 0.0031308 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055;
 }
 
+/**
+ * `Math.round(255 * linearToSrgb(value))` for millions of texels: the byte only steps up as the
+ * value grows, so the smallest value of each step, found once, gives the same byte with no power.
+ */
+const SRGB_STEPS = (() => {
+  const byte = (value: number) => Math.round(255 * linearToSrgb(value));
+  const steps = new Float64Array(256);
+  for (let level = 1; level < 256; level += 1) {
+    let low = 0;
+    let high = 1;
+    // Halve until the two ends are adjacent doubles: `high` is then the step's first value.
+    for (;;) {
+      const middle = low + (high - low) / 2;
+      if (middle === low || middle === high) break;
+      if (byte(middle) >= level) high = middle;
+      else low = middle;
+    }
+    steps[level] = high;
+  }
+  return steps;
+})();
+
+function srgbByte(value: number): number {
+  let low = 0;
+  let high = 255;
+  while (low < high) {
+    const middle = (low + high + 1) >> 1;
+    if (value >= (SRGB_STEPS[middle] as number)) low = middle;
+    else high = middle - 1;
+  }
+  return low;
+}
+
 /** `fill` is the environment light: by default the sky itself, in this game `skyTexture(0.3, 128)`. */
 export function setupSky(scene: Scene, sky: DataTexture, fill: DataTexture = sky): void {
   scene.background = sky;
diff --git a/packages/create-threenative/templates/collectathon/src/render/water.ts b/packages/create-threenative/templates/collectathon/src/render/water.ts
index ff524ef574..1af767d3e5 100644
--- a/packages/create-threenative/templates/collectathon/src/render/water.ts
+++ b/packages/create-threenative/templates/collectathon/src/render/water.ts
@@ -85,12 +85,39 @@ function depthMap(floor: ISeaFloor): DataTexture {
 }
 
 /** Tiling ripples: periodic value noise, its slope in red/green and its height in alpha. */
+const RIPPLE_SIZE = 256;
+let primedRipples: Uint8Array | undefined;
+/** Hand the ripple pixels back from a store (`ctx.assets.memo`), so `seaMaterial` skips painting them. */
+export function primeRipplePixels(pixels: Uint8Array): void {
+  if (pixels.length !== RIPPLE_SIZE * RIPPLE_SIZE * 4)
+    throw new Error("ripple pixels do not match RIPPLE_SIZE.");
+  primedRipples = pixels;
+}
 function rippleMap(): DataTexture {
-  const n = 256;
+  const n = RIPPLE_SIZE;
+  const map = new DataTexture(primedRipples ?? ripplePixels(), n, n);
+  map.wrapS = RepeatWrapping;
+  map.wrapT = RepeatWrapping;
+  map.magFilter = LinearFilter;
+  map.minFilter = LinearMipmapLinearFilter;
+  map.generateMipmaps = true;
+  map.needsUpdate = true;
+  return map;
+}
+/** The sea's ripple normal (RG) and height (A), the same every run: no input, no randomness. */
+export function ripplePixels(): Uint8Array {
+  const n = RIPPLE_SIZE;
   const hash = (x: number, z: number): number => {
     const a = Math.sin(x * 127.1 + z * 311.7) * 43758.5453;
     return a - Math.floor(a);
   };
+  // Each octave's lattice is k x k whole points, hashed once: a texel reads 64 of them.
+  const lattices = new Map<number, Float64Array>();
+  for (const k of [8, 16, 32, 64]) {
+    const lattice = new Float64Array(k * k);
+    for (let x = 0; x < k; x += 1) for (let z = 0; z < k; z += 1) lattice[x * k + z] = hash(x, z);
+    lattices.set(k, lattice);
+  }
   const noise = (u: number, v: number, k: number): number => {
     const x = u * k;
     const z = v * k;
@@ -100,7 +127,9 @@ function rippleMap(): DataTexture {
     let b = z - j;
     a = a * a * a * (a * (a * 6 - 15) + 10);
     b = b * b * b * (b * (b * 6 - 15) + 10);
-    const h = (hx: number, hz: number): number => hash(((hx % k) + k) % k, ((hz % k) + k) % k);
+    const lattice = lattices.get(k) as Float64Array;
+    const h = (hx: number, hz: number): number =>
+      lattice[(((hx % k) + k) % k) * k + (((hz % k) + k) % k)] as number;
     return (
       (h(i, j) * (1 - a) + h(i + 1, j) * a) * (1 - b) +
       (h(i, j + 1) * (1 - a) + h(i + 1, j + 1) * a) * b
@@ -126,14 +155,7 @@ function rippleMap(): DataTexture {
       data[at + 3] = height(u, v) * 255;
     }
   }
-  const map = new DataTexture(data, n, n);
-  map.wrapS = RepeatWrapping;
-  map.wrapT = RepeatWrapping;
-  map.magFilter = LinearFilter;
-  map.minFilter = LinearMipmapLinearFilter;
-  map.generateMipmaps = true;
-  map.needsUpdate = true;
-  return map;
+  return data;
 }
 
 export function seaMaterial(floor: ISeaFloor, swell: ISwell): MeshStandardNodeMaterial {
diff --git a/packages/create-threenative/templates/collectathon/src/scenes/Play.ts b/packages/create-threenative/templates/collectathon/src/scenes/Play.ts
index 36ebd6a72e..b5b1424504 100644
--- a/packages/create-threenative/templates/collectathon/src/scenes/Play.ts
+++ b/packages/create-threenative/templates/collectathon/src/scenes/Play.ts
@@ -25,9 +25,10 @@ import { setupLighting } from "../render/lighting.js";
 import { createLoadingScreen } from "../render/loading.js";
 import { postTier, setupPost } from "../render/postprocessing.js";
 import { GRASS_SHARE } from "../render/quality.js";
-import { setupSky, skyTexture } from "../render/sky.js";
+import { setupSky, skyPixels, skyTexture } from "../render/sky.js";
 import { loadSurfaces, updateSurfaceSampling } from "../render/surface.js";
 import { TouchControls } from "../render/touch-controls.js";
+import { primeRipplePixels, ripplePixels } from "../render/water.js";
 import { type GameState, HUD_PILL } from "../state.js";
 
 export type { GameCtx };
@@ -90,9 +91,19 @@ export class Play extends Scene<GameState, IPhysicsContext> {
     this.#loading = createLoadingScreen(ctx);
     // The HUD is page UI the cover cannot hide, so it waits for the same readiness.
     void ctx.startup.whenReady().then(() => ctx.state.set({ loaded: true }));
-    const surfaces = await loadSurfaces(ctx.assets);
-    this.#sky = skyTexture();
-    this.#fill = skyTexture(0.3, 128);
+    // The sky is the same every run of this build: paint it once, then read the pixels back. A first
+    // visit paints it (~600 ms on a laptop) while the surface textures download, not after them.
+    const [surfaces, painted] = await Promise.all([
+      loadSurfaces(ctx.assets),
+      ctx.assets.memo("sky", () => ({
+        fill: skyPixels(0.3, 128),
+        ripples: ripplePixels(),
+        sky: skyPixels(),
+      })),
+    ]);
+    primeRipplePixels(painted.ripples);
+    this.#sky = skyTexture(1, 2048, painted.sky);
+    this.#fill = skyTexture(0.3, 128, painted.fill);
     setupSky(ctx.scene, this.#sky, this.#fill);
     const tier = postTier({
       gpuClass: ctx.renderer.gpuClass?.class,
diff --git a/packages/create-threenative/templates/minimal/src/render/atmosphere.ts b/packages/create-threenative/templates/minimal/src/render/atmosphere.ts
index ec2183f9d7..d5f4a636e9 100644
--- a/packages/create-threenative/templates/minimal/src/render/atmosphere.ts
+++ b/packages/create-threenative/templates/minimal/src/render/atmosphere.ts
@@ -235,7 +235,13 @@ function march(
  * approximation in RenderMultiScatteredLuminanceLutCS); the full sphere gather overestimated the
  * ground bounce against the Unreal frames by up to 1.6x, so this uses the same two rays.
  */
+// The table depends on no input: build it once a run, not once a sky refresh.
+let multipleScattering: Multi | undefined;
 function multipleScatteringTable(): Multi {
+  multipleScattering ??= buildMultipleScatteringTable();
+  return multipleScattering;
+}
+function buildMultipleScatteringTable(): Multi {
   const nh = 12;
   const nc = 16;
   const dirs: Vec3[] = [
diff --git a/packages/create-threenative/templates/minimal/src/render/clouds.ts b/packages/create-threenative/templates/minimal/src/render/clouds.ts
index 4047017f19..0bb22540cb 100644
--- a/packages/create-threenative/templates/minimal/src/render/clouds.ts
+++ b/packages/create-threenative/templates/minimal/src/render/clouds.ts
@@ -282,6 +282,19 @@ export interface ICloudTextures {
 }
 const textureCache = new Map<number, ICloudTextures>();
 
+/**
+ * Hand back the textures an earlier run generated, so `cloudTextures(seed)` skips ~0.6 s of noise
+ * on the main thread. The scene keeps them between runs with `ctx.assets.memo`.
+ */
+export function primeCloudTextures(textures: ICloudTextures, seed = 631): void {
+  if (
+    textures.pattern.length !== PATTERN_SIZE ** 2 * 4 ||
+    textures.volume.length !== VOLUME_SIZE ** 3 * 2
+  )
+    throw new Error("cloud textures do not match PATTERN_SIZE and VOLUME_SIZE.");
+  textureCache.set(seed, textures);
+}
+
 export function cloudTextures(seed = 631): ICloudTextures {
   const cached = textureCache.get(seed);
   if (cached) return cached;
diff --git a/packages/create-threenative/templates/minimal/src/scenes/Play.ts b/packages/create-threenative/templates/minimal/src/scenes/Play.ts
index 0110511269..e07c7c6407 100644
--- a/packages/create-threenative/templates/minimal/src/scenes/Play.ts
+++ b/packages/create-threenative/templates/minimal/src/scenes/Play.ts
@@ -26,6 +26,7 @@ import {
 import { RoundedBoxGeometry } from "three/addons/geometries/RoundedBoxGeometry.js";
 import { type IPlayerModel, Player } from "../entities/Player.js";
 import { followCamera, setupCamera } from "../render/camera.js";
+import { cloudTextures, primeCloudTextures } from "../render/clouds.js";
 import { type IEnvironmentSample, sampleEnvironment } from "../render/environmentSampling.js";
 import { setupLighting } from "../render/lighting.js";
 import { createLoadingScreen } from "../render/loading.js";
@@ -62,6 +63,8 @@ export class Play extends Scene<GameState, IPhysicsContext> {
       // Only the photo-sky override reads the photograph; the atmosphere sky is computed.
       SKY_OPTIONS.sky === "photo" ? ctx.assets.texture("sky.jpg") : undefined,
     ]);
+    // The cloud noise is the same every run of this build: generate it once, then read it back.
+    primeCloudTextures(await ctx.assets.memo("clouds", () => cloudTextures()));
     setupSky(ctx.scene, this.#sky, ctx.renderer.softwareAdapter !== undefined);
     this.#environmentSample = await sampleEnvironment(ctx.renderer.raw, ctx.scene, {
       web: getPlatform().runtime === "web",
diff --git a/packages/create-threenative/templates/racing/src/render/atmosphere.ts b/packages/create-threenative/templates/racing/src/render/atmosphere.ts
index ec2183f9d7..d5f4a636e9 100644
--- a/packages/create-threenative/templates/racing/src/render/atmosphere.ts
+++ b/packages/create-threenative/templates/racing/src/render/atmosphere.ts
@@ -235,7 +235,13 @@ function march(
  * approximation in RenderMultiScatteredLuminanceLutCS); the full sphere gather overestimated the
  * ground bounce against the Unreal frames by up to 1.6x, so this uses the same two rays.
  */
+// The table depends on no input: build it once a run, not once a sky refresh.
+let multipleScattering: Multi | undefined;
 function multipleScatteringTable(): Multi {
+  multipleScattering ??= buildMultipleScatteringTable();
+  return multipleScattering;
+}
+function buildMultipleScatteringTable(): Multi {
   const nh = 12;
   const nc = 16;
   const dirs: Vec3[] = [
diff --git a/packages/create-threenative/templates/racing/src/render/clouds.ts b/packages/create-threenative/templates/racing/src/render/clouds.ts
index 4047017f19..0bb22540cb 100644
--- a/packages/create-threenative/templates/racing/src/render/clouds.ts
+++ b/packages/create-threenative/templates/racing/src/render/clouds.ts
@@ -282,6 +282,19 @@ export interface ICloudTextures {
 }
 const textureCache = new Map<number, ICloudTextures>();
 
+/**
+ * Hand back the textures an earlier run generated, so `cloudTextures(seed)` skips ~0.6 s of noise
+ * on the main thread. The scene keeps them between runs with `ctx.assets.memo`.
+ */
+export function primeCloudTextures(textures: ICloudTextures, seed = 631): void {
+  if (
+    textures.pattern.length !== PATTERN_SIZE ** 2 * 4 ||
+    textures.volume.length !== VOLUME_SIZE ** 3 * 2
+  )
+    throw new Error("cloud textures do not match PATTERN_SIZE and VOLUME_SIZE.");
+  textureCache.set(seed, textures);
+}
+
 export function cloudTextures(seed = 631): ICloudTextures {
   const cached = textureCache.get(seed);
   if (cached) return cached;
diff --git a/packages/create-threenative/templates/racing/src/scenes/Race.ts b/packages/create-threenative/templates/racing/src/scenes/Race.ts
index 4620f9d7b5..22a3ac252e 100644
--- a/packages/create-threenative/templates/racing/src/scenes/Race.ts
+++ b/packages/create-threenative/templates/racing/src/scenes/Race.ts
@@ -13,6 +13,7 @@ import { RacingCar } from "../entities/RacingCar.js";
 import { Rival } from "../entities/Rival.js";
 import { emitPlaytestEvent } from "../playtest-events.js";
 import { cameraBank, chaseCamera, setupCamera } from "../render/camera.js";
+import { cloudTextures, primeCloudTextures } from "../render/clouds.js";
 import { type IEnvironmentSample, sampleEnvironment } from "../render/environmentSampling.js";
 import { setupLighting } from "../render/lighting.js";
 import { createLoadingScreen } from "../render/loading.js";
@@ -119,6 +120,8 @@ export class Race extends Scene<GameState, IPhysicsContext> {
     this.#sky = texture;
     const scene = ctx.scene;
     if (scene === undefined) return;
+    // The cloud noise is the same every run of this build: generate it once, then read it back.
+    primeCloudTextures(await ctx.assets.memo("clouds", () => cloudTextures()));
     setupSky(scene, texture, ctx.renderer.softwareAdapter !== undefined);
     // The measurement is not awaited: it reads the GPU back and must not hold the first frame.
     void this.#sampleSky(ctx, scene, generation);
diff --git a/packages/create-threenative/templates/runner/src/render/atmosphere.ts b/packages/create-threenative/templates/runner/src/render/atmosphere.ts
index ec2183f9d7..d5f4a636e9 100644
--- a/packages/create-threenative/templates/runner/src/render/atmosphere.ts
+++ b/packages/create-threenative/templates/runner/src/render/atmosphere.ts
@@ -235,7 +235,13 @@ function march(
  * approximation in RenderMultiScatteredLuminanceLutCS); the full sphere gather overestimated the
  * ground bounce against the Unreal frames by up to 1.6x, so this uses the same two rays.
  */
+// The table depends on no input: build it once a run, not once a sky refresh.
+let multipleScattering: Multi | undefined;
 function multipleScatteringTable(): Multi {
+  multipleScattering ??= buildMultipleScatteringTable();
+  return multipleScattering;
+}
+function buildMultipleScatteringTable(): Multi {
   const nh = 12;
   const nc = 16;
   const dirs: Vec3[] = [
diff --git a/packages/create-threenative/templates/runner/src/render/clouds.ts b/packages/create-threenative/templates/runner/src/render/clouds.ts
index 4047017f19..0bb22540cb 100644
--- a/packages/create-threenative/templates/runner/src/render/clouds.ts
+++ b/packages/create-threenative/templates/runner/src/render/clouds.ts
@@ -282,6 +282,19 @@ export interface ICloudTextures {
 }
 const textureCache = new Map<number, ICloudTextures>();
 
+/**
+ * Hand back the textures an earlier run generated, so `cloudTextures(seed)` skips ~0.6 s of noise
+ * on the main thread. The scene keeps them between runs with `ctx.assets.memo`.
+ */
+export function primeCloudTextures(textures: ICloudTextures, seed = 631): void {
+  if (
+    textures.pattern.length !== PATTERN_SIZE ** 2 * 4 ||
+    textures.volume.length !== VOLUME_SIZE ** 3 * 2
+  )
+    throw new Error("cloud textures do not match PATTERN_SIZE and VOLUME_SIZE.");
+  textureCache.set(seed, textures);
+}
+
 export function cloudTextures(seed = 631): ICloudTextures {
   const cached = textureCache.get(seed);
   if (cached) return cached;
diff --git a/packages/create-threenative/templates/runner/src/scenes/Run.ts b/packages/create-threenative/templates/runner/src/scenes/Run.ts
index d87a3d944e..9c055446df 100644
--- a/packages/create-threenative/templates/runner/src/scenes/Run.ts
+++ b/packages/create-threenative/templates/runner/src/scenes/Run.ts
@@ -13,6 +13,7 @@ import { type PerspectiveCamera, type Texture, Vector3 } from "three";
 import { HITBOX, type IRunnerModel, Runner } from "../entities/Runner.js";
 import type { RunnerPhysics } from "../physics.js";
 import { chaseRunner, setupCamera } from "../render/camera.js";
+import { cloudTextures, primeCloudTextures } from "../render/clouds.js";
 import { createDustTrail } from "../render/dust.js";
 import { type IEnvironmentSample, sampleEnvironment } from "../render/environmentSampling.js";
 import { setupLighting } from "../render/lighting.js";
@@ -55,6 +56,8 @@ export class Run extends Scene<GameState, RunnerPhysics> {
       // Only the photo-sky override reads the photograph; the atmosphere sky is computed.
       SKY_OPTIONS.sky === "photo" ? ctx.assets.texture("sky.jpg") : undefined,
     ]);
+    // The cloud noise is the same every run of this build: generate it once, then read it back.
+    primeCloudTextures(await ctx.assets.memo("clouds", () => cloudTextures()));
     setupSky(ctx.scene, this.#sky, ctx.renderer.softwareAdapter !== undefined);
     this.#environmentSample = await sampleEnvironment(ctx.renderer.raw, ctx.scene, {
       web: getPlatform().runtime === "web",
diff --git a/packages/create-threenative/templates/shooter/src/render/atmosphere.ts b/packages/create-threenative/templates/shooter/src/render/atmosphere.ts
index ec2183f9d7..d5f4a636e9 100644
--- a/packages/create-threenative/templates/shooter/src/render/atmosphere.ts
+++ b/packages/create-threenative/templates/shooter/src/render/atmosphere.ts
@@ -235,7 +235,13 @@ function march(
  * approximation in RenderMultiScatteredLuminanceLutCS); the full sphere gather overestimated the
  * ground bounce against the Unreal frames by up to 1.6x, so this uses the same two rays.
  */
+// The table depends on no input: build it once a run, not once a sky refresh.
+let multipleScattering: Multi | undefined;
 function multipleScatteringTable(): Multi {
+  multipleScattering ??= buildMultipleScatteringTable();
+  return multipleScattering;
+}
+function buildMultipleScatteringTable(): Multi {
   const nh = 12;
   const nc = 16;
   const dirs: Vec3[] = [
diff --git a/packages/create-threenative/templates/shooter/src/render/clouds.ts b/packages/create-threenative/templates/shooter/src/render/clouds.ts
index 4047017f19..0bb22540cb 100644
--- a/packages/create-threenative/templates/shooter/src/render/clouds.ts
+++ b/packages/create-threenative/templates/shooter/src/render/clouds.ts
@@ -282,6 +282,19 @@ export interface ICloudTextures {
 }
 const textureCache = new Map<number, ICloudTextures>();
 
+/**
+ * Hand back the textures an earlier run generated, so `cloudTextures(seed)` skips ~0.6 s of noise
+ * on the main thread. The scene keeps them between runs with `ctx.assets.memo`.
+ */
+export function primeCloudTextures(textures: ICloudTextures, seed = 631): void {
+  if (
+    textures.pattern.length !== PATTERN_SIZE ** 2 * 4 ||
+    textures.volume.length !== VOLUME_SIZE ** 3 * 2
+  )
+    throw new Error("cloud textures do not match PATTERN_SIZE and VOLUME_SIZE.");
+  textureCache.set(seed, textures);
+}
+
 export function cloudTextures(seed = 631): ICloudTextures {
   const cached = textureCache.get(seed);
   if (cached) return cached;
diff --git a/packages/create-threenative/templates/shooter/src/scenes/Play.ts b/packages/create-threenative/templates/shooter/src/scenes/Play.ts
index d43e4dddd8..ed79342e64 100644
--- a/packages/create-threenative/templates/shooter/src/scenes/Play.ts
+++ b/packages/create-threenative/templates/shooter/src/scenes/Play.ts
@@ -35,6 +35,7 @@ import { MAGAZINE, RESERVE, Rifle } from "../entities/Rifle.js";
 import { Target } from "../entities/Target.js";
 import { TouchControls } from "../entities/TouchControls.js";
 import { onAfterPhysics } from "../postPhysics.js";
+import { cloudTextures, primeCloudTextures } from "../render/clouds.js";
 import { DecalField, bulletHoleTexture } from "../render/decals.js";
 import { type IEnvironmentSample, sampleEnvironment } from "../render/environmentSampling.js";
 import { ImpactBursts, MuzzleFlash, MuzzleFlashPool, softCircleTexture } from "../render/gunfx.js";
@@ -143,6 +144,8 @@ export class Play extends Scene<GameState, IPhysicsContext> {
     // The town's five generated surfaces (`render/surface.ts`), before `enter` builds the town.
     await loadSurfaces(ctx.assets);
     this.#assets = { enemy, viewmodel, sky };
+    // The cloud noise is the same every run of this build: generate it once, then read it back.
+    primeCloudTextures(await ctx.assets.memo("clouds", () => cloudTextures()));
     setupSky(ctx.scene, this.#assets.sky, ctx.renderer.softwareAdapter !== undefined);
     this.#environmentSample = await sampleEnvironment(ctx.renderer.raw, ctx.scene, {
       web: getPlatform().runtime === "web",
diff --git a/packages/create-threenative/templates/starter/src/render/atmosphere.ts b/packages/create-threenative/templates/starter/src/render/atmosphere.ts
index ec2183f9d7..d5f4a636e9 100644
--- a/packages/create-threenative/templates/starter/src/render/atmosphere.ts
+++ b/packages/create-threenative/templates/starter/src/render/atmosphere.ts
@@ -235,7 +235,13 @@ function march(
  * approximation in RenderMultiScatteredLuminanceLutCS); the full sphere gather overestimated the
  * ground bounce against the Unreal frames by up to 1.6x, so this uses the same two rays.
  */
+// The table depends on no input: build it once a run, not once a sky refresh.
+let multipleScattering: Multi | undefined;
 function multipleScatteringTable(): Multi {
+  multipleScattering ??= buildMultipleScatteringTable();
+  return multipleScattering;
+}
+function buildMultipleScatteringTable(): Multi {
   const nh = 12;
   const nc = 16;
   const dirs: Vec3[] = [
diff --git a/packages/create-threenative/templates/starter/src/render/clouds.ts b/packages/create-threenative/templates/starter/src/render/clouds.ts
index 4047017f19..0bb22540cb 100644
--- a/packages/create-threenative/templates/starter/src/render/clouds.ts
+++ b/packages/create-threenative/templates/starter/src/render/clouds.ts
@@ -282,6 +282,19 @@ export interface ICloudTextures {
 }
 const textureCache = new Map<number, ICloudTextures>();
 
+/**
+ * Hand back the textures an earlier run generated, so `cloudTextures(seed)` skips ~0.6 s of noise
+ * on the main thread. The scene keeps them between runs with `ctx.assets.memo`.
+ */
+export function primeCloudTextures(textures: ICloudTextures, seed = 631): void {
+  if (
+    textures.pattern.length !== PATTERN_SIZE ** 2 * 4 ||
+    textures.volume.length !== VOLUME_SIZE ** 3 * 2
+  )
+    throw new Error("cloud textures do not match PATTERN_SIZE and VOLUME_SIZE.");
+  textureCache.set(seed, textures);
+}
+
 export function cloudTextures(seed = 631): ICloudTextures {
   const cached = textureCache.get(seed);
   if (cached) return cached;
diff --git a/packages/create-threenative/templates/starter/src/scenes/Play.ts b/packages/create-threenative/templates/starter/src/scenes/Play.ts
index 3248e776eb..8496b95e8c 100644
--- a/packages/create-threenative/templates/starter/src/scenes/Play.ts
+++ b/packages/create-threenative/templates/starter/src/scenes/Play.ts
@@ -24,6 +24,7 @@ import { Goal, ISLAND } from "../entities/Goal.js";
 import { type IPlayerModel, PLAYER_STAND_Y, Player } from "../entities/Player.js";
 import { createArena, platform } from "../render/arena.js";
 import { createSpringArm } from "../render/camera.js";
+import { cloudTextures, primeCloudTextures } from "../render/clouds.js";
 import { pickupRiseEase } from "../render/easing.js";
 import { type IEnvironmentSample, sampleEnvironment } from "../render/environmentSampling.js";
 import { setupLighting, shadeLikeSubstrate } from "../render/lighting.js";
@@ -84,6 +85,8 @@ export class Play extends Scene<GameState, IPhysicsContext> {
     ]);
     this.#playerModel = playerModel;
     this.#sky = sky;
+    // The cloud noise is the same every run of this build: generate it once, then read it back.
+    primeCloudTextures(await ctx.assets.memo("clouds", () => cloudTextures()));
     setupSky(ctx.scene, sky, ctx.renderer.softwareAdapter !== undefined);
     this.#environmentSample = await sampleEnvironment(ctx.renderer.raw, ctx.scene, {
       web: getPlatform().runtime === "web",
diff --git a/packages/physics/__tests__/plugin.spec.ts b/packages/physics/__tests__/plugin.spec.ts
index 227f228ae6..be84e3054a 100644
--- a/packages/physics/__tests__/plugin.spec.ts
+++ b/packages/physics/__tests__/plugin.spec.ts
@@ -7,6 +7,7 @@ import { Area3D } from "../src/Area3D.js";
 import { CollisionShape3D } from "../src/CollisionShape3D.js";
 import { RigidBody3D } from "../src/RigidBody3D.js";
 import { PHYSICS_TRANSFORM_STRIDE } from "../src/index.js";
+import { recast } from "../src/navigation/index.js";
 import { type IPhysicsContext, rapier } from "../src/plugin.js";
 
 const plugins: Array<ReturnType<typeof rapier>> = [];
@@ -26,6 +27,49 @@ afterEach(() => {
 });
 
 describe("rapier plugin", () => {
+  it("initializes while the scene loads and holds enter() until ctx.physics is set (PRD-860)", async () => {
+    await RAPIER.init();
+    const plugin = rapier();
+    const navigation = recast();
+    const ctx = { physics: undefined } as unknown as ICtx<Record<string, unknown>, IPhysicsContext>;
+    const gates: Promise<void>[] = [];
+    const runtime = {
+      fixedStep: () => 0,
+      holdStart: (gate: Promise<void>) => {
+        gates.push(gate);
+        return gate;
+      },
+      observations: { contribute: () => () => undefined, contributions: () => [] },
+      rapier: null,
+      seed: 1,
+      step: 1 / 60,
+      tick: () => 0,
+    } satisfies IGamePluginRuntime;
+
+    const cleanup = plugin.setup?.(ctx, runtime);
+    const navigationCleanup = navigation.setup?.(ctx, runtime);
+
+    // Neither setup waits for its Wasm: both return at once and leave a gate that holds enter().
+    expect(cleanup).toBeTypeOf("function");
+    expect(navigationCleanup).toBeUndefined();
+    expect(gates).toHaveLength(2);
+    expect(ctx.physics).toBeUndefined();
+    expect(
+      () =>
+        new RigidBody3D({
+          object: new Object3D(),
+          physics: ctx.physics,
+          shape: CollisionShape3D.box(1, 1, 1),
+        }),
+    ).toThrow("TN_PHYSICS_NOT_READY");
+    await Promise.all(gates);
+    expect(ctx.physics?.numBodies()).toBe(0);
+    expect(ctx.physics?.navigation).toBeDefined();
+    expect(runtime.rapier).toBe(RAPIER.version());
+    navigation.dispose?.(ctx);
+    plugin.dispose?.(ctx);
+  });
+
   it("should register the actual Rapier runtime version", async () => {
     await RAPIER.init();
     const plugin = rapier();
diff --git a/packages/physics/__tests__/static-colliders.spec.ts b/packages/physics/__tests__/static-colliders.spec.ts
index b992fb0542..a105c53be4 100644
--- a/packages/physics/__tests__/static-colliders.spec.ts
+++ b/packages/physics/__tests__/static-colliders.spec.ts
@@ -9,6 +9,7 @@ import {
   Matrix4,
   Mesh,
   MeshBasicMaterial,
+  SphereGeometry,
 } from "three";
 import { beforeAll, describe, expect, it } from "vitest";
 import "../src/index.js";
@@ -137,4 +138,20 @@ describe("buildStaticColliders", () => {
 
     plugin.dispose?.(ctx);
   });
+
+  it("culls by the lowest transformed vertex, not by a loose box around the rotated mesh", async () => {
+    const { ctx, plugin } = await setup();
+    const root = new Group();
+    // A unit sphere at y 7 turned 45 degrees: its lowest vertex is at 6.0, the box around its rotated
+    // bounding box reaches 5.59. A 5.8 ceiling culls it only when the cull reads the real vertices.
+    const tilted = new Mesh(new SphereGeometry(1, 16, 12));
+    tilted.position.y = 7;
+    tilted.rotation.z = Math.PI / 4;
+    root.add(tilted);
+    root.add(new Mesh(new BoxGeometry(1, 1, 1)));
+
+    expect(buildStaticColliders(ctx, root, { reachableCeiling: 5.8 })).toHaveLength(1);
+    expect(buildStaticColliders(ctx, root, { reachableCeiling: 6.1 })).toHaveLength(2);
+    plugin.dispose?.(ctx);
+  });
 });
diff --git a/packages/physics/src/index.ts b/packages/physics/src/index.ts
index 25e4287d16..9e760a3cc8 100644
--- a/packages/physics/src/index.ts
+++ b/packages/physics/src/index.ts
@@ -184,6 +184,7 @@ export type { IRigidBody3DOptions, RigidBodyType } from "./RigidBody3D.js";
  * @situation add physics to a portable game
  * @situation provide the context used by character and rigid bodies
  * @constraint place rapier() before recast() in the plugin list
+ * @constraint ctx.physics is set before Scene.enter(), not during load(): Rapier initializes while the scene loads, so create bodies in enter() or later (TN_PHYSICS_NOT_READY)
  * @example const game = defineGame({ plugins: [rapier()] });
  * @requires npm i @threenative/physics
  */
diff --git a/packages/physics/src/navigation/index.ts b/packages/physics/src/navigation/index.ts
index 7417e8b64c..e8018aa0d0 100644
--- a/packages/physics/src/navigation/index.ts
+++ b/packages/physics/src/navigation/index.ts
@@ -54,19 +54,27 @@ function disposeNavigation(navigation: INavigationContext): void {
 export function recast(): NavigationPlugin {
   let navigation: INavigationContext | undefined;
   return {
-    setup: async (ctx: ICtx<Record<string, unknown>, IPhysicsContext>) => {
-      await initialize();
-      if (ctx.physics === undefined)
+    // Like rapier(), Recast initializes while the scene loads and holds `enter()` until it is up.
+    setup: (ctx: ICtx<Record<string, unknown>, IPhysicsContext>, runtime) => {
+      // rapier() leaves its readiness here (`plugin.ts` PHYSICS_READY); this bundle has no copy of it.
+      const physics = (ctx as unknown as { [key: symbol]: Promise<IPhysicsContext> | undefined })[
+        Symbol.for("threenative.physics.ready")
+      ];
+      if (physics === undefined)
         throw new Error("recast() requires rapier() earlier in the plugins array.");
-      const empty = emptyNavigation();
-      navigation = {
-        agents: new Set(),
-        navMesh: empty.navMesh,
-        obstacles: new Set(),
-        query: empty.query,
-        regions: new Set(),
-      };
-      ctx.physics.navigation = navigation;
+      const ready = Promise.all([physics, initialize()]).then(([context]) => {
+        const empty = emptyNavigation();
+        navigation = {
+          agents: new Set(),
+          navMesh: empty.navMesh,
+          obstacles: new Set(),
+          query: empty.query,
+          regions: new Set(),
+        };
+        context.navigation = navigation;
+      });
+      if (runtime?.holdStart === undefined) return ready.then(() => undefined);
+      void runtime.holdStart(ready).catch(() => undefined);
       return undefined;
     },
     update: (ctx, dt) => {
diff --git a/packages/physics/src/plugin.ts b/packages/physics/src/plugin.ts
index 055f1c3aae..117328acaa 100644
--- a/packages/physics/src/plugin.ts
+++ b/packages/physics/src/plugin.ts
@@ -113,6 +113,12 @@ function visibleId(buffer: Readonly<Float32Array>, offset: number): number {
   return value;
 }
 
+/**
+ * Each game's `ctx.physics` once Rapier is up, which `recast()` waits on. A registry symbol on the
+ * ctx, not module state: the navigation subpath is its own bundle and may hold its own copy.
+ */
+const PHYSICS_READY = Symbol.for("threenative.physics.ready");
+
 export function rapier(options: IPhysicsOptions = {}): PhysicsPlugin {
   const backend = physicsSimulationBackend();
   let simulation: IPhysicsSimulation | undefined;
@@ -141,6 +147,8 @@ export function rapier(options: IPhysicsOptions = {}): PhysicsPlugin {
   // game-authored state can answer. Monotone for the plugin's lifetime, scene restarts included.
   let completedSteps = 0;
   let gameContext: ICtx<Record<string, unknown>, IPhysicsContext> | undefined;
+  /** Bumped by each setup and dispose, so an init that lands after dispose builds nothing. */
+  let generations = 0;
   const interpolationRemovals = new Map<PhysicsBody3D, () => void>();
   function updateInterpolation(body: PhysicsBody3D): void {
     interpolationRemovals.get(body)?.();
@@ -190,19 +198,32 @@ export function rapier(options: IPhysicsOptions = {}): PhysicsPlugin {
   }
 
   return {
-    setup: async (ctx: ICtx<Record<string, unknown>, IPhysicsContext>, runtime) => {
+    // Rapier's Wasm initializes while the scene loads: a game builds bodies in `enter()`, and the
+    // start gate holds `enter()` until `ctx.physics` is set, so a first visit does not wait for
+    // Rapier before loading its textures and world (PRD-860). With no gate, setup awaits it.
+    setup: (ctx: ICtx<Record<string, unknown>, IPhysicsContext>, runtime) => {
       gameContext = ctx;
-      await backend.initialize();
-      const selected = backend.createSimulation(options);
-      simulation = selected;
-      if (runtime !== undefined) runtime.rapier = selected.version;
-      context = buildContext(selected);
-      ctx.physics = context;
-      unregisterObservations = runtime?.observations?.contribute({
-        capabilities: ["runtime.physics"],
-        sample: (request) => physicsObservations(ctx, runtime, request),
+      const generation = ++generations;
+      const ready = backend.initialize().then(() => {
+        if (generation !== generations)
+          throw new Error("rapier() was disposed before it initialized.");
+        const selected = backend.createSimulation(options);
+        simulation = selected;
+        if (runtime !== undefined) runtime.rapier = selected.version;
+        const built = buildContext(selected);
+        context = built;
+        ctx.physics = built;
+        unregisterObservations = runtime?.observations?.contribute({
+          capabilities: ["runtime.physics"],
+          sample: (request) => physicsObservations(ctx, runtime, request),
+        });
+        return built;
       });
-      return unregisterObservations;
+      Object.defineProperty(ctx, PHYSICS_READY, { configurable: true, value: ready });
+      const cleanup = () => unregisterObservations?.();
+      if (runtime?.holdStart === undefined) return ready.then(() => cleanup);
+      void runtime.holdStart(ready.then(() => undefined)).catch(() => undefined);
+      return cleanup;
     },
     update: (_ctx, dt) => {
       if (simulation === undefined) throw new Error("Physics plugin updated before setup.");
@@ -340,6 +361,7 @@ export function rapier(options: IPhysicsOptions = {}): PhysicsPlugin {
       ctx.physics = context;
     },
     dispose: () => {
+      generations += 1;
       unregisterObservations?.();
       unregisterObservations = undefined;
       for (const buoyancy of [...buoyancies]) buoyancy.dispose();
diff --git a/packages/physics/src/simulation.ts b/packages/physics/src/simulation.ts
index 6d5f5c1b79..6d3ebb7aeb 100644
--- a/packages/physics/src/simulation.ts
+++ b/packages/physics/src/simulation.ts
@@ -1857,6 +1857,10 @@ export function requirePhysicsSimulation(
     );
   }
   if (physics?.simulation !== undefined) return physics.simulation;
+  if (physics === undefined && world === undefined)
+    throw new Error(
+      "TN_PHYSICS_NOT_READY: `physics` is undefined. ctx.physics is set before Scene.enter(), not during load(), because Rapier initializes while the scene loads: create physics nodes in enter() or later.",
+    );
   const candidate =
     typeof world === "object" && world !== null && "simulation" in world
       ? (world as { readonly simulation?: unknown }).simulation
diff --git a/packages/physics/src/static-colliders.ts b/packages/physics/src/static-colliders.ts
index fd543506d4..48f506a9a2 100644
--- a/packages/physics/src/static-colliders.ts
+++ b/packages/physics/src/static-colliders.ts
@@ -1,4 +1,4 @@
-import { Box3, InstancedMesh, Matrix4, Mesh, Object3D, Quaternion, Vector3 } from "three";
+import { InstancedMesh, Matrix4, Mesh, Object3D, Quaternion, Vector3 } from "three";
 import { CollisionShape3D } from "./CollisionShape3D.js";
 import { RigidBody3D } from "./RigidBody3D.js";
 import type { IPhysicsContext } from "./plugin.js";
@@ -31,7 +31,6 @@ const scratchWorld = new Matrix4();
 const scratchPosition = new Vector3();
 const scratchScale = new Vector3();
 const scratchRotation = new Quaternion();
-const scratchBounds = new Box3();
 
 function optionsFor(filter: StaticColliderFilter | undefined): IBuildStaticCollidersOptions {
   return typeof filter === "function" ? { predicate: filter } : (filter ?? {});
@@ -63,9 +62,20 @@ function configureCarrier(carrier: Mesh, transform: Matrix4, scale: Vector3): vo
   carrier.updateMatrixWorld(true);
 }
 
+/**
+ * Whether the carrier's lowest world-space vertex sits below the ceiling: the exact answer
+ * `Box3.setFromObject(carrier, true)` gives, read from the Y row of the world matrix alone.
+ * The Box3 walk calls getVertexPosition and applyMatrix4 per vertex, about 35 ms per arena at load.
+ */
 function isReachable(carrier: Mesh, ceiling: number): boolean {
-  scratchBounds.setFromObject(carrier, true);
-  return !scratchBounds.isEmpty() && scratchBounds.min.y < ceiling;
+  const position = carrier.geometry.getAttribute("position");
+  if (position === undefined || position.count === 0) return false;
+  const e = carrier.matrixWorld.elements;
+  const [m1, m5, m9, m13] = [e[1] ?? 0, e[5] ?? 0, e[9] ?? 0, e[13] ?? 0];
+  for (let i = 0; i < position.count; i++)
+    if (m1 * position.getX(i) + m5 * position.getY(i) + m9 * position.getZ(i) + m13 < ceiling)
+      return true;
+  return false;
 }
 
 function addCollider(
diff --git a/packages/physics/src/web.ts b/packages/physics/src/web.ts
index 4a3c2d03fa..b6b9425bde 100644
--- a/packages/physics/src/web.ts
+++ b/packages/physics/src/web.ts
@@ -1,4 +1,4 @@
-import * as rapier from "@dimforge/rapier3d-compat";
+import type * as Rapier from "@dimforge/rapier3d-compat";
 import {
   type IPhysicsSimulation,
   createWebPhysicsShape,
@@ -6,19 +6,35 @@ import {
   installPhysicsSimulationBackend,
 } from "./simulation.js";
 
+// Fetched the moment physics is imported, awaited only by `initialize`: a static import put Rapier's
+// ~660 KB (Brotli) in the entry chunk, so a first visit downloaded it before the engine could boot.
+// As its own chunk it downloads while the engine's Wasm compiles and the game boots (PRD-860).
+// A caller that inits Rapier itself and hands over a World needs the module bound once it resolves,
+// not only after `initialize`. A failed fetch rejects `initialize`, where the game awaits it.
+let loaded: typeof Rapier | undefined;
+const rapierModule = import("@dimforge/rapier3d-compat").then((module) => {
+  loaded = module;
+  return module;
+});
+rapierModule.catch(() => undefined);
+const rapierReady = (): typeof Rapier => {
+  if (loaded === undefined) throw new Error("Rapier used before the physics backend initialized.");
+  return loaded;
+};
 let initialized: Promise<void> | undefined;
 const simulations = new WeakMap<object, IPhysicsSimulation>();
 const RAPIER_INIT_WARNING =
   "using deprecated parameters for the initialization function; pass a single object instead";
 
-function initializeRapier(): Promise<void> {
+async function initializeRapier(): Promise<void> {
+  const rapier = await rapierModule;
   const previousWarn = console.warn;
   console.warn = (...args) => {
     if (args[0] === RAPIER_INIT_WARNING) return;
     previousWarn(...args);
   };
   try {
-    return rapier.init().finally(() => {
+    await rapier.init().finally(() => {
       console.warn = previousWarn;
     });
   } catch (error) {
@@ -33,6 +49,7 @@ installPhysicsSimulationBackend({
     return initialized;
   },
   createSimulation: (options = {}) => {
+    const rapier = rapierReady();
     const world = new rapier.World(options.gravity ?? { x: 0, y: -9.81, z: 0 });
     const simulation = createWebPhysicsSimulation({
       eventQueue: new rapier.EventQueue(true),
@@ -48,14 +65,15 @@ installPhysicsSimulationBackend({
       throw new Error("Physics nodes expected a Rapier World.");
     const simulation = simulations.get(world);
     if (simulation !== undefined) return simulation;
+    const rapier = rapierReady();
     const created = createWebPhysicsSimulation({
       eventQueue: new rapier.EventQueue(true),
       rapier,
       version: rapier.version(),
-      world: world as rapier.World,
+      world: world as Rapier.World,
     });
     simulations.set(world, created);
     return created;
   },
-  createShape: (shape) => createWebPhysicsShape(rapier, shape),
+  createShape: (shape) => createWebPhysicsShape(rapierReady(), shape),
 });
diff --git a/packages/runtime-native/src/engine/renderer/renderer.cpp b/packages/runtime-native/src/engine/renderer/renderer.cpp
index d4b368bea0..2b3bb25107 100644
--- a/packages/runtime-native/src/engine/renderer/renderer.cpp
+++ b/packages/runtime-native/src/engine/renderer/renderer.cpp
@@ -2475,7 +2475,9 @@ void Renderer::beginEnvironment(const Texture& equirect) {
         for (uint32_t face = 0; face < 6; ++face)
             passes.push_back({env.targetViews[size_t(lod) * 6 + face], env.sourceView, env.sampler,
                               integrate ? envIntegrationPipeline_ : envGgxPipeline_, size,
-                              integrate ? kPmremIntegrationSize * kPmremIntegrationSize * 3u : kPmremGgxSamples,
+                              // Roughness 0 reads one texel (kPmremGgx's roughness < 0.001 branch), not 256.
+                              integrate ? kPmremIntegrationSize * kPmremIntegrationSize * 3u
+                                        : roughness < 0.001f ? 1u : kPmremGgxSamples,
                               roughness, float(bias), sourceLod, face});
     }
 
@@ -2514,7 +2516,8 @@ void Renderer::beginEnvironment(const Texture& equirect) {
     for (std::size_t p = 0; p < passes.size(); ++p)
         prep.packets.push_back({passes[p].target, passes[p].source, passes[p].sampler, passes[p].pipeline,
                                 passes[p].size, passes[p].size, passes[p].samples, uint32_t(p)});
-    for (const PmremPacket& packet : prep.packets) prep.budget = std::max(prep.budget, pmremPacketCost(packet));
+    for (const PmremPacket& packet : prep.packets) prep.heaviest = std::max(prep.heaviest, pmremPacketCost(packet));
+    prep.budget = prep.heaviest;
     envPrep_ = std::move(prep);
 }
 void Renderer::abandonEnvironment() {
@@ -2534,7 +2537,10 @@ bool Renderer::pumpEnvironment() {
         return false;
     }
     // Advance one packet only once the previous submission's completion is observed.
-    if (prep.next > 0 && gpu_.completedSerial() < prep.awaitSerial) return false;
+    if (prep.next > 0 && gpu_.completedSerial() < prep.awaitSerial) {
+        ++prep.waits;
+        return false;
+    }
     if (prep.next >= prep.packets.size()) {
         if (const auto found = environments_.find(prep.ident);
             found != environments_.end() && found->second.version == prep.version)
@@ -2542,8 +2548,14 @@ bool Renderer::pumpEnvironment() {
         abandonEnvironment();
         return true;
     }
-    // One frame carries packets up to the cost of the heaviest single packet (fragments x samples),
-    // so the cheap low-LOD packets share frames while no submission outgrows the costliest one.
+    // One frame carries packets up to the budget (fragments x samples). It starts at the heaviest single packet, so
+    // the cheap low-LOD packets share frames, and doubles after each group the GPU finished by the next frame: every
+    // group costs a completion round trip (about two frames), and a GPU that keeps up needs 4 groups for a 512 cube,
+    // not 10 (PRD-860). It stops at 4x the heaviest packet, and a slow group (a software adapter) puts it back.
+    constexpr uint64_t kPmremBudgetGrowth = 4;
+    if (prep.next > 0)
+        prep.budget = prep.waits <= 1 ? std::min(prep.budget * 2, prep.heaviest * kPmremBudgetGrowth) : prep.heaviest;
+    prep.waits = 0;
     uint64_t spent = 0;
     do {
     const PmremPacket& packet = prep.packets[prep.next];
diff --git a/packages/runtime-native/src/engine/renderer/renderer.h b/packages/runtime-native/src/engine/renderer/renderer.h
index 14b8d771a6..35379df1fc 100644
--- a/packages/runtime-native/src/engine/renderer/renderer.h
+++ b/packages/runtime-native/src/engine/renderer/renderer.h
@@ -1158,10 +1158,12 @@ class Renderer {
         std::vector<PmremPacket> packets;
         std::size_t next = 0;
         uint64_t awaitSerial = 0;        // the last submitted packet's serial, awaited before the next
+        uint32_t waits = 0;              // calls that found the last group still on the GPU
         WGPUBindGroup group = nullptr;   // the current packet's bind group, rebuilt per packet
         uint32_t groupUniform = UINT32_MAX;
         uint64_t stride = 0;
-        uint64_t budget = 0;             // the costliest packet's cost: the per-call submission cap
+        uint64_t heaviest = 0;           // the costliest packet's cost: the smallest per-call cap
+        uint64_t budget = 0;             // the per-call submission cap, heaviest..4x heaviest
     };
     std::optional<EnvironmentPreparation> envPrep_;
     bool environmentPending_ = false;
diff --git a/packages/runtime-native/tests/native-engine/renderer_lifetime_test.cpp b/packages/runtime-native/tests/native-engine/renderer_lifetime_test.cpp
index 1125e1b45a..ac95279411 100644
--- a/packages/runtime-native/tests/native-engine/renderer_lifetime_test.cpp
+++ b/packages/runtime-native/tests/native-engine/renderer_lifetime_test.cpp
@@ -11,6 +11,9 @@
 // hands the camera it renders with: a shared object posed at the probe, looking down the face's axis.
 // `database_environment_warmup`: startup warm-up's bake step (the V8 player's tn.prepareEnvironment)
 // advances the PMREM bake with no frame drawn, so the first frame after it draws the world.
+// `environment_bake_round_trips`: a GPU that finishes each group before the next call bakes a 2048-wide sky
+// in a few submissions. Every group waits for the GPU, so each one costs about two frames of a held startup
+// (PRD-860: ten groups held the minimal kit 350 ms on an Intel iGPU).
 
 #include "check.h"
 #include "engine/assets/probe_volume.h"
@@ -256,9 +259,35 @@ void databaseEnvironmentWarmUp() {
     CHECK(renderer.lastFrame().draws > 0);
 }
 
+void environmentBakeRoundTrips() {
+    mystral::webgpu::Context context;
+    CHECK(context.initializeHeadless());
+    EventQueue events;
+    Renderer renderer(context.getInstance(), context.getDevice(), context.getQueue(), events);
+    auto sky = std::make_shared<DataTexture>();
+    sky->mapping = 303;
+    sky->width = 2048;  // a 512 cube: the kits' sky
+    sky->height = 1024;
+    sky->data.assign(size_t(sky->width) * sky->height * 4, 200);
+    sky->needsUpdate();
+    std::array<DrawItem, 1> items{};
+    items[0].envMap = sky.get();
+    int calls = 0;
+    bool done = false;
+    while (!done && calls < 64) {
+        done = renderer.prepareEnvironments(items);
+        ++calls;
+        CHECK(waitFor(renderer, [&] { return renderer.gpu().completedSerial() >= renderer.gpu().submittedSerial(); }));
+    }
+    std::printf("environment_bake_round_trips: %d calls\n", calls);
+    CHECK(done);
+    CHECK(calls <= 5);
+}
+
 }  // namespace
 
 TN_TEST_MAIN({"database_environment_warmup", databaseEnvironmentWarmUp},
+             {"environment_bake_round_trips", environmentBakeRoundTrips},
              {"shared_retired_sweep", sharedRetiredSweep},
              {"probe_capture_environment", probeCaptureDuringEnvironmentBake},
              {"probe_capture_callback_camera", probeCaptureCallbackCamera})
diff --git a/packages/three-native/__tests__/browser-backend-coverage.spec.ts b/packages/three-native/__tests__/browser-backend-coverage.spec.ts
index a844f95f04..a8a2cc03ba 100644
--- a/packages/three-native/__tests__/browser-backend-coverage.spec.ts
+++ b/packages/three-native/__tests__/browser-backend-coverage.spec.ts
@@ -403,6 +403,7 @@ interface IInstancedMesh {
   instanceColor: IAttribute | null;
   setMatrixAt(index: number, matrix: unknown): unknown;
   setColorAt(index: number, color: unknown): unknown;
+  computeBoundingSphere(): void;
 }
 
 // The typed array a value crossed as, by the marker `toEngine` puts on it: the mock keeps the same
@@ -595,6 +596,7 @@ describe("BufferAttribute sync between the JS array and the engine, on the brows
       };
       const index = Number(args[0]);
       const argument = args[1] as IEngineRef;
+      if (method === "computeBoundingSphere") return null;
       if (method === "setColorAt") {
         // three makes the colour attribute on the first call, every colour white.
         if (instance.color === null) {
@@ -1025,12 +1027,51 @@ describe("BufferAttribute sync between the JS array and the engine, on the brows
     expect(writes.at(-1)?.values.slice(0, 3)).toEqual([0, 0.5, 0.25]);
   });
 
-  it("creates no shadow for a setMatrixAt the game holds no array for", () => {
-    const { classes, counts } = facade();
+  it("writes setMatrixAt into the instance array and sends the items once, before the next engine call (PRD-860)", () => {
+    const { runtime, counts, writes } = engine();
+    const calls: string[] = [];
+    const invoke = runtime.invoke.bind(runtime);
+    runtime.invoke = (self, method, args) => {
+      calls.push(method);
+      return invoke(self, method, args);
+    };
+    const { classes } = defineBrowserClasses(registry, runtime, loadCatalog(REPO));
     const { mesh, translation } = instanced(classes);
     mesh.setMatrixAt(0, translation(4, 5, 6));
-    // No shadow: the mesh-level write costs no array read, and the first read is the engine's own.
-    expect(counts.reads).toBe(0);
-    expect(Array.from(mesh.instanceMatrix.array.subarray(12, 15))).toEqual([4, 5, 6]);
+    mesh.setMatrixAt(1, translation(7, 8, 9));
+    // One array read for the mesh, no engine call an instance, and nothing sent yet.
+    expect(calls).not.toContain("setMatrixAt");
+    expect(counts.reads).toBe(32);
+    expect(writes).toEqual([]);
+    mesh.computeBoundingSphere();
+    // The written items reach the engine before the call that reads them, as one range.
+    expect(writes).toHaveLength(1);
+    expect(writes[0]?.offset).toBe(0);
+    expect(writes[0]?.values.slice(12, 15)).toEqual([4, 5, 6]);
+    expect(writes[0]?.values.slice(28, 31)).toEqual([7, 8, 9]);
+    expect(Array.from(mesh.instanceMatrix.array.subarray(28, 31))).toEqual([7, 8, 9]);
+    // An index three would not write keeps the engine's call, and its refusal.
+    mesh.setMatrixAt(5, translation(1, 1, 1));
+    expect(calls).toContain("setMatrixAt");
+  });
+
+  it("writes setColorAt into the instance colours once the engine made them (PRD-860)", () => {
+    const { runtime, writes } = engine();
+    const calls: string[] = [];
+    const invoke = runtime.invoke.bind(runtime);
+    runtime.invoke = (self, method, args) => {
+      calls.push(method);
+      return invoke(self, method, args);
+    };
+    const { classes } = defineBrowserClasses(registry, runtime, loadCatalog(REPO));
+    const { mesh, color } = instanced(classes);
+    // The first colour makes the attribute in the engine, as three makes it on first use.
+    mesh.setColorAt(0, color(1, 0, 0));
+    expect(calls.filter((method) => method === "setColorAt")).toHaveLength(1);
+    mesh.setColorAt(1, color(0, 0.5, 0.25));
+    expect(calls.filter((method) => method === "setColorAt")).toHaveLength(1);
+    mesh.computeBoundingSphere();
+    expect(writes.at(-1)).toMatchObject({ offset: 3, values: [0, 0.5, 0.25] });
+    expect(Array.from((mesh.instanceColor as IAttribute).array)).toEqual([1, 0, 0, 0, 0.5, 0.25]);
   });
 });
diff --git a/packages/three-native/__tests__/browser-math.spec.ts b/packages/three-native/__tests__/browser-math.spec.ts
index 8fe170f67b..04170c247b 100644
--- a/packages/three-native/__tests__/browser-math.spec.ts
+++ b/packages/three-native/__tests__/browser-math.spec.ts
@@ -7,7 +7,7 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 
-import { Euler, Quaternion } from "three";
+import { Euler, Matrix4, Quaternion, Vector3 } from "three";
 import { describe, expect, it } from "vitest";
 
 import {
@@ -473,6 +473,45 @@ describe("three's math values on the browser back end", () => {
     expect(matrix.elements[12]).toBe(7);
   });
 
+  it("writes a matrix's elements straight into shared engine memory, with no per-element call (PRD-860)", () => {
+    // Collectathon composes ~6k instance matrices at load: 16 trapped writes each cost a laptop 49 ms.
+    const { runtime } = memoryRuntime();
+    const heap = new Float64Array(new SharedArrayBuffer(1024 * 8));
+    let writes = 0;
+    const { classes } = defineBrowserClasses(registry, {
+      ...runtime,
+      heapF64: () => heap,
+      writeDouble(address, value) {
+        writes++;
+        heap[address / 8] = value;
+      },
+      get(self, property) {
+        if (property === "matrixWorld") {
+          const matrix = runtime.construct("Matrix4", []);
+          runtime.construct("Object3D", []); // the spacer: a matrix is 16 doubles, an object 8
+          return matrix;
+        }
+        return runtime.get(self, property);
+      },
+    });
+    const matrix = new (
+      classes.Group as new () => {
+        matrixWorld: { elements: number[]; compose(p: object, q: object, s: object): unknown };
+      }
+    )().matrixWorld;
+    const [offset = 0] = registry.classes.Matrix4?.fields?.elements ?? [];
+    const at = (64 + offset) / 8;
+    const held = matrix.elements;
+    writes = 0;
+    const turn = new Quaternion().setFromEuler(new Euler(0.3, -0.7, 0.2));
+    matrix.compose({ x: 1, y: 2, z: 3 }, turn, { x: 2, y: 2, z: 2 });
+    expect(writes).toBe(0);
+    const expected = new Matrix4().compose(new Vector3(1, 2, 3), turn, new Vector3(2, 2, 2));
+    expect([...heap.subarray(at, at + 16)]).toEqual(expected.elements);
+    heap[at + 12] = 9; // the engine moved it: an elements array the game kept sees it
+    expect(held[12]).toBe(9);
+  });
+
   it("binds the host projection report as one engine call, which core's projection takes (web cut 3)", () => {
     const { runtime } = memoryRuntime();
     const invoked: string[] = [];
diff --git a/packages/three-native/src/browser-attribute-sync.ts b/packages/three-native/src/browser-attribute-sync.ts
index 6275ae5a5d..43b05b4671 100644
--- a/packages/three-native/src/browser-attribute-sync.ts
+++ b/packages/three-native/src/browser-attribute-sync.ts
@@ -42,6 +42,8 @@ export interface IAttributeSync {
   /** Shape survives data uploads and transform calls; only copy/replacement changes it. */
   readonly shapes: WeakMap<object, Map<string, unknown>>;
   readonly pending: Set<object>;
+  /** Item ranges a mesh-level write put in an attribute's array, sent with `pending` (PRD-860). */
+  readonly dirty: Map<object, { from: number; to: number }>;
   writeBack(): void;
   itemSizeOf(attribute: object): number;
   rangeOf(method: string, args: readonly unknown[], itemSize: number): readonly [number, number];
@@ -53,6 +55,12 @@ export interface IAttributeSync {
     index: unknown,
     argument: unknown,
   ): { array: TypedArray; at: number; values: ArrayLike<number> } | undefined;
+  writeItemAt(
+    mesh: object,
+    name: "instanceMatrix" | "instanceColor",
+    index: unknown,
+    value: unknown,
+  ): boolean;
 }
 
 export function defineAttributeSync(host: IAttributeSyncHost): IAttributeSync {
@@ -70,7 +78,14 @@ export function defineAttributeSync(host: IAttributeSyncHost): IAttributeSync {
   // Shape survives data uploads and transform calls; only copy/replacement changes it.
   const shapes = new WeakMap<object, Map<string, unknown>>();
   const pending = new Set<object>();
+  const dirty = new Map<object, { from: number; to: number }>();
   const writeBack = (): void => {
+    for (const [attribute, { from, to }] of dirty) {
+      const entry = arrays.get(attribute);
+      if (entry !== undefined && !pending.has(attribute))
+        attributeWrite?.call(runtime, refOf(attribute), entry.array.subarray(from, to), from);
+    }
+    dirty.clear();
     for (const attribute of pending) {
       const entry = arrays.get(attribute);
       if (entry !== undefined) attributeWrite?.call(runtime, refOf(attribute), entry.array);
@@ -163,6 +178,58 @@ export function defineAttributeSync(host: IAttributeSyncHost): IAttributeSync {
       return undefined;
     return { array: entry.array, at, values };
   };
+  // three's `setMatrixAt` and `setColorAt` write the item into the attribute's array, and so does
+  // this: one engine call an instance made a meadow of a few thousand tufts cost 60 ms of a laptop
+  // load (PRD-860). The written range goes to the engine once, before the next engine call, which is
+  // the first thing that can read it. Anything three would not write (a bad index, no value) and the
+  // first colour (the engine creates `instanceColor` then) take the engine's call.
+  const writeItemAt = (
+    mesh: object,
+    name: "instanceMatrix" | "instanceColor",
+    index: unknown,
+    value: unknown,
+  ): boolean => {
+    const source = value as {
+      elements?: ArrayLike<number>;
+      r?: unknown;
+      g?: unknown;
+      b?: unknown;
+    } | null;
+    const size = name === "instanceMatrix" ? 16 : 3;
+    const values =
+      name === "instanceMatrix"
+        ? source?.elements
+        : typeof source?.r === "number" &&
+            typeof source.g === "number" &&
+            typeof source.b === "number"
+          ? [source.r, source.g, source.b]
+          : undefined;
+    const attribute = (mesh as Record<string, unknown>)[name];
+    const at = Number(index) * size;
+    if (
+      attributeArray === undefined ||
+      values?.length !== size ||
+      typeof attribute !== "object" ||
+      attribute === null ||
+      !Number.isSafeInteger(at) ||
+      at < 0
+    )
+      return false;
+    let entry = arrays.get(attribute);
+    if (entry === undefined) {
+      entry = { array: attributeArray.call(runtime, refOf(attribute)) };
+      arrays.set(attribute, entry);
+    }
+    if (at + size > entry.array.length) return false;
+    entry.array.set(values, at);
+    const range = dirty.get(attribute);
+    if (range === undefined) dirty.set(attribute, { from: at, to: at + size });
+    else {
+      range.from = Math.min(range.from, at);
+      range.to = Math.max(range.to, at + size);
+    }
+    return true;
+  };
   return {
     attributeArray,
     attributeWrite,
@@ -170,11 +237,13 @@ export function defineAttributeSync(host: IAttributeSyncHost): IAttributeSync {
     itemSizes,
     shapes,
     pending,
+    dirty,
     writeBack,
     itemSizeOf,
     rangeOf,
     syncRange,
     syncFull,
     instanceItem,
+    writeItemAt,
   };
 }
diff --git a/packages/three-native/src/browser-backend.ts b/packages/three-native/src/browser-backend.ts
index 3069a5a377..2f9a664c09 100644
--- a/packages/three-native/src/browser-backend.ts
+++ b/packages/three-native/src/browser-backend.ts
@@ -683,12 +683,14 @@ export function defineBrowserClasses(
     itemSizes,
     shapes,
     pending,
+    dirty,
     writeBack,
     itemSizeOf,
     rangeOf,
     syncRange,
     syncFull,
     instanceItem,
+    writeItemAt,
   } = defineAttributeSync({ runtime, refOf });
 
   const fromEngine = (value: EngineValue): unknown => {
@@ -898,6 +900,12 @@ export function defineBrowserClasses(
         writable: true,
         value(this: object, ...args: unknown[]) {
           if (glueCounting) methodCalls += 1;
+          // An instance's matrix or colour is an array write, as in three, sent before the next engine call.
+          if (instanceWrite !== undefined && writeItemAt(this, instanceWrite, args[0], args[1])) {
+            labels.delete(this);
+            animated.delete(this);
+            return this;
+          }
           // three's toArray(array, offset) writes the lanes into the array it is given and answers that array; the
           // engine answers a new one, since a plain array crosses by value.
           if (method === "toArray" && args[0] !== undefined) {
@@ -919,7 +927,7 @@ export function defineBrowserClasses(
           } else if (schedule === "all") scheduling = new WeakMap();
           // A per-vertex setter writes its own range and reads no kept array, so a whole-shadow flush
           // would cost O(N) a call; it syncs just its range back below. Anything else flushes edits.
-          if (pending.size > 0 && !rangeMethod && !bookkeeping) writeBack();
+          if ((pending.size > 0 || dirty.size > 0) && !rangeMethod && !bookkeeping) writeBack();
           // A full-array attribute transform reads its own array: send the game's shadow first.
           if (transformMethod) {
             const entry = arrays.get(this);
@@ -1715,6 +1723,7 @@ export function defineBrowserClasses(
                   );
               }
               pending.delete(this);
+              dirty.delete(this);
             }
             needsUpdate.set?.call(this, value);
           },
diff --git a/packages/three-native/src/browser-value-views.ts b/packages/three-native/src/browser-value-views.ts
index ea7defdafb..b413c414f6 100644
--- a/packages/three-native/src/browser-value-views.ts
+++ b/packages/three-native/src/browser-value-views.ts
@@ -465,10 +465,26 @@ export function defineValueViews(host: IValueViewHost): IValueViews {
             const memory = read(address, count) as number[];
             for (let i = 0; i < count; i++) values[i] = memory[i] as number;
           };
+      // Shared memory (the threads build) never detaches when it grows, so a view onto it is the
+      // matrix itself: three's compose wrote 16 trapped elements a call, 49 ms of a laptop load (PRD-860).
+      const shared = new WeakMap<object, Float64Array>();
       Object.defineProperty(accessors, "elements", {
         configurable: true,
         get(this: object): number[] {
           const address = addressOf(this) + offset;
+          const memory = heap?.();
+          if (
+            typeof SharedArrayBuffer !== "undefined" &&
+            memory?.buffer instanceof SharedArrayBuffer
+          ) {
+            let view = shared.get(this);
+            if (view === undefined) {
+              view = memory.subarray(address / 8, address / 8 + count);
+              shared.set(this, view);
+            }
+            // quality-allow: three's elements are an indexable number list; a Float64Array is one.
+            return view as unknown as number[];
+          }
           let mirror = mirrors.get(this);
           if (mirror === undefined) {
             const values = new Array<number>(count);
diff --git a/scripts/__tests__/load-bench.spec.ts b/scripts/__tests__/load-bench.spec.ts
new file mode 100644
index 0000000000..f7f2f391d4
--- /dev/null
+++ b/scripts/__tests__/load-bench.spec.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { parseHeadersFile } from "../load-bench.js";
+
+describe("load-bench _headers parser", () => {
+  it("applies every matching rule's headers, with * matching any run", () => {
+    const rules = parseHeadersFile(
+      "/*\n  Cross-Origin-Opener-Policy: same-origin\n/assets/*\n  Cache-Control: public, max-age=31536000, immutable\n",
+    );
+    const matched = (path: string) =>
+      rules.filter((rule) => rule.pattern.test(path)).flatMap((rule) => rule.headers);
+    expect(matched("/assets/index-abc.js")).toEqual([
+      ["Cross-Origin-Opener-Policy", "same-origin"],
+      ["Cache-Control", "public, max-age=31536000, immutable"],
+    ]);
+    expect(matched("/index.html")).toEqual([["Cross-Origin-Opener-Policy", "same-origin"]]);
+  });
+
+  it("fails on a header line with no path line above it", () => {
+    expect(() => parseHeadersFile("  Cache-Control: no-cache\n")).toThrow("TN_LOAD_BENCH_HEADERS");
+  });
+});
diff --git a/scripts/load-bench.ts b/scripts/load-bench.ts
new file mode 100644
index 0000000000..d73fa0923d
--- /dev/null
+++ b/scripts/load-bench.ts
@@ -0,0 +1,419 @@
+/**
+ * PRD-860 load benchmark: how long a built web game takes from navigation to
+ * `__TN_STARTUP_READY__`, on a first visit (empty browser profile) and on repeat visits
+ * (the same profile, browser relaunched), served the way a production host serves it.
+ *
+ *   pnpm bench:load --prepare <out> [--kit collectathon]   scaffold from local packages, build
+ *   pnpm bench:load --dist <out>/dist [--runs 5] [--network 20000:40] [--json]
+ *     [--cpu-profile <file.cpuprofile>]   the first repeat visit's main-thread CPU profile
+ *
+ * The server sends the build's `.br` copies with `Content-Encoding: br` and applies the
+ * `_headers` file, so the result reads the bytes and cache rules a player gets, not a dev server's.
+ * A software WebGPU adapter fails the run: its timings describe a CPU rasteriser.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { type IncomingMessage, type ServerResponse, createServer } from "node:http";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { chromium } from "@playwright/test";
+import { WEBGPU_BROWSER_ARGS } from "../packages/playtest/src/runner/browser.js";
+
+const READY = "globalThis.__TN_STARTUP_READY__ === true";
+const STAGE_MARKERS = ["TN_STATIC_COLLIDERS", "TN_STARTUP_WARMUP", "TN_AUTO_EXPOSURE"] as const;
+
+export interface ILoadRun {
+  readonly arm: "first" | "repeat";
+  readonly readyMs: number;
+  readonly requests: number;
+  readonly wireBytes: number;
+  readonly stages: Readonly<Record<string, number>>;
+}
+
+interface IArgs {
+  readonly prepare?: string;
+  readonly kit: string;
+  readonly dist?: string;
+  readonly runs: number;
+  readonly network?: { readonly kbps: number; readonly latencyMs: number };
+  readonly json: boolean;
+  readonly cpuProfile?: string;
+}
+
+function parseArgs(argv: readonly string[]): IArgs {
+  const value = (name: string): string | undefined => {
+    const index = argv.indexOf(name);
+    if (index === -1) return undefined;
+    const next = argv[index + 1];
+    if (next === undefined || next.startsWith("--"))
+      throw new Error(`TN_LOAD_BENCH_ARGS: ${name} needs a value.`);
+    return next;
+  };
+  const runs = Number(value("--runs") ?? 5);
+  if (!Number.isInteger(runs) || runs < 1)
+    throw new Error("TN_LOAD_BENCH_ARGS: --runs must be a positive integer.");
+  const net = value("--network");
+  let network: IArgs["network"];
+  if (net !== undefined) {
+    const [kbps = Number.NaN, latencyMs = Number.NaN] = net.split(":").map(Number);
+    if (!(kbps > 0) || !(latencyMs >= 0))
+      throw new Error("TN_LOAD_BENCH_ARGS: --network is <kbps>:<latencyMs>, for example 20000:40.");
+    network = { kbps, latencyMs };
+  }
+  const args = {
+    cpuProfile: value("--cpu-profile"),
+    dist: value("--dist"),
+    json: argv.includes("--json"),
+    kit: value("--kit") ?? "collectathon",
+    network,
+    prepare: value("--prepare"),
+    runs,
+  };
+  if ((args.dist === undefined) === (args.prepare === undefined))
+    throw new Error("TN_LOAD_BENCH_ARGS: pass exactly one of --prepare <out> or --dist <dir>.");
+  return args;
+}
+
+const TYPES: Record<string, string> = {
+  ".css": "text/css",
+  ".glb": "model/gltf-binary",
+  ".html": "text/html",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".mjs": "text/javascript",
+  ".ogg": "audio/ogg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".wasm": "application/wasm",
+  ".webmanifest": "application/manifest+json",
+};
+
+/** Netlify/Cloudflare `_headers`: a path line, then indented `Name: value` lines. `*` matches any run. */
+export function parseHeadersFile(
+  text: string,
+): Array<{ pattern: RegExp; headers: [string, string][] }> {
+  const rules: Array<{ pattern: RegExp; headers: [string, string][] }> = [];
+  for (const line of text.split("\n")) {
+    if (line.trim() === "" || line.trim().startsWith("#")) continue;
+    if (!/^\s/.test(line)) {
+      const source = line
+        .trim()
+        .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*");
+      rules.push({ headers: [], pattern: new RegExp(`^${source}$`) });
+      continue;
+    }
+    const rule = rules.at(-1);
+    const colon = line.indexOf(":");
+    if (rule === undefined || colon === -1)
+      throw new Error(`TN_LOAD_BENCH_HEADERS: cannot read _headers line "${line.trim()}".`);
+    rule.headers.push([line.slice(0, colon).trim(), line.slice(colon + 1).trim()]);
+  }
+  return rules;
+}
+
+function serve(dist: string): Promise<{ url: string; close: () => Promise<void> }> {
+  const headersFile = path.join(dist, "_headers");
+  const rules = existsSync(headersFile) ? parseHeadersFile(readFileSync(headersFile, "utf8")) : [];
+  const handler = (request: IncomingMessage, response: ServerResponse): void => {
+    const urlPath = decodeURIComponent(new URL(request.url ?? "/", "http://x").pathname);
+    const relative = urlPath.endsWith("/") ? `${urlPath}index.html` : urlPath;
+    const file = path.join(dist, relative);
+    if (!file.startsWith(dist) || !existsSync(file) || !statSync(file).isFile()) {
+      response.writeHead(404).end();
+      return;
+    }
+    const headers: Record<string, string> = {
+      "Content-Type": TYPES[path.extname(file)] ?? "application/octet-stream",
+    };
+    for (const rule of rules)
+      if (rule.pattern.test(urlPath)) for (const [k, v] of rule.headers) headers[k] = v;
+    // A production host revalidates a file with no cache rule; ETag lets the browser get a 304.
+    const stat = statSync(file);
+    const etag = `"${stat.size}-${stat.mtimeMs}"`;
+    headers.ETag = etag;
+    if (request.headers["if-none-match"] === etag) {
+      response.writeHead(304, headers).end();
+      return;
+    }
+    const brotli = `${file}.br`;
+    const acceptsBr = String(request.headers["accept-encoding"] ?? "").includes("br");
+    const body = acceptsBr && existsSync(brotli) ? readFileSync(brotli) : readFileSync(file);
+    if (acceptsBr && existsSync(brotli)) headers["Content-Encoding"] = "br";
+    headers.Vary = "Accept-Encoding";
+    response.writeHead(200, headers).end(body);
+  };
+  const server = createServer(handler);
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address !== null ? address.port : 0;
+      resolve({
+        close: () => new Promise<void>((done) => server.close(() => done())),
+        url: `http://127.0.0.1:${port}/`,
+      });
+    });
+  });
+}
+
+async function visit(
+  url: string,
+  profile: string,
+  arm: ILoadRun["arm"],
+  network: IArgs["network"],
+  cpuProfile?: string,
+  marksFile?: string,
+): Promise<ILoadRun & { adapter: string }> {
+  const context = await chromium.launchPersistentContext(profile, {
+    // TN_LOAD_BENCH_CHROME_ARGS adds browser switches for one experiment, e.g. a Dawn toggle.
+    args: [
+      ...WEBGPU_BROWSER_ARGS,
+      ...(process.env.TN_LOAD_BENCH_CHROME_ARGS?.split(" ").filter(Boolean) ?? []),
+    ],
+    headless: false,
+    viewport: { height: 720, width: 1280 },
+  });
+  // TN_LOAD_BENCH_INIT=<file.js> runs a probe before the page's own scripts (for example, one that
+  // logs a hash of every shader module), so a stage can be attributed without rebuilding the game.
+  if (process.env.TN_LOAD_BENCH_INIT)
+    await context.addInitScript({ path: process.env.TN_LOAD_BENCH_INIT });
+  try {
+    const page = await context.newPage();
+    const stages: Record<string, number> = {};
+    let started = 0;
+    const marks: string[] = [];
+    page.on("console", (message) => {
+      const text = message.text();
+      if (text.startsWith("TN_")) marks.push(`${Date.now() - started} ${text.slice(0, 240)}`);
+      for (const marker of STAGE_MARKERS)
+        if (text.startsWith(marker) && stages[marker] === undefined)
+          stages[marker] = Date.now() - started;
+    });
+    let requests = 0;
+    let wireBytes = 0;
+    const cdp = await context.newCDPSession(page);
+    await cdp.send("Network.enable");
+    cdp.on("Network.loadingFinished", (event) => {
+      requests += 1;
+      wireBytes += event.encodedDataLength;
+    });
+    if (network !== undefined)
+      await cdp.send("Network.emulateNetworkConditions", {
+        downloadThroughput: (network.kbps * 1000) / 8,
+        latency: network.latencyMs,
+        offline: false,
+        uploadThroughput: (network.kbps * 1000) / 8,
+      });
+    if (cpuProfile !== undefined) {
+      await cdp.send("Profiler.enable");
+      await cdp.send("Profiler.setSamplingInterval", { interval: 200 });
+      await cdp.send("Profiler.start");
+      // TN_LOAD_BENCH_TRACE=1: a whole-browser trace too, for the GPU process the CPU profile cannot see.
+      if (process.env.TN_LOAD_BENCH_TRACE === "1")
+        await cdp.send("Tracing.start", {
+          transferMode: "ReturnAsStream",
+          traceConfig: {
+            includedCategories: [
+              "toplevel",
+              "gpu",
+              "dawn",
+              "disabled-by-default-gpu.dawn",
+              "gpu.capture",
+              "v8.execute",
+              "blink",
+            ],
+          },
+        });
+    }
+    started = Date.now();
+    await page.goto(url, { waitUntil: "commit" });
+    await page.waitForFunction(READY, null, { polling: 16, timeout: 180_000 });
+    // TN_LOAD_BENCH_SHOTS=<dir>: the ready frame of every visit, for a visual judge (PRD-860 AC-4).
+    if (marksFile !== undefined && process.env.TN_LOAD_BENCH_SHOTS)
+      await page.screenshot({
+        path: path.join(process.env.TN_LOAD_BENCH_SHOTS, `${path.basename(marksFile, ".txt")}.png`),
+      });
+    // TN_LOAD_BENCH_RESOURCES=1: each request's start and end since navigation, as `TN_RESOURCE` marks.
+    if (process.env.TN_LOAD_BENCH_RESOURCES === "1")
+      for (const line of await page.evaluate(() =>
+        performance.getEntriesByType("resource").map((resource) => {
+          const entry = resource as PerformanceResourceTiming;
+          return `${Math.round(entry.responseEnd)} TN_RESOURCE ${Math.round(entry.startTime)}-${Math.round(entry.responseEnd)} ${entry.encodedBodySize} ${entry.name.split("/").pop()}`;
+        }),
+      ))
+        marks.push(line);
+    if (cpuProfile !== undefined) {
+      const { profile } = await cdp.send("Profiler.stop");
+      await writeFile(cpuProfile, JSON.stringify(profile));
+      // Every TN_ line with its time since navigation, beside the profile it explains.
+      await writeFile(`${cpuProfile}.marks.txt`, `${marks.join("\n")}\n`);
+      if (process.env.TN_LOAD_BENCH_TRACE === "1") {
+        const done = new Promise<{ stream?: string }>((resolve) =>
+          cdp.once("Tracing.tracingComplete", resolve),
+        );
+        await cdp.send("Tracing.end");
+        const { stream } = await done;
+        const chunks: string[] = [];
+        for (let eof = false; stream !== undefined && !eof; ) {
+          const chunk = await cdp.send("IO.read", { handle: stream });
+          chunks.push(chunk.data);
+          eof = chunk.eof;
+        }
+        await writeFile(`${cpuProfile}.trace.json`, chunks.join(""));
+      }
+    }
+    if (marksFile !== undefined) await writeFile(marksFile, `${marks.join("\n")}\n`);
+    const readyMs = await page.evaluate(() => Math.round(performance.now()));
+    const adapter = await page.evaluate(async () => {
+      const gpu = (navigator as Navigator & { gpu?: { requestAdapter(): Promise<unknown> } }).gpu;
+      const found = (await gpu?.requestAdapter()) as
+        | { info?: { vendor?: string; architecture?: string }; isFallbackAdapter?: boolean }
+        | null
+        | undefined;
+      if (found === null || found === undefined) return "none";
+      return `${found.info?.vendor ?? "?"}/${found.info?.architecture ?? "?"}${found.isFallbackAdapter === true ? "/fallback" : ""}`;
+    });
+    return { adapter, arm, readyMs, requests, stages, wireBytes };
+  } finally {
+    await context.close();
+  }
+}
+
+function median(values: readonly number[]): number {
+  if (values.length === 0) throw new Error("TN_LOAD_BENCH_EMPTY: no run to take a median of.");
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  const at = (index: number): number => sorted[index] as number;
+  return sorted.length % 2 === 1 ? at(middle) : Math.round((at(middle - 1) + at(middle)) / 2);
+}
+
+export async function measure(args: IArgs & { dist: string }) {
+  const dist = path.resolve(args.dist);
+  if (!existsSync(path.join(dist, "index.html")))
+    throw new Error(`TN_LOAD_BENCH_DIST: ${dist} has no index.html; build the game first.`);
+  const server = await serve(dist);
+  const runs: Array<ILoadRun & { adapter: string }> = [];
+  try {
+    for (let cycle = 0; cycle < args.runs; cycle += 1) {
+      const profile = await mkdtemp(path.join(tmpdir(), "tn-load-bench-"));
+      try {
+        // TN_LOAD_BENCH_MARKS=<dir> keeps every visit's TN_ lines, to compare one stage across visits.
+        const marks = (n: number) =>
+          process.env.TN_LOAD_BENCH_MARKS &&
+          path.join(process.env.TN_LOAD_BENCH_MARKS, `${cycle}-${n}.txt`);
+        const profileOut = cycle === 0 ? args.cpuProfile : undefined;
+        // TN_LOAD_BENCH_PROFILE=first profiles the first visit instead of the first repeat.
+        const first = process.env.TN_LOAD_BENCH_PROFILE === "first";
+        runs.push(
+          await visit(
+            server.url,
+            profile,
+            "first",
+            args.network,
+            first ? profileOut : undefined,
+            marks(0),
+          ),
+        );
+        runs.push(
+          await visit(
+            server.url,
+            profile,
+            "repeat",
+            args.network,
+            first ? undefined : profileOut,
+            marks(1),
+          ),
+        );
+        runs.push(await visit(server.url, profile, "repeat", args.network, undefined, marks(2)));
+      } finally {
+        await rm(profile, { force: true, recursive: true });
+      }
+    }
+  } finally {
+    await server.close();
+  }
+  const adapters = [...new Set(runs.map((run) => run.adapter))];
+  if (adapters.some((adapter) => adapter === "none" || /fallback|swiftshader|cpu/i.test(adapter)))
+    throw new Error(
+      `TN_LOAD_BENCH_ADAPTER: a run had no hardware WebGPU adapter (${adapters.join(", ")}).`,
+    );
+  const summary = (arm: ILoadRun["arm"]) => {
+    const own = runs.filter((run) => run.arm === arm);
+    const stage = (marker: string) => {
+      const seen = own
+        .map((run) => run.stages[marker])
+        .filter((ms): ms is number => ms !== undefined);
+      return seen.length === own.length ? median(seen) : undefined;
+    };
+    return {
+      medianReadyMs: median(own.map((run) => run.readyMs)),
+      minReadyMs: Math.min(...own.map((run) => run.readyMs)),
+      maxReadyMs: Math.max(...own.map((run) => run.readyMs)),
+      medianRequests: median(own.map((run) => run.requests)),
+      medianWireKB: Math.round(median(own.map((run) => run.wireBytes)) / 1024),
+      runs: own.length,
+      stagesMs: Object.fromEntries(STAGE_MARKERS.map((marker) => [marker, stage(marker)])),
+    };
+  };
+  return {
+    adapter: adapters.join(", "),
+    first: summary("first"),
+    network: args.network ?? null,
+    repeat: summary("repeat"),
+    runs,
+  };
+}
+
+function run(command: string, commandArgs: readonly string[], cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, commandArgs, { cwd, stdio: "inherit" });
+    child.on("exit", (code) =>
+      code === 0
+        ? resolve()
+        : reject(new Error(`${command} ${commandArgs.join(" ")} exited ${code}.`)),
+    );
+  });
+}
+
+async function prepare(out: string, kit: string): Promise<string> {
+  const { createProject } = await import("../packages/create-threenative/src/index.js");
+  const { packageLocalFramework } = await import("./visual-gate.js");
+  const root = path.resolve(out);
+  await mkdir(root, { recursive: true });
+  const packageSources = await packageLocalFramework(root);
+  const project = await createProject(
+    { install: true, packageSources, target: kit, template: kit },
+    root,
+  );
+  await run("pnpm", ["build:web"], project.target);
+  return path.join(project.target, "dist");
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.prepare !== undefined) {
+    process.stdout.write(`TN_LOAD_BENCH_DIST ${await prepare(args.prepare, args.kit)}\n`);
+    return;
+  }
+  const result = await measure({ ...args, dist: args.dist as string });
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
+  const line = (name: string, arm: typeof result.first) =>
+    `${name}: median ${arm.medianReadyMs} ms (min ${arm.minReadyMs}, max ${arm.maxReadyMs}, n=${arm.runs}), ` +
+    `${arm.medianRequests} requests, ${arm.medianWireKB} KB on the wire, stages ${JSON.stringify(arm.stagesMs)}`;
+  process.stdout.write(
+    `TN_LOAD_BENCH adapter=${result.adapter} network=${JSON.stringify(result.network)}\n` +
+      `${line("first visit", result.first)}\n${line("repeat visit", result.repeat)}\n`,
+  );
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error: unknown) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}