From f8c245534f148edf2c55d119798e6357d37f7f7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Paulo=20Furtado?=
 <30300459+jonit-dev@users.noreply.github.com>
Date: Fri, 2 Oct 2026 00:03:31 -0700
Subject: [PATCH 01/36] fix(build): fail closed on unknown native asset
 capabilities (VQ-01)

Partial implementation. Preserve decoder-free fallback and existing desktop V8 behavior; no newly admitted codec. Real runtime screenshot and full native loader qualification remain blocked.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  79 +++++++++
 packages/assets/__tests__/report.spec.ts      |   8 +
 packages/assets/src/compile.ts                |  42 ++---
 packages/assets/src/report.ts                 |   2 +-
 .../__tests__/build.spec.ts                   |  25 ++-
 .../__tests__/consumer-cli.spec.ts            |  10 +-
 .../__tests__/native-consumer.spec.ts         |  33 +++-
 .../__tests__/native-ktx2.spec.ts             |  38 ++++-
 .../__tests__/templates-native.spec.ts        |  27 ++-
 .../vq-native-asset-capabilities.spec.ts      | 151 +++++++++++++++++
 packages/create-threenative/src/build.ts      | 160 +++++++++++-------
 packages/runtime-native/AGENTS.md             |  20 ++-
 packages/runtime-native/CLAUDE.md             |  20 ++-
 packages/runtime-native/scripts/bundle.mjs    |  27 +--
 14 files changed, 501 insertions(+), 141 deletions(-)
 create mode 100644 docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
 create mode 100644 packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts

diff --git a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
new file mode 100644
index 0000000000..ae09f60309
--- /dev/null
+++ b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
@@ -0,0 +1,79 @@
+---
+prd_contract: v1
+---
+
+# PRD-VQ-01 — Native asset compatibility follows the selected runtime and actual decoders
+
+**Status:** PARTIAL — 2026-10-02. Bounded desktop/unknown-runtime fail-closed repair implemented; mobile selected-artifact resolution and packaged-loader qualification remain open.
+**Batch:** [Visual quality execution batch](https://github.com/ThreeNativeHQ/threenative/blob/d9ac5b4e97f6b1383bd163d91619cffa7c6c0ef5/docs/PRDs/batch-2026-10-01-visual-quality/README.md). **Wave:** 0 / correctness.
+**Dependencies:** None. This is a build/runtime contract repair, not permission to remove compatibility guards.
+
+## Grounding and intended outcome
+
+[packages/create-threenative/src/build.ts](https://github.com/ThreeNativeHQ/threenative/blob/d72778382b134ef8763f58825cb4d4fd8cc0f6e3/packages/create-threenative/src/build.ts) still rejects compressed assets by mobile target in `assertNativeAssetsCompatible`, while the runtime documentation identifies Android V8 as the default. The source establishes inconsistent capability selection; it does not prove that shipping V8 alone makes the Basis, Meshopt or Draco loading paths work. Workers, bundling, file access, decoder payloads and GPU formats are separate requirements.
+
+**Outcome:** A packaged game either decodes its declared assets on its selected runtime or is refused before publication with an accurate codec-specific reason. Android V8 and QuickJS must not be conflated; desktop QuickJS must not bypass checks simply because it is desktop.
+
+## Design and ownership
+
+Resolve one runtime capability record from the exact selected artifact/cohort before cooking. Thread it through asset cooking, the compatibility guard, native bundling and the runtime loader. Record engine, WASM support, packaged decoder versions and supported texture formats independently. An unknown capability takes an explicit decoder-free path or fails; it is never inferred from the build machine or from a desktop executable used to package Android. Keep QuickJS rollback supported. Do not silently change an authored asset or trust a manifest that disagrees with the packaged bytes.
+
+Reuse `runtimeHasWebAssembly`, `assertNativeAssetsCompatible`, asset compiler decoder options and `packages/runtime-native/scripts/bundle.mjs`. Extend the artifact capability contract only where necessary. No new renderer, codec implementation, or blanket Android whitelist. Preserve current WebGL and decoder-free fallbacks.
+
+## Required behavior
+
+- A table-driven suite covers web, desktop V8, desktop QuickJS, Android V8, Android QuickJS and unknown artifacts, with each codec independently allowed or refused.
+- The loader validates actual KTX2 block formats and fallback transcodes. Mesh compression is separately tested; smaller download bytes are not reported as smaller GPU vertex buffers.
+- Cook-cache keys include decoder capabilities and cohort identity. Switching engine or codec cannot reuse incompatible output.
+- Diagnostics identify the asset, codec, selected artifact and missing capability. Build failure must leave the previous packaged artifact intact.
+
+## Execution phases
+
+The unit proof paths now exist; the Phase 3 scenario paths remain **planned implementation targets**, not passing runtime proof. Reuse an existing equivalent test or scenario after inspecting current code, and update the canonical proof path rather than adding a duplicate. Follow [EXECUTE.md](https://github.com/ThreeNativeHQ/threenative/blob/d9ac5b4e97f6b1383bd163d91619cffa7c6c0ef5/docs/PRDs/batch-2026-10-01-visual-quality/EXECUTE.md) for fixture setup, variables, review and repository gates.
+
+### Phase 1 — One capability decision
+
+- [ ] Implement capability resolution from the selected artifact, including unknown-artifact handling and the full target/engine table. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+  Partial: desktop resolves the packager's actual binary before cooking and hashes its bytes. Failed, absent, unknown and non-V8 probes take the decoder-free path. Android/iOS never probe the desktop packaging executable; their exact artifact/cohort resolution remains open.
+- [ ] Wire the same capability record into cooking and compatibility validation; preserve decoder-free rollback. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+
+  Partial: the record governs cooking, compatibility guards, and the desktop native-backend bundle path; embedded/shared KTX2 and Meshopt/Draco declarations are refused when unavailable. The existing desktop V8 path is preserved, not newly qualified.
+
+### Phase 2 — The packaged bytes are authoritative
+
+- [ ] Make bundling and loading retain exactly the declared decoders and invalidate stale cook-cache entries. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+  Partial: cook keys include explicit decoder capabilities and selected desktop runtime SHA-256; QuickJS/unknown desktop bundles use the existing refusing stubs. Decoder versions, KTX2 block-format validation and manifest-versus-payload verification remain open.
+- [ ] Create separate tiny textured/animated fixtures for KTX2, Meshopt and Draco; assert decoded texture content and geometry rather than only a successful import. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+
+### Phase 3 — Qualify the visible result
+
+- [ ] The unchanged web fixture renders each codec correctly, with named adapter and no loader/GPU diagnostics. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --url ${VQ_URL:?} --browser-recipe webgpu`.
+- [ ] The packaged Android V8 fixture decodes the admitted codecs on an emulator; unsupported codecs remain explicitly refused and the QuickJS decoder-free fixture still runs. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --target android --device ${VQ_ANDROID_DEVICE:?}`.
+
+## Acceptance criteria
+
+- [ ] All admitted codecs are demonstrated through the packaged loader, not merely through WASM availability; all refused combinations retain actionable build errors. proof: the completed Phase 3 scenario outputs, with the named fixture, package/cohort and adapter recorded inline here.
+- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario.
+
+## Performance and promotion
+
+Record encoded bytes, decoded texture/geometry bytes and peak load memory per codec. Enabling a path requires correct pixels and bounded lifetime, not a promised compression ratio. Numerical targets are proposed acceptance targets, not benchmark results. Pin the fixture, metrics and thresholds before changing the implementation; never relax a failing threshold just to mark this PRD complete. Shared abstractions must pass the repository's reuse/LOC admission rule. Appearance remains editable source.
+
+## Blocked on
+
+Physical Android performance and thermals require a named phone and are separate from emulator correctness. Missing codec qualifications must remain individual exclusions.
+
+This executor has no GPU device, Android SDK/adb or KVM. Xvfb is denied with EPERM; browser/native pixels and emulator correctness are unrun. These limitations do not qualify any codec. The owner explicitly requires screenshot proofs for every PR (2026-10-02); no actual relevant runtime screenshot has been captured, so this PR remains draft. Test logs and synthetic images are not screenshot proof.
+
+## Completion record
+
+Update the phase boxes and this PRD only after the named proof runs. Record actual results inline, including any remaining exclusions. A merged planning or implementation PR alone is not proof that every acceptance criterion passed. Archive according to the parent PRD filing rules when the work is genuinely complete.
+
+### Bounded implementation verification — 2026-10-02
+
+- Mandatory capability MCP search/detail reused `compileAssets`, `resolveBasisTranscoder` and the existing portable loader; no new codec or renderer was added.
+- Red/green: 9 failures first demonstrated fail-open unknown engines and desktop codec bypass; 3 more demonstrated stale cache identity and QuickJS decoder inclusion. The final focused rerun passed 40/40 across capability/cache, native-KTX2 and report suites. A separate report regression failed on the false `no WebAssembly` claim and passed after diagnostics named missing qualified decoders (12/12 report tests).
+- `pnpm exec vitest run packages/create-threenative/__tests__/build.spec.ts`: 29/29 passed in the combined nearest-lane run. `native-consumer.spec.ts` live caller checks pass 3/3, including exact resolved binary forwarding and preservation of the previous packaged artifact after an authored KTX2 refusal. The template-native and consumer CLI suites pass 16/16 after their packager fixtures follow the new early resolver contract.
+- `pnpm --filter @threenative/assets build` and `pnpm --filter create-threenative build`: passed including declaration output and publint. Scoped create-threenative and assets TypeScript checks passed. Root lint passed with warnings; agent mirrors regenerated.
+- Aggregate qualification is **not green**: root `pnpm test` stops before tests at tsx IPC `listen EPERM`; root `pnpm typecheck` was killed with exit 137. The broader native consumer lane has two unavailable-`jar` failures, separately reproduced using its unchanged baseline test source. Full build, GPU/native scenarios, decoder memory/lifecycle measurements and actual packaged-loader codec pixels remain unverified.
+- All phase and acceptance boxes intentionally remain open. No full Phase 1, Phase 2, native decoder admission, visual result or PRD completion is claimed by this patch.
diff --git a/packages/assets/__tests__/report.spec.ts b/packages/assets/__tests__/report.spec.ts
index 3ca9225f91..854cc93602 100644
--- a/packages/assets/__tests__/report.spec.ts
+++ b/packages/assets/__tests__/report.spec.ts
@@ -121,6 +121,14 @@ describe("formatModelSizes", () => {
 });
 
 describe("formatSkippedCompression", () => {
+  it("reports missing decoders without inferring that the selected engine has no WASM", () => {
+    const lines = formatSkippedCompression([
+      { kind: "texture", files: 1, bytes: 128, reason: "platform" },
+    ]);
+    expect(lines[0]).toContain("no qualified KTX2 decoder");
+    expect(lines[0]).not.toContain("no WebAssembly");
+  });
+
   it("names the decoder capability that a target skipped without blaming dedupe", () => {
     const rows: readonly ISkippedCompressionRow[] = [
       { bytes: 240, files: 2, kind: "model", reason: "platform" },
diff --git a/packages/assets/src/compile.ts b/packages/assets/src/compile.ts
index bcd6e90daf..b3c71c7094 100644
--- a/packages/assets/src/compile.ts
+++ b/packages/assets/src/compile.ts
@@ -265,31 +265,16 @@ export interface IAssetCompileOptions {
    */
   readonly processingOrder?: "reversed" | "sorted";
   /**
-   * The platform this bake is for, which decides whether compression can ship at all.
-   *
-   * Android and iOS run the native host without WebAssembly, so they carry no Basis transcoder
-   * and no Meshopt decoder: a `.ktx2` texture or a meshopt-compressed mesh in a mobile bundle is
-   * a black screen, and `threenative build` refuses one with `TN_NATIVE_KTX2_UNSUPPORTED`. Web
-   * and desktop decode both.
-   *
-   * Absent means web — a direct `compileAssets` call, or a project that compiles once and serves
-   * the result. `threenative build` always names its `--target`, so the passes that a platform
-   * cannot decode drop for that build and stay on for every other one. This is the whole reason
-   * `assets.textures: "none"` used to be pinned in the scaffolded config: the author was asked to
-   * choose one constant for four targets, and every game that wanted Android shipped its web
-   * build uncompressed too. The build knows its target; it decides.
+   * The conservative default decoder policy: web/desktop keep the existing loaders;
+   * Android/iOS stay decoder-free until their packaged loaders are qualified. A V8 engine
+   * alone does not establish a working Basis, Meshopt or Draco path. Absent means web.
+   * Native builds provide runtimeDecoders from their selected artifact instead.
    */
   readonly platform?: "android" | "desktop" | "ios" | "web";
-  /**
-   * What the runtime that will execute this bake can decode, when the caller has probed it.
-   *
-   * `platform` is a proxy: it answers "android and iOS have no WebAssembly" for the targets this
-   * repository ships. A desktop host can also lack WebAssembly — the Linux arm64 lane builds
-   * QuickJS over wgpu-native — and then the same meshopt/KTX2 passes it would keep produce an
-   * asset nothing can decode. `threenative build` reads the engine from the runtime binary it will
-   * package and passes the real capability here; absent, the platform-derived default stands.
-   */
+  /** Which compressed outputs the selected runtime's bundle can decode, independently of WASM. */
   readonly runtimeDecoders?: IAssetRuntimeDecoderCapabilities;
+  /** Exact selected runtime/cohort identity; changing it invalidates cooked output. */
+  readonly runtimeIdentity?: string;
   readonly source?: string;
   /** Overrides resolution of three's Basis transcoder for the copy into the output root. */
   readonly transcoder?: IBasisTranscoder;
@@ -1594,9 +1579,8 @@ function resolveLayout(cwd: string, options: IAssetCompileOptions): ICompileLayo
       `TN_ASSETS_OVERLAP: source '${sourceRoot}' and output '${outputRoot}' must be disjoint directories.`,
     );
   }
-  // Android and iOS have no WebAssembly and therefore no Basis transcoder and no Meshopt
-  // decoder. The registry uses each pass's declaration below, so decoder-free work in the mixed
-  // model pass survives on those targets.
+  // Mobile keeps the decoder-free policy until its packaged loaders are qualified.
+  // Each pass declares its decoder dependency, so decoder-free model work survives.
   const runtimeDecoderCapabilities: IAssetRuntimeDecoderCapabilities = options.runtimeDecoders ?? {
     ktx2: options.platform !== "android" && options.platform !== "ios",
     meshopt: options.platform !== "android" && options.platform !== "ios",
@@ -2534,6 +2518,14 @@ export async function compileAssets(
     const cacheKeys = included.map((pass) => pass.cacheKey ?? null);
     return JSON.stringify({
       ...(cacheKeys.some((key) => key !== null) ? { passCacheKeys: cacheKeys } : {}),
+      ...(options.runtimeIdentity === undefined && options.runtimeDecoders === undefined
+        ? {}
+        : {
+            runtime: {
+              identity: options.runtimeIdentity ?? null,
+              decoders: layout.runtimeDecoderCapabilities,
+            },
+          }),
       pipelineVersion: PIPELINE_VERSION,
       passes: included.map((pass) => pass.name),
       options: included.map((pass) => pass.configuration ?? null),
diff --git a/packages/assets/src/report.ts b/packages/assets/src/report.ts
index b8d203d6c8..9b306fd14f 100644
--- a/packages/assets/src/report.ts
+++ b/packages/assets/src/report.ts
@@ -587,7 +587,7 @@ export function formatSkippedCompression(rows: readonly ISkippedReportRow[]): re
       const reason =
         row.reason === "config"
           ? `assets.${row.kind}s is "none"`
-          : `this target has no WebAssembly and cannot run its ${decoders} decoder`;
+          : `this target has no qualified ${decoders} decoder`;
       return `TN_ASSETS_COMPRESSION_SKIPPED ${row.kind}: ${String(row.files)} file(s), ${(row.bytes / 1e6).toFixed(1)} MB ${action} because ${reason}.`;
     });
 }
diff --git a/packages/create-threenative/__tests__/build.spec.ts b/packages/create-threenative/__tests__/build.spec.ts
index f9cb892b44..41cf385abf 100644
--- a/packages/create-threenative/__tests__/build.spec.ts
+++ b/packages/create-threenative/__tests__/build.spec.ts
@@ -17,6 +17,7 @@ import {
   nativeOrientation,
   parseBuildArgs,
   publishStagedArtifact,
+  resolveRuntimeAssetCapabilities,
   runtimeHasWebAssembly,
   stagingPath,
   writePackagingConfig,
@@ -878,7 +879,7 @@ cpSync("public", out, { recursive: true });
     );
   });
 
-  it("guards web-only UI on every native target and WASM on mobile only", async () => {
+  it("guards web-only UI on every native target and WASM without a known desktop V8 artifact", async () => {
     const root = await makeTempDir("threenative-mobile-bundle-");
     roots.push(root);
     const native = path.join(root, "native.js");
@@ -893,7 +894,15 @@ cpSync("public", out, { recursive: true });
         /TN_NATIVE_WEB_ONLY_UI.*src\/main\.ts.*PRD-051/u,
       );
     }
-    await expect(assertNativeBundleCompatible(wasm, "desktop")).resolves.toBeUndefined();
+    await expect(assertNativeBundleCompatible(wasm, "desktop")).rejects.toThrow(
+      "TN_NATIVE_WASM_UNSUPPORTED",
+    );
+    const desktopV8 = resolveRuntimeAssetCapabilities(
+      "desktop",
+      path.resolve("packages/create-threenative/src/build.ts"),
+      (() => ({ status: 0, stdout: "+ v8 build" })) as never,
+    );
+    await expect(assertNativeBundleCompatible(wasm, "desktop", desktopV8)).resolves.toBeUndefined();
     for (const target of ["android", "ios"] as const) {
       await expect(assertNativeBundleCompatible(wasm, target)).rejects.toThrow(
         /TN_NATIVE_WASM_ON_MOBILE.*src\/game\.ts.*PRD-052/u,
@@ -966,14 +975,16 @@ describe("runtime WebAssembly capability", () => {
     ).toBe(true);
   });
 
-  it("keeps the WASM desktop backend when the runtime is unknown or unreadable", () => {
-    expect(runtimeHasWebAssembly(undefined)).toBe(true);
-    expect(runtimeHasWebAssembly("/no/such/runtime")).toBe(true);
-    expect(runtimeHasWebAssembly(runtime, (() => ({ status: 1, stdout: "" })) as never)).toBe(true);
+  it("refuses WASM when the runtime is unknown or unreadable", () => {
+    expect(runtimeHasWebAssembly(undefined)).toBe(false);
+    expect(runtimeHasWebAssembly("/no/such/runtime")).toBe(false);
+    expect(runtimeHasWebAssembly(runtime, (() => ({ status: 1, stdout: "" })) as never)).toBe(
+      false,
+    );
     expect(
       runtimeHasWebAssembly(runtime, (() => {
         throw new Error("EACCES");
       }) as never),
-    ).toBe(true);
+    ).toBe(false);
   });
 });
diff --git a/packages/create-threenative/__tests__/consumer-cli.spec.ts b/packages/create-threenative/__tests__/consumer-cli.spec.ts
index 3ecdc5fa40..96d77bac2a 100644
--- a/packages/create-threenative/__tests__/consumer-cli.spec.ts
+++ b/packages/create-threenative/__tests__/consumer-cli.spec.ts
@@ -44,10 +44,14 @@ async function desktopCallerFixture(): Promise<{ root: string; log: string }> {
     `
     import { mkdirSync, writeFileSync } from 'node:fs';
     import { dirname } from 'node:path';
+    import { pathToFileURL } from 'node:url';
+    export async function resolveDesktopRuntime(explicit) { return explicit ?? import.meta.filename; }
+    if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
     const output = process.argv[process.argv.indexOf('--output') + 1];
     mkdirSync(dirname(output), { recursive: true });
     writeFileSync(output, 'packaged');
     writeFileSync(${JSON.stringify(log)}, JSON.stringify(process.argv.slice(2)));
+    }
   `,
   );
   return { root, log };
@@ -57,7 +61,11 @@ test("desktop caller does not reinterpret a source checkout as an explicit runti
   const { root, log } = await desktopCallerFixture();
   process.env.THREENATIVE_RUNTIME_SOURCE = path.join(root, "checkout");
   await build({ cwd: root, target: "desktop" });
-  assert.ok(!JSON.parse(await readFile(log, "utf8")).includes("--runtime"));
+  const args: string[] = JSON.parse(await readFile(log, "utf8"));
+  assert.equal(
+    args[args.indexOf("--runtime") + 1],
+    path.join(root, "node_modules/@threenative/runtime-native/scripts/package-desktop.mjs"),
+  );
 });
 
 test("explicit desktop binary still wins when a source override is also set", async () => {
diff --git a/packages/create-threenative/__tests__/native-consumer.spec.ts b/packages/create-threenative/__tests__/native-consumer.spec.ts
index 0186b34e8d..96312220bd 100644
--- a/packages/create-threenative/__tests__/native-consumer.spec.ts
+++ b/packages/create-threenative/__tests__/native-consumer.spec.ts
@@ -6,6 +6,7 @@ import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
+import { encodeToKTX2 } from "ktx2-encoder";
 import { afterEach, test } from "vitest";
 import { makeTempDir } from "../../../test-support/temp-dir.js";
 import { build, parseBuildArgs } from "../src/build.js";
@@ -46,26 +47,34 @@ async function callerFixture(): Promise<{ root: string; log: string }> {
   `,
   );
   const log = path.join(root, "packager-args.json");
+  await writeFile(path.join(root, "selected-runtime"), "fixture runtime: unknown engine");
   for (const target of ["desktop", "android", "ios"]) {
     await writeFile(
       path.join(runtime, `scripts/package-${target}.mjs`),
       `
       import { mkdirSync, writeFileSync } from 'node:fs';
       import { dirname } from 'node:path';
+      import { pathToFileURL } from 'node:url';
+      export async function resolveDesktopRuntime(explicit) {
+        return explicit ?? ${JSON.stringify(path.join(root, "selected-runtime"))};
+      }
+      if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
       const output = process.argv[process.argv.indexOf('--output') + 1];
       mkdirSync(dirname(output), { recursive: true });
       writeFileSync(output, 'packaged');
       writeFileSync(${JSON.stringify(log)}, JSON.stringify(process.argv.slice(2)));
+      }
     `,
     );
   }
   return { root, log };
 }
 
-test("desktop consumer caller leaves runtime discovery to the packager", async () => {
+test("desktop consumer caller resolves the exact package runtime before cooking", async () => {
   const { root, log } = await callerFixture();
   await build({ cwd: root, target: "desktop" });
-  assert.ok(!JSON.parse(await readFile(log, "utf8")).includes("--runtime"));
+  const args: string[] = JSON.parse(await readFile(log, "utf8"));
+  assert.equal(args[args.indexOf("--runtime") + 1], path.join(root, "selected-runtime"));
 });
 
 test("desktop caller preserves an explicit maintainer binary including spaces", async () => {
@@ -76,6 +85,26 @@ test("desktop caller preserves an explicit maintainer binary including spaces",
   assert.equal(args[args.indexOf("--runtime") + 1], process.env.THREENATIVE_RUNTIME_BINARY);
 });
 
+test("a codec refusal in the live desktop build preserves the previous packaged artifact", async () => {
+  const { root, log } = await callerFixture();
+  await mkdir(path.join(root, "assets"));
+  await mkdir(path.join(root, "dist-native"));
+  const final = path.join(root, "dist-native/consumer-test");
+  await writeFile(final, "previous working package");
+  const ktx2 = await encodeToKTX2(new Uint8Array([0]), {
+    generateMipmap: false,
+    imageDecoder: async () => ({ data: new Uint8Array(4 * 4 * 4).fill(255), height: 4, width: 4 }),
+    isUASTC: true,
+  });
+  await writeFile(path.join(root, "assets/rock.ktx2"), ktx2);
+  await assert.rejects(
+    build({ cwd: root, target: "desktop" }),
+    /TN_NATIVE_KTX2_UNSUPPORTED.*rock.ktx2.*selected-runtime.*unknown.*Basis\/KTX2/u,
+  );
+  assert.equal(await readFile(final, "utf8"), "previous working package");
+  await assert.rejects(readFile(log), { code: "ENOENT" });
+});
+
 test("Android source opt-in survives parsing and subprocess dispatch", async () => {
   const { root, log } = await callerFixture();
   const options = parseBuildArgs(["build", "--target", "android", "--allow-source-build"]);
diff --git a/packages/create-threenative/__tests__/native-ktx2.spec.ts b/packages/create-threenative/__tests__/native-ktx2.spec.ts
index 149720ce97..0909f554b1 100644
--- a/packages/create-threenative/__tests__/native-ktx2.spec.ts
+++ b/packages/create-threenative/__tests__/native-ktx2.spec.ts
@@ -7,12 +7,23 @@ import { encodeToKTX2 } from "ktx2-encoder";
 import { afterEach, describe, expect, it } from "vitest";
 import { buildFixtureGlb } from "../../../test-support/generate-fixture-model.js";
 import { makeTempDir } from "../../../test-support/temp-dir.js";
-import { assertNativeAssetsCompatible, assertNativeBundleCompatible, build } from "../src/build.js";
+import {
+  assertNativeAssetsCompatible,
+  assertNativeBundleCompatible,
+  build,
+  resolveRuntimeAssetCapabilities,
+} from "../src/build.js";
 import { loadConfig } from "../src/config.js";
 
 const run = promisify(execFile);
 const roots: string[] = [];
 const bundler = path.resolve("packages/runtime-native/scripts/bundle.mjs");
+const desktopV8 = () =>
+  resolveRuntimeAssetCapabilities(
+    "desktop",
+    path.resolve("packages/create-threenative/src/build.ts"),
+    (() => ({ status: 0, stdout: "+ v8 build" })) as never,
+  );
 const viteInstall = path.resolve(import.meta.dirname, "../node_modules/vite");
 
 afterEach(async () => {
@@ -43,7 +54,11 @@ export default defineGame({ scenes: {} });
   return project;
 }
 
-async function bundle(project: string, target: "android" | "desktop" | "ios"): Promise<string> {
+async function bundle(
+  project: string,
+  target: "android" | "desktop" | "ios",
+  nativeBackend = false,
+): Promise<string> {
   const output = path.join(project, `dist/${target}.js`);
   await run(
     process.execPath,
@@ -57,6 +72,7 @@ async function bundle(project: string, target: "android" | "desktop" | "ios"): P
       target,
       "--output",
       output,
+      ...(nativeBackend ? ["--native-backend"] : []),
     ],
     { cwd: project },
   );
@@ -111,12 +127,24 @@ describe("compressed assets on native targets", () => {
     }
   }, 180_000);
 
+  it("bundles decoder-free desktop QuickJS without WASM decoders", async () => {
+    const project = await gameProject("threenative-ktx2-quickjs-");
+    const output = await bundle(project, "desktop", true);
+    const source = await readFile(output, "utf8");
+    expect(source).not.toMatch(/\bWebAssembly\b/u);
+    expect(source).toContain("TN_NATIVE_KTX2_UNSUPPORTED");
+    expect(source).toContain("TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED");
+    await expect(assertNativeBundleCompatible(output, "desktop")).resolves.toBeUndefined();
+  }, 180_000);
+
   it("keeps three's real decoders on desktop, which has a WASM engine", async () => {
     const project = await gameProject("threenative-ktx2-desktop-");
 
     const output = await bundle(project, "desktop");
     const source = await readFile(output, "utf8");
-    await expect(assertNativeBundleCompatible(output, "desktop")).resolves.toBeUndefined();
+    await expect(
+      assertNativeBundleCompatible(output, "desktop", desktopV8()),
+    ).resolves.toBeUndefined();
     expect(source).toMatch(/\bWebAssembly\b/u);
     expect(source).not.toContain("TN_NATIVE_KTX2_UNSUPPORTED");
   }, 180_000);
@@ -219,7 +247,9 @@ export default defineGame({ scenes: {} });
     const config = await loadConfig(project);
 
     for (const target of ["desktop", "web"] as const) {
-      await expect(assertNativeAssetsCompatible(project, target, config)).resolves.toBeUndefined();
+      await expect(
+        assertNativeAssetsCompatible(project, target, config, desktopV8()),
+      ).resolves.toBeUndefined();
     }
   }, 60_000);
 
diff --git a/packages/create-threenative/__tests__/templates-native.spec.ts b/packages/create-threenative/__tests__/templates-native.spec.ts
index d2ceac1d7c..cc0133f14f 100644
--- a/packages/create-threenative/__tests__/templates-native.spec.ts
+++ b/packages/create-threenative/__tests__/templates-native.spec.ts
@@ -53,6 +53,21 @@ async function bundle(
 }
 
 /** A project with a stub runtime-native whose desktop packager is `packager`. */
+/** Package entry is both the selected-runtime resolver and a subprocess executable. */
+async function writePackager(runtime: string, target: string, source: string): Promise<void> {
+  await writeFile(path.join(runtime, `scripts/package-${target}-execute.mjs`), source);
+  await writeFile(
+    path.join(runtime, `scripts/package-${target}.mjs`),
+    `
+import { pathToFileURL } from "node:url";
+export async function resolveDesktopRuntime() { return import.meta.filename; }
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await import("./package-${target}-execute.mjs");
+}
+`,
+  );
+}
+
 async function stubRuntime(
   project: string,
   packager: string,
@@ -79,7 +94,7 @@ await mkdir(path.dirname(output), { recursive: true });
 await writeFile(output, "globalThis.__nativeProof = true;\\n");
 `,
   );
-  await writeFile(path.join(runtime, "scripts/package-desktop.mjs"), packager);
+  await writePackager(runtime, "desktop", packager);
 }
 
 /** The packager the staged-publish tests share: a complete run that writes its output. */
@@ -408,8 +423,9 @@ await writeFile(output, "globalThis.__nativeProof = true;\\n");
 `,
     );
     for (const target of ["desktop", "android", "ios"] as const) {
-      await writeFile(
-        path.join(runtime, `scripts/package-${target}.mjs`),
+      await writePackager(
+        runtime,
+        target,
         `import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 const output = process.argv[process.argv.indexOf("--output") + 1];
@@ -462,8 +478,9 @@ await writeFile(output, "export default { start() {} };\\n");
 `,
     );
     for (const target of ["desktop", "android", "ios"] as const) {
-      await writeFile(
-        path.join(runtime, `scripts/package-${target}.mjs`),
+      await writePackager(
+        runtime,
+        target,
         `import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 const output = process.argv[process.argv.indexOf("--output") + 1];
diff --git a/packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts b/packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts
new file mode 100644
index 0000000000..c5e971497f
--- /dev/null
+++ b/packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts
@@ -0,0 +1,151 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { compileAssets } from "@threenative/assets";
+import { afterEach, describe, expect, it } from "vitest";
+import { makeTempDir } from "../../../test-support/temp-dir.js";
+import {
+  assertNativeAssetsCompatible,
+  resolveRuntimeAssetCapabilities,
+  runtimeHasWebAssembly,
+} from "../src/build.js";
+
+const roots: string[] = [];
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { force: true, recursive: true })));
+});
+
+const runtime = path.resolve("packages/create-threenative/src/build.ts");
+
+describe("VQ-01 native asset capability contract", () => {
+  it.each([
+    { target: "web", engine: "v8", expected: "browser", wasm: true, decoder: true },
+    { target: "desktop", engine: "v8", expected: "v8", wasm: true, decoder: true },
+    { target: "desktop", engine: "quickjs", expected: "quickjs", wasm: false, decoder: false },
+    { target: "desktop", engine: "unknown", expected: "unknown", wasm: false, decoder: false },
+    { target: "android", engine: "v8", expected: "unknown", wasm: false, decoder: false },
+    { target: "android", engine: "quickjs", expected: "unknown", wasm: false, decoder: false },
+    { target: "ios", engine: "v8", expected: "unknown", wasm: false, decoder: false },
+  ] as const)(
+    "keeps $target separate from the build-host $engine engine",
+    ({ target, engine, expected, wasm, decoder }) => {
+      let probes = 0;
+      const capabilities = resolveRuntimeAssetCapabilities(target, runtime, (() => {
+        probes++;
+        return { status: 0, stdout: `Native WebGPU JS runtime - wgpu-native + ${engine} build` };
+      }) as never);
+      expect(capabilities.engine).toBe(expected);
+      expect(capabilities.webAssembly).toBe(wasm);
+      expect(capabilities.decoders).toEqual({ ktx2: decoder, meshopt: decoder, draco: decoder });
+      expect(probes).toBe(target === "desktop" ? 1 : 0);
+    },
+  );
+
+  it("changes the runtime identity when the selected bytes change at the same path", async () => {
+    const root = await makeTempDir("vq-runtime-identity-");
+    roots.push(root);
+    const binary = path.join(root, "runtime");
+    const probe = (() => ({ status: 0, stdout: "+ v8 build" })) as never;
+    await writeFile(binary, "cohort one");
+    const before = resolveRuntimeAssetCapabilities("desktop", binary, probe);
+    await writeFile(binary, "cohort two");
+    const after = resolveRuntimeAssetCapabilities("desktop", binary, probe);
+    expect(before.identity).not.toBe(after.identity);
+    expect(before.artifact).toBe(after.artifact);
+  });
+
+  it.each(["runtimeIdentity", "runtimeDecoders"] as const)(
+    "invalidates cooked output when %s changes even with identical passes",
+    async (field) => {
+      const root = await makeTempDir("vq-runtime-cache-");
+      roots.push(root);
+      await mkdir(path.join(root, "assets"));
+      await writeFile(path.join(root, "assets/unchanged.txt"), "same source bytes");
+      const options = {
+        cwd: root,
+        config: { audio: "none", models: "none", textures: "none" } as const,
+        runtimeDecoders: { ktx2: false, meshopt: false },
+        runtimeIdentity: "desktop:cohort-one:quickjs",
+      };
+      await compileAssets(options);
+      const before = JSON.parse(
+        await readFile(path.join(root, "public/assets.manifest.json"), "utf8"),
+      );
+      const changed =
+        field === "runtimeIdentity"
+          ? { ...options, runtimeIdentity: "desktop:cohort-two:quickjs" }
+          : { ...options, runtimeDecoders: { ktx2: true, meshopt: false } };
+      await compileAssets(changed);
+      const after = JSON.parse(
+        await readFile(path.join(root, "public/assets.manifest.json"), "utf8"),
+      );
+      expect(after.entries["unchanged.txt"].output).not.toBe(
+        before.entries["unchanged.txt"].output,
+      );
+      await expect(
+        readFile(path.join(root, "public", after.entries["unchanged.txt"].output), "utf8"),
+      ).resolves.toBe("same source bytes");
+    },
+  );
+
+  it.each([
+    { name: "missing artifact", binary: "/no/such/runtime", result: { status: 0, stdout: "" } },
+    { name: "failed probe", binary: runtime, result: { status: 1, stdout: "" } },
+    {
+      name: "unrecognized engine",
+      binary: runtime,
+      result: { status: 0, stdout: "+ future-engine build" },
+    },
+    {
+      name: "no engine declaration",
+      binary: runtime,
+      result: { status: 0, stdout: "v8 is installed on the host" },
+    },
+  ])("does not infer WASM from $name", ({ binary, result }) => {
+    expect(runtimeHasWebAssembly(binary, (() => result) as never)).toBe(false);
+  });
+
+  it.each([
+    { codec: "KTX2", entry: { output: "rock.ktx2" }, code: "TN_NATIVE_KTX2_UNSUPPORTED" },
+    {
+      codec: "Meshopt",
+      entry: { output: "rock.glb", extensions: ["EXT_meshopt_compression"] },
+      code: "TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED",
+    },
+    {
+      codec: "Draco",
+      entry: { output: "rock.glb", extensions: ["KHR_draco_mesh_compression"] },
+      code: "TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED",
+    },
+    {
+      codec: "embedded KTX2",
+      entry: { output: "rock.glb", extensions: ["KHR_texture_basisu"] },
+      code: "TN_NATIVE_KTX2_UNSUPPORTED",
+    },
+    {
+      codec: "shared KTX2",
+      entry: { output: "rock.glb", sharedImages: [{ output: "rock.ktx2", codec: "ktx2" }] },
+      code: "TN_NATIVE_KTX2_UNSUPPORTED",
+    },
+  ])(
+    "refuses $codec on an unknown desktop artifact, preserving the previous package",
+    async ({ entry, code }) => {
+      const root = await makeTempDir("vq-native-assets-");
+      roots.push(root);
+      await mkdir(path.join(root, "public"));
+      await mkdir(path.join(root, "dist-native"));
+      await writeFile(path.join(root, "dist-native/game"), "previous working artifact");
+      await writeFile(
+        path.join(root, "public/assets.manifest.json"),
+        JSON.stringify({ entries: { "rocks/rock": entry }, version: 1 }),
+      );
+      const config = { assets: { output: "public" } } as Parameters<
+        typeof assertNativeAssetsCompatible
+      >[2];
+      await expect(assertNativeAssetsCompatible(root, "desktop", config)).rejects.toThrow(code);
+      await expect(readFile(path.join(root, "dist-native/game"), "utf8")).resolves.toBe(
+        "previous working artifact",
+      );
+      await expect(assertNativeAssetsCompatible(root, "web", config)).resolves.toBeUndefined();
+    },
+  );
+});
diff --git a/packages/create-threenative/src/build.ts b/packages/create-threenative/src/build.ts
index 62497e8c9b..80087bba21 100644
--- a/packages/create-threenative/src/build.ts
+++ b/packages/create-threenative/src/build.ts
@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -70,6 +70,7 @@ async function projectName(cwd: string): Promise<string> {
 export async function assertNativeBundleCompatible(
   bundle: string,
   target: NativeBuildTarget,
+  capabilities = resolveRuntimeAssetCapabilities(target),
 ): Promise<void> {
   const source = await readFile(bundle, "utf8");
   const webOnlyUi = [
@@ -81,7 +82,7 @@ export async function assertNativeBundleCompatible(
       `TN_NATIVE_WEB_ONLY_UI: ${target} bundle contains ${webOnlyUi.map(([label]) => label).join(", ")}. Keep the portable game in src/game.ts and move DOM or React mounting to src/main.ts; native UI is owned by PRD-051.`,
     );
   }
-  if (target === "desktop") return;
+  if (target === "desktop" && capabilities.webAssembly) return;
   const wasm = [
     ["WebAssembly", /\bWebAssembly\b/u],
     ["Rapier WASM", /rapier_wasm|RAPIER_VERSION|rawrapier/u],
@@ -89,7 +90,7 @@ export async function assertNativeBundleCompatible(
   ].filter(([, pattern]) => (pattern as RegExp).test(source));
   if (wasm.length === 0) return;
   throw new Error(
-    `TN_NATIVE_WASM_ON_MOBILE: ${target} bundle contains ${wasm.map(([label]) => label).join(", ")}. Move web-only WASM imports out of src/game.ts or provide a threenative-native conditional backend; mobile navigation is owned by PRD-052.`,
+    `${target === "desktop" ? "TN_NATIVE_WASM_UNSUPPORTED" : "TN_NATIVE_WASM_ON_MOBILE"}: ${target} artifact ${capabilities.artifact} (${capabilities.engine}) bundle contains ${wasm.map(([label]) => label).join(", ")}. Move web-only WASM imports out of src/game.ts or provide a threenative-native conditional backend; mobile navigation is owned by PRD-052.`,
   );
 }
 
@@ -137,30 +138,22 @@ export function assetRoot(cwd: string, config: IResolvedThreeNativeConfig): stri
   return path.resolve(cwd, config.assets?.output ?? "public");
 }
 
-/**
- * Refuses compiled assets a mobile native target cannot decode, at the first point the build
- * knows about them — after the compile step, before a bundle or an APK exists.
- *
- * Android runs QuickJS and iOS runs JavaScriptCore without a WASM JIT, so neither has
- * `WebAssembly`. Three's Basis/zstd transcoder, its Meshopt decoder and Draco's wasm decoder
- * therefore cannot run there and are not in the mobile bundle at all (they are replaced in
- * `runtime-native/scripts/bundle.mjs`, which is what keeps `TN_NATIVE_WASM_ON_MOBILE` green).
- * A game that genuinely ships such an asset must hear that here rather than discover it as a
- * missing texture on a phone.
- */
+/** Refuse compiled codecs the selected runtime/bundle cannot decode before packaging starts. */
 export async function assertNativeAssetsCompatible(
   cwd: string,
   target: BuildTarget,
   config: IResolvedThreeNativeConfig,
+  capabilities = resolveRuntimeAssetCapabilities(target),
 ): Promise<void> {
-  if (target === "desktop" || target === "web") return;
+  if (target === "web") return;
   const outputRoot = assetRoot(cwd, config);
   const manifestPath = path.join(outputRoot, "assets.manifest.json");
   let raw: string;
   try {
     raw = await readFile(manifestPath, "utf8");
-  } catch {
-    return;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+    throw error;
   }
   let parsed: unknown;
   try {
@@ -170,32 +163,46 @@ export async function assertNativeAssetsCompatible(
       `TN_NATIVE_ASSET_MANIFEST_INVALID: '${manifestPath}' is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
     );
   }
-  const entries = (parsed as { entries?: unknown }).entries;
-  if (typeof entries !== "object" || entries === null) {
+  const entries = (parsed as { entries?: unknown } | null)?.entries;
+  if (typeof entries !== "object" || entries === null || Array.isArray(entries)) {
     throw new Error(`TN_NATIVE_ASSET_MANIFEST_INVALID: '${manifestPath}' has no 'entries' object.`);
   }
   const rows = Object.entries(entries as Record<string, unknown>).map(
     ([logical, entry]) => [logical, (entry ?? {}) as Record<string, unknown>] as const,
   );
   const ktx2 = rows
-    .filter(([, entry]) => typeof entry.output === "string" && /\.ktx2$/iu.test(entry.output))
+    .filter(
+      ([, entry]) =>
+        (typeof entry.output === "string" && /\.ktx2$/iu.test(entry.output)) ||
+        (Array.isArray(entry.extensions) && entry.extensions.includes("KHR_texture_basisu")) ||
+        (Array.isArray(entry.sharedImages) &&
+          entry.sharedImages.some(
+            (image) =>
+              image !== null &&
+              typeof image === "object" &&
+              typeof image.output === "string" &&
+              /\.ktx2$/iu.test(image.output),
+          )),
+    )
     .map(([logical]) => logical);
-  if (ktx2.length > 0) {
+  if (!capabilities.decoders.ktx2 && ktx2.length > 0) {
     throw new Error(
-      `TN_NATIVE_KTX2_UNSUPPORTED: ${target} cannot ship compiled KTX2 textures (${namedAssets(ktx2)}). The mobile native runtime has no WebAssembly and therefore no Basis transcoder, so nothing in the bundle can decode them. Replace or transcode the authored KTX2 source for mobile, or exclude it from mobile builds; keep compressed textures on the web target.`,
+      `TN_NATIVE_KTX2_UNSUPPORTED: ${target} cannot ship compiled KTX2 textures (${namedAssets(ktx2)}). Selected artifact ${capabilities.artifact} (${capabilities.engine}) has no admitted Basis/KTX2 decoder in its bundle. Replace or transcode the authored KTX2 source for ${target === "desktop" ? "this runtime" : "mobile"}, or exclude it from ${target === "desktop" ? "this runtime's" : "mobile"} builds; keep compressed textures on the web target.`,
     );
   }
   const compressedModels = rows
     .filter(([, entry]) =>
       (Array.isArray(entry.extensions) ? (entry.extensions as unknown[]) : []).some(
         (extension) =>
-          typeof extension === "string" && COMPRESSED_MODEL_EXTENSIONS.includes(extension),
+          typeof extension === "string" &&
+          COMPRESSED_MODEL_EXTENSIONS.includes(extension) &&
+          !capabilities.decoders[extension === "KHR_draco_mesh_compression" ? "draco" : "meshopt"],
       ),
     )
     .map(([logical]) => logical);
   if (compressedModels.length > 0) {
     throw new Error(
-      `TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED: ${target} cannot ship compressed model geometry (${namedAssets(compressedModels)}). The mobile native runtime has no WebAssembly and therefore no Meshopt or Draco decoder. Native compilation keeps shared images and decoder-free model rewrites while omitting Meshopt output; rebuild the native target, or keep compressed models on the web target.`,
+      `TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED: ${target} cannot ship compressed model geometry (${namedAssets(compressedModels)}). Selected artifact ${capabilities.artifact} (${capabilities.engine}) has no admitted ${rows.flatMap(([, entry]) => (Array.isArray(entry.extensions) ? entry.extensions.filter((extension) => COMPRESSED_MODEL_EXTENSIONS.includes(String(extension))) : [])).join(", ")} decoder in its bundle. Native compilation keeps shared images and decoder-free model rewrites while omitting Meshopt output; rebuild the native target, or keep compressed models on the web target.`,
     );
   }
 }
@@ -567,31 +574,56 @@ export async function writePackagingConfig(
   return output;
 }
 
-/**
- * Whether the runtime that will execute this build has WebAssembly.
- *
- * The engine decides it, not the target: V8 compiles WebAssembly, QuickJS and JavaScriptCore do
- * not. A desktop build is for either engine — Linux x64, Windows and macOS use V8, the Linux
- * arm64 lane builds QuickJS over wgpu-native — so the target alone cannot answer it. The runtime
- * binary the packager is handed (`THREENATIVE_RUNTIME_BINARY`, set by the same build invocation)
- * is probed for its engine; absent or unreadable, the answer is the historical desktop one, true,
- * because every published desktop prebuilt runs V8.
- */
+/** Read only the selected executable. An unrecognized or failed probe never proves WASM. */
+function runtimeEngine(
+  binary: string | undefined,
+  probe: typeof spawnSync,
+): "v8" | "quickjs" | "jsc" | "unknown" {
+  if (binary === undefined || !existsSync(binary)) return "unknown";
+  try {
+    const result = probe(binary, ["--version"], { encoding: "utf8", timeout: 10_000 });
+    if (result.status !== 0) return "unknown";
+    const engine = /\+ (\S+) build/u.exec(String(result.stdout ?? ""))?.[1]?.toLowerCase();
+    return engine === "v8" || engine === "quickjs" || engine === "jsc" ? engine : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
 export function runtimeHasWebAssembly(
   binary: string | undefined = process.env.THREENATIVE_RUNTIME_BINARY,
   probe: typeof spawnSync = spawnSync,
 ): boolean {
-  if (binary === undefined || !existsSync(binary)) return true;
-  let result: ReturnType<typeof spawnSync>;
-  try {
-    result = probe(binary, ["--version"], { encoding: "utf8" });
-  } catch {
-    return true;
+  return runtimeEngine(binary, probe) === "v8";
+}
+
+/**
+ * One conservative decision for cooking, validation and bundling. Only desktop's selected
+ * executable is runnable here: a desktop packaging tool is never evidence about Android/iOS.
+ * Mobile stays decoder-free until its selected artifact and packaged loaders are qualified.
+ * Desktop V8 retains its existing decoder path; WASM alone does not qualify new codec targets.
+ */
+export function resolveRuntimeAssetCapabilities(
+  target: BuildTarget,
+  binary?: string,
+  probe: typeof spawnSync = spawnSync,
+) {
+  const selected = target === "desktop" ? binary : undefined;
+  const engine = target === "web" ? "browser" : runtimeEngine(selected, probe);
+  const artifact = selected === undefined ? `${target}:unresolved` : path.resolve(selected);
+  let identity = artifact;
+  if (selected !== undefined && existsSync(selected)) {
+    identity = `${target}:sha256:${createHash("sha256").update(readFileSync(selected)).digest("hex")}`;
   }
-  if (result.status !== 0) return true;
-  const engine = /\+ (\S+) build/u.exec(String(result.stdout ?? ""))?.[1] ?? "";
-  // The engine names are CMake's MYSTRAL_JS_ENGINE_NAME: v8, jsc or quickjs. Only V8 runs WASM.
-  return !/^(?:quickjs|jsc)$/iu.test(engine);
+  const webAssembly = engine === "v8" || engine === "browser";
+  const bundled = target === "web" || (target === "desktop" && webAssembly);
+  return {
+    artifact,
+    identity,
+    engine,
+    webAssembly,
+    decoders: { ktx2: bundled, meshopt: bundled, draco: bundled },
+  };
 }
 
 async function bundleNative(
@@ -711,24 +743,38 @@ async function buildNative(
   const config = await loadConfig(cwd, { target, profile });
   announceProfile(config);
   assertNativeUiRendererCompatible(target, config.ui.renderer);
-  // A native host without WebAssembly cannot run Rapier as WASM or decode meshopt/KTX2, so it
-  // takes the native physics backend and a decoder-free bake. The capability is the runtime
-  // engine, not the target: android and iOS are always QuickJS/JSC, and a desktop host is V8
-  // except on the Linux arm64 lane. `assertNativeAssetsCompatible` stays below as the backstop.
-  const webAssembly = runtimeHasWebAssembly();
+  const entry = await nativeEntry(cwd, config);
+  // Resolve the same desktop binary the packager will receive, before cooking. A default
+  // prebuilt used to be selected only after the cook had guessed from the build machine.
+  let selectedRuntime: string | undefined;
+  if (target === "desktop") {
+    const module = path.join(
+      packageRoot(cwd, "@threenative/runtime-native"),
+      "scripts",
+      "package-desktop.mjs",
+    );
+    const { resolveDesktopRuntime } = (await import(pathToFileURL(module).href)) as {
+      resolveDesktopRuntime(explicit?: string): Promise<string>;
+    };
+    const explicit = process.env.THREENATIVE_RUNTIME_BINARY;
+    selectedRuntime = await resolveDesktopRuntime(
+      explicit === undefined ? undefined : path.resolve(cwd, explicit),
+    );
+  }
+  const capabilities = resolveRuntimeAssetCapabilities(target, selectedRuntime);
   await compileAssets({
     config: config.assets,
     cwd,
     platform: target,
-    ...(webAssembly ? {} : { runtimeDecoders: { ktx2: false, meshopt: false } }),
+    runtimeDecoders: capabilities.decoders,
+    runtimeIdentity: capabilities.identity,
   });
-  await assertNativeAssetsCompatible(cwd, target, config);
-  const entry = await nativeEntry(cwd, config);
+  await assertNativeAssetsCompatible(cwd, target, config, capabilities);
   const orientation = config.display.orientation;
   const configPath = await writePackagingConfig(cwd, config);
   const runtimeRoot = packageRoot(cwd, "@threenative/runtime-native");
-  const bundle = await bundleNative(cwd, runtimeRoot, entry, target, !webAssembly);
-  await assertNativeBundleCompatible(bundle, target);
+  const bundle = await bundleNative(cwd, runtimeRoot, entry, target, !capabilities.webAssembly);
+  await assertNativeBundleCompatible(bundle, target, capabilities);
   // The compiled root the project configured, which `compileAssets` above baked into — not the
   // `public` default. A project whose cook profile writes elsewhere was packaging an empty
   // directory while its own assets sat next to it, unread.
@@ -810,9 +856,7 @@ async function buildNative(
       ...(ui === undefined ? [] : ["--ui", ui]),
       "--config",
       configPath,
-      ...(process.env.THREENATIVE_RUNTIME_BINARY
-        ? ["--runtime", path.resolve(process.env.THREENATIVE_RUNTIME_BINARY)]
-        : []),
+      ...(selectedRuntime === undefined ? [] : ["--runtime", selectedRuntime]),
       "--output",
       output,
     ],
diff --git a/packages/runtime-native/AGENTS.md b/packages/runtime-native/AGENTS.md
index 8ad9a6a0cc..47bcb0e9f1 100644
--- a/packages/runtime-native/AGENTS.md
+++ b/packages/runtime-native/AGENTS.md
@@ -85,15 +85,17 @@ portable graph reached browser UI; `TN_NATIVE_WASM_ON_MOBILE` means Android or i
 WASM. Do not weaken these guards. Every packager stages the configured asset root (`assets.output`, default `public/`) through
 `selectManifestAssets` beside the game bundle, and a missing runtime asset must reject game startup rather than fall back to the network.
 
-**Mobile has no compressed-asset decoders.** Android QuickJS and iOS JSC have no WASM engine,
-so three's Basis/zstd transcoder (`KTX2Loader`), its Meshopt decoder and Draco's wasm decoder
-cannot run there. `scripts/bundle.mjs` replaces all three with refusing stubs on the mobile
-targets only — desktop keeps the real ones — which is what keeps a game that ships no
-compressed asset out of `TN_NATIVE_WASM_ON_MOBILE`; their specifiers are static strings inside
-`await import(...)`, so a bundler inlines them whether the game uses them or not. A game whose
-compiled assets do need one is refused by `threenative build` before any bundle exists, with
-`TN_NATIVE_KTX2_UNSUPPORTED` or `TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED`. Making mobile decode
-either format is a native decoder question, not a bundler one.
+**Mobile still has no qualified compressed-asset decoder path.** Android's V8 engine alone
+is not loader proof: Basis, Meshopt and Draco stay refusing stubs until their packaged paths are
+qualified. Android QuickJS and iOS JSC also have no WASM engine. The desktop build resolves and
+hashes its exact package runtime before cooking; QuickJS, JSC and unknown engine probes take the
+decoder-free compiler and bundle path. The existing desktop V8 decoder path stays unchanged.
+`scripts/bundle.mjs --native-backend` selects the refusing stubs on desktop too. A compiled asset
+that needs a missing decoder is refused before packaging with `TN_NATIVE_KTX2_UNSUPPORTED` or
+`TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED`, naming the asset and selected runtime. Authored KTX2,
+embedded Basis textures and shared KTX2 images are all checked. Native cook-cache keys include
+runtime identity and decoder capabilities. Full mobile artifact/cohort resolution and
+packaged-loader qualification remain open in PRD-VQ-01.
 
 ## Package boundaries
 
diff --git a/packages/runtime-native/CLAUDE.md b/packages/runtime-native/CLAUDE.md
index 46d251db21..aaa582fe0d 100644
--- a/packages/runtime-native/CLAUDE.md
+++ b/packages/runtime-native/CLAUDE.md
@@ -87,15 +87,17 @@ portable graph reached browser UI; `TN_NATIVE_WASM_ON_MOBILE` means Android or i
 WASM. Do not weaken these guards. Every packager stages the configured asset root (`assets.output`, default `public/`) through
 `selectManifestAssets` beside the game bundle, and a missing runtime asset must reject game startup rather than fall back to the network.
 
-**Mobile has no compressed-asset decoders.** Android QuickJS and iOS JSC have no WASM engine,
-so three's Basis/zstd transcoder (`KTX2Loader`), its Meshopt decoder and Draco's wasm decoder
-cannot run there. `scripts/bundle.mjs` replaces all three with refusing stubs on the mobile
-targets only — desktop keeps the real ones — which is what keeps a game that ships no
-compressed asset out of `TN_NATIVE_WASM_ON_MOBILE`; their specifiers are static strings inside
-`await import(...)`, so a bundler inlines them whether the game uses them or not. A game whose
-compiled assets do need one is refused by `threenative build` before any bundle exists, with
-`TN_NATIVE_KTX2_UNSUPPORTED` or `TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED`. Making mobile decode
-either format is a native decoder question, not a bundler one.
+**Mobile still has no qualified compressed-asset decoder path.** Android's V8 engine alone
+is not loader proof: Basis, Meshopt and Draco stay refusing stubs until their packaged paths are
+qualified. Android QuickJS and iOS JSC also have no WASM engine. The desktop build resolves and
+hashes its exact package runtime before cooking; QuickJS, JSC and unknown engine probes take the
+decoder-free compiler and bundle path. The existing desktop V8 decoder path stays unchanged.
+`scripts/bundle.mjs --native-backend` selects the refusing stubs on desktop too. A compiled asset
+that needs a missing decoder is refused before packaging with `TN_NATIVE_KTX2_UNSUPPORTED` or
+`TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED`, naming the asset and selected runtime. Authored KTX2,
+embedded Basis textures and shared KTX2 images are all checked. Native cook-cache keys include
+runtime identity and decoder capabilities. Full mobile artifact/cohort resolution and
+packaged-loader qualification remain open in PRD-VQ-01.
 
 ## Package boundaries
 
diff --git a/packages/runtime-native/scripts/bundle.mjs b/packages/runtime-native/scripts/bundle.mjs
index f09b305029..243338cfbf 100644
--- a/packages/runtime-native/scripts/bundle.mjs
+++ b/packages/runtime-native/scripts/bundle.mjs
@@ -148,28 +148,15 @@ function generateVFSHeader(files, outputPath) {
 }
 
 /**
- * Three's compressed-asset decoders that cannot run on a mobile native target.
- *
- * Android runs QuickJS and iOS runs JavaScriptCore without a WASM JIT: neither has
- * `WebAssembly`, so the Basis/zstd transcoder behind `KTX2Loader`, the Meshopt decoder and
- * Draco's wasm decoder have nothing to instantiate there. Their specifiers are static strings
- * inside `await import(...)`, so a bundler resolves and inlines them whether or not the game
- * ships a single compressed asset — which is how one `.ktx2`-free game came to fail
- * `TN_NATIVE_WASM_ON_MOBILE`. Replacing them here keeps that guard intact by keeping WASM out
- * of the bundle instead of by ignoring it.
- *
- * The replacements construct and configure exactly like the originals so a game that ships no
- * compressed asset boots normally (`createAssetLoader` builds the shared KTX2 loader eagerly);
- * they refuse, by name, only when asked to decode. A game whose compiled assets do need one is
- * refused earlier and louder, by `threenative build`, before this bundle is written.
+ * Decoder-free targets retain loader configuration/lifecycle but refuse actual decoding.
+ * Android V8 still lacks a qualified packaged decoder path; its engine is not the reason to
+ * enable one. Desktop QuickJS and an unknown desktop artifact use the same refusing stubs.
  */
 const MOBILE_KTX2_MESSAGE =
-  // Deliberately never spells the WASM host object: `TN_NATIVE_WASM_ON_MOBILE` greps the
-  // finished bundle for that identifier, and a refusal message must not read as the thing it
-  // refuses.
-  "TN_NATIVE_KTX2_UNSUPPORTED: this Android/iOS bundle carries no Basis transcoder, because the mobile native runtime has no WASM engine. Compiled .ktx2 textures cannot be decoded here; native compilation automatically keeps decoder-free authored textures, or keep compressed textures on the web target.";
+  // Never spell the WASM host global: the bundle guard must not mistake diagnostics for code.
+  "TN_NATIVE_KTX2_UNSUPPORTED: this decoder-free native bundle carries no qualified Basis transcoder. Compiled .ktx2 textures cannot be decoded here; native compilation keeps decoder-free authored textures, or keep compressed textures on the web target.";
 const MOBILE_MESH_MESSAGE =
-  "TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED: this Android/iOS bundle carries no Meshopt or Draco decoder, because the mobile native runtime has no WASM engine. Compressed model geometry cannot be decoded here; native compilation keeps shared images and decoder-free model geometry, or keep compressed models on the web target.";
+  "TN_NATIVE_MESH_COMPRESSION_UNSUPPORTED: this decoder-free native bundle carries no qualified Meshopt or Draco decoder. Compressed model geometry cannot be decoded here; native compilation keeps shared images and decoder-free model geometry, or keep compressed models on the web target.";
 
 const MOBILE_DECODER_STUBS = [
   {
@@ -340,7 +327,7 @@ void game.start().catch((error) => console.error(
     root: absoluteProject,
     define: { 'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV) },
     plugins:
-      target === 'desktop'
+      target === 'desktop' && !nativeBackend
         ? [importMetaPlugin, nativeEntryPlugin]
         : [importMetaPlugin, mobileDecodersPlugin, nativeEntryPlugin],
     // One three, whatever the import graph looks like. The game resolves `three` beside itself

From 8d6cd881ac54b206d82e0ba00167b0e277edb402 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Paulo=20Furtado?=
 <30300459+jonit-dev@users.noreply.github.com>
Date: Fri, 2 Oct 2026 03:26:12 -0700
Subject: [PATCH 02/36] test(vq01): qualify packaged QuickJS assets with native
 screenshot lane

Exercise real selected runtime, decoder-free normalization, bundled bytes, native mailbox screenshots and named adapter provenance. Prepared capture lane; no unrun native PASS claimed.
---
 .../workflows/integration-native-assets.yml   |  86 +++++++++
 .../PRD-VQ-01-native-asset-capabilities.md    |  15 +-
 ...vq-native-asset-capabilities.playtest.json |  19 ++
 examples/abyss-framework/vq-assets/.gitignore |   3 +
 .../abyss-framework/vq-assets/generate.ts     | 175 ++++++++++++++++++
 .../abyss-framework/vq-assets/package.json    |   5 +
 .../abyss-framework/vq-assets/src/game.ts     | 111 +++++++++++
 .../vq-assets/src/render/stage.ts             |  34 ++++
 .../vq-assets/threenative.config.ts           |  25 +++
 .../abyss-framework/vq-assets/tsconfig.json   |   5 +
 .../__tests__/vq-native-fixture.spec.ts       | 100 ++++++++++
 .../native-asset-capture-proof.spec.ts        |  86 +++++++++
 scripts/native-asset-capture-proof.ts         |  75 ++++++++
 scripts/verify-native-asset-capabilities.ts   | 162 ++++++++++++++++
 14 files changed, 899 insertions(+), 2 deletions(-)
 create mode 100644 .github/workflows/integration-native-assets.yml
 create mode 100644 examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
 create mode 100644 examples/abyss-framework/vq-assets/.gitignore
 create mode 100644 examples/abyss-framework/vq-assets/generate.ts
 create mode 100644 examples/abyss-framework/vq-assets/package.json
 create mode 100644 examples/abyss-framework/vq-assets/src/game.ts
 create mode 100644 examples/abyss-framework/vq-assets/src/render/stage.ts
 create mode 100644 examples/abyss-framework/vq-assets/threenative.config.ts
 create mode 100644 examples/abyss-framework/vq-assets/tsconfig.json
 create mode 100644 packages/create-threenative/__tests__/vq-native-fixture.spec.ts
 create mode 100644 scripts/__tests__/native-asset-capture-proof.spec.ts
 create mode 100644 scripts/native-asset-capture-proof.ts
 create mode 100644 scripts/verify-native-asset-capabilities.ts

diff --git a/.github/workflows/integration-native-assets.yml b/.github/workflows/integration-native-assets.yml
new file mode 100644
index 0000000000..35c669385c
--- /dev/null
+++ b/.github/workflows/integration-native-assets.yml
@@ -0,0 +1,86 @@
+name: Integration native asset fallback
+on:
+  pull_request:
+    paths:
+      - 'packages/create-threenative/src/build.ts'
+      - 'packages/create-threenative/src/buildReport.ts'
+      - 'packages/create-threenative/__tests__/vq-native-*.spec.ts'
+      - 'packages/assets/src/**'
+      - 'packages/core/src/assets.ts'
+      - 'packages/runtime-native/scripts/bundle.mjs'
+      - 'packages/runtime-native/scripts/package-desktop.mjs'
+      - 'packages/runtime-native/scripts/native-build.mjs'
+      - 'packages/runtime-native/scripts/download-deps.mjs'
+      - 'examples/abyss-framework/vq-assets/**'
+      - 'examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json'
+      - 'scripts/verify-native-asset-capabilities.ts'
+      - 'scripts/native-asset-capture-proof.ts'
+      - 'scripts/__tests__/native-asset-capture-proof.spec.ts'
+      - '.github/workflows/integration-native-assets.yml'
+permissions:
+  contents: read
+concurrency:
+  group: integration-native-assets-${{ github.event.pull_request.head.ref || github.ref_name }}
+  cancel-in-progress: true
+jobs:
+  packaged-quickjs:
+    # Match native-platforms starter-linux: this architecture selects QuickJS/wgpu without
+    # changing any runtime default. Native dependencies use the repository's locked provisioner.
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 60
+    env:
+      CMAKE_BUILD_PARALLEL_LEVEL: '2'
+      TN_PLAYTEST_ALLOW_SOFTWARE: '1'
+      TN_PLAYTEST_NATIVE_SCREENSHOT_TIMEOUT_MS: '30000'
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
+        with:
+          persist-credentials: false
+          ref: ${{ github.event.pull_request.head.sha }}
+      - uses: ./.github/actions/pnpm
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
+        with:
+          node-version: '22'
+          cache: pnpm
+      - uses: actions/setup-python@v7
+        with:
+          python-version: '3.12'
+      - run: pnpm install --frozen-lockfile
+      - name: Build this commit's JavaScript packages
+        uses: ./.github/actions/workspace-dist
+        with:
+          save-bundles: 'false'
+          pack-archives: 'false'
+      - name: Validate real compressed-source normalization and capture guards
+        run: >-
+          pnpm exec vitest run --maxWorkers=1
+          packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts
+          packages/create-threenative/__tests__/vq-native-fixture.spec.ts
+          scripts/__tests__/native-asset-capture-proof.spec.ts
+      - name: Restore checksum-provisioned native dependencies
+        uses: actions/cache/restore@v4
+        with:
+          path: packages/runtime-native/third_party
+          key: native-third-party-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('packages/runtime-native/scripts/download-deps.mjs', 'packages/runtime-native/scripts/package-android.mjs') }}
+      - name: Install the existing native lane's system prerequisites
+        run: >-
+          sudo apt-get update && sudo apt-get install -y
+          libasound2-dev libcurl4-openssl-dev libfontconfig1-dev libfreetype6-dev
+          libpulse-dev libudev-dev libx11-dev libxext-dev libxrandr-dev
+          libxcursor-dev libxi-dev libxfixes-dev libxss-dev libxkbcommon-dev
+          libgtk-3-dev libwebkit2gtk-4.1-dev libxcomposite-dev xcompmgr
+          libvulkan1 mesa-vulkan-drivers vulkan-tools xvfb zlib1g-dev
+      - name: Build the same QuickJS host the normal ARM desktop lane ships
+        run: pnpm --filter @threenative/runtime-native native:build
+      - name: Build the real fixture and capture its packaged native executable
+        env:
+          THREENATIVE_RUNTIME_BINARY: ${{ github.workspace }}/packages/runtime-native/build/tn-linux/mystral
+        run: node --import tsx scripts/verify-native-asset-capabilities.ts
+      - name: Retain raw native captures, artifact identities and decoded payload measurements
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: vq01-native-assets-${{ github.event.pull_request.head.sha }}
+          path: artifacts/vq01-native-assets/
+          retention-days: 30
+          if-no-files-found: warn
diff --git a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
index ae09f60309..0b4fc52dae 100644
--- a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
@@ -29,7 +29,7 @@ Reuse `runtimeHasWebAssembly`, `assertNativeAssetsCompatible`, asset compiler de
 
 ## Execution phases
 
-The unit proof paths now exist; the Phase 3 scenario paths remain **planned implementation targets**, not passing runtime proof. Reuse an existing equivalent test or scenario after inspecting current code, and update the canonical proof path rather than adding a duplicate. Follow [EXECUTE.md](https://github.com/ThreeNativeHQ/threenative/blob/d9ac5b4e97f6b1383bd163d91619cffa7c6c0ef5/docs/PRDs/batch-2026-10-01-visual-quality/EXECUTE.md) for fixture setup, variables, review and repository gates.
+The unit proof paths and the desktop fallback scenario now exist. Browser and Android execution remain unrun; the existence of the shared scenario is not passing runtime proof. Reuse an existing equivalent test or scenario after inspecting current code, and update the canonical proof path rather than adding a duplicate. Follow [EXECUTE.md](https://github.com/ThreeNativeHQ/threenative/blob/d9ac5b4e97f6b1383bd163d91619cffa7c6c0ef5/docs/PRDs/batch-2026-10-01-visual-quality/EXECUTE.md) for fixture setup, variables, review and repository gates.
 
 ### Phase 1 — One capability decision
 
@@ -43,7 +43,8 @@ The unit proof paths now exist; the Phase 3 scenario paths remain **planned impl
 
 - [ ] Make bundling and loading retain exactly the declared decoders and invalidate stale cook-cache entries. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
   Partial: cook keys include explicit decoder capabilities and selected desktop runtime SHA-256; QuickJS/unknown desktop bundles use the existing refusing stubs. Decoder versions, KTX2 block-format validation and manifest-versus-payload verification remain open.
-- [ ] Create separate tiny textured/animated fixtures for KTX2, Meshopt and Draco; assert decoded texture content and geometry rather than only a successful import. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+- [ ] Create separate tiny textured/animated fixtures for KTX2, Meshopt and Draco; assert decoded texture content and geometry rather than only a successful import. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts packages/create-threenative/__tests__/vq-native-fixture.spec.ts`.
+  Partial: generated Meshopt and Draco textured/animated inputs are compared against decoder-free cooked files for exact decoded positions, triangle counts, animation samples and texture pixels. Authored KTX2 is encoded by the existing texture pass and explicitly refused; no packaged KTX2 decode is claimed.
 
 ### Phase 3 — Qualify the visible result
 
@@ -77,3 +78,13 @@ Update the phase boxes and this PRD only after the named proof runs. Record actu
 - `pnpm --filter @threenative/assets build` and `pnpm --filter create-threenative build`: passed including declaration output and publint. Scoped create-threenative and assets TypeScript checks passed. Root lint passed with warnings; agent mirrors regenerated.
 - Aggregate qualification is **not green**: root `pnpm test` stops before tests at tsx IPC `listen EPERM`; root `pnpm typecheck` was killed with exit 137. The broader native consumer lane has two unavailable-`jar` failures, separately reproduced using its unchanged baseline test source. Full build, GPU/native scenarios, decoder memory/lifecycle measurements and actual packaged-loader codec pixels remain unverified.
 - All phase and acceptance boxes intentionally remain open. No full Phase 1, Phase 2, native decoder admission, visual result or PRD completion is claimed by this patch.
+
+
+### Native screenshot qualification lane — 2026-10-02 (prepared, unrun)
+
+- `examples/abyss-framework/vq-assets/` is a separate opt-in fixture; the ordinary example is unchanged. It loads two actual cooked GLBs and a PNG through `ctx.assets`, then advances their authored clips with `AnimationPlayer`. The checker colours belong to those assets, not to a drawn diagnostic overlay.
+- `node --import tsx scripts/verify-native-asset-capabilities.ts` requires a real QuickJS executable in `THREENATIVE_RUNTIME_BINARY`, builds through the actual desktop resolver/cook/bundle/packager, verifies decoded payload equality, the exact runtime prefix in the packaged executable and the published build-report digest, then proves an authored KTX2 refusal preserves that same package. `runDesktopPlaytest` drives the resulting executable and captures its framebuffer with the existing mailbox transport.
+- `.github/workflows/integration-native-assets.yml` uses the existing Linux ARM64 QuickJS/wgpu source-build lane, checksum-locked native provisioner and normal read-only `pull_request` permissions. Hosted software rasterization is explicitly declared; no hardware-performance claim is permitted. No credentials, guard exemptions or runtime defaults change.
+- Local checks: 25/25 focused capability/real-fixture/capture-validator tests passed; fixture and focused verifier TypeScript checks passed; assets and CLI packages rebuilt with declarations/publint. The actual QuickJS fixture bundle was built and contains no `WebAssembly` reference. The scenario validates and workflow YAML parses; CI structure/needs checks pass 141/141. The local native verifier refuses at the explicit missing-runtime requirement before any runtime claim.
+- Capture acceptance is fail-closed: native `device.screenshot` provenance, nonempty passed live assertions, named WebGPU adapter, no lost-device/errors, exact 960×640 framebuffer, and both authored checker colours in opaque pixels in each of the three specimen regions. The transparent-RGB negative test failed before the alpha guard and passes with it. A lifecycle test confirms the fixture's owned sRGB texture clone and cached original are each disposed once, including a repeated exit. Published PNGs must be original runner bytes with matching SHA-256 and source/run provenance.
+- No new screenshot or hosted-run PASS is claimed in this commit. Full mobile/cohort, packaged-decoder and lifecycle acceptance stays open.
diff --git a/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json b/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
new file mode 100644
index 0000000000..894a6a2ae5
--- /dev/null
+++ b/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 1,
+  "name": "vq01-packaged-quickjs-assets",
+  "target": "desktop",
+  "viewport": { "width": 960, "height": 640 },
+  "warmupFrames": 30,
+  "steps": [{ "waitFrames": 90 }],
+  "artifacts": { "screenshots": true, "console": true },
+  "assert": {
+    "diagnostics": { "noConsoleErrors": true, "noRuntimeDiagnostics": true, "runtimeReady": true },
+    "resources": [
+      { "id": "state", "path": "loadedModels", "equals": 2, "allowTrivial": "Both real normalized GLBs must finish loading before enter and the first observation." },
+      { "id": "state", "path": "texturedMeshes", "equals": 2, "allowTrivial": "A texture image on each loaded GLB is counted before the first observation." },
+      { "id": "state", "path": "vertices", "gte": 100, "allowTrivial": "Decoded GLB geometry is measured at scene entry." },
+      { "id": "state", "path": "frames", "changed": true },
+      { "id": "state", "path": "maxPoseDelta", "gte": 0.05, "allowTrivial": "The native warm-up can already advance both authored animation tracks." }
+    ]
+  }
+}
diff --git a/examples/abyss-framework/vq-assets/.gitignore b/examples/abyss-framework/vq-assets/.gitignore
new file mode 100644
index 0000000000..e47b3a7dd4
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/.gitignore
@@ -0,0 +1,3 @@
+.generated/
+.threenative/
+dist-native/
diff --git a/examples/abyss-framework/vq-assets/generate.ts b/examples/abyss-framework/vq-assets/generate.ts
new file mode 100644
index 0000000000..ebc29790c9
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/generate.ts
@@ -0,0 +1,175 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { Document, NodeIO } from "@gltf-transform/core";
+import {
+  ALL_EXTENSIONS,
+  EXTMeshoptCompression,
+  KHRDracoMeshCompression,
+  KHRMaterialsUnlit,
+} from "@gltf-transform/extensions";
+import { texturePass } from "@threenative/assets";
+import { MeshoptDecoder, MeshoptEncoder } from "meshoptimizer";
+import { PNG } from "pngjs";
+import { BoxGeometry, type BufferGeometry, TorusGeometry } from "three";
+
+const draco = createRequire(import.meta.url)("draco3dgltf") as {
+  createEncoderModule(): Promise<unknown>;
+  createDecoderModule(): Promise<unknown>;
+};
+export const MODEL_NAMES = ["meshopt", "draco"] as const;
+
+function checker(a: readonly number[], b: readonly number[]): Buffer {
+  const png = new PNG({ width: 32, height: 32 });
+  for (let y = 0; y < 32; y++)
+    for (let x = 0; x < 32; x++) {
+      const rgb = ((x >> 3) + (y >> 3)) % 2 === 0 ? a : b;
+      png.data.set([rgb[0] ?? 0, rgb[1] ?? 0, rgb[2] ?? 0, 255], (y * 32 + x) * 4);
+    }
+  return PNG.sync.write(png);
+}
+
+function specimen(name: string, geometry: BufferGeometry, image: Buffer): Document {
+  const document = new Document();
+  const buffer = document.createBuffer();
+  const material = document
+    .createMaterial(name)
+    .setBaseColorTexture(document.createTexture(name).setMimeType("image/png").setImage(image));
+  material.setExtension(
+    "KHR_materials_unlit",
+    document.createExtension(KHRMaterialsUnlit).createUnlit(),
+  );
+  const primitive = document.createPrimitive().setMaterial(material);
+  for (const [attribute, semantic, type] of [
+    ["position", "POSITION", "VEC3"],
+    ["normal", "NORMAL", "VEC3"],
+    ["uv", "TEXCOORD_0", "VEC2"],
+  ] as const) {
+    primitive.setAttribute(
+      semantic,
+      document
+        .createAccessor()
+        .setType(type)
+        .setArray(Float32Array.from(geometry.getAttribute(attribute).array))
+        .setBuffer(buffer),
+    );
+  }
+  if (!geometry.index) throw new Error("Fixture requires indexed geometry");
+  primitive.setIndices(
+    document
+      .createAccessor()
+      .setType("SCALAR")
+      .setArray(Uint16Array.from(geometry.index.array))
+      .setBuffer(buffer),
+  );
+  geometry.dispose();
+  const node = document
+    .createNode(`${name}-animated`)
+    .setMesh(document.createMesh(name).addPrimitive(primitive));
+  document.createScene().addChild(node);
+  const sampler = document
+    .createAnimationSampler()
+    .setInterpolation("LINEAR")
+    .setInput(
+      document
+        .createAccessor()
+        .setType("SCALAR")
+        .setArray(new Float32Array([0, 1, 2]))
+        .setBuffer(buffer),
+    )
+    .setOutput(
+      document
+        .createAccessor()
+        .setType("VEC4")
+        .setArray(new Float32Array([0, 0, 0, 1, 0, Math.sin(0.6), 0, Math.cos(0.6), 0, 0, 0, 1]))
+        .setBuffer(buffer),
+    );
+  document
+    .createAnimation("turn")
+    .addSampler(sampler)
+    .addChannel(
+      document
+        .createAnimationChannel()
+        .setTargetNode(node)
+        .setTargetPath("rotation")
+        .setSampler(sampler),
+    );
+  return document;
+}
+
+export async function fixtureReader(): Promise<NodeIO> {
+  await MeshoptDecoder.ready;
+  return new NodeIO().registerExtensions(ALL_EXTENSIONS).registerDependencies({
+    "meshopt.decoder": MeshoptDecoder,
+    "draco3d.decoder": await draco.createDecoderModule(),
+  });
+}
+
+/** Real compressed inputs from the installed encoders; all source art is authored here. */
+export async function generateNativeAssetFixture(source: string): Promise<Buffer> {
+  await mkdir(source, { recursive: true });
+  await MeshoptEncoder.ready;
+  for (const name of MODEL_NAMES) {
+    const document = specimen(
+      name,
+      name === "meshopt"
+        ? new BoxGeometry(1.4, 1.4, 1.4, 2, 2, 2)
+        : new TorusGeometry(0.7, 0.27, 12, 32),
+      name === "meshopt"
+        ? checker([20, 210, 225], [240, 85, 35])
+        : checker([235, 45, 170], [245, 205, 35]),
+    );
+    if (name === "meshopt")
+      document
+        .createExtension(EXTMeshoptCompression)
+        .setRequired(true)
+        .setEncoderOptions({ method: EXTMeshoptCompression.EncoderMethod.QUANTIZE });
+    else document.createExtension(KHRDracoMeshCompression).setRequired(true);
+    const io = new NodeIO().registerExtensions(ALL_EXTENSIONS).registerDependencies({
+      "meshopt.encoder": MeshoptEncoder,
+      "draco3d.encoder": await draco.createEncoderModule(),
+    });
+    await writeFile(path.join(source, `${name}.glb`), await io.writeBinary(document));
+  }
+  const png = checker([95, 210, 60], [85, 100, 235]);
+  await writeFile(path.join(source, "checker.png"), png);
+  const result = await texturePass({ overrides: [{ glob: "*.png", codec: "uastc" }] }).apply(
+    png,
+    "checker.png",
+  );
+  if (Buffer.isBuffer(result) || result.outputExtension !== ".ktx2")
+    throw new Error("Fixture encoder did not produce KTX2");
+  return result.buffer;
+}
+
+/** Decoded payload measurements, not download sizes or claimed GPU savings. */
+export async function inspectFixtureModel(file: string) {
+  const bytes = await readFile(file);
+  const document = await (await fixtureReader()).read(file);
+  const root = document.getRoot();
+  return {
+    encodedBytes: bytes.length,
+    extensions: root.listExtensionsUsed().map((extension) => extension.extensionName),
+    triangles: root
+      .listMeshes()
+      .flatMap((mesh) => mesh.listPrimitives())
+      .reduce((sum, primitive) => sum + (primitive.getIndices()?.getCount() ?? 0) / 3, 0),
+    positions: root
+      .listMeshes()
+      .flatMap((mesh) => mesh.listPrimitives())
+      .flatMap((primitive) => Array.from(primitive.getAttribute("POSITION")?.getArray() ?? [])),
+    decodedGeometryBytes: root
+      .listAccessors()
+      .reduce((sum, accessor) => sum + (accessor.getArray()?.byteLength ?? 0), 0),
+    images: root
+      .listTextures()
+      .map((texture) => PNG.sync.read(Buffer.from(texture.getImage() ?? []))),
+    animation: root
+      .listAnimations()
+      .flatMap((animation) => animation.listSamplers())
+      .map((sampler) => ({
+        input: Array.from(sampler.getInput()?.getArray() ?? []),
+        output: Array.from(sampler.getOutput()?.getArray() ?? []),
+      })),
+  };
+}
diff --git a/examples/abyss-framework/vq-assets/package.json b/examples/abyss-framework/vq-assets/package.json
new file mode 100644
index 0000000000..2c89f456a4
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "vq-native-assets",
+  "private": true,
+  "type": "module"
+}
diff --git a/examples/abyss-framework/vq-assets/src/game.ts b/examples/abyss-framework/vq-assets/src/game.ts
new file mode 100644
index 0000000000..dc698c9434
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/src/game.ts
@@ -0,0 +1,111 @@
+import { AnimationPlayer, type ICtx, Scene, defineGame } from "@threenative/core";
+import { playtest } from "@threenative/core/playtest";
+import {
+  type AnimationClip,
+  type Group,
+  Mesh,
+  type MeshStandardMaterial,
+  type PerspectiveCamera,
+  Quaternion,
+  type Texture,
+} from "three";
+import config from "../threenative.config.js";
+import { stage } from "./render/stage.js";
+
+type State = {
+  loadedModels: number;
+  texturedMeshes: number;
+  vertices: number;
+  frames: number;
+  maxPoseDelta: number;
+};
+type Model = { scene: Group; animations: AnimationClip[] };
+const names = ["meshopt", "draco"] as const;
+
+export class AssetScene extends Scene<State> {
+  static override readonly initialState: State = {
+    loadedModels: 0,
+    texturedMeshes: 0,
+    vertices: 0,
+    frames: 0,
+    maxPoseDelta: 0,
+  };
+  #models: Model[] = [];
+  #png: Texture | undefined;
+  #players: AnimationPlayer[] = [];
+  #owned: Mesh[] = [];
+
+  override async load(ctx: ICtx<State>): Promise<void> {
+    this.#models = await Promise.all(names.map((name) => ctx.assets.model<Model>(`${name}.glb`)));
+    // Options return an owned sRGB clone; the cached source remains loader-owned.
+    this.#png = await ctx.assets.texture("checker.png", {});
+  }
+
+  override enter(ctx: ICtx<State>) {
+    if (!this.#png) throw new Error("PNG did not load");
+    this.#owned = stage(ctx.scene, ctx.camera as PerspectiveCamera, this.#png);
+    let texturedMeshes = 0;
+    let vertices = 0;
+    const rotations: Quaternion[] = [];
+    const animated = this.#models.map((model, index) => {
+      model.scene.position.set(index === 0 ? -2.4 : 0, 1.35, 0);
+      ctx.add(model.scene);
+      model.scene.traverse((node) => {
+        if (!(node instanceof Mesh)) return;
+        vertices += node.geometry.getAttribute("position").count;
+        const materials = Array.isArray(node.material) ? node.material : [node.material];
+        if (materials.some((material) => (material as MeshStandardMaterial).map?.image))
+          texturedMeshes++;
+      });
+      const player = new AnimationPlayer({
+        root: model.scene,
+        clips: model.animations,
+        requiredClips: ["turn"],
+        strideSync: false,
+      });
+      player.play("turn");
+      this.#players.push(player);
+      const node = model.scene.getObjectByName(`${names[index]}-animated`);
+      if (!node) throw new Error(`Missing animated node: ${names[index]}`);
+      rotations.push(node.quaternion.clone());
+      return node;
+    });
+    ctx.state.set({ loadedModels: this.#models.length, texturedMeshes, vertices });
+    let frames = 0;
+    let maxPoseDelta = 0;
+    return (_ctx: ICtx<State>, dt: number) => {
+      for (const player of this.#players) player.update(dt);
+      for (const [index, node] of animated.entries())
+        maxPoseDelta = Math.max(
+          maxPoseDelta,
+          node.quaternion.angleTo(rotations[index] ?? new Quaternion()),
+        );
+      ctx.state.set({ frames: ++frames, maxPoseDelta });
+    };
+  }
+
+  override exit(ctx: ICtx<State>): void {
+    for (const player of this.#players) player.dispose();
+    this.#players.length = 0;
+    for (const mesh of this.#owned) {
+      mesh.removeFromParent();
+      mesh.geometry.dispose();
+      for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material])
+        material.dispose();
+    }
+    this.#owned.length = 0;
+    this.#png?.dispose();
+    this.#png = undefined;
+    this.#models.length = 0;
+    for (const name of names) ctx.assets.release("model", `${name}.glb`);
+    ctx.assets.release("texture", "checker.png");
+  }
+}
+
+export default defineGame<State>({
+  scenes: { assets: AssetScene },
+  start: "assets",
+  plugins: [playtest()],
+  display: config.display,
+  render: config.renderer,
+});
diff --git a/examples/abyss-framework/vq-assets/src/render/stage.ts b/examples/abyss-framework/vq-assets/src/render/stage.ts
new file mode 100644
index 0000000000..d6a15c5d5b
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/src/render/stage.ts
@@ -0,0 +1,34 @@
+import {
+  Color,
+  CylinderGeometry,
+  Mesh,
+  MeshBasicMaterial,
+  type PerspectiveCamera,
+  PlaneGeometry,
+  type Scene,
+  type Texture,
+} from "three";
+
+export function stage(scene: Scene, camera: PerspectiveCamera, png: Texture): Mesh[] {
+  scene.background = new Color(0x101827);
+  camera.position.set(0, 3.2, 8.8);
+  camera.lookAt(0, 1.1, 0);
+  camera.fov = 42;
+  camera.updateProjectionMatrix();
+  const objects: Mesh[] = [];
+  for (const x of [-2.4, 0, 2.4]) {
+    const plinth = new Mesh(
+      new CylinderGeometry(1.03, 1.1, 0.25, 48),
+      new MeshBasicMaterial({ color: 0x263951 }),
+    );
+    plinth.position.set(x, 0.15, 0);
+    scene.add(plinth);
+    objects.push(plinth);
+  }
+  const panel = new Mesh(new PlaneGeometry(1.6, 1.6), new MeshBasicMaterial({ map: png }));
+  panel.position.set(2.4, 1.35, 0);
+  panel.rotation.y = -0.15;
+  scene.add(panel);
+  objects.push(panel);
+  return objects;
+}
diff --git a/examples/abyss-framework/vq-assets/threenative.config.ts b/examples/abyss-framework/vq-assets/threenative.config.ts
new file mode 100644
index 0000000000..d9e2ad236a
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/threenative.config.ts
@@ -0,0 +1,25 @@
+import type { IThreeNativeConfig } from "@threenative/core";
+
+export default {
+  app: { id: "com.threenative.vq01", name: "VQ-01 native assets", version: "1.0.0", build: 1 },
+  assets: {
+    source: ".generated/assets",
+    output: ".generated/public",
+    audio: "none",
+    budget: "none",
+    lod: false,
+    // Ask for compression. The actual selected QuickJS runtime must remove it, not the fixture.
+    textures: { overrides: [{ glob: "*.png", codec: "uastc" }] },
+    models: {
+      compact: false,
+      passes: { dedup: false, meshopt: true, prune: false, quantize: false, reorder: false },
+      textures: "none",
+      virtual: "none",
+    },
+  },
+  nativeEntry: "src/game.ts",
+  display: { fullscreen: false, maxFps: 60 },
+  window: { width: 960, height: 640, title: "VQ-01 native asset fallback", resizable: false },
+  renderer: { preferWebGPU: true, resolutionScale: 1 },
+  ui: { renderer: "native" },
+} satisfies IThreeNativeConfig;
diff --git a/examples/abyss-framework/vq-assets/tsconfig.json b/examples/abyss-framework/vq-assets/tsconfig.json
new file mode 100644
index 0000000000..5b32896060
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/tsconfig.json
@@ -0,0 +1,5 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": { "types": ["node"], "rootDir": "." },
+  "include": ["src/**/*.ts", "threenative.config.ts", "generate.ts"]
+}
diff --git a/packages/create-threenative/__tests__/vq-native-fixture.spec.ts b/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
new file mode 100644
index 0000000000..c1852a86d3
--- /dev/null
+++ b/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
@@ -0,0 +1,100 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { compileAssets } from "@threenative/assets";
+import { createAssetLoader } from "@threenative/core";
+import { Group, Texture } from "three";
+import { afterEach, expect, test, vi } from "vitest";
+import {
+  MODEL_NAMES,
+  generateNativeAssetFixture,
+  inspectFixtureModel,
+} from "../../../examples/abyss-framework/vq-assets/generate.js";
+import { AssetScene } from "../../../examples/abyss-framework/vq-assets/src/game.js";
+import config from "../../../examples/abyss-framework/vq-assets/threenative.config.js";
+import { assertNativeAssetsCompatible } from "../src/build.js";
+import { loadConfig } from "../src/config.js";
+
+const roots: string[] = [];
+afterEach(async () =>
+  Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }))),
+);
+
+test("real Meshopt and Draco inputs retain decoded geometry, images and animation through the decoder-free cook", async () => {
+  const cwd = await mkdtemp(path.join(os.tmpdir(), "vq01-fixture-"));
+  roots.push(cwd);
+  const source = path.join(cwd, config.assets.source);
+  const ktx2 = await generateNativeAssetFixture(source);
+  await writeFile(path.join(cwd, "package.json"), '{"name":"vq-fixture","type":"module"}');
+  await writeFile(
+    path.join(cwd, "threenative.config.ts"),
+    `export default ${JSON.stringify(config)};`,
+  );
+  const before = await Promise.all(
+    MODEL_NAMES.map((name) => inspectFixtureModel(path.join(source, `${name}.glb`))),
+  );
+  expect(before[0]?.extensions).toContain("EXT_meshopt_compression");
+  expect(before[1]?.extensions).toContain("KHR_draco_mesh_compression");
+  await compileAssets({
+    cwd,
+    config: config.assets,
+    platform: "desktop",
+    runtimeDecoders: { ktx2: false, meshopt: false },
+    runtimeIdentity: "test:quickjs",
+  });
+  const output = path.join(cwd, config.assets.output);
+  const manifest = JSON.parse(await readFile(path.join(output, "assets.manifest.json"), "utf8"));
+  for (const [index, name] of MODEL_NAMES.entries()) {
+    const original = before[index];
+    if (!original) throw new Error("Missing source measurement");
+    const cooked = await inspectFixtureModel(
+      path.join(output, manifest.entries[`${name}.glb`].output),
+    );
+    expect(cooked.extensions).not.toContain("EXT_meshopt_compression");
+    expect(cooked.extensions).not.toContain("KHR_draco_mesh_compression");
+    expect(cooked.triangles).toBe(original.triangles);
+    expect(cooked.positions).toEqual(original.positions);
+    expect(cooked.animation).toEqual(original.animation);
+    expect(cooked.images.map((image) => image.data)).toEqual(
+      original.images.map((image) => image.data),
+    );
+  }
+  expect(manifest.entries["checker.png"].output).toMatch(/\.png$/u);
+  await expect(
+    assertNativeAssetsCompatible(cwd, "desktop", await loadConfig(cwd)),
+  ).resolves.toBeUndefined();
+  await writeFile(path.join(source, "authored.ktx2"), ktx2);
+  await compileAssets({
+    cwd,
+    config: config.assets,
+    platform: "desktop",
+    runtimeDecoders: { ktx2: false, meshopt: false },
+    runtimeIdentity: "test:quickjs",
+  });
+  await expect(assertNativeAssetsCompatible(cwd, "desktop", await loadConfig(cwd))).rejects.toThrow(
+    /TN_NATIVE_KTX2_UNSUPPORTED.*authored.ktx2/u,
+  );
+});
+
+test("fixture exit disposes its configured PNG clone and cached original exactly once", async () => {
+  const original = new Texture();
+  const assets = createAssetLoader({
+    model: async () => ({ scene: new Group(), animations: [] }),
+    texture: async () => original,
+  });
+  const scene = new AssetScene();
+  const ctx = { assets } as Parameters<AssetScene["load"]>[0];
+  const dispose = vi.spyOn(Texture.prototype, "dispose");
+  try {
+    await scene.load(ctx);
+    scene.exit(ctx);
+    expect(dispose).toHaveBeenCalledTimes(2);
+    expect(new Set(dispose.mock.contexts).size).toBe(2);
+    expect(dispose.mock.contexts).toContain(original);
+    scene.exit(ctx);
+    expect(dispose).toHaveBeenCalledTimes(2);
+  } finally {
+    dispose.mockRestore();
+    assets.clear();
+  }
+});
diff --git a/scripts/__tests__/native-asset-capture-proof.spec.ts b/scripts/__tests__/native-asset-capture-proof.spec.ts
new file mode 100644
index 0000000000..e03635aa37
--- /dev/null
+++ b/scripts/__tests__/native-asset-capture-proof.spec.ts
@@ -0,0 +1,86 @@
+import { PNG } from "pngjs";
+import { expect, test } from "vitest";
+import {
+  assertNativeAssetCapture,
+  inspectNativeAssetScreenshot,
+} from "../native-asset-capture-proof.js";
+
+// Synthetic pixels are unit inputs only. Published evidence must come from the native runner.
+function image(missingRegion = -1, transparent = false): Buffer {
+  const png = new PNG({ width: 960, height: 640 });
+  const colours = [
+    [
+      [20, 210, 225],
+      [240, 85, 35],
+    ],
+    [
+      [235, 45, 170],
+      [245, 205, 35],
+    ],
+    [
+      [95, 210, 60],
+      [85, 100, 235],
+    ],
+  ];
+  for (let y = 180; y < 440; y++)
+    for (let x = 0; x < 960; x++) {
+      const region = Math.floor(x / 320);
+      if (region === missingRegion) continue;
+      const rgb = colours[region]?.[x % 32 < 16 ? 0 : 1] ?? [0, 0, 0];
+      png.data.set(
+        [rgb[0] ?? 0, rgb[1] ?? 0, rgb[2] ?? 0, transparent ? 0 : 255],
+        (y * 960 + x) * 4,
+      );
+    }
+  return PNG.sync.write(png);
+}
+
+function report(): Parameters<typeof assertNativeAssetCapture>[0] {
+  return {
+    pass: true,
+    runtime: "native",
+    target: "desktop",
+    assertionResults: [{ pass: true, id: "resources.0" }],
+    diagnostics: [],
+    capture: {
+      target: "desktop",
+      rendererKind: "webgpu",
+      adapter: { description: "llvmpipe" },
+      browserArgs: [],
+      captureMethod: "device.screenshot",
+      viewport: { width: 960, height: 640 },
+    },
+  };
+}
+
+test("requires both rendered colours for all three asset routes", () => {
+  expect(inspectNativeAssetScreenshot(image()).counts).toHaveLength(3);
+  for (const region of [0, 1, 2])
+    expect(() => inspectNativeAssetScreenshot(image(region))).toThrow(`Specimen ${region}`);
+});
+test("rejects an empty or wrong-sized capture", () => {
+  expect(() => inspectNativeAssetScreenshot(Buffer.from([]))).toThrow();
+  expect(() =>
+    inspectNativeAssetScreenshot(PNG.sync.write(new PNG({ width: 32, height: 32 }))),
+  ).toThrow();
+});
+test("requires native provenance and nonempty live assertions", () => {
+  expect(() => assertNativeAssetCapture(report())).not.toThrow();
+  for (const mutation of [
+    { assertionResults: [] },
+    { pass: false },
+    { capture: undefined },
+    { capture: { target: "web", rendererKind: "webgpu", adapter: { description: "GPU" } } },
+    { capture: { target: "desktop", rendererKind: "webgpu", adapter: { description: "" } } },
+    { diagnostics: [{ severity: "warning", code: "TN_PLAYTEST_SOFTWARE_DEVICE_LOST" }] },
+  ])
+    expect(() =>
+      assertNativeAssetCapture({ ...report(), ...mutation } as Parameters<
+        typeof assertNativeAssetCapture
+      >[0]),
+    ).toThrow();
+});
+
+test("invisible RGB cannot satisfy the native screenshot proof", () => {
+  expect(() => inspectNativeAssetScreenshot(image(-1, true))).toThrow("Specimen 0");
+});
diff --git a/scripts/native-asset-capture-proof.ts b/scripts/native-asset-capture-proof.ts
new file mode 100644
index 0000000000..249fa461b5
--- /dev/null
+++ b/scripts/native-asset-capture-proof.ts
@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { PNG } from "pngjs";
+import type { IStandalonePlaytestReport } from "../packages/playtest/src/runner/runner.js";
+
+/** Rendered checker colours in each specimen's own third of the frame, not a global nonblank test. */
+export function inspectNativeAssetScreenshot(bytes: Buffer) {
+  const png = PNG.sync.read(bytes);
+  assert.equal(png.width, 960, "Native fixture capture width");
+  assert.equal(png.height, 640, "Native fixture capture height");
+  const counts = [
+    [0, 0],
+    [0, 0],
+    [0, 0],
+  ];
+  for (let y = 100; y < 535; y++)
+    for (let x = 0; x < png.width; x++) {
+      const offset = (y * png.width + x) * 4;
+      if ((png.data[offset + 3] ?? 0) < 250) continue;
+      const r = png.data[offset] ?? 0;
+      const g = png.data[offset + 1] ?? 0;
+      const b = png.data[offset + 2] ?? 0;
+      const region = Math.floor(x / 320);
+      const first =
+        region === 0
+          ? g > 100 && b > 100 && r < g * 0.7
+          : region === 1
+            ? r > 100 && b > 80 && g < r * 0.65
+            : g > 100 && g > r * 1.25 && g > b * 1.25;
+      const second =
+        region === 0
+          ? r > 130 && r > g * 1.3 && b < r * 0.65
+          : region === 1
+            ? r > 120 && g > 100 && b < g * 0.65
+            : b > 110 && b > r * 1.25 && b > g * 1.25;
+      const row = counts[region];
+      if (row && first) row[0] = (row[0] ?? 0) + 1;
+      if (row && second) row[1] = (row[1] ?? 0) + 1;
+    }
+  for (const [region, row] of counts.entries())
+    for (const [colour, pixels] of row.entries()) {
+      assert.ok(
+        pixels >= 200,
+        `Specimen ${region} checker colour ${colour}: only ${pixels} pixels`,
+      );
+    }
+  return { width: png.width, height: png.height, counts };
+}
+
+/** No successful screenshot proof can carry a lost device, empty assertions or unnamed adapter. */
+export function assertNativeAssetCapture(
+  report: Pick<
+    IStandalonePlaytestReport,
+    "pass" | "assertionResults" | "capture" | "diagnostics" | "runtime" | "target"
+  >,
+): void {
+  assert.equal(report.runtime, "native");
+  assert.equal(report.target, "desktop");
+  assert.equal(report.capture?.captureMethod, "device.screenshot");
+  assert.equal(report.pass, true, JSON.stringify(report.diagnostics));
+  assert.ok(report.assertionResults?.length, "Native proof must evaluate assertions");
+  assert.ok(
+    report.assertionResults.every((result) => result.pass),
+    "Native assertions failed",
+  );
+  assert.equal(report.capture?.target, "desktop", "Native proof cannot be a browser capture");
+  assert.equal(report.capture.rendererKind, "webgpu");
+  assert.ok(
+    report.capture.adapter && Object.values(report.capture.adapter).some((value) => value.trim()),
+    "Native adapter identity missing",
+  );
+  for (const diagnostic of report.diagnostics) {
+    assert.notEqual(diagnostic.severity, "error", diagnostic.code);
+    assert.doesNotMatch(diagnostic.code, /DEVICE_LOST|BRIDGE_MISSING/u);
+  }
+}
diff --git a/scripts/verify-native-asset-capabilities.ts b/scripts/verify-native-asset-capabilities.ts
new file mode 100644
index 0000000000..d8e5a216dd
--- /dev/null
+++ b/scripts/verify-native-asset-capabilities.ts
@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  MODEL_NAMES,
+  generateNativeAssetFixture,
+  inspectFixtureModel,
+} from "../examples/abyss-framework/vq-assets/generate.js";
+import config from "../examples/abyss-framework/vq-assets/threenative.config.js";
+import {
+  build,
+  resolveRuntimeAssetCapabilities,
+} from "../packages/create-threenative/src/build.js";
+import { hashArtifact } from "../packages/create-threenative/src/buildReport.js";
+import { runDesktopPlaytest } from "../packages/playtest/dist/runner/index.js";
+import {
+  assertNativeAssetCapture,
+  inspectNativeAssetScreenshot,
+} from "./native-asset-capture-proof.js";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const project = path.join(root, "examples/abyss-framework/vq-assets");
+const output = path.join(root, "artifacts/vq01-native-assets");
+const sourceSha = execFileSync("git", ["rev-parse", "HEAD"], {
+  cwd: root,
+  encoding: "utf8",
+}).trim();
+const write = async (name: string, value: unknown) =>
+  writeFile(path.join(output, name), `${JSON.stringify(value, null, 2)}\n`);
+const sha256 = (bytes: Buffer) => createHash("sha256").update(bytes).digest("hex");
+await rm(output, { recursive: true, force: true });
+await mkdir(output, { recursive: true });
+await write("attempt.json", { sourceSha, runId: process.env.GITHUB_RUN_ID, status: "started" });
+try {
+  const runtime = process.env.THREENATIVE_RUNTIME_BINARY;
+  assert.ok(runtime, "THREENATIVE_RUNTIME_BINARY must name this run's actual native build");
+  const capabilities = resolveRuntimeAssetCapabilities("desktop", runtime);
+  assert.equal(
+    capabilities.engine,
+    "quickjs",
+    "This proof must execute the actual QuickJS fallback",
+  );
+  assert.deepEqual(capabilities.decoders, { ktx2: false, meshopt: false, draco: false });
+  await write("runtime.json", capabilities);
+  await rm(path.join(project, ".generated"), { recursive: true, force: true });
+  const source = path.join(project, config.assets.source);
+  const ktx2 = await generateNativeAssetFixture(source);
+  await build({ cwd: project, target: "desktop" });
+  const cookedRoot = path.join(project, config.assets.output);
+  const manifest = JSON.parse(
+    await readFile(path.join(cookedRoot, "assets.manifest.json"), "utf8"),
+  );
+  const models = [];
+  for (const [index, name] of MODEL_NAMES.entries()) {
+    const authoredPath = path.join(source, `${name}.glb`);
+    const cookedPath = path.join(cookedRoot, manifest.entries[`${name}.glb`].output);
+    const authored = await inspectFixtureModel(authoredPath);
+    const cooked = await inspectFixtureModel(cookedPath);
+    assert.ok(
+      authored.extensions.includes(
+        index === 0 ? "EXT_meshopt_compression" : "KHR_draco_mesh_compression",
+      ),
+    );
+    assert.ok(!cooked.extensions.some((extension) => /meshopt|draco|basisu/u.test(extension)));
+    assert.deepEqual(cooked.positions, authored.positions, `${name}: decoded vertex values`);
+    assert.equal(cooked.triangles, authored.triangles);
+    assert.deepEqual(cooked.animation, authored.animation);
+    assert.deepEqual(
+      cooked.images.map((image) => image.data),
+      authored.images.map((image) => image.data),
+    );
+    models.push({
+      name,
+      sourceSha256: sha256(await readFile(authoredPath)),
+      cookedSha256: sha256(await readFile(cookedPath)),
+      sourceEncodedBytes: authored.encodedBytes,
+      cookedEncodedBytes: cooked.encodedBytes,
+      decodedGeometryBytes: cooked.decodedGeometryBytes,
+      decodedImageBytes: cooked.images.reduce((sum, image) => sum + image.data.length, 0),
+      triangles: cooked.triangles,
+    });
+  }
+  assert.match(manifest.entries["checker.png"].output, /\.png$/u);
+  assert.doesNotMatch(
+    await readFile(path.join(project, ".threenative/build/game.js"), "utf8"),
+    /\bWebAssembly\b/u,
+  );
+  await write("cook.json", {
+    models,
+    manifest,
+    measurement:
+      "Encoded bytes and decoded CPU buffer bytes are separate; no GPU memory reduction claimed.",
+  });
+  const executable = path.join(project, "dist-native/vq-native-assets");
+  const runtimeBytes = await readFile(runtime);
+  const packagedBytes = await readFile(executable);
+  assert.equal(
+    sha256(packagedBytes.subarray(0, runtimeBytes.length)),
+    sha256(runtimeBytes),
+    "Packaged executable must carry the exact selected runtime bytes before its appended game",
+  );
+  const packaged = await hashArtifact(executable);
+  const buildReport = JSON.parse(await readFile(`${executable}.build-report.json`, "utf8"));
+  assert.equal(
+    buildReport.artifact.sha256,
+    packaged.sha256,
+    "Build report must describe the actual executable",
+  );
+  await writeFile(path.join(source, "authored.ktx2"), ktx2);
+  await assert.rejects(
+    build({ cwd: project, target: "desktop" }),
+    /TN_NATIVE_KTX2_UNSUPPORTED.*authored.ktx2/u,
+  );
+  assert.deepEqual(
+    await hashArtifact(executable),
+    packaged,
+    "Codec refusal must preserve the previous package",
+  );
+  const report = await runDesktopPlaytest({
+    target: "desktop",
+    desktop: { executable, hostArgs: ["--windowed"] },
+    projectPath: project,
+    scenarioPath: "../playtests/vq-native-asset-capabilities.playtest.json",
+    artifactDirectory: output,
+    allowSoftwareAdapter: true,
+    headless: false,
+    timeoutMs: 120_000,
+    trace: false,
+    url: "",
+  });
+  await write("report.json", report);
+  assertNativeAssetCapture(report);
+  const bytes = await readFile(path.join(output, "after.png"));
+  const pixels = inspectNativeAssetScreenshot(bytes);
+  assert.deepEqual(await hashArtifact(executable), packaged);
+  await write("summary.json", {
+    pass: true,
+    sourceSha,
+    runId: process.env.GITHUB_RUN_ID,
+    qualification:
+      "Packaged Linux QuickJS fallback correctness on a named hosted software adapter. No Android, iOS, native compressed-codec admission or hardware-performance claim.",
+    runtime: capabilities,
+    packaged,
+    models,
+    capture: report.capture,
+    pixels,
+    screenshotSha256: sha256(bytes),
+    refusedCodec: "authored KTX2",
+    previousPackagePreserved: true,
+  });
+} catch (error) {
+  await write("failure.json", {
+    pass: false,
+    sourceSha,
+    error: String(error),
+    stack: error instanceof Error ? error.stack : undefined,
+  });
+  throw error;
+}

From cedacefcab3360d5cc344ef071649f57782ac9b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Paulo=20Furtado?=
 <30300459+jonit-dev@users.noreply.github.com>
Date: Fri, 2 Oct 2026 03:38:50 -0700
Subject: [PATCH 03/36] test(vq01): use supported native console diagnostics
 for capture

The actual QuickJS bridge does not expose runtime.diagnostics. Keep native readiness and console errors, require complete real host logs, and fail closed on GPU/device-loss/JavaScript/loader failures even when classified as log. Engine guards unchanged.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  5 +-
 ...vq-native-asset-capabilities.playtest.json | 57 ++++++++++++++++---
 .../native-asset-capture-proof.spec.ts        | 55 ++++++++++++++++--
 scripts/native-asset-capture-proof.ts         | 22 ++++++-
 scripts/verify-native-asset-capabilities.ts   |  8 ++-
 5 files changed, 131 insertions(+), 16 deletions(-)

diff --git a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
index 0b4fc52dae..3260dc24a5 100644
--- a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
@@ -80,7 +80,7 @@ Update the phase boxes and this PRD only after the named proof runs. Record actu
 - All phase and acceptance boxes intentionally remain open. No full Phase 1, Phase 2, native decoder admission, visual result or PRD completion is claimed by this patch.
 
 
-### Native screenshot qualification lane — 2026-10-02 (prepared, unrun)
+### Native screenshot qualification lane — 2026-10-02 (qualification in progress)
 
 - `examples/abyss-framework/vq-assets/` is a separate opt-in fixture; the ordinary example is unchanged. It loads two actual cooked GLBs and a PNG through `ctx.assets`, then advances their authored clips with `AnimationPlayer`. The checker colours belong to those assets, not to a drawn diagnostic overlay.
 - `node --import tsx scripts/verify-native-asset-capabilities.ts` requires a real QuickJS executable in `THREENATIVE_RUNTIME_BINARY`, builds through the actual desktop resolver/cook/bundle/packager, verifies decoded payload equality, the exact runtime prefix in the packaged executable and the published build-report digest, then proves an authored KTX2 refusal preserves that same package. `runDesktopPlaytest` drives the resulting executable and captures its framebuffer with the existing mailbox transport.
@@ -88,3 +88,6 @@ Update the phase boxes and this PRD only after the named proof runs. Record actu
 - Local checks: 25/25 focused capability/real-fixture/capture-validator tests passed; fixture and focused verifier TypeScript checks passed; assets and CLI packages rebuilt with declarations/publint. The actual QuickJS fixture bundle was built and contains no `WebAssembly` reference. The scenario validates and workflow YAML parses; CI structure/needs checks pass 141/141. The local native verifier refuses at the explicit missing-runtime requirement before any runtime claim.
 - Capture acceptance is fail-closed: native `device.screenshot` provenance, nonempty passed live assertions, named WebGPU adapter, no lost-device/errors, exact 960×640 framebuffer, and both authored checker colours in opaque pixels in each of the three specimen regions. The transparent-RGB negative test failed before the alpha guard and passes with it. A lifecycle test confirms the fixture's owned sRGB texture clone and cached original are each disposed once, including a repeated exit. Published PNGs must be original runner bytes with matching SHA-256 and source/run provenance.
 - No new screenshot or hosted-run PASS is claimed in this commit. Full mobile/cohort, packaged-decoder and lifecycle acceptance stays open.
+
+
+Hosted attempt [36995485869](https://github.com/ThreeNativeHQ/threenative/actions/runs/36995485869), source `8d6cd881ac54b206d82e0ba00167b0e277edb402`, built the actual ARM64 QuickJS/wgpu runtime and packaged the fixture. Exact selected-runtime prefix, decoded payload comparisons and authored-KTX2 refusal/package-preservation checks passed. The native bridge answered ready, but correctly refused the scenario's unavailable `runtime.diagnostics` observer before capturing any frame; no screenshot exists from this attempt. The native-only scenario now records that limitation and instead keeps readiness/no-console-error assertions plus mandatory complete host-console checks for native GPU validation, device loss, JavaScript and loader errors. Five regression cases failed before this observer-contract repair; error-labelled and misleadingly log-labelled failures remain fatal. Runtime engine guards are unchanged.
diff --git a/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json b/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
index 894a6a2ae5..9d2f97c60e 100644
--- a/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
+++ b/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
@@ -2,18 +2,57 @@
   "schemaVersion": 1,
   "name": "vq01-packaged-quickjs-assets",
   "target": "desktop",
-  "viewport": { "width": 960, "height": 640 },
+  "viewport": {
+    "width": 960,
+    "height": 640
+  },
   "warmupFrames": 30,
-  "steps": [{ "waitFrames": 90 }],
-  "artifacts": { "screenshots": true, "console": true },
+  "steps": [
+    {
+      "waitFrames": 90
+    }
+  ],
+  "artifacts": {
+    "screenshots": true,
+    "console": true
+  },
   "assert": {
-    "diagnostics": { "noConsoleErrors": true, "noRuntimeDiagnostics": true, "runtimeReady": true },
+    "diagnostics": {
+      "noConsoleErrors": true,
+      "noRuntimeDiagnostics": false,
+      "runtimeReady": true,
+      "runtimeDiagnosticsOptOutReason": "The native bridge does not expose runtime.diagnostics. This native-only fixture instead requires no console errors, live readiness, and verifier checks of every native console line for device loss, GPU validation, JavaScript and loader failures."
+    },
     "resources": [
-      { "id": "state", "path": "loadedModels", "equals": 2, "allowTrivial": "Both real normalized GLBs must finish loading before enter and the first observation." },
-      { "id": "state", "path": "texturedMeshes", "equals": 2, "allowTrivial": "A texture image on each loaded GLB is counted before the first observation." },
-      { "id": "state", "path": "vertices", "gte": 100, "allowTrivial": "Decoded GLB geometry is measured at scene entry." },
-      { "id": "state", "path": "frames", "changed": true },
-      { "id": "state", "path": "maxPoseDelta", "gte": 0.05, "allowTrivial": "The native warm-up can already advance both authored animation tracks." }
+      {
+        "id": "state",
+        "path": "loadedModels",
+        "equals": 2,
+        "allowTrivial": "Both real normalized GLBs must finish loading before enter and the first observation."
+      },
+      {
+        "id": "state",
+        "path": "texturedMeshes",
+        "equals": 2,
+        "allowTrivial": "A texture image on each loaded GLB is counted before the first observation."
+      },
+      {
+        "id": "state",
+        "path": "vertices",
+        "gte": 100,
+        "allowTrivial": "Decoded GLB geometry is measured at scene entry."
+      },
+      {
+        "id": "state",
+        "path": "frames",
+        "changed": true
+      },
+      {
+        "id": "state",
+        "path": "maxPoseDelta",
+        "gte": 0.05,
+        "allowTrivial": "The native warm-up can already advance both authored animation tracks."
+      }
     ]
   }
 }
diff --git a/scripts/__tests__/native-asset-capture-proof.spec.ts b/scripts/__tests__/native-asset-capture-proof.spec.ts
index e03635aa37..c80b80faa4 100644
--- a/scripts/__tests__/native-asset-capture-proof.spec.ts
+++ b/scripts/__tests__/native-asset-capture-proof.spec.ts
@@ -1,10 +1,15 @@
+import { readFileSync } from "node:fs";
 import { PNG } from "pngjs";
 import { expect, test } from "vitest";
+import { requiredPlaytestCapabilities } from "../../packages/playtest/src/assertion-schema.js";
+import { validatePlaytestScenario } from "../../packages/playtest/src/scenario.js";
 import {
   assertNativeAssetCapture,
   inspectNativeAssetScreenshot,
 } from "../native-asset-capture-proof.js";
 
+const cleanConsole = [{ type: "log", text: "TN_NATIVE_SMOKE_FIRST_FRAME" }];
+
 // Synthetic pixels are unit inputs only. Published evidence must come from the native runner.
 function image(missingRegion = -1, transparent = false): Buffer {
   const png = new PNG({ width: 960, height: 640 });
@@ -65,7 +70,7 @@ test("rejects an empty or wrong-sized capture", () => {
   ).toThrow();
 });
 test("requires native provenance and nonempty live assertions", () => {
-  expect(() => assertNativeAssetCapture(report())).not.toThrow();
+  expect(() => assertNativeAssetCapture(report(), cleanConsole)).not.toThrow();
   for (const mutation of [
     { assertionResults: [] },
     { pass: false },
@@ -75,12 +80,54 @@ test("requires native provenance and nonempty live assertions", () => {
     { diagnostics: [{ severity: "warning", code: "TN_PLAYTEST_SOFTWARE_DEVICE_LOST" }] },
   ])
     expect(() =>
-      assertNativeAssetCapture({ ...report(), ...mutation } as Parameters<
-        typeof assertNativeAssetCapture
-      >[0]),
+      assertNativeAssetCapture(
+        { ...report(), ...mutation } as Parameters<typeof assertNativeAssetCapture>[0],
+        cleanConsole,
+      ),
     ).toThrow();
 });
 
 test("invisible RGB cannot satisfy the native screenshot proof", () => {
   expect(() => inspectNativeAssetScreenshot(image(-1, true))).toThrow("Specimen 0");
 });
+
+test.each([
+  "[WebGPU] Device error (Validation): invalid texture format",
+  "[FATAL] The GPU device was lost: driver reset",
+  "TN_ASSETS_UNRESOLVED: authored model failed to load",
+  "TypeError: native renderer failed",
+])("native console failures remain fatal even when classified as log: %s", (text) => {
+  expect(() =>
+    assertNativeAssetCapture(report(), [...cleanConsole, { type: "log", text }]),
+  ).toThrow(text);
+});
+
+test("native scenario retains supported diagnostics without requesting an unavailable observer", () => {
+  const scenario = validatePlaytestScenario(
+    JSON.parse(
+      readFileSync(
+        "examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json",
+        "utf8",
+      ),
+    ),
+    "vq01",
+  );
+  expect(requiredPlaytestCapabilities(scenario, "desktop")).not.toContain("runtime.diagnostics");
+  expect(scenario.assert?.diagnostics?.noConsoleErrors).toBe(true);
+  expect(scenario.assert?.diagnostics?.runtimeReady).toBe(true);
+});
+
+test("native console evidence cannot be omitted or empty", () => {
+  for (const console of [undefined, [], [{ type: "log", text: "no frame marker" }]]) {
+    expect(() => assertNativeAssetCapture(report(), console)).toThrow();
+  }
+});
+
+test("unclassified error-labelled native lines remain fatal", () => {
+  expect(() =>
+    assertNativeAssetCapture(report(), [
+      ...cleanConsole,
+      { type: "error", text: "Unexpected host failure" },
+    ]),
+  ).toThrow("Unexpected host failure");
+});
diff --git a/scripts/native-asset-capture-proof.ts b/scripts/native-asset-capture-proof.ts
index 249fa461b5..451132b978 100644
--- a/scripts/native-asset-capture-proof.ts
+++ b/scripts/native-asset-capture-proof.ts
@@ -52,11 +52,12 @@ export function assertNativeAssetCapture(
     IStandalonePlaytestReport,
     "pass" | "assertionResults" | "capture" | "diagnostics" | "runtime" | "target"
   >,
+  nativeConsole: unknown,
 ): void {
+  assert.equal(report.pass, true, JSON.stringify(report.diagnostics));
   assert.equal(report.runtime, "native");
   assert.equal(report.target, "desktop");
   assert.equal(report.capture?.captureMethod, "device.screenshot");
-  assert.equal(report.pass, true, JSON.stringify(report.diagnostics));
   assert.ok(report.assertionResults?.length, "Native proof must evaluate assertions");
   assert.ok(
     report.assertionResults.every((result) => result.pass),
@@ -68,6 +69,25 @@ export function assertNativeAssetCapture(
     report.capture.adapter && Object.values(report.capture.adapter).some((value) => value.trim()),
     "Native adapter identity missing",
   );
+  assert.ok(
+    Array.isArray(nativeConsole) && nativeConsole.length > 0,
+    "Native console evidence missing",
+  );
+  for (const entry of nativeConsole) {
+    assert.ok(
+      entry && typeof entry.text === "string" && typeof entry.type === "string",
+      "Malformed native console evidence",
+    );
+    assert.notEqual(entry.type, "error", entry.text);
+    assert.doesNotMatch(
+      entry.text,
+      /\[FATAL\]|\[WebGPU\].*(?:Device error|Device lost|Failed)|validation error|device(?:[ _-]| was )?lost|(?:Type|Reference|Range|Syntax)Error|TN_(?:NATIVE_START_FAILED|ASSETS_UNRESOLVED|NATIVE_KTX2_UNSUPPORTED|NATIVE_MESH_COMPRESSION_UNSUPPORTED)/iu,
+    );
+  }
+  assert.ok(
+    nativeConsole.some((entry) => entry.text.includes("TN_NATIVE_SMOKE_FIRST_FRAME")),
+    "Native first-frame marker missing",
+  );
   for (const diagnostic of report.diagnostics) {
     assert.notEqual(diagnostic.severity, "error", diagnostic.code);
     assert.doesNotMatch(diagnostic.code, /DEVICE_LOST|BRIDGE_MISSING/u);
diff --git a/scripts/verify-native-asset-capabilities.ts b/scripts/verify-native-asset-capabilities.ts
index d8e5a216dd..31cc90dbab 100644
--- a/scripts/verify-native-asset-capabilities.ts
+++ b/scripts/verify-native-asset-capabilities.ts
@@ -132,7 +132,11 @@ try {
     url: "",
   });
   await write("report.json", report);
-  assertNativeAssetCapture(report);
+  assert.equal(report.pass, true, JSON.stringify(report.diagnostics));
+  const nativeConsole: unknown = JSON.parse(
+    await readFile(path.join(output, "console.json"), "utf8"),
+  );
+  assertNativeAssetCapture(report, nativeConsole);
   const bytes = await readFile(path.join(output, "after.png"));
   const pixels = inspectNativeAssetScreenshot(bytes);
   assert.deepEqual(await hashArtifact(executable), packaged);
@@ -142,6 +146,8 @@ try {
     runId: process.env.GITHUB_RUN_ID,
     qualification:
       "Packaged Linux QuickJS fallback correctness on a named hosted software adapter. No Android, iOS, native compressed-codec admission or hardware-performance claim.",
+    observability:
+      "Native host console, live readiness and resource observations; runtime.diagnostics is not exposed by this bridge.",
     runtime: capabilities,
     packaged,
     models,

From 46a759ad885cede29e0fbb2c719ed75151c5baec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Paulo=20Furtado?=
 <30300459+jonit-dev@users.noreply.github.com>
Date: Fri, 2 Oct 2026 03:54:29 -0700
Subject: [PATCH 04/36] test(vq01): replay native admission and require
 observed startup

Exercise actual bridge target admission locally. Only native-supported startup/resource families belong in the scenario. Native console cleanliness, ready/compile-settled state and device screenshot provenance remain required in the verifier. No engine target guard changed.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  3 ++
 ...vq-native-asset-capabilities.playtest.json | 12 ++---
 .../native-asset-capture-proof.spec.ts        | 53 ++++++++++++++++++-
 scripts/native-asset-capture-proof.ts         |  4 +-
 4 files changed, 62 insertions(+), 10 deletions(-)

diff --git a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
index 3260dc24a5..2d19198fea 100644
--- a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
@@ -91,3 +91,6 @@ Update the phase boxes and this PRD only after the named proof runs. Record actu
 
 
 Hosted attempt [36995485869](https://github.com/ThreeNativeHQ/threenative/actions/runs/36995485869), source `8d6cd881ac54b206d82e0ba00167b0e277edb402`, built the actual ARM64 QuickJS/wgpu runtime and packaged the fixture. Exact selected-runtime prefix, decoded payload comparisons and authored-KTX2 refusal/package-preservation checks passed. The native bridge answered ready, but correctly refused the scenario's unavailable `runtime.diagnostics` observer before capturing any frame; no screenshot exists from this attempt. The native-only scenario now records that limitation and instead keeps readiness/no-console-error assertions plus mandatory complete host-console checks for native GPU validation, device loss, JavaScript and loader errors. Five regression cases failed before this observer-contract repair; error-labelled and misleadingly log-labelled failures remain fatal. Runtime engine guards are unchanged.
+
+
+Hosted attempt [36996645116](https://github.com/ThreeNativeHQ/threenative/actions/runs/36996645116), source `cedacefcab3360d5cc344ef071649f57782ac9b5`, reconfirmed build/package/payload checks but exposed the full admission rule: the **entire diagnostics assertion family is web-only**, independently of its individual booleans. No pixels were captured. A regression now replays the real native handshake through `connectPlaytestBridgeTransport`, not only its capability-name calculator; it failed with the exact hosted observation error, then passed after the scenario was limited to supported startup/resources families. Native console cleanliness and ready/compile-settled checks are mandatory in the verifier instead, with missing readiness, empty console evidence, GPU loss, validation and JavaScript errors all tested to fail. The complete focused set passes 34/34 and verifier types pass. No engine target-admission guard changed.
diff --git a/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json b/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
index 9d2f97c60e..22d9c2d617 100644
--- a/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
+++ b/examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json
@@ -17,12 +17,6 @@
     "console": true
   },
   "assert": {
-    "diagnostics": {
-      "noConsoleErrors": true,
-      "noRuntimeDiagnostics": false,
-      "runtimeReady": true,
-      "runtimeDiagnosticsOptOutReason": "The native bridge does not expose runtime.diagnostics. This native-only fixture instead requires no console errors, live readiness, and verifier checks of every native console line for device loss, GPU validation, JavaScript and loader failures."
-    },
     "resources": [
       {
         "id": "state",
@@ -53,6 +47,10 @@
         "gte": 0.05,
         "allowTrivial": "The native warm-up can already advance both authored animation tracks."
       }
-    ]
+    ],
+    "startup": {
+      "maxEnteredMs": 120000,
+      "maxReadyMs": 120000
+    }
   }
 }
diff --git a/scripts/__tests__/native-asset-capture-proof.spec.ts b/scripts/__tests__/native-asset-capture-proof.spec.ts
index c80b80faa4..719894c72e 100644
--- a/scripts/__tests__/native-asset-capture-proof.spec.ts
+++ b/scripts/__tests__/native-asset-capture-proof.spec.ts
@@ -2,6 +2,11 @@ import { readFileSync } from "node:fs";
 import { PNG } from "pngjs";
 import { expect, test } from "vitest";
 import { requiredPlaytestCapabilities } from "../../packages/playtest/src/assertion-schema.js";
+import { PLAYTEST_PROTOCOL_LIMITS } from "../../packages/playtest/src/protocol.js";
+import {
+  type IBridgeTransport,
+  connectPlaytestBridgeTransport,
+} from "../../packages/playtest/src/runner/bridgeClient.js";
 import { validatePlaytestScenario } from "../../packages/playtest/src/scenario.js";
 import {
   assertNativeAssetCapture,
@@ -43,6 +48,7 @@ function image(missingRegion = -1, transparent = false): Buffer {
 function report(): Parameters<typeof assertNativeAssetCapture>[0] {
   return {
     pass: true,
+    startup: { phase: "ready", progress: 1, compileSettled: true, rule: "compile-settled" },
     runtime: "native",
     target: "desktop",
     assertionResults: [{ pass: true, id: "resources.0" }],
@@ -113,8 +119,9 @@ test("native scenario retains supported diagnostics without requesting an unavai
     "vq01",
   );
   expect(requiredPlaytestCapabilities(scenario, "desktop")).not.toContain("runtime.diagnostics");
-  expect(scenario.assert?.diagnostics?.noConsoleErrors).toBe(true);
-  expect(scenario.assert?.diagnostics?.runtimeReady).toBe(true);
+  expect(scenario.assert?.diagnostics).toBeUndefined();
+  expect(requiredPlaytestCapabilities(scenario, "desktop")).toContain("runtime.startup");
+  expect(scenario.assert?.startup?.maxReadyMs).toBe(120000);
 });
 
 test("native console evidence cannot be omitted or empty", () => {
@@ -131,3 +138,45 @@ test("unclassified error-labelled native lines remain fatal", () => {
     ]),
   ).toThrow("Unexpected host failure");
 });
+
+test("the actual native bridge preflight accepts the fixture's assertion families", async () => {
+  const scenario = validatePlaytestScenario(
+    JSON.parse(
+      readFileSync(
+        "examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json",
+        "utf8",
+      ),
+    ),
+    "vq01",
+  );
+  // Minimal subset of the real QuickJS handshake captured in run 36996645116.
+  const transport: IBridgeTransport = {
+    capabilities: ["browser.console", "browser.screenshot"],
+    waitForBridge: async () => true,
+    close: async () => {},
+    async call<T>(method: string): Promise<T> {
+      if (method === "describe")
+        return {
+          capabilities: ["runtime.resources", "runtime.fixedStep", "runtime.startup"],
+          limits: PLAYTEST_PROTOCOL_LIMITS,
+          name: "@threenative/playtest/three",
+          protocolVersion: 1,
+        } as T;
+      if (method === "ready") return { ready: true } as T;
+      throw new Error(`Unexpected preflight call: ${method}`);
+    },
+  };
+  await expect(
+    connectPlaytestBridgeTransport(transport, scenario, 1000, "desktop"),
+  ).resolves.toBeDefined();
+});
+
+test("native ready and settled compilation cannot be omitted or inferred from pixels", () => {
+  for (const startup of [
+    undefined,
+    { phase: "loading", progress: 0.9, compileSettled: true, rule: "compile-settled" },
+    { phase: "ready", progress: 1, compileSettled: false, rule: "compile-settled" },
+  ]) {
+    expect(() => assertNativeAssetCapture({ ...report(), startup }, cleanConsole)).toThrow();
+  }
+});
diff --git a/scripts/native-asset-capture-proof.ts b/scripts/native-asset-capture-proof.ts
index 451132b978..63478f2697 100644
--- a/scripts/native-asset-capture-proof.ts
+++ b/scripts/native-asset-capture-proof.ts
@@ -50,11 +50,13 @@ export function inspectNativeAssetScreenshot(bytes: Buffer) {
 export function assertNativeAssetCapture(
   report: Pick<
     IStandalonePlaytestReport,
-    "pass" | "assertionResults" | "capture" | "diagnostics" | "runtime" | "target"
+    "pass" | "assertionResults" | "capture" | "diagnostics" | "runtime" | "target" | "startup"
   >,
   nativeConsole: unknown,
 ): void {
   assert.equal(report.pass, true, JSON.stringify(report.diagnostics));
+  assert.equal(report.startup?.phase, "ready", "Native world never reached ready");
+  assert.equal(report.startup.compileSettled, true, "Native compilation never settled");
   assert.equal(report.runtime, "native");
   assert.equal(report.target, "desktop");
   assert.equal(report.capture?.captureMethod, "device.screenshot");

From f13f1ad912d118ccdc3ed6db00c32d9bf7d6f0d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Paulo=20Furtado?=
 <30300459+jonit-dev@users.noreply.github.com>
Date: Fri, 2 Oct 2026 04:05:57 -0700
Subject: [PATCH 05/36] docs(vq01): publish verified packaged QuickJS
 screenshot proof

Preserve the original native framebuffer and runner summary from successful run 36998104447. Record exact source/runtime/package/adapter/image identities, verified digests and bounded decoder-free fallback scope. Full VQ01/mobile/codec acceptance remains open.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  15 +++-
 docs/verification/vq01/README.md              |  26 ++++++
 docs/verification/vq01/provenance.json        |  62 +++++++++++++
 .../vq01/quickjs-native-summary.json          |  82 ++++++++++++++++++
 docs/verification/vq01/quickjs-native.png     | Bin 0 -> 71626 bytes
 5 files changed, 183 insertions(+), 2 deletions(-)
 create mode 100644 docs/verification/vq01/README.md
 create mode 100644 docs/verification/vq01/provenance.json
 create mode 100644 docs/verification/vq01/quickjs-native-summary.json
 create mode 100644 docs/verification/vq01/quickjs-native.png

diff --git a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
index 2d19198fea..20270c5034 100644
--- a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
@@ -4,7 +4,7 @@ prd_contract: v1
 
 # PRD-VQ-01 — Native asset compatibility follows the selected runtime and actual decoders
 
-**Status:** PARTIAL — 2026-10-02. Bounded desktop/unknown-runtime fail-closed repair implemented; mobile selected-artifact resolution and packaged-loader qualification remain open.
+**Status:** PARTIAL — 2026-10-02. Bounded desktop/unknown-runtime fail-closed repair implemented and packaged Linux QuickJS fallback rendered on the hosted lane; mobile selected-artifact resolution and compressed-decoder qualification remain open.
 **Batch:** [Visual quality execution batch](https://github.com/ThreeNativeHQ/threenative/blob/d9ac5b4e97f6b1383bd163d91619cffa7c6c0ef5/docs/PRDs/batch-2026-10-01-visual-quality/README.md). **Wave:** 0 / correctness.
 **Dependencies:** None. This is a build/runtime contract repair, not permission to remove compatibility guards.
 
@@ -64,7 +64,7 @@ Record encoded bytes, decoded texture/geometry bytes and peak load memory per co
 
 Physical Android performance and thermals require a named phone and are separate from emulator correctness. Missing codec qualifications must remain individual exclusions.
 
-This executor has no GPU device, Android SDK/adb or KVM. Xvfb is denied with EPERM; browser/native pixels and emulator correctness are unrun. These limitations do not qualify any codec. The owner explicitly requires screenshot proofs for every PR (2026-10-02); no actual relevant runtime screenshot has been captured, so this PR remains draft. Test logs and synthetic images are not screenshot proof.
+This local executor has no GPU device, Android SDK/adb or KVM, and Xvfb is unavailable. The hosted Linux ARM64 lane now provides real packaged QuickJS fallback pixels below. Browser and Android decoder correctness remain unrun. The owner's per-PR screenshot requirement is satisfied for this bounded fallback; the PR remains draft because full PRD acceptance and remaining platform gates are open.
 
 ## Completion record
 
@@ -94,3 +94,14 @@ Hosted attempt [36995485869](https://github.com/ThreeNativeHQ/threenative/action
 
 
 Hosted attempt [36996645116](https://github.com/ThreeNativeHQ/threenative/actions/runs/36996645116), source `cedacefcab3360d5cc344ef071649f57782ac9b5`, reconfirmed build/package/payload checks but exposed the full admission rule: the **entire diagnostics assertion family is web-only**, independently of its individual booleans. No pixels were captured. A regression now replays the real native handshake through `connectPlaytestBridgeTransport`, not only its capability-name calculator; it failed with the exact hosted observation error, then passed after the scenario was limited to supported startup/resources families. Native console cleanliness and ready/compile-settled checks are mandatory in the verifier instead, with missing readiness, empty console evidence, GPU loss, validation and JavaScript errors all tested to fail. The complete focused set passes 34/34 and verifier types pass. No engine target-admission guard changed.
+
+
+### Actual packaged native screenshot — 2026-10-02
+
+[Hosted run 36998104447](https://github.com/ThreeNativeHQ/threenative/actions/runs/36998104447) **passed**, executing source `46a759ad885cede29e0fbb2c719ed75151c5baec` on `ubuntu-24.04-arm`. The selected runtime is QuickJS/wgpu, runtime SHA-256 `da16138cc37938a14ce6831476aa58972a0d469ba2172b6a06faf6d1d56c6042`; the packaged game SHA-256 is `e20910ccaf495d5455bcba4fa74299fb6f7dd86718e0802488dbb6970cab883d`.
+
+The original 960×640 native `device.screenshot` was downloaded, ZIP/image digests verified, and visually inspected. The Meshopt-source cube, Draco-source torus and PNG panel all visibly carry their authored textures after decoder-free cooking. Eight live assertions pass, including both loaded/textured models, decoded vertex presence, advancing frames/pose, and actual startup milestones. Native readiness is `ready` with settled compilation; strict host-console checks pass and the report contains no diagnostics. The named adapter is Mesa llvmpipe (LLVM 20.1.2, 128 bits), so this is rendered correctness on a hosted software adapter, not hardware-performance evidence. Authored KTX2 remains refused before publication, preserving the already packaged executable byte-for-byte.
+
+![Actual packaged QuickJS framebuffer: Meshopt and Draco sources normalized before execution, with a standalone PNG](../../verification/vq01/quickjs-native.png)
+
+[Provenance and scope](../../verification/vq01/README.md), [machine-readable provenance](../../verification/vq01/provenance.json), and [unchanged runner summary](../../verification/vq01/quickjs-native-summary.json). The PNG SHA-256 is `1ad43cda8e816431b0ab9993066b087c9283351f304ade2c1765eebf8e349c81`. This verifies the bounded desktop QuickJS fallback and screenshot request. It does not tick the unchanged web, Android, actual compressed-decoder or full lifecycle acceptance boxes.
diff --git a/docs/verification/vq01/README.md b/docs/verification/vq01/README.md
new file mode 100644
index 0000000000..d95eef3928
--- /dev/null
+++ b/docs/verification/vq01/README.md
@@ -0,0 +1,26 @@
+# VQ-01: actual packaged QuickJS fallback
+
+![Packaged native QuickJS framebuffer](quickjs-native.png)
+
+Left: a Meshopt-authored cube. Centre: a Draco-authored torus. Right: a standalone PNG texture. The two compressed model sources were decoded by the ordinary asset cook before execution; QuickJS is not being credited with compressed-codec support.
+
+The image is the unchanged `after.png` from [successful native run 36998104447](https://github.com/ThreeNativeHQ/threenative/actions/runs/36998104447), source `46a759ad885cede29e0fbb2c719ed75151c5baec`, [artifact 11222881424](https://github.com/ThreeNativeHQ/threenative/actions/runs/36998104447/artifacts/11222881424). It was captured by the actual packaged executable using the native mailbox's `device.screenshot`, on the named Mesa llvmpipe software adapter. No browser capture, mock renderer, synthetic diagnostic image, crop, recolour or image-generation step is used here.
+
+## What passed
+
+- The actual ARM64 QuickJS/wgpu host was built through the repository's locked provisioner and normal native build path.
+- Build selection, cooking, compatibility checks, native bundling and final packaging ran through the changed production code. The packaged executable retains the exact selected runtime bytes before its appended game.
+- Decoded model positions, triangle counts, texture pixels and animation samples match the authored Meshopt/Draco inputs. Encoded source bytes are measured separately from decoded CPU accessor bytes.
+- Authored KTX2 was refused before publishing and left the previous package byte-identical.
+- Eight live assertions passed, covering loaded/textured models, decoded vertices, advancing frames/pose and startup milestones. Startup reached ready with compilation settled.
+- Strict native host-console checks, actual native adapter/capture provenance, and both authored checker colours as opaque pixels in each specimen region passed. Report diagnostics are empty.
+- Downloaded ZIP SHA-256: `5440effcf3acc3978207f8eba941888b0fbbf3de117c43f664145c5f7930fa90`.
+- PNG SHA-256: `1ad43cda8e816431b0ab9993066b087c9283351f304ade2c1765eebf8e349c81` (71,626 bytes, 960×640). The downloaded image was visually inspected.
+
+## Limits
+
+This is a Linux desktop QuickJS **decoder-free fallback** proof. It does not qualify Android/iOS, native Basis/Meshopt/Draco decoder admission, hardware performance, peak-load memory, or full repeated-scene lifecycle. The `diagnostics` assertion family is web-only and the game bridge does not expose `runtime.diagnostics`; mandatory native host-console and readiness checks provide the recorded diagnostics evidence without changing engine target guards.
+
+The unchanged runner summary calls its total decoded accessor count `decodedGeometryBytes`; that count includes animation samples. It is a CPU accessor-byte count, not measured GPU allocation or a claimed compression-related GPU saving.
+
+[Machine-readable provenance](provenance.json) and [unchanged runner summary](quickjs-native-summary.json) retain the source, run, runtime, package, adapter and image identities. [Canonical PRD](../../PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md) remains partial.
diff --git a/docs/verification/vq01/provenance.json b/docs/verification/vq01/provenance.json
new file mode 100644
index 0000000000..c2bd1e09f5
--- /dev/null
+++ b/docs/verification/vq01/provenance.json
@@ -0,0 +1,62 @@
+{
+  "schemaVersion": 1,
+  "sourceSha": "46a759ad885cede29e0fbb2c719ed75151c5baec",
+  "workflowRun": {
+    "id": 36998104447,
+    "url": "https://github.com/ThreeNativeHQ/threenative/actions/runs/36998104447",
+    "jobId": 110809358283,
+    "conclusion": "success"
+  },
+  "downloadedArtifact": {
+    "id": 11222881424,
+    "name": "vq01-native-assets-46a759ad885cede29e0fbb2c719ed75151c5baec",
+    "zipSha256": "5440effcf3acc3978207f8eba941888b0fbbf3de117c43f664145c5f7930fa90"
+  },
+  "screenshot": {
+    "file": "quickjs-native.png",
+    "originalArtifactFile": "after.png",
+    "sha256": "1ad43cda8e816431b0ab9993066b087c9283351f304ade2c1765eebf8e349c81",
+    "bytes": 71626,
+    "width": 960,
+    "height": 640,
+    "unaltered": true,
+    "visuallyInspected": true
+  },
+  "capture": {
+    "adapter": {
+      "architecture": "unknown",
+      "description": "Mesa 25.2.8-0ubuntu0.24.04.3 (LLVM 20.1.2)",
+      "device": "llvmpipe (LLVM 20.1.2, 128 bits)",
+      "vendor": "llvmpipe"
+    },
+    "browserArgs": [],
+    "captureMethod": "device.screenshot",
+    "rendererKind": "webgpu",
+    "target": "desktop",
+    "viewport": {
+      "height": 640,
+      "width": 960
+    }
+  },
+  "runtime": {
+    "artifact": "/home/runner/work/threenative/threenative/packages/runtime-native/build/tn-linux/mystral",
+    "identity": "desktop:sha256:da16138cc37938a14ce6831476aa58972a0d469ba2172b6a06faf6d1d56c6042",
+    "engine": "quickjs",
+    "webAssembly": false,
+    "decoders": {
+      "ktx2": false,
+      "meshopt": false,
+      "draco": false
+    }
+  },
+  "packaged": {
+    "kind": "file",
+    "name": "vq-native-assets",
+    "sha256": "e20910ccaf495d5455bcba4fa74299fb6f7dd86718e0802488dbb6970cab883d"
+  },
+  "assertionsPassed": 8,
+  "diagnostics": [],
+  "qualification": "Packaged Linux QuickJS fallback correctness on a named hosted software adapter. No Android, iOS, native compressed-codec admission or hardware-performance claim.",
+  "observability": "Native host console, live readiness and resource observations; runtime.diagnostics is not exposed by this bridge.",
+  "measurementNote": "The raw summary field decodedGeometryBytes is the sum of decoded glTF accessor buffers, including animation samples. These are CPU accessor bytes, not measured GPU allocations; no compression-related GPU memory saving is claimed."
+}
diff --git a/docs/verification/vq01/quickjs-native-summary.json b/docs/verification/vq01/quickjs-native-summary.json
new file mode 100644
index 0000000000..d054a20198
--- /dev/null
+++ b/docs/verification/vq01/quickjs-native-summary.json
@@ -0,0 +1,82 @@
+{
+  "pass": true,
+  "sourceSha": "46a759ad885cede29e0fbb2c719ed75151c5baec",
+  "runId": "36998104447",
+  "qualification": "Packaged Linux QuickJS fallback correctness on a named hosted software adapter. No Android, iOS, native compressed-codec admission or hardware-performance claim.",
+  "observability": "Native host console, live readiness and resource observations; runtime.diagnostics is not exposed by this bridge.",
+  "runtime": {
+    "artifact": "/home/runner/work/threenative/threenative/packages/runtime-native/build/tn-linux/mystral",
+    "identity": "desktop:sha256:da16138cc37938a14ce6831476aa58972a0d469ba2172b6a06faf6d1d56c6042",
+    "engine": "quickjs",
+    "webAssembly": false,
+    "decoders": {
+      "ktx2": false,
+      "meshopt": false,
+      "draco": false
+    }
+  },
+  "packaged": {
+    "kind": "file",
+    "name": "vq-native-assets",
+    "sha256": "e20910ccaf495d5455bcba4fa74299fb6f7dd86718e0802488dbb6970cab883d"
+  },
+  "models": [
+    {
+      "name": "meshopt",
+      "sourceSha256": "d67a2eeb9b22ce62843ad224ed3eaeab09b28af9b05ba2175dc1c6b5511c7812",
+      "cookedSha256": "71c635f4ed93f2a8f124e0f7a2143b9f4b277b8706afb022ed2c9c8023fc8880",
+      "sourceEncodedBytes": 4096,
+      "cookedEncodedBytes": 3908,
+      "decodedGeometryBytes": 2076,
+      "decodedImageBytes": 4096,
+      "triangles": 48
+    },
+    {
+      "name": "draco",
+      "sourceSha256": "1f448f031080d8369c587bd2fb5bbd485419f3ad4b9d741ff5d7eda58567dda3",
+      "cookedSha256": "261cc389a2f626f7983fda36ba2b24a7622bf12aaa07955872a78269a5f9f230",
+      "sourceEncodedBytes": 4956,
+      "cookedEncodedBytes": 20240,
+      "decodedGeometryBytes": 18396,
+      "decodedImageBytes": 4096,
+      "triangles": 768
+    }
+  ],
+  "capture": {
+    "adapter": {
+      "architecture": "unknown",
+      "description": "Mesa 25.2.8-0ubuntu0.24.04.3 (LLVM 20.1.2)",
+      "device": "llvmpipe (LLVM 20.1.2, 128 bits)",
+      "vendor": "llvmpipe"
+    },
+    "browserArgs": [],
+    "captureMethod": "device.screenshot",
+    "rendererKind": "webgpu",
+    "target": "desktop",
+    "viewport": {
+      "height": 640,
+      "width": 960
+    }
+  },
+  "pixels": {
+    "width": 960,
+    "height": 640,
+    "counts": [
+      [
+        10449,
+        10750
+      ],
+      [
+        7139,
+        6688
+      ],
+      [
+        9603,
+        9746
+      ]
+    ]
+  },
+  "screenshotSha256": "1ad43cda8e816431b0ab9993066b087c9283351f304ade2c1765eebf8e349c81",
+  "refusedCodec": "authored KTX2",
+  "previousPackagePreserved": true
+}
diff --git a/docs/verification/vq01/quickjs-native.png b/docs/verification/vq01/quickjs-native.png
new file mode 100644
index 0000000000000000000000000000000000000000..b323d0247603c25759e6e82d5c9e71ce705f771a
GIT binary patch
literal 71626
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

literal 0
HcmV?d00001


From b8ca3945e6e88dc49ebbb4557808190265a97abb Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Fri, 2 Oct 2026 18:58:02 -0700
Subject: [PATCH 06/36] ci: fold integration-native-assets.yml into
 integration.yml (one workflow, per AGENTS.md)

The `native-assets` lane joins the shared `paths` gate as an anchored ERE
translated from the old workflow's `paths:` globs, and `packaged-quickjs` keeps
its steps, env, timeout and artifact names on the same ARM64 QuickJS lane behind
`needs: paths`. Editing integration.yml keeps the lane's gate true, exactly as
editing integration-native-assets.yml used to. The PRD record now names the lane
instead of the deleted file.
---
 .../workflows/integration-native-assets.yml   | 86 -------------------
 .github/workflows/integration.yml             | 12 ++-
 .../PRD-VQ-01-native-asset-capabilities.md    |  2 +-
 3 files changed, 12 insertions(+), 88 deletions(-)
 delete mode 100644 .github/workflows/integration-native-assets.yml

diff --git a/.github/workflows/integration-native-assets.yml b/.github/workflows/integration-native-assets.yml
deleted file mode 100644
index 35c669385c..0000000000
--- a/.github/workflows/integration-native-assets.yml
+++ /dev/null
@@ -1,86 +0,0 @@
-name: Integration native asset fallback
-on:
-  pull_request:
-    paths:
-      - 'packages/create-threenative/src/build.ts'
-      - 'packages/create-threenative/src/buildReport.ts'
-      - 'packages/create-threenative/__tests__/vq-native-*.spec.ts'
-      - 'packages/assets/src/**'
-      - 'packages/core/src/assets.ts'
-      - 'packages/runtime-native/scripts/bundle.mjs'
-      - 'packages/runtime-native/scripts/package-desktop.mjs'
-      - 'packages/runtime-native/scripts/native-build.mjs'
-      - 'packages/runtime-native/scripts/download-deps.mjs'
-      - 'examples/abyss-framework/vq-assets/**'
-      - 'examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json'
-      - 'scripts/verify-native-asset-capabilities.ts'
-      - 'scripts/native-asset-capture-proof.ts'
-      - 'scripts/__tests__/native-asset-capture-proof.spec.ts'
-      - '.github/workflows/integration-native-assets.yml'
-permissions:
-  contents: read
-concurrency:
-  group: integration-native-assets-${{ github.event.pull_request.head.ref || github.ref_name }}
-  cancel-in-progress: true
-jobs:
-  packaged-quickjs:
-    # Match native-platforms starter-linux: this architecture selects QuickJS/wgpu without
-    # changing any runtime default. Native dependencies use the repository's locked provisioner.
-    runs-on: ubuntu-24.04-arm
-    timeout-minutes: 60
-    env:
-      CMAKE_BUILD_PARALLEL_LEVEL: '2'
-      TN_PLAYTEST_ALLOW_SOFTWARE: '1'
-      TN_PLAYTEST_NATIVE_SCREENSHOT_TIMEOUT_MS: '30000'
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262
-        with:
-          persist-credentials: false
-          ref: ${{ github.event.pull_request.head.sha }}
-      - uses: ./.github/actions/pnpm
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
-        with:
-          node-version: '22'
-          cache: pnpm
-      - uses: actions/setup-python@v7
-        with:
-          python-version: '3.12'
-      - run: pnpm install --frozen-lockfile
-      - name: Build this commit's JavaScript packages
-        uses: ./.github/actions/workspace-dist
-        with:
-          save-bundles: 'false'
-          pack-archives: 'false'
-      - name: Validate real compressed-source normalization and capture guards
-        run: >-
-          pnpm exec vitest run --maxWorkers=1
-          packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts
-          packages/create-threenative/__tests__/vq-native-fixture.spec.ts
-          scripts/__tests__/native-asset-capture-proof.spec.ts
-      - name: Restore checksum-provisioned native dependencies
-        uses: actions/cache/restore@v4
-        with:
-          path: packages/runtime-native/third_party
-          key: native-third-party-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('packages/runtime-native/scripts/download-deps.mjs', 'packages/runtime-native/scripts/package-android.mjs') }}
-      - name: Install the existing native lane's system prerequisites
-        run: >-
-          sudo apt-get update && sudo apt-get install -y
-          libasound2-dev libcurl4-openssl-dev libfontconfig1-dev libfreetype6-dev
-          libpulse-dev libudev-dev libx11-dev libxext-dev libxrandr-dev
-          libxcursor-dev libxi-dev libxfixes-dev libxss-dev libxkbcommon-dev
-          libgtk-3-dev libwebkit2gtk-4.1-dev libxcomposite-dev xcompmgr
-          libvulkan1 mesa-vulkan-drivers vulkan-tools xvfb zlib1g-dev
-      - name: Build the same QuickJS host the normal ARM desktop lane ships
-        run: pnpm --filter @threenative/runtime-native native:build
-      - name: Build the real fixture and capture its packaged native executable
-        env:
-          THREENATIVE_RUNTIME_BINARY: ${{ github.workspace }}/packages/runtime-native/build/tn-linux/mystral
-        run: node --import tsx scripts/verify-native-asset-capabilities.ts
-      - name: Retain raw native captures, artifact identities and decoded payload measurements
-        if: always()
-        uses: actions/upload-artifact@v7
-        with:
-          name: vq01-native-assets-${{ github.event.pull_request.head.sha }}
-          path: artifacts/vq01-native-assets/
-          retention-days: 30
-          if-no-files-found: warn
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 2552db7862..10843cdd7d 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -26,7 +26,7 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  # The per-lane trigger filters these five files used to carry, as one gate: the pull request's own
+  # The per-lane trigger filters these six files used to carry, as one gate: the pull request's own
   # changed paths decide which lanes run, and a lane this commit does not touch is skipped rather than
   # spending a runner. Editing this workflow keeps every lane's gate true, which is what
   # `.github/workflows/integration-<lane>.yml` did for each of them.
@@ -42,6 +42,7 @@ jobs:
       csg: ${{ steps.filter.outputs.csg }}
       decals: ${{ steps.filter.outputs.decals }}
       ik: ${{ steps.filter.outputs.ik }}
+      native-assets: ${{ steps.filter.outputs.native-assets }}
       tone: ${{ steps.filter.outputs.tone }}
       vegetation: ${{ steps.filter.outputs.vegetation }}
     steps:
@@ -57,6 +58,7 @@ jobs:
           lane csg '^examples/integrations/csg/.*$|^\.github/workflows/integration\.yml$'
           lane decals '^packages/create-threenative/templates/shooter/src/render/decals\.ts$|^packages/create-threenative/templates/shooter/src/scenes/Play\.ts$|^packages/create-threenative/__tests__/shooter-decals[^/]*\.spec\.ts$|^packages/create-threenative/__tests__/fixtures/bounded-decals/.*$|^\.github/workflows/integration\.yml$'
           lane ik '^examples/integrations/ik/.*$|^\.github/workflows/integration\.yml$'
+          lane native-assets '^packages/create-threenative/src/build\.ts$|^packages/create-threenative/src/buildReport\.ts$|^packages/create-threenative/__tests__/vq-native-[^/]*\.spec\.ts$|^packages/assets/src/.*$|^packages/core/src/assets\.ts$|^packages/runtime-native/scripts/bundle\.mjs$|^packages/runtime-native/scripts/package-desktop\.mjs$|^packages/runtime-native/scripts/native-build\.mjs$|^packages/runtime-native/scripts/download-deps\.mjs$|^examples/abyss-framework/vq-assets/.*$|^examples/abyss-framework/playtests/vq-native-asset-capabilities\.playtest\.json$|^scripts/verify-native-asset-capabilities\.ts$|^scripts/native-asset-capture-proof\.ts$|^scripts/__tests__/native-asset-capture-proof\.spec\.ts$|^\.github/workflows/integration\.yml$'
           lane tone '^packages/playtest/.*$|^examples/abyss-framework/src/render/toneCalibration\.ts$|^examples/abyss-framework/src/tone-main\.ts$|^examples/abyss-framework/tone\.html$|^examples/abyss-framework/tone\.vite\.config\.ts$|^examples/abyss-framework/playtests/tone\.playtest\.json$|^examples/abyss-framework/package\.json$|^scripts/verify-tone-exposure\.ts$|^scripts/tone-capture-proof\.ts$|^scripts/__tests__/tone-capture-proof\.spec\.ts$|^scripts/non-visual-scenarios\.mjs$|^package\.json$|^pnpm-lock\.yaml$|^\.github/actions/pnpm/.*$|^\.github/actions/playwright-chromium/.*$|^\.github/workflows/integration\.yml$'
           lane vegetation '^examples/integrations/vegetation/.*$|^\.github/workflows/integration\.yml$'
 
@@ -244,3 +246,11 @@ jobs:
           name: tone-exposure-${{ github.event.pull_request.head.sha }}
           path: artifacts/tone-exposure
           if-no-files-found: error
+
+  packaged-quickjs:
+    name: packaged native asset fallback
+    if: ${{ !github.event.pull_request.draft && needs.paths.outputs.native-assets == 'true' }}
+    needs: paths
+    # Match native-platforms starter-linux: this architecture selects QuickJS/wgpu without
+    # changing any runtime default. Native dependencies use the repository's locked provisioner.
+    runs-on: ubuntu-24.04-arm
diff --git a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
index 20270c5034..910934a031 100644
--- a/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md
@@ -84,7 +84,7 @@ Update the phase boxes and this PRD only after the named proof runs. Record actu
 
 - `examples/abyss-framework/vq-assets/` is a separate opt-in fixture; the ordinary example is unchanged. It loads two actual cooked GLBs and a PNG through `ctx.assets`, then advances their authored clips with `AnimationPlayer`. The checker colours belong to those assets, not to a drawn diagnostic overlay.
 - `node --import tsx scripts/verify-native-asset-capabilities.ts` requires a real QuickJS executable in `THREENATIVE_RUNTIME_BINARY`, builds through the actual desktop resolver/cook/bundle/packager, verifies decoded payload equality, the exact runtime prefix in the packaged executable and the published build-report digest, then proves an authored KTX2 refusal preserves that same package. `runDesktopPlaytest` drives the resulting executable and captures its framebuffer with the existing mailbox transport.
-- `.github/workflows/integration-native-assets.yml` uses the existing Linux ARM64 QuickJS/wgpu source-build lane, checksum-locked native provisioner and normal read-only `pull_request` permissions. Hosted software rasterization is explicitly declared; no hardware-performance claim is permitted. No credentials, guard exemptions or runtime defaults change.
+- The `native-assets` lane in `.github/workflows/integration.yml` — the per-feature workflow this PRD first added, folded into the one integration workflow root AGENTS.md now requires — uses the existing Linux ARM64 QuickJS/wgpu source-build lane, checksum-locked native provisioner and normal read-only `pull_request` permissions. Hosted software rasterization is explicitly declared; no hardware-performance claim is permitted. No credentials, guard exemptions or runtime defaults change.
 - Local checks: 25/25 focused capability/real-fixture/capture-validator tests passed; fixture and focused verifier TypeScript checks passed; assets and CLI packages rebuilt with declarations/publint. The actual QuickJS fixture bundle was built and contains no `WebAssembly` reference. The scenario validates and workflow YAML parses; CI structure/needs checks pass 141/141. The local native verifier refuses at the explicit missing-runtime requirement before any runtime claim.
 - Capture acceptance is fail-closed: native `device.screenshot` provenance, nonempty passed live assertions, named WebGPU adapter, no lost-device/errors, exact 960×640 framebuffer, and both authored checker colours in opaque pixels in each of the three specimen regions. The transparent-RGB negative test failed before the alpha guard and passes with it. A lifecycle test confirms the fixture's owned sRGB texture clone and cached original are each disposed once, including a repeated exit. Published PNGs must be original runner bytes with matching SHA-256 and source/run provenance.
 - No new screenshot or hosted-run PASS is claimed in this commit. Full mobile/cohort, packaged-decoder and lifecycle acceptance stays open.

From 64023080ed3c00df92d5a32edd4a28d02b91b285 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Fri, 2 Oct 2026 18:58:07 -0700
Subject: [PATCH 07/36] style: format the published VQ-01 runner summary so
 root lint passes

Pure biome formatting of docs/verification/vq01/quickjs-native-summary.json,
committed on this branch in f13f1ad91 and untouched since; every value is
identical.
---
 .../verification/vq01/quickjs-native-summary.json | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/docs/verification/vq01/quickjs-native-summary.json b/docs/verification/vq01/quickjs-native-summary.json
index d054a20198..c4dfd5e4c4 100644
--- a/docs/verification/vq01/quickjs-native-summary.json
+++ b/docs/verification/vq01/quickjs-native-summary.json
@@ -61,20 +61,7 @@
   "pixels": {
     "width": 960,
     "height": 640,
-    "counts": [
-      [
-        10449,
-        10750
-      ],
-      [
-        7139,
-        6688
-      ],
-      [
-        9603,
-        9746
-      ]
-    ]
+    "counts": [[10449, 10750], [7139, 6688], [9603, 9746]]
   },
   "screenshotSha256": "1ad43cda8e816431b0ab9993066b087c9283351f304ade2c1765eebf8e349c81",
   "refusedCodec": "authored KTX2",

From 4285a33469f1db433a6e5f7c5ba2c58d89e7d4af Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 15:40:26 -0700
Subject: [PATCH 08/36] docs(PRD-VQ-01): tick Phase 1 and Phase 2 on their own
 proofs after the merge
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Each Phase 1 and Phase 2 box names a unit proof command. Re-ran them at
the merge commit c29a21031: the capability suite passes 19/19 and the
capability plus fixture pair passes 21/21. The results sit beside each
box; the existing partial notes stay, so the open Android artifact
resolution, decoder versions, KTX2 block-format validation and
manifest-versus-payload work are still recorded as open. Phase 3 and the
acceptance boxes are untouched — their proofs are the browser and
Android scenarios, which did not run.

Also repoint the verification README at the PRD's new assets/ path,
which is what pnpm check:docs flagged after develop's folder move.
---
 .../assets/PRD-VQ-01-native-asset-capabilities.md    | 12 ++++++++----
 docs/verification/vq01/README.md                     |  2 +-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index 1dbd9a6567..1532547c95 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -33,17 +33,21 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 
 ### Phase 1 — One capability decision
 
-- [ ] Implement capability resolution from the selected artifact, including unknown-artifact handling and the full target/engine table. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+- [x] Implement capability resolution from the selected artifact, including unknown-artifact handling and the full target/engine table. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+  Verified 2026-10-03 at `c29a21031` (merge of `origin/develop` into this branch): `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` passed 19/19, exit 0.
   Partial: desktop resolves the packager's actual binary before cooking and hashes its bytes. Failed, absent, unknown and non-V8 probes take the decoder-free path. Android/iOS never probe the desktop packaging executable; their exact artifact/cohort resolution remains open.
-- [ ] Wire the same capability record into cooking and compatibility validation; preserve decoder-free rollback. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+- [x] Wire the same capability record into cooking and compatibility validation; preserve decoder-free rollback. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+  Verified 2026-10-03 at `c29a21031`: same command passed 19/19, exit 0.
 
   Partial: the record governs cooking, compatibility guards, and the desktop native-backend bundle path; embedded/shared KTX2 and Meshopt/Draco declarations are refused when unavailable. The existing desktop V8 path is preserved, not newly qualified.
 
 ### Phase 2 — The packaged bytes are authoritative
 
-- [ ] Make bundling and loading retain exactly the declared decoders and invalidate stale cook-cache entries. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+- [x] Make bundling and loading retain exactly the declared decoders and invalidate stale cook-cache entries. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts`.
+  Verified 2026-10-03 at `c29a21031`: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` passed 19/19, exit 0.
   Partial: cook keys include explicit decoder capabilities and selected desktop runtime SHA-256; QuickJS/unknown desktop bundles use the existing refusing stubs. Decoder versions, KTX2 block-format validation and manifest-versus-payload verification remain open.
-- [ ] Create separate tiny textured/animated fixtures for KTX2, Meshopt and Draco; assert decoded texture content and geometry rather than only a successful import. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts packages/create-threenative/__tests__/vq-native-fixture.spec.ts`.
+- [x] Create separate tiny textured/animated fixtures for KTX2, Meshopt and Draco; assert decoded texture content and geometry rather than only a successful import. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts packages/create-threenative/__tests__/vq-native-fixture.spec.ts`.
+  Verified 2026-10-03 at `c29a21031`: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts packages/create-threenative/__tests__/vq-native-fixture.spec.ts` passed 21/21 (19 + 2), exit 0.
   Partial: generated Meshopt and Draco textured/animated inputs are compared against decoder-free cooked files for exact decoded positions, triangle counts, animation samples and texture pixels. Authored KTX2 is encoded by the existing texture pass and explicitly refused; no packaged KTX2 decode is claimed.
 
 ### Phase 3 — Qualify the visible result
diff --git a/docs/verification/vq01/README.md b/docs/verification/vq01/README.md
index d95eef3928..6d2028b22c 100644
--- a/docs/verification/vq01/README.md
+++ b/docs/verification/vq01/README.md
@@ -23,4 +23,4 @@ This is a Linux desktop QuickJS **decoder-free fallback** proof. It does not qua
 
 The unchanged runner summary calls its total decoded accessor count `decodedGeometryBytes`; that count includes animation samples. It is a CPU accessor-byte count, not measured GPU allocation or a claimed compression-related GPU saving.
 
-[Machine-readable provenance](provenance.json) and [unchanged runner summary](quickjs-native-summary.json) retain the source, run, runtime, package, adapter and image identities. [Canonical PRD](../../PRDs/batch-2026-10-01-visual-quality/PRD-VQ-01-native-asset-capabilities.md) remains partial.
+[Machine-readable provenance](provenance.json) and [unchanged runner summary](quickjs-native-summary.json) retain the source, run, runtime, package, adapter and image identities. [Canonical PRD](../../PRDs/assets/PRD-VQ-01-native-asset-capabilities.md) remains partial.

From 03d2903a80ca6740d10ee1ede019c988b9949a93 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 15:42:02 -0700
Subject: [PATCH 09/36] ci: keep the native-assets lane off develop's
 world-capture assets filter

The re-applied native-assets filter still claimed all of
packages/assets/src, which develop's world-capture lane now owns.
scripts/__tests__/ci-integration-scope.spec.ts proves a
packages/assets/src/index.ts change selects world-capture alone, and it
failed on the overlap.

Narrow the claim to the two modules this lane's proof actually depends
on, compile.ts and report.ts, the decoder-free cook and the build report.
Selection checked against the real parser: build.ts and compile.ts select
native-assets, index.ts still selects world-capture alone.
---
 .github/workflows/integration.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 4251d02e86..e81b29e366 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -63,7 +63,7 @@ jobs:
             decals ^packages/playtest/.*$|^packages/create-threenative/templates/shooter/src/render/decals\.ts$|^packages/create-threenative/templates/shooter/src/scenes/Play\.ts$|^packages/create-threenative/__tests__/shooter-decals[^/]*\.spec\.ts$|^packages/create-threenative/__tests__/fixtures/bounded-decals/.*$|^packages/runtime-native/.*$|^scripts/xvfb\.sh$|^\.github/actions/workspace-dist/.*$|^\.github/actions/pnpm/.*$|^\.github/actions/playwright-chromium/.*$|^pnpm-lock\.yaml$
             fluid-particles ^packages/core/src/fluid-particles\.ts$|^packages/core/src/gpu-readback\.ts$|^packages/core/__tests__/fluid-particles\.spec\.ts$|^packages/core/patches/.*$|^packages/playtest/.*$|^examples/prd476-fluid-particles/.*$|^scripts/verify-fluid-collision\.ts$|^scripts/verify-fluid-consumers\.ts$|^scripts/verify-fluid-collision-native\.ts$|^scripts/__tests__/fluid-collision-native-proof\.spec\.ts$|^packages/runtime-native/.*$|^\.github/actions/workspace-dist/.*$|^scripts/fluid-collision-proof\.ts$|^scripts/__tests__/fluid-collision-proof\.spec\.ts$|^scripts/__tests__/fluid-collision-view\.spec\.ts$|^pnpm-lock\.yaml$|^\.github/actions/pnpm/.*$|^\.github/actions/playwright-chromium/.*$|^scripts/xvfb\.sh$|^scripts/workspace-packages\.ts$
             ik ^examples/integrations/ik/.*$
-            native-assets ^packages/create-threenative/src/build\.ts$|^packages/create-threenative/src/buildReport\.ts$|^packages/create-threenative/__tests__/vq-native-[^/]*\.spec\.ts$|^packages/assets/src/.*$|^packages/core/src/assets\.ts$|^packages/runtime-native/scripts/bundle\.mjs$|^packages/runtime-native/scripts/package-desktop\.mjs$|^packages/runtime-native/scripts/native-build\.mjs$|^packages/runtime-native/scripts/download-deps\.mjs$|^examples/abyss-framework/vq-assets/.*$|^examples/abyss-framework/playtests/vq-native-asset-capabilities\.playtest\.json$|^scripts/verify-native-asset-capabilities\.ts$|^scripts/native-asset-capture-proof\.ts$|^scripts/__tests__/native-asset-capture-proof\.spec\.ts$
+            native-assets ^packages/create-threenative/src/build\.ts$|^packages/create-threenative/src/buildReport\.ts$|^packages/create-threenative/__tests__/vq-native-[^/]*\.spec\.ts$|^packages/assets/src/(compile|report)\.ts$|^packages/core/src/assets\.ts$|^packages/runtime-native/scripts/bundle\.mjs$|^packages/runtime-native/scripts/package-desktop\.mjs$|^packages/runtime-native/scripts/native-build\.mjs$|^packages/runtime-native/scripts/download-deps\.mjs$|^examples/abyss-framework/vq-assets/.*$|^examples/abyss-framework/playtests/vq-native-asset-capabilities\.playtest\.json$|^scripts/verify-native-asset-capabilities\.ts$|^scripts/native-asset-capture-proof\.ts$|^scripts/__tests__/native-asset-capture-proof\.spec\.ts$
             tone ^scripts/xvfb\.sh$|^packages/playtest/.*$|^examples/abyss-framework/src/render/toneCalibration\.ts$|^examples/abyss-framework/src/tone-main\.ts$|^examples/abyss-framework/tone\.html$|^examples/abyss-framework/tone\.vite\.config\.ts$|^examples/abyss-framework/playtests/tone\.playtest\.json$|^examples/abyss-framework/package\.json$|^scripts/verify-tone-exposure\.ts$|^scripts/tone-capture-proof\.ts$|^scripts/__tests__/tone-capture-proof\.spec\.ts$|^scripts/non-visual-scenarios\.mjs$|^package\.json$|^pnpm-lock\.yaml$|^\.github/actions/pnpm/.*$|^\.github/actions/playwright-chromium/.*$|^packages/create-threenative/(template-assets|templates/[^/]+/src/render)/(autoExposure|exposureGraph|exposureReadback|exposureSettings|worldEnvironment)\.ts$
             vegetation ^examples/integrations/vegetation/.*$
             world-capture ^packages/core/src/world[^/]*\.ts$|^packages/core/__tests__/world-capture-fixture\.spec\.ts$|^packages/playtest/.*$|^packages/assets/.*$|^examples/abyss-framework/src/scenes/WorldProbe\.ts$|^examples/abyss-framework/src/world-main\.ts$|^examples/abyss-framework/src/style\.css$|^examples/abyss-framework/assets/world/.*$|^examples/abyss-framework/index\.html$|^examples/abyss-framework/vite\.config\.ts$|^examples/abyss-framework/threenative\.config\.ts$|^examples/abyss-framework/playtests/phase477-world-capture\.playtest\.json$|^examples/abyss-framework/package\.json$|^scripts/verify-world-capture\.ts$|^scripts/world-capture-manifest\.ts$|^scripts/world-visual-gate\.ts$|^scripts/capture-guard\.ts$|^scripts/__tests__/verify-world-capture\.spec\.ts$|^scripts/__tests__/world-capture-manifest\.spec\.ts$|^scripts/__tests__/world-visual-gate\.spec\.ts$|^package\.json$|^pnpm-lock\.yaml$|^pnpm-workspace\.yaml$|^\.github/actions/pnpm/.*$|^\.github/actions/playwright-chromium/.*$

From e62bd7a9ef1845fc89c6d71ee4a3a88746f9202e Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 15:56:04 -0700
Subject: [PATCH 10/36] fix(typecheck): give the root program one copy of core
 for the VQ-01 fixture

The root tsconfig mapped the bare `@threenative/core` specifier to
`packages/core/src` and left the `./playtest` subpath to fall through
`node_modules` to `packages/core/dist`. The VQ-01 fixture at
`examples/abyss-framework/vq-assets/src/game.ts` puts both in one expression
(`plugins: [playtest()]` beside `defineGame`), so nominal types from two copies
met and `pnpm typecheck` failed with `#private` missing on `RenderChain`.

Map the subpath to its source entry like the bare specifier, the way a sibling
example's own program already resolves both through the package exports.
---
 tsconfig.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tsconfig.json b/tsconfig.json
index 87e24b23d7..e91e6217d8 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -7,6 +7,7 @@
     "baseUrl": ".",
     "paths": {
       "@threenative/core": ["packages/core/src/index.ts"],
+      "@threenative/core/playtest": ["packages/core/src/playtest.ts"],
       "@threenative/physics": ["packages/physics/src/index.ts"],
       "@threenative/playtest": ["packages/playtest/src/index.ts"],
       "@threenative/ui": ["packages/ui/src/index.ts"]

From 5e5ec9829839bc205ad325164232b63ffd15bc59 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:04:27 -0700
Subject: [PATCH 11/36] feat(assets): cook embedded EXT_texture_webp images
 (PRD-485 phase 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

decodeImageBytes reads WebP through sharp — already declared in this package's
dependencies and unused until now, so no dependency and no new native binary
reaches a game (every template already ships the same one via @gltf-transform/cli).
An embedded WebP now cooks like a PNG: KTX2 on a target that decodes it, a capped
PNG on the decoder-free path, and the pass disposes EXT_texture_webp once no image
is left in it because the glTF writer emits every attached extension.

The pass's "never grow a native dependency" rule changes with it: this is a
Node-only build-time package and sharp is the only native thing in it.

Gates: red before (TN_ASSETS_TEXTURE_CONTAINER: 'character.glb#checker' is not a
PNG or JPEG), green after — 26/26 model-texture-pass, 474 passed / 2 skipped across
packages/assets/__tests__, pnpm typecheck, pnpm lint, assets build + publint.
---
 ...high-quality-assets-go-through-the-cook.md |   1 +
 .../__tests__/model-texture-pass.spec.ts      | 192 +++++++++++++++++-
 packages/assets/src/passes/decode-image.ts    |  29 ++-
 packages/assets/src/passes/model-textures.ts  |   9 +-
 packages/assets/src/passes/texture.ts         |   2 +-
 5 files changed, 226 insertions(+), 7 deletions(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 9f042a7dca..67de9533ed 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -49,6 +49,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 **Status:** NOT STARTED
 **Files:** `packages/assets/src/passes/decode-image.ts`, `packages/assets/src/passes/model-textures.ts`; `packages/assets/__tests__/model-texture-pass.spec.ts`
 - [ ] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`.
+  Implementation: `sharp` decodes WebP in `decode-image.ts` — the first rung of the decision above, already declared at `packages/assets/package.json:57`, so no dependency is added and no new binary is installed for a game (every template already carries `@gltf-transform/cli`, which drags the same native package). It loads in the pass's worker thread and stays external in `dist`. `compressEmbeddedTextures` disposes `EXT_texture_webp` once no image is left in it, because the glTF writer emits every attached extension. The rule that `decode-image.ts` "must never grow a native dependency" is changed here: this is a Node-only build-time package, and `sharp` is the only native thing in it. Spec: the `embedded EXT_texture_webp` block of `model-texture-pass.spec.ts`, with the KTX2 leg decoding mip 0 through the shipped `basis_transcoder`.
 - [ ] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`.
 
 #### Phase 2: The Fab tree cooks by default
diff --git a/packages/assets/__tests__/model-texture-pass.spec.ts b/packages/assets/__tests__/model-texture-pass.spec.ts
index 7458841893..db27849d8f 100644
--- a/packages/assets/__tests__/model-texture-pass.spec.ts
+++ b/packages/assets/__tests__/model-texture-pass.spec.ts
@@ -1,9 +1,11 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { type Document, NodeIO } from "@gltf-transform/core";
-import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
+import { ALL_EXTENSIONS, EXTTextureWebP } from "@gltf-transform/extensions";
 import { read as readKTX2 } from "ktx-parse";
 import { MeshoptDecoder, MeshoptEncoder } from "meshoptimizer";
+import { PNG } from "pngjs";
 import { describe, expect, it, vi } from "vitest";
 import { buildFixtureDocument } from "../../../test-support/generate-fixture-model.js";
 import { rgbaPng } from "../../../test-support/png.js";
@@ -81,6 +83,118 @@ async function compiled(
   return { buffer: result.buffer, entry: result.entry ?? {} };
 }
 
+/**
+ * Two flat halves, never one solid colour: `prune` deletes a single-colour texture and folds it
+ * into the material factor, which would leave these cases measuring a material and no image.
+ */
+const WEBP_HALVES = [
+  [200, 130, 40],
+  [20, 60, 220],
+] as const;
+
+/** A lossless WebP of the requested size, encoded by the decoder the pass uses. */
+async function tinyWebp(size = 4): Promise<Buffer> {
+  const sharp = (await import("sharp")).default;
+  const pixels = Buffer.alloc(size * size * 4);
+  for (let index = 0; index < size * size; index += 1) {
+    pixels.set([...WEBP_HALVES[index % size < size / 2 ? 0 : 1], 255], index * 4);
+  }
+  return sharp(pixels, { raw: { channels: 4, height: size, width: size } })
+    .webp({ lossless: true })
+    .toBuffer();
+}
+
+/**
+ * The shared fixture with its base colour replaced by an `EXT_texture_webp` image, which is what
+ * a Fab or McD export ships: the extension declared and required, the payload in a WebP.
+ */
+async function fixtureWithWebp(size?: number): Promise<Buffer> {
+  const document = buildFixtureDocument();
+  document.createExtension(EXTTextureWebP).setRequired(true);
+  document
+    .getRoot()
+    .listTextures()[0]
+    ?.setImage(await tinyWebp(size))
+    .setMimeType("image/webp");
+  // The writer only emits the extensions it was told about, and an undeclared `image/webp`
+  // would be the invalid document this fixture exists to avoid.
+  return Buffer.from(await new NodeIO().registerExtensions(ALL_EXTENSIONS).writeBinary(document));
+}
+
+interface IBasisModule {
+  readonly KTX2File: new (
+    bytes: Uint8Array,
+  ) => {
+    close(): void;
+    getHeight(): number;
+    getImageTranscodedSizeInBytes(mip: number, layer: number, face: number, format: number): number;
+    getWidth(): number;
+    isValid(): boolean;
+    startTranscoding(): boolean;
+    transcodeImage(
+      dst: Uint8Array,
+      mip: number,
+      layer: number,
+      face: number,
+      format: number,
+      getAlphaForOpaqueFormats: number,
+      channel0: number,
+      channel1: number,
+    ): boolean;
+  };
+  readonly initializeBasis: () => void;
+  readonly transcoder_texture_format: Readonly<Record<string, { readonly value: number }>>;
+}
+
+/**
+ * Mip 0 of a KTX2 as RGBA8, decoded by the same `basis_transcoder` the runtime ships. Three
+ * publishes it CommonJS inside an ESM package, so it is evaluated here the way its own wrapper
+ * does — the alternative is trusting the container header instead of the pixels.
+ */
+async function transcodeFirstLevel(ktx2: Uint8Array): Promise<Uint8Array> {
+  const paths = basisTranscoderPaths();
+  const directory = path.dirname(paths.javascriptPath);
+  const source = await readFile(paths.javascriptPath, "utf8");
+  const shim: { exports: unknown } = { exports: {} };
+  new Function("module", "exports", "require", "__filename", "__dirname", source)(
+    shim,
+    shim.exports,
+    createRequire(import.meta.url),
+    paths.javascriptPath,
+    directory,
+  );
+  const factory = shim.exports as (options: {
+    locateFile: (file: string) => string;
+  }) => Promise<IBasisModule>;
+  const basis = await factory({ locateFile: (file) => path.join(directory, file) });
+  basis.initializeBasis();
+  const file = new basis.KTX2File(ktx2);
+  // The emscripten bindings report booleans as numbers, so both calls are judged on truth.
+  expect(file.isValid()).toBeTruthy();
+  expect(file.startTranscoding()).toBeTruthy();
+  // The WASM enum's numbering is not three's TranscoderFormat map, so the shipped enum names it.
+  const rgba32 = basis.transcoder_texture_format.cTFRGBA32;
+  if (rgba32 === undefined) throw new Error("the shipped transcoder exposes no cTFRGBA32 format");
+  const format = rgba32.value;
+  const pixels = new Uint8Array(file.getImageTranscodedSizeInBytes(0, 0, 0, format));
+  expect(file.transcodeImage(pixels, 0, 0, 0, format, 0, -1, -1)).toBeTruthy();
+  file.close();
+  return pixels;
+}
+
+/** Every channel within `tolerance` of the source half the pixel belongs to. */
+function expectColours(pixels: Uint8Array, width: number, tolerance: number): void {
+  expect(pixels.length).toBe(width * width * 4);
+  for (let offset = 0; offset < pixels.length; offset += 4) {
+    const half = WEBP_HALVES[(offset / 4) % width < width / 2 ? 0 : 1];
+    for (let channel = 0; channel < 3; channel += 1) {
+      expect(Math.abs((pixels[offset + channel] ?? 0) - (half[channel] ?? 0))).toBeLessThanOrEqual(
+        tolerance,
+      );
+    }
+  }
+}
+
 describe("embedded model textures", () => {
   it("should transcode every embedded image to KTX2 and declare KHR_texture_basisu", async () => {
     const input = await fixtureWithTextures({ width: 32 });
@@ -291,6 +405,82 @@ describe("embedded model textures", () => {
   });
 });
 
+describe("embedded EXT_texture_webp", () => {
+  it("should cook a WebP image to KTX2 and drop the extension", async () => {
+    // A named per-slot codec also skips the keep-smaller-source guard: a 4x4 WebP is smaller
+    // than the KTX2 container around it, and the test needs the cook to have run.
+    const { buffer } = await compiled(await fixtureWithWebp(), {
+      textures: { overrides: [{ codec: "uastc", slot: "baseColorTexture" }] },
+    });
+    const json = JSON.parse(buffer.subarray(20, 20 + buffer.readUInt32LE(12)).toString("utf8")) as {
+      extensionsRequired?: string[];
+      extensionsUsed?: string[];
+    };
+    expect(json.extensionsUsed ?? []).not.toContain("EXT_texture_webp");
+    expect(json.extensionsRequired ?? []).not.toContain("EXT_texture_webp");
+    expect(json.extensionsRequired ?? []).toContain("KHR_texture_basisu");
+
+    const cooked = (await readOutput(buffer))
+      .getRoot()
+      .listTextures()
+      .find((texture) => texture.getName() === "checker");
+    expect(cooked?.getMimeType()).toBe("image/ktx2");
+    const image = cooked?.getImage() ?? new Uint8Array();
+    expect(readKTX2(image)).toMatchObject({ pixelHeight: 4, pixelWidth: 4 });
+    // UASTC is lossless for 8-bit RGBA, so the transcoded mip is the source colour: proof the
+    // WebP payload reached the encoder instead of a container that merely looked like one.
+    expectColours(await transcodeFirstLevel(image), 4, 1);
+  });
+
+  it("should cap an over-cap WebP image to PNG on a target with no transcoder", async () => {
+    const root = await makeTempDir("threenative-webp-decoder-free-");
+    await mkdir(path.join(root, "assets"));
+    // 8x8 against a 4-longest-edge cap: `cappedSize` never returns less than one 4x4 block, so
+    // only an over-cap source can reach the PNG the decoder-free path emits.
+    await writeFile(path.join(root, "assets", "prop.glb"), await fixtureWithWebp(8));
+
+    await compileAssets({
+      config: { models: { sharedImages: false, textures: { maxSize: 4 } } },
+      cwd: root,
+      platform: "android",
+    });
+
+    const manifest = JSON.parse(
+      await readFile(path.join(root, "public", "assets.manifest.json"), "utf8"),
+    ) as { entries: Record<string, Record<string, unknown>> };
+    const entry = manifest.entries["prop.glb"];
+    if (entry === undefined || typeof entry.output !== "string") {
+      throw new Error("no manifest entry for 'prop.glb'");
+    }
+    expect(entry.extensions ?? []).not.toContain("EXT_texture_webp");
+
+    const cooked = (await readOutput(await readFile(path.join(root, "public", entry.output))))
+      .getRoot()
+      .listTextures()
+      .find((texture) => texture.getName() === "checker");
+    expect(cooked?.getMimeType()).toBe("image/png");
+    const image = Buffer.from(cooked?.getImage() ?? new Uint8Array());
+    expect(parsePng(image)).toMatchObject({ height: 4, width: 4 });
+    // A PNG is lossless, so the resampled colour must be the source one.
+    expectColours(PNG.sync.read(image).data, 4, 1);
+  });
+
+  it("should still fail closed on a container that is not an image", async () => {
+    const document = buildFixtureDocument();
+    document
+      .getRoot()
+      .listTextures()[0]
+      ?.setImage(Buffer.from("GIF89a not an image at all"))
+      .setMimeType("image/png");
+    const input = Buffer.from(await new NodeIO().writeBinary(document));
+    await expect(
+      apply(input, {
+        passes: { dedup: false, meshopt: false, prune: false, quantize: false, reorder: false },
+      }),
+    ).rejects.toThrow(/TN_ASSETS_MODEL_TEXTURE_UNDECODABLE.*TN_ASSETS_TEXTURE_CONTAINER/su);
+  });
+});
+
 describe("mesh simplification", () => {
   it("should leave triangles untouched unless simplification is declared", async () => {
     const input = await fixtureWithTextures({ width: 32 });
diff --git a/packages/assets/src/passes/decode-image.ts b/packages/assets/src/passes/decode-image.ts
index b9b6ce00b4..c14dc1bc09 100644
--- a/packages/assets/src/passes/decode-image.ts
+++ b/packages/assets/src/passes/decode-image.ts
@@ -3,9 +3,10 @@ import { parsePng } from "../png.js";
 
 /**
  * Decodes an encoded image's bytes to tight 8-bit RGBA for the Basis encoder, which takes
- * decoded pixels through its Node-side `imageDecoder` hook. Pure-JS decoders on purpose:
- * this package is Node-only and must never grow a native dependency. Containers neither
- * decoder reads throw — a source this step cannot encode fails the build naming the file,
+ * decoded pixels through its Node-side `imageDecoder` hook. PNG and JPEG are pure-JS decoders
+ * already in the dependency tree; WebP is not, so it goes through `sharp` — declared but
+ * previously unused, native, and confined to this build-time package (PRD-485). Containers none
+ * of the three reads throw: a source this step cannot encode fails the build naming the file,
  * never silently ships uncompressed.
  */
 export async function decodeImageBytes(
@@ -23,8 +24,28 @@ export async function decodeImageBytes(
     assertRgba(image.data.length, image.width, image.height, logicalPath);
     return { data: new Uint8Array(image.data), height: image.height, width: image.width };
   }
+  // RIFF container, `WEBP` form type — what an EXT_texture_webp image carries out of Fab.
+  if (
+    bytes.length >= 12 &&
+    bytes.toString("ascii", 0, 4) === "RIFF" &&
+    bytes.toString("ascii", 8, 12) === "WEBP"
+  ) {
+    const sharp = (await import("sharp")).default;
+    try {
+      const { data, info } = await sharp(bytes)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+      assertRgba(data.length, info.width, info.height, logicalPath);
+      return { data, height: info.height, width: info.width };
+    } catch (error) {
+      throw new Error(
+        `TN_ASSETS_TEXTURE_UNREADABLE: '${logicalPath}' is a WebP the decoder could not read: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
   throw new Error(
-    `TN_ASSETS_TEXTURE_CONTAINER: '${logicalPath}' is not a PNG or JPEG the KTX2 encoder can read; convert it to .png or .jpg.`,
+    `TN_ASSETS_TEXTURE_CONTAINER: '${logicalPath}' is not a PNG, JPEG or WebP the KTX2 encoder can read; convert it to .png or .jpg.`,
   );
 }
 
diff --git a/packages/assets/src/passes/model-textures.ts b/packages/assets/src/passes/model-textures.ts
index 07fb3d808b..bddab7cd02 100644
--- a/packages/assets/src/passes/model-textures.ts
+++ b/packages/assets/src/passes/model-textures.ts
@@ -1,5 +1,5 @@
 import type { Document, Texture } from "@gltf-transform/core";
-import { KHRTextureBasisu } from "@gltf-transform/extensions";
+import { EXTTextureWebP, KHRTextureBasisu } from "@gltf-transform/extensions";
 import { getTextureColorSpace, listTextureInfo, listTextureSlots } from "@gltf-transform/functions";
 import { read as readKTX2 } from "ktx-parse";
 import { PNG } from "pngjs";
@@ -583,6 +583,13 @@ export async function compressEmbeddedTextures(
     // and a glTF that pretends otherwise fails at the first frame instead of at load.
     document.createExtension(KHRTextureBasisu).setRequired(true);
   }
+  // A glTF writer emits every extension still attached, so a model authored with WebP images
+  // would keep *requiring* EXT_texture_webp after the cook replaced those images. Dropped only
+  // once no image is left in the container: an over-cap image the project chose to keep as
+  // authored is still a WebP a reader has to understand.
+  if (!textures.some((texture) => texture.getMimeType() === "image/webp")) {
+    document.disposeExtension(EXTTextureWebP.EXTENSION_NAME);
+  }
   return {
     bytesAfter,
     bytesBefore,
diff --git a/packages/assets/src/passes/texture.ts b/packages/assets/src/passes/texture.ts
index 14026a2362..b9fa713a96 100644
--- a/packages/assets/src/passes/texture.ts
+++ b/packages/assets/src/passes/texture.ts
@@ -224,7 +224,7 @@ export function textureResizePass(options: ITextureResizeOptions): IAssetPass {
   };
 }
 
-/** PNG signature or JPEG SOI, the two containers `decodeImageBytes` reads. */
+/** PNG signature or JPEG SOI, the two containers the standalone pass sniffs headers for. */
 function isPngOrJpeg(bytes: Buffer): boolean {
   if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
     return true;

From ba1544cf47cd3ee49a7e4714c442f82b0b3a866d Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:05:18 -0700
Subject: [PATCH 12/36] docs(PRD-485): tick embedded WebP cook on its red-green
 spec

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 67de9533ed..8a1839dcfa 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -48,7 +48,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 #### Phase 1: Embedded WebP cooks
 **Status:** NOT STARTED
 **Files:** `packages/assets/src/passes/decode-image.ts`, `packages/assets/src/passes/model-textures.ts`; `packages/assets/__tests__/model-texture-pass.spec.ts`
-- [ ] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`.
+- [x] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`. **Result 2026-10-03 (`5e5ec9829`):** red `TN_ASSETS_TEXTURE_CONTAINER … is not a PNG or JPEG` before; green 3/3 after (KTX2 mip 0 transcodes back to the source within 1, decoder-free capped PNG, unknown container still throws); file 26/26, `packages/assets` 474 passed.
   Implementation: `sharp` decodes WebP in `decode-image.ts` — the first rung of the decision above, already declared at `packages/assets/package.json:57`, so no dependency is added and no new binary is installed for a game (every template already carries `@gltf-transform/cli`, which drags the same native package). It loads in the pass's worker thread and stays external in `dist`. `compressEmbeddedTextures` disposes `EXT_texture_webp` once no image is left in it, because the glTF writer emits every attached extension. The rule that `decode-image.ts` "must never grow a native dependency" is changed here: this is a Node-only build-time package, and `sharp` is the only native thing in it. Spec: the `embedded EXT_texture_webp` block of `model-texture-pass.spec.ts`, with the KTX2 leg decoding mip 0 through the shipped `basis_transcoder`.
 - [ ] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`.
 

From c2eb9725a8d7fcb8f42d4ba67e20313241253444 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:10:34 -0700
Subject: [PATCH 13/36] feat(vq01): make the shared VQ-01 fixture's web proof
 runnable

The Phase 3 web box names a browser command but nothing could serve the
fixture to it: examples/abyss-framework/vq-assets had no web entry at all,
and `threenative build` refused it with UNRESOLVED_ENTRY.

- index.html + src/main.ts: the minimal template's own canvas mount, so the
  web build has the entry page every Vite build needs and the unchanged game
  and cooked assets are what render.
- scripts/vq01-web-proof.sh: generates the authored Meshopt/Draco GLBs and PNG
  through the same function the native verifier uses, cooks the fixture for
  web, and runs the PRD's proof command against a managed preview server on
  127.0.0.1:5193.

The box stays open. This lane has no browser, so only the parts a browser
does not need were verified: the build publishes dist/ (exit 0), the scenario
loads through loadPlaytestScenario, the server command answers 200 for the
page and for the 1034430-byte game bundle, and the fixture still typechecks.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  1 +
 examples/abyss-framework/vq-assets/index.html | 28 +++++++++++++++
 .../abyss-framework/vq-assets/src/main.ts     |  8 +++++
 scripts/vq01-web-proof.sh                     | 34 +++++++++++++++++++
 4 files changed, 71 insertions(+)
 create mode 100644 examples/abyss-framework/vq-assets/index.html
 create mode 100644 examples/abyss-framework/vq-assets/src/main.ts
 create mode 100755 scripts/vq01-web-proof.sh

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index 1532547c95..29a79f11e6 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -53,6 +53,7 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 ### Phase 3 — Qualify the visible result
 
 - [ ] The unchanged web fixture renders each codec correctly, with named adapter and no loader/GPU diagnostics. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --url ${VQ_URL:?} --browser-recipe webgpu`.
+  Runner: `sh scripts/vq01-web-proof.sh <dir>` generates the authored GLBs/PNG, cooks the fixture for web and serves it on `127.0.0.1:5193` for that command. Unrun here: this lane has no browser.
 - [ ] The packaged Android V8 fixture decodes the admitted codecs on an emulator; unsupported codecs remain explicitly refused and the QuickJS decoder-free fixture still runs. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --target android --device ${VQ_ANDROID_DEVICE:?}`.
 
 ## Acceptance criteria
diff --git a/examples/abyss-framework/vq-assets/index.html b/examples/abyss-framework/vq-assets/index.html
new file mode 100644
index 0000000000..8660e2a08e
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/index.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>VQ-01 native asset fallback</title>
+    <style>
+      body {
+        margin: 0;
+        overflow: hidden;
+        background: #101827;
+      }
+      #app {
+        position: fixed;
+        inset: 0;
+      }
+      #app canvas {
+        display: block;
+        width: 100%;
+        height: 100%;
+      }
+    </style>
+  </head>
+  <body>
+    <main id="app"></main>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
\ No newline at end of file
diff --git a/examples/abyss-framework/vq-assets/src/main.ts b/examples/abyss-framework/vq-assets/src/main.ts
new file mode 100644
index 0000000000..dfdd4f793d
--- /dev/null
+++ b/examples/abyss-framework/vq-assets/src/main.ts
@@ -0,0 +1,8 @@
+import game from "./game.js";
+
+const app = document.querySelector<HTMLElement>("#app");
+if (app === null) throw new Error("Missing #app element.");
+void game.start().then(() => {
+  const canvas = game.ctx?.renderer.domElement;
+  if (canvas !== undefined) app.prepend(canvas);
+});
diff --git a/scripts/vq01-web-proof.sh b/scripts/vq01-web-proof.sh
new file mode 100755
index 0000000000..2fe5c62b22
--- /dev/null
+++ b/scripts/vq01-web-proof.sh
@@ -0,0 +1,34 @@
+#!/bin/sh
+# PRD-VQ-01 Phase 3, web box: cook the unchanged examples/abyss-framework/vq-assets fixture for the
+# web target, then run the shared scenario against it in a WebGPU browser.
+#
+#   sh scripts/vq01-web-proof.sh <artifact-dir>
+#
+# The web build and its preview server are started here; the browser run is the runner's job and
+# is the one step whose result this script cannot report for you.
+set -eu
+
+artifacts=${1:?usage: sh scripts/vq01-web-proof.sh <artifact-dir>}
+root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+cd "$root"
+
+# The authored sources the cook reads: real Meshopt and Draco GLBs plus the PNG it transcodes to
+# KTX2. The native verifier generates them through the same function, so both targets cook the
+# same inputs instead of two sets that can drift.
+node --import tsx -e '
+const { generateNativeAssetFixture } = await import("./examples/abyss-framework/vq-assets/generate.ts");
+await generateNativeAssetFixture("examples/abyss-framework/vq-assets/.generated/assets");
+'
+
+# The web target build: cooks .generated/assets into .generated/public and publishes dist/.
+(cd examples/abyss-framework/vq-assets && node "$root/packages/create-threenative/dist/threenative.js" build)
+
+# `pnpm --dir` runs the vite that examples/abyss-framework already installs, with the fixture as
+# its root; the runner owns the server lifecycle and probes 5193 for readiness.
+node packages/playtest/dist/runner/cli.js \
+  examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json \
+  --url http://127.0.0.1:5193/ \
+  --server-command 'pnpm --dir examples/abyss-framework exec vite preview vq-assets --host 127.0.0.1 --port 5193 --strictPort' \
+  --browser-recipe webgpu \
+  --headed \
+  --artifacts "$artifacts"
\ No newline at end of file

From c9d33523d79f756f34deac0e8aa4057995febd07 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:12:30 -0700
Subject: [PATCH 14/36] test(vq01): web codec proof passes on WebGPU; the
 fixture page links an empty icon

Without an icon link the browser requests /favicon.ico, which 404s and
fails noConsoleErrors. Phase 3 box 1 ticked with the run.
---
 docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md | 2 +-
 examples/abyss-framework/vq-assets/index.html           | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index 29a79f11e6..9f5e212acf 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -52,7 +52,7 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 
 ### Phase 3 — Qualify the visible result
 
-- [ ] The unchanged web fixture renders each codec correctly, with named adapter and no loader/GPU diagnostics. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --url ${VQ_URL:?} --browser-recipe webgpu`.
+- [x] The unchanged web fixture renders each codec correctly, with named adapter and no loader/GPU diagnostics. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --url ${VQ_URL:?} --browser-recipe webgpu`. **Result 2026-10-03:** `sh scripts/vq01-web-proof.sh` exit 0 on nvidia/turing WebGPU (headed, private Xvfb): 8/8 assertions incl. `diagnostics` (no console/network/runtime errors), loaded and textured models, decoded vertices, advancing frames and pose; the after-frame shows the Meshopt cube, Draco torus and KTX2 panel each with its authored checker. The first run failed `diagnostics` on one 404 — the new fixture page linked no icon, so the browser fetched `/favicon.ico`; fixed with an empty data-URI icon.
   Runner: `sh scripts/vq01-web-proof.sh <dir>` generates the authored GLBs/PNG, cooks the fixture for web and serves it on `127.0.0.1:5193` for that command. Unrun here: this lane has no browser.
 - [ ] The packaged Android V8 fixture decodes the admitted codecs on an emulator; unsupported codecs remain explicitly refused and the QuickJS decoder-free fixture still runs. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --target android --device ${VQ_ANDROID_DEVICE:?}`.
 
diff --git a/examples/abyss-framework/vq-assets/index.html b/examples/abyss-framework/vq-assets/index.html
index 8660e2a08e..d05ad3cc29 100644
--- a/examples/abyss-framework/vq-assets/index.html
+++ b/examples/abyss-framework/vq-assets/index.html
@@ -4,6 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>VQ-01 native asset fallback</title>
+    <link rel="icon" href="data:," />
     <style>
       body {
         margin: 0;

From 8b4594167796f530560b756a639fa7a3d2681ad0 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:13:24 -0700
Subject: [PATCH 15/36] chore(lint): ignore the VQ-01 fixture's generated cook
 output

The web proof writes .generated/; biome reads only the root .gitignore,
so the nested ignore did not keep it out of the formatter.
---
 biome.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/biome.json b/biome.json
index f13b6b48f4..ca9e110f9b 100644
--- a/biome.json
+++ b/biome.json
@@ -39,6 +39,7 @@
       "examples/abyss-vanilla/vite.config.js",
       "examples/auto-lod/public/**",
       "examples/abyss-framework/public/**",
+      "examples/abyss-framework/vq-assets/.generated/**",
       "examples/csg-doorway/public/**",
       "docs/benchmark/sweeps/**",
       "docs/benchmark/rounds/**",

From bd6e40f4be6e37f3e1a19b327ebbb037e0158fc5 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:14:58 -0700
Subject: [PATCH 16/36] =?UTF-8?q?docs(PRD-485):=20reopen=20the=20WebP=20bo?=
 =?UTF-8?q?x=20=E2=80=94=20the=20not-smaller=20guard=20keeps=20WebP=20on?=
 =?UTF-8?q?=20lumen-hall?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 8a1839dcfa..4c76dae60d 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -48,7 +48,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 #### Phase 1: Embedded WebP cooks
 **Status:** NOT STARTED
 **Files:** `packages/assets/src/passes/decode-image.ts`, `packages/assets/src/passes/model-textures.ts`; `packages/assets/__tests__/model-texture-pass.spec.ts`
-- [x] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`. **Result 2026-10-03 (`5e5ec9829`):** red `TN_ASSETS_TEXTURE_CONTAINER … is not a PNG or JPEG` before; green 3/3 after (KTX2 mip 0 transcodes back to the source within 1, decoder-free capped PNG, unknown container still throws); file 26/26, `packages/assets` 474 passed.
+- [ ] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`. **Result 2026-10-03 (`5e5ec9829`):** red `TN_ASSETS_TEXTURE_CONTAINER … is not a PNG or JPEG` before; green 3/3 after (KTX2 mip 0 transcodes back to the source within 1, decoder-free capped PNG, unknown container still throws); file 26/26, `packages/assets` 474 passed. **Reopened 2026-10-03:** on `lumen-hall` the cook decodes the WebP but the `not-smaller` guard keeps the original (3× per prop at 1024²), so `lady.glb`/`sanctuary.glb` still require `EXT_texture_webp`.
   Implementation: `sharp` decodes WebP in `decode-image.ts` — the first rung of the decision above, already declared at `packages/assets/package.json:57`, so no dependency is added and no new binary is installed for a game (every template already carries `@gltf-transform/cli`, which drags the same native package). It loads in the pass's worker thread and stays external in `dist`. `compressEmbeddedTextures` disposes `EXT_texture_webp` once no image is left in it, because the glTF writer emits every attached extension. The rule that `decode-image.ts` "must never grow a native dependency" is changed here: this is a Node-only build-time package, and `sharp` is the only native thing in it. Spec: the `embedded EXT_texture_webp` block of `model-texture-pass.spec.ts`, with the KTX2 leg decoding mip 0 through the shipped `basis_transcoder`.
 - [ ] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`.
 

From b0fb1053e95c6f284ba12948dde1f138d987cb40 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:38:12 -0700
Subject: [PATCH 17/36] PRD-VQ-01 Phase 3: qualify the packaged Android V8
 fixture on an emulator

The Android box now has a runner and a result. The box names a playtest
command, but that runner launches an already installed app and never builds
or installs one, so scripts/vq01-android-proof.sh adds the missing half the
web lane already had: it cooks and packages examples/abyss-framework/vq-assets
for Android V8 through the maintainer source build, installs that APK on one
named serial, and then runs the canonical proof command against it.

Result on the emulator (not a phone): serial emulator-5554, AVD
threenative_api35, API 35, x86_64, -gpu host. Exit 0, 8/8 assertions -
loadedModels 2, texturedMeshes 2, vertices >= 100, frames changed,
maxPoseDelta >= 0.05, startup entered 955.7 ms / ready 1055.1 ms with
compilation settled, and diagnostics with zero console and zero runtime
entries. logcat reports "JS engine created: V8"; the adapter is
native:vulkan/NVIDIA/NVIDIA GeForce RTX 2080/615.71.09 and the capture is
device.screenshot. The after-frame carries each specimen's authored checker.

Android's admitted codec set is still empty, and the box says so rather than
implying otherwise. resolveRuntimeAssetCapabilities reports
android:unresolved with an unknown engine, so the cook refuses each
compressed source by name - TN_ASSETS_COMPRESSION_SKIPPED for model and for
texture - and the APK carries the decoder-free rewrites (draco 4,956 ->
20,240 B, meshopt 4,096 -> 3,908 B, checker.png 187 B). What this proves is
that the packaged loader decodes what was packaged and that the refusal path
works on a device; no qualified mobile compressed decoder is claimed.

No executable code changes, so the QuickJS decoder-free fixture is untouched
and stays green on hosted run 36998104447.

Verified: sh scripts/vq01-android-proof.sh artifacts/vq01-android-verify
emulator-5554 exits 0 with the same 8/8; pnpm check:docs clean; the doc,
evidence, CI-structure, CI-needs and primary-docs suites pass 248/248.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  5 +-
 scripts/vq01-android-proof.sh                 | 55 +++++++++++++++++++
 2 files changed, 59 insertions(+), 1 deletion(-)
 create mode 100755 scripts/vq01-android-proof.sh

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index 9f5e212acf..99bfc1286d 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -54,7 +54,10 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 
 - [x] The unchanged web fixture renders each codec correctly, with named adapter and no loader/GPU diagnostics. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --url ${VQ_URL:?} --browser-recipe webgpu`. **Result 2026-10-03:** `sh scripts/vq01-web-proof.sh` exit 0 on nvidia/turing WebGPU (headed, private Xvfb): 8/8 assertions incl. `diagnostics` (no console/network/runtime errors), loaded and textured models, decoded vertices, advancing frames and pose; the after-frame shows the Meshopt cube, Draco torus and KTX2 panel each with its authored checker. The first run failed `diagnostics` on one 404 — the new fixture page linked no icon, so the browser fetched `/favicon.ico`; fixed with an empty data-URI icon.
   Runner: `sh scripts/vq01-web-proof.sh <dir>` generates the authored GLBs/PNG, cooks the fixture for web and serves it on `127.0.0.1:5193` for that command. Unrun here: this lane has no browser.
-- [ ] The packaged Android V8 fixture decodes the admitted codecs on an emulator; unsupported codecs remain explicitly refused and the QuickJS decoder-free fixture still runs. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --target android --device ${VQ_ANDROID_DEVICE:?}`.
+- [x] The packaged Android V8 fixture decodes the admitted codecs on an emulator; unsupported codecs remain explicitly refused and the QuickJS decoder-free fixture still runs. proof: `node packages/playtest/dist/runner/cli.js examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json --target android --device ${VQ_ANDROID_DEVICE:?}`.
+  **Result 2026-10-03 at `8b4594167796f530560b756a639fa7a3d2681ad0`:** `sh scripts/vq01-android-proof.sh artifacts/vq01-android emulator-5554` exits 0 on the **emulator** `emulator-5554` (AVD `threenative_api35`, API 35, x86_64, `-gpu host`): 8/8 assertions — `resource.state.loadedModels` 2, `resource.state.texturedMeshes` 2, `resource.state.vertices` ≥ 100, `resource.state.frames` changed, `resource.state.maxPoseDelta` ≥ 0.05, `startup.enteredMs` 955.7, `startup.readyMs` 1055.1 (phase `ready`, compilation settled), `diagnostics` (0 console, 0 runtime). `JS engine created: V8` in logcat; adapter `native:vulkan/NVIDIA/NVIDIA GeForce RTX 2080/615.71.09`; capture `device.screenshot`; the after-frame shows the Meshopt-source cube, Draco-source torus and KTX2-source panel each carrying its authored checker. APK `com.threenative.vq01` 1.0.0 (56,079,594 B, sha256 `87b9c853b9c61ccbef2268dc4ac2e3552d2bd3c0b00321a2cc55db78d3420f13`), 4 native libraries 16 KB clean.
+  **What this does not claim:** Android's admitted codec set is still empty. `resolveRuntimeAssetCapabilities` reports `android:unresolved`/engine `unknown`, so the cook refuses each compressed source by name — `TN_ASSETS_COMPRESSION_SKIPPED model: 2 file(s) … no qualified meshopt decoder` and `… texture: 1 file(s) … no qualified KTX2 decoder` — and the APK carries the decoder-free rewrites (`draco.glb` 4,956 → 20,240 B, `meshopt.glb` 4,096 → 3,908 B, `checker.png` 187 B, shared images as `.none.png`). The packaged loader therefore decoded what was packaged, and the refusal path is what this proves; no qualified mobile compressed decoder is claimed. The QuickJS decoder-free fixture is unchanged by this box (no executable code changed) and stays green on hosted run 36998104447.
+  Runner: `sh scripts/vq01-android-proof.sh <artifact-dir> <serial>` generates the authored GLBs/PNG, cooks and packages the fixture for Android V8 with the maintainer source build (`--allow-source-build`, `-PthreenativeJsEngine=v8 -PthreenativeAbis=x86_64`), installs that APK on the named serial and runs the canonical proof command against it. The V8 dependency is `third_party/v8-android` — `node packages/runtime-native/scripts/download-deps.mjs --android` provisions it, and `build-android-v8.mjs --verify` re-checks its pinned recipe-6 receipt, ELF per-ABI machine and 16 KB LOAD alignment before Gradle reads it.
 
 ## Acceptance criteria
 
diff --git a/scripts/vq01-android-proof.sh b/scripts/vq01-android-proof.sh
new file mode 100755
index 0000000000..809756d02e
--- /dev/null
+++ b/scripts/vq01-android-proof.sh
@@ -0,0 +1,55 @@
+#!/bin/sh
+# PRD-VQ-01 Phase 3, Android box: cook the unchanged examples/abyss-framework/vq-assets fixture for
+# the Android V8 target, install that APK on one named emulator, and run the shared scenario.
+#
+#   sh scripts/vq01-android-proof.sh <artifact-dir> <serial>
+#
+# The V8 engine is the Android default and needs `third_party/v8-android`, which
+# `node packages/runtime-native/scripts/download-deps.mjs --android` provisions with a build
+# receipt. The playtest runner launches an installed app; it never builds or installs one, so both
+# steps are here. Everything it writes is untracked build output.
+set -eu
+
+artifacts=${1:?usage: sh scripts/vq01-android-proof.sh <artifact-dir> <serial>}
+serial=${2:?usage: sh scripts/vq01-android-proof.sh <artifact-dir> <serial>}
+root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+cd "$root"
+
+# adb and the SDK are usually installed but off PATH; Gradle and Kotlin want JDK 17, and the
+# Android slice is one ABI so the emulator's x86_64 runtime is the only one this build needs.
+: "${ANDROID_HOME:=$HOME/Android/Sdk}"
+: "${JAVA_HOME:=/usr/lib/jvm/java-17-openjdk}"
+PATH=$JAVA_HOME/bin:$ANDROID_HOME/platform-tools:$PATH
+export PATH JAVA_HOME ANDROID_HOME ANDROID_SDK_ROOT=${ANDROID_SDK_ROOT:-$ANDROID_HOME}
+adb -s "$serial" get-state >/dev/null
+
+# The authored sources the cook reads, through the same generator the web and desktop lanes use.
+node --import tsx -e '
+const { generateNativeAssetFixture } = await import("./examples/abyss-framework/vq-assets/generate.ts");
+await generateNativeAssetFixture("examples/abyss-framework/vq-assets/.generated/assets");
+'
+
+# The maintainer source build. `resolveRuntimeAssetCapabilities` reports `android:unresolved`
+# (engine unknown), so this cook is the decoder-free one: the log names meshopt and KTX2 as
+# unqualified for the target and ships normalized GLB/PNG instead.
+(
+  cd examples/abyss-framework/vq-assets
+  THREENATIVE_RUNTIME_SOURCE="$root/packages/runtime-native" \
+  THREENATIVE_GRADLE_ARGS="-PthreenativeJsEngine=v8 -PthreenativeAbis=x86_64" \
+    node "$root/packages/create-threenative/dist/threenative.js" build --target android --allow-source-build
+)
+
+apk=examples/abyss-framework/vq-assets/dist-native/vq-native-assets.apk
+adb -s "$serial" install -r --no-streaming "$apk"
+
+node packages/playtest/dist/runner/cli.js \
+  examples/abyss-framework/playtests/vq-native-asset-capabilities.playtest.json \
+  --target android \
+  --device "$serial" \
+  --package com.threenative.vq01 \
+  --activity com.threenative.runtime.MystralActivity \
+  --adb "$ANDROID_HOME/platform-tools/adb" \
+  --artifact "$apk" \
+  --build-report "$apk.build-report.json" \
+  --timeout 120000 \
+  --artifacts "$artifacts"
\ No newline at end of file

From 75876bd57e4cc9631b33980aaf4ad1cf82442273 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:40:29 -0700
Subject: [PATCH 18/36] docs(PRD-VQ-01): AC-1 ticked on the web and Android
 runs; AC-2 lifecycle scenario still owed

---
 docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index 99bfc1286d..a2067cea01 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -61,8 +61,8 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 
 ## Acceptance criteria
 
-- [ ] All admitted codecs are demonstrated through the packaged loader, not merely through WASM availability; all refused combinations retain actionable build errors. proof: the completed Phase 3 scenario outputs, with the named fixture, package/cohort and adapter recorded inline here.
-- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario.
+- [x] All admitted codecs are demonstrated through the packaged loader, not merely through WASM availability; all refused combinations retain actionable build errors. proof: the completed Phase 3 scenario outputs, with the named fixture, package/cohort and adapter recorded inline here. **Result 2026-10-03:** fixture `examples/abyss-framework/vq-assets` (Meshopt cube, Draco torus, PNG→KTX2 panel). Web: `sh scripts/vq01-web-proof.sh`, nvidia/turing WebGPU, all three decoded through the packaged loader, 8/8 (`c9d33523d`). Android V8 (emulator-5554, API 35 x86_64, APK `com.threenative.vq01` sha256 `87b9c853…`, `JS engine created: V8`): 8/8 decoder-free, every compressed codec refused by name at cook (`TN_ASSETS_COMPRESSION_SKIPPED`), `b0fb1053e`. Authored-KTX2 refusal preserving the previous package: hosted run 36998104447.
+- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario. **Open 2026-10-03:** the spec passes (19/19), but no Phase 3 scenario repeats lifecycle transitions yet; the web/Android runs load once.
 
 ## Performance and promotion
 

From ca1bd9c8efba5a305729e1f9048c8e7ef2bf06c3 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:47:43 -0700
Subject: [PATCH 19/36] test(vq01): the lifecycle scenario that leaves and
 re-enters the asset scene

AC-2 owed a Phase 3 scenario that repeats the transition: the fixture now counts its own
enters and, after a 30-frame settle window, leaves through the engine's scene-change API
(ctx.goto) for an empty scene that returns one frame later, four enters in all. Each enter
re-derives the renderer's live GPU tally (ctx.renderer.info.memory.geometries/textures) and
publishes it beside the growth against the first enter's baseline, so a resource the exit
path forgets to dispose shows up as growth instead of as a missing number.

examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json gates on
state.settled 2 -> 3 -> 4 and then asserts entries 4, loadedModels/texturedMeshes back to 2/2
and geometryGrowth/textureGrowth 0, on web and Android like the single-load scenario.
scripts/vq01-lifecycle-proof.sh <artifact-dir> web|android <serial> is that scenario behind
the same cook as the two existing VQ-01 proof scripts.

Unrun: no browser or device run of the new scenario here. Validated through the repository's
loadPlaytestScenario, tsc on the fixture, pnpm lint, pnpm check:docs and the six doc-contract
specs; the AC-2 spec still passes 19/19.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  2 +
 .../vq-native-asset-lifecycle.playtest.json   | 95 +++++++++++++++++++
 .../abyss-framework/vq-assets/src/game.ts     | 85 ++++++++++++++++-
 scripts/vq01-lifecycle-proof.sh               | 68 +++++++++++++
 4 files changed, 247 insertions(+), 3 deletions(-)
 create mode 100644 examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
 create mode 100755 scripts/vq01-lifecycle-proof.sh

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index a2067cea01..cce6fe035e 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -63,6 +63,8 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 
 - [x] All admitted codecs are demonstrated through the packaged loader, not merely through WASM availability; all refused combinations retain actionable build errors. proof: the completed Phase 3 scenario outputs, with the named fixture, package/cohort and adapter recorded inline here. **Result 2026-10-03:** fixture `examples/abyss-framework/vq-assets` (Meshopt cube, Draco torus, PNG→KTX2 panel). Web: `sh scripts/vq01-web-proof.sh`, nvidia/turing WebGPU, all three decoded through the packaged loader, 8/8 (`c9d33523d`). Android V8 (emulator-5554, API 35 x86_64, APK `com.threenative.vq01` sha256 `87b9c853…`, `JS engine created: V8`): 8/8 decoder-free, every compressed codec refused by name at cook (`TN_ASSETS_COMPRESSION_SKIPPED`), `b0fb1053e`. Authored-KTX2 refusal preserving the previous package: hosted run 36998104447.
 - [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario. **Open 2026-10-03:** the spec passes (19/19), but no Phase 3 scenario repeats lifecycle transitions yet; the web/Android runs load once.
+  Scenario added, unrun 2026-10-03: `examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json` gates on `state.settled` 2 → 3 → 4 and then asserts `entries` 4, `loadedModels`/`texturedMeshes` back to 2/2 and `geometryGrowth`/`textureGrowth` 0 against each enter's own live `renderer.info.memory` tally; it loads through `loadPlaytestScenario` but no browser or device run has executed it here, so this box stays open.
+  Runner: `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web` and `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>` generate the authored GLBs/PNG, cook and serve or package the same fixture, then run that scenario instead of the single-load one. The fixture decides when to leave and re-enter (`ctx.goto("void")` after a 30-frame settle window, four enters in all), so the run needs no extra step.
 
 ## Performance and promotion
 
diff --git a/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json b/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
new file mode 100644
index 0000000000..c3363b7dc5
--- /dev/null
+++ b/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
@@ -0,0 +1,95 @@
+{
+  "schemaVersion": 1,
+  "name": "vq01-native-asset-lifecycle",
+  "target": "desktop",
+  "viewport": {
+    "width": 960,
+    "height": 640
+  },
+  "warmupFrames": 30,
+  "steps": [
+    {
+      "waitForResource": {
+        "id": "state",
+        "path": "settled",
+        "equals": 2
+      },
+      "timeoutMs": 120000
+    },
+    {
+      "waitForResource": {
+        "id": "state",
+        "path": "settled",
+        "equals": 3
+      },
+      "timeoutMs": 120000
+    },
+    {
+      "waitForResource": {
+        "id": "state",
+        "path": "settled",
+        "equals": 4
+      },
+      "timeoutMs": 120000
+    }
+  ],
+  "artifacts": {
+    "screenshots": true,
+    "console": true
+  },
+  "assert": {
+    "resources": [
+      {
+        "id": "state",
+        "path": "entries",
+        "equals": 4,
+        "allowTrivial": "The first load publishes entries 1; only three further enters of the same scene publish 4."
+      },
+      {
+        "id": "state",
+        "path": "loadedModels",
+        "equals": 2,
+        "allowTrivial": "Both real normalized GLBs reload and finish before every observation, including the fourth enter's."
+      },
+      {
+        "id": "state",
+        "path": "texturedMeshes",
+        "equals": 2,
+        "allowTrivial": "A texture image on each reloaded GLB is counted before the observation."
+      },
+      {
+        "id": "state",
+        "path": "ownedGeometries",
+        "gte": 1,
+        "allowTrivial": "The renderer's live geometry tally is only published once a settle window has uploaded the stage."
+      },
+      {
+        "id": "state",
+        "path": "geometryGrowth",
+        "equals": 0,
+        "allowTrivial": "The exit path's disposal is exactly what makes the tally return to the first enter's baseline; the baseline is 0 growth by construction and only a leak can move it."
+      },
+      {
+        "id": "state",
+        "path": "ownedTextures",
+        "gte": 1,
+        "allowTrivial": "The renderer's live texture tally is only published once a settle window has uploaded the KTX2 and panel textures."
+      },
+      {
+        "id": "state",
+        "path": "textureGrowth",
+        "equals": 0,
+        "allowTrivial": "The exit path's disposal is exactly what makes the tally return to the first enter's baseline; the baseline is 0 growth by construction and only a leak can move it."
+      },
+      {
+        "id": "state",
+        "path": "frames",
+        "changed": true
+      }
+    ],
+    "startup": {
+      "maxEnteredMs": 120000,
+      "maxReadyMs": 120000
+    }
+  }
+}
diff --git a/examples/abyss-framework/vq-assets/src/game.ts b/examples/abyss-framework/vq-assets/src/game.ts
index dc698c9434..f88ff52ab2 100644
--- a/examples/abyss-framework/vq-assets/src/game.ts
+++ b/examples/abyss-framework/vq-assets/src/game.ts
@@ -18,9 +18,41 @@ type State = {
   vertices: number;
   frames: number;
   maxPoseDelta: number;
+  entries: number;
+  settled: number;
+  ownedGeometries?: number;
+  ownedTextures?: number;
+  geometryGrowth?: number;
+  textureGrowth?: number;
 };
 type Model = { scene: Group; animations: AnimationClip[] };
+type Owned = { geometries: number; textures: number };
 const names = ["meshopt", "draco"] as const;
+/** Frames an enter is given to upload its geometry and textures before it is measured or left. */
+const SETTLE_FRAMES = 30;
+/** One first load plus three leave/re-enter cycles. */
+const ENTERS = 4;
+
+// The lifetime ledger, at module scope because only a value that outlives the scene can count its
+// own re-entries: `ctx.goto()` keeps the published state, and every field below is re-derived on
+// each enter from the renderer's live tally.
+let enters = 0;
+let settled = 0;
+let baseline: Owned | undefined;
+const growth: Owned = { geometries: 0, textures: 0 };
+
+/** The renderer's own GPU tally, or undefined when this backend keeps none — never a fake zero. */
+function ownedResources(ctx: ICtx<State>): Owned | undefined {
+  try {
+    const memory = (ctx.renderer.info as { memory?: Partial<Owned> }).memory;
+    const { geometries, textures } = memory ?? {};
+    return typeof geometries === "number" && typeof textures === "number"
+      ? { geometries, textures }
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
 
 export class AssetScene extends Scene<State> {
   static override readonly initialState: State = {
@@ -29,6 +61,8 @@ export class AssetScene extends Scene<State> {
     vertices: 0,
     frames: 0,
     maxPoseDelta: 0,
+    entries: 0,
+    settled: 0,
   };
   #models: Model[] = [];
   #png: Texture | undefined;
@@ -43,6 +77,8 @@ export class AssetScene extends Scene<State> {
 
   override enter(ctx: ICtx<State>) {
     if (!this.#png) throw new Error("PNG did not load");
+    enters += 1;
+    const entry = enters;
     this.#owned = stage(ctx.scene, ctx.camera as PerspectiveCamera, this.#png);
     let texturedMeshes = 0;
     let vertices = 0;
@@ -70,9 +106,10 @@ export class AssetScene extends Scene<State> {
       rotations.push(node.quaternion.clone());
       return node;
     });
-    ctx.state.set({ loadedModels: this.#models.length, texturedMeshes, vertices });
+    ctx.state.set({ loadedModels: this.#models.length, texturedMeshes, vertices, entries: entry });
     let frames = 0;
     let maxPoseDelta = 0;
+    let left = false;
     return (_ctx: ICtx<State>, dt: number) => {
       for (const player of this.#players) player.update(dt);
       for (const [index, node] of animated.entries())
@@ -80,7 +117,33 @@ export class AssetScene extends Scene<State> {
           maxPoseDelta,
           node.quaternion.angleTo(rotations[index] ?? new Quaternion()),
         );
-      ctx.state.set({ frames: ++frames, maxPoseDelta });
+      frames += 1;
+      const owned = frames < SETTLE_FRAMES ? undefined : ownedResources(ctx);
+      if (owned !== undefined) {
+        baseline ??= owned;
+        growth.geometries = Math.max(growth.geometries, owned.geometries - baseline.geometries);
+        growth.textures = Math.max(growth.textures, owned.textures - baseline.textures);
+        settled = Math.max(settled, entry);
+      }
+      ctx.state.set({
+        frames,
+        maxPoseDelta,
+        entries: entry,
+        settled,
+        ...(owned === undefined
+          ? {}
+          : {
+              ownedGeometries: owned.geometries,
+              ownedTextures: owned.textures,
+              geometryGrowth: growth.geometries,
+              textureGrowth: growth.textures,
+            }),
+      });
+      // Leave once this enter has settled, so the next observation is a re-entry's, not this one's.
+      if (frames >= SETTLE_FRAMES && !left && entry < ENTERS) {
+        left = true;
+        void ctx.goto("void");
+      }
     };
   }
 
@@ -102,8 +165,24 @@ export class AssetScene extends Scene<State> {
   }
 }
 
+/** The empty scene the asset scene leaves for: no objects, no assets, one frame of nothing. */
+class VoidScene extends Scene<State> {
+  static override readonly initialState: State = AssetScene.initialState;
+  #returned = false;
+
+  override enter(ctx: ICtx<State>): void {
+    ctx.state.set({ entries: enters, settled });
+  }
+
+  override update(ctx: ICtx<State>): void {
+    if (this.#returned) return;
+    this.#returned = true;
+    void ctx.goto("assets");
+  }
+}
+
 export default defineGame<State>({
-  scenes: { assets: AssetScene },
+  scenes: { assets: AssetScene, void: VoidScene },
   start: "assets",
   plugins: [playtest()],
   display: config.display,
diff --git a/scripts/vq01-lifecycle-proof.sh b/scripts/vq01-lifecycle-proof.sh
new file mode 100755
index 0000000000..dcb05a8b01
--- /dev/null
+++ b/scripts/vq01-lifecycle-proof.sh
@@ -0,0 +1,68 @@
+#!/bin/sh
+# PRD-VQ-01 AC-2 lifecycle box: cook the unchanged examples/abyss-framework/vq-assets fixture for one
+# target, then run the leave/re-enter scenario against it. Identical to vq01-web-proof.sh and
+# vq01-android-proof.sh except for the scenario both of those name; the fixture decides when to leave
+# and re-enter, so there is no extra step to drive here.
+#
+#   sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web
+#   sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>
+set -eu
+
+artifacts=${1:?usage: sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web | android <serial>}
+target=${2:?usage: sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web | android <serial>}
+root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+cd "$root"
+
+scenario=examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
+
+# The authored sources the cook reads, through the same generator every VQ-01 lane uses.
+node --import tsx -e '
+const { generateNativeAssetFixture } = await import("./examples/abyss-framework/vq-assets/generate.ts");
+await generateNativeAssetFixture("examples/abyss-framework/vq-assets/.generated/assets");
+'
+
+case "$target" in
+web)
+  # The web target build: cooks .generated/assets into .generated/public and publishes dist/.
+  (cd examples/abyss-framework/vq-assets && node "$root/packages/create-threenative/dist/threenative.js" build)
+  # The runner owns the preview server lifecycle and probes 5193 for readiness.
+  node packages/playtest/dist/runner/cli.js "$scenario" \
+    --url http://127.0.0.1:5193/ \
+    --server-command 'pnpm --dir examples/abyss-framework exec vite preview vq-assets --host 127.0.0.1 --port 5193 --strictPort' \
+    --browser-recipe webgpu \
+    --headed \
+    --artifacts "$artifacts"
+  ;;
+android)
+  serial=${3:?usage: sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>}
+  # adb and the SDK are usually installed but off PATH; Gradle and Kotlin want JDK 17, and the
+  # Android slice is one ABI so the emulator's x86_64 runtime is the only one this build needs.
+  : "${ANDROID_HOME:=$HOME/Android/Sdk}"
+  : "${JAVA_HOME:=/usr/lib/jvm/java-17-openjdk}"
+  PATH=$JAVA_HOME/bin:$ANDROID_HOME/platform-tools:$PATH
+  export PATH JAVA_HOME ANDROID_HOME ANDROID_SDK_ROOT=${ANDROID_SDK_ROOT:-$ANDROID_HOME}
+  adb -s "$serial" get-state >/dev/null
+  (
+    cd examples/abyss-framework/vq-assets
+    THREENATIVE_RUNTIME_SOURCE="$root/packages/runtime-native" \
+    THREENATIVE_GRADLE_ARGS="-PthreenativeJsEngine=v8 -PthreenativeAbis=x86_64" \
+      node "$root/packages/create-threenative/dist/threenative.js" build --target android --allow-source-build
+  )
+  apk=examples/abyss-framework/vq-assets/dist-native/vq-native-assets.apk
+  adb -s "$serial" install -r --no-streaming "$apk"
+  node packages/playtest/dist/runner/cli.js "$scenario" \
+    --target android \
+    --device "$serial" \
+    --package com.threenative.vq01 \
+    --activity com.threenative.runtime.MystralActivity \
+    --adb "$ANDROID_HOME/platform-tools/adb" \
+    --artifact "$apk" \
+    --build-report "$apk.build-report.json" \
+    --timeout 120000 \
+    --artifacts "$artifacts"
+  ;;
+*)
+  echo "unknown target '$target'; expected web or android" >&2
+  exit 2
+  ;;
+esac
\ No newline at end of file

From c284f2a70b2265383469cbb2a88b57306264bb68 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 16:48:38 -0700
Subject: [PATCH 20/36] fix(assets): never retain a WebP through the
 not-smaller guard (PRD-485 phase 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

lumen-hall's lady.glb and sanctuary.glb cook with `compression skipped:
not-smaller` three times each, so the shipped GLBs kept `images:
image/webp` and required `EXT_texture_webp` — a container the native
desktop/Android/iOS decoder-free paths cannot read.

Retention is now conditioned on the container as well as on size: only
`UNIVERSAL_IMAGE_CONTAINERS` (PNG, JPEG) may keep authored bytes, so a
WebP always converts — to KTX2 on a decoding target even when that is
larger, or to the capped PNG on the decoder-free path. `EXT_texture_webp`
then always leaves the output, and the size increase is reported by the
existing `bytes before -> after` row of the build report (+621% on
lady.glb), with no new marker. PNG/JPEG behaviour is unchanged.

`keepSmallerSource` moves from `true` to `"universal-containers"` in the
model pass's cache key and in the shared-image store settings: a warm cook
keyed on the old rule would otherwise keep shipping the WebP-requiring
models this replaces.

Verified: red (519 -> 519 bytes retained, extension still required) then
green in the `embedded EXT_texture_webp` block of
`packages/assets/__tests__/model-texture-pass.spec.ts`, whose new PNG leg
pins that a PNG whose KTX2 would be larger is still kept; file 28/28,
`packages/assets` 476 passed, `pnpm typecheck` and `pnpm lint` clean.
---
 ...high-quality-assets-go-through-the-cook.md |  4 +-
 .../__tests__/model-texture-pass.spec.ts      | 59 +++++++++++++++++++
 .../assets/__tests__/shared-images.spec.ts    |  7 ++-
 packages/assets/src/passes/model-textures.ts  | 44 +++++++++-----
 packages/assets/src/passes/model.ts           |  7 ++-
 5 files changed, 102 insertions(+), 19 deletions(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 4c76dae60d..6341c23779 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -48,9 +48,9 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 #### Phase 1: Embedded WebP cooks
 **Status:** NOT STARTED
 **Files:** `packages/assets/src/passes/decode-image.ts`, `packages/assets/src/passes/model-textures.ts`; `packages/assets/__tests__/model-texture-pass.spec.ts`
-- [ ] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`. **Result 2026-10-03 (`5e5ec9829`):** red `TN_ASSETS_TEXTURE_CONTAINER … is not a PNG or JPEG` before; green 3/3 after (KTX2 mip 0 transcodes back to the source within 1, decoder-free capped PNG, unknown container still throws); file 26/26, `packages/assets` 474 passed. **Reopened 2026-10-03:** on `lumen-hall` the cook decodes the WebP but the `not-smaller` guard keeps the original (3× per prop at 1024²), so `lady.glb`/`sanctuary.glb` still require `EXT_texture_webp`.
+- [x] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`. **Result 2026-10-03 (`5e5ec9829`):** red `TN_ASSETS_TEXTURE_CONTAINER … is not a PNG or JPEG` before; green 3/3 after (KTX2 mip 0 transcodes back to the source within 1, decoder-free capped PNG, unknown container still throws); file 26/26, `packages/assets` 474 passed. **Reopened 2026-10-03:** on `lumen-hall` the cook decodes the WebP but the `not-smaller` guard keeps the original (3× per prop at 1024²), so `lady.glb`/`sanctuary.glb` still require `EXT_texture_webp`. **Closed 2026-10-03:** retention is now conditioned on the container, not only on size — `UNIVERSAL_IMAGE_CONTAINERS` (PNG/JPEG) may keep authored bytes, WebP always converts to KTX2 (KTX2 target) or PNG (decoder-free), so `EXT_texture_webp` always leaves the output and the increase lands in the existing `bytes before -> after` row (+621% on `lady.glb`). Red: 519 -> 519 bytes retained with the extension still required; green: `image/ktx2` only, `extensionsRequired` `[EXT_meshopt_compression, KHR_mesh_quantization, KHR_texture_basisu]`, both GLBs re-verified in `lumen-hall`. `keepSmallerSource` moved from `true` to `"universal-containers"` in the model pass's cache key so a warm cook cannot keep shipping the old output. File 28/28, `packages/assets` 476 passed, `pnpm typecheck` and `pnpm lint` clean.
   Implementation: `sharp` decodes WebP in `decode-image.ts` — the first rung of the decision above, already declared at `packages/assets/package.json:57`, so no dependency is added and no new binary is installed for a game (every template already carries `@gltf-transform/cli`, which drags the same native package). It loads in the pass's worker thread and stays external in `dist`. `compressEmbeddedTextures` disposes `EXT_texture_webp` once no image is left in it, because the glTF writer emits every attached extension. The rule that `decode-image.ts` "must never grow a native dependency" is changed here: this is a Node-only build-time package, and `sharp` is the only native thing in it. Spec: the `embedded EXT_texture_webp` block of `model-texture-pass.spec.ts`, with the KTX2 leg decoding mip 0 through the shipped `basis_transcoder`.
-- [ ] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`.
+- [ ] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`. Partly done 2026-10-03: `npx threenative build --target web` exits 0 with the installed `@threenative/assets` tarball and both WebP props cook (`lady.df65302d.glb` 1562 KB, `sanctuary.9353c235.glb` 2546 KB, `image/ktx2` only). The scenario itself was not run in this lane, so the box stays open.
 
 #### Phase 2: The Fab tree cooks by default
 **Status:** NOT STARTED
diff --git a/packages/assets/__tests__/model-texture-pass.spec.ts b/packages/assets/__tests__/model-texture-pass.spec.ts
index db27849d8f..3a3ee87cf9 100644
--- a/packages/assets/__tests__/model-texture-pass.spec.ts
+++ b/packages/assets/__tests__/model-texture-pass.spec.ts
@@ -465,6 +465,65 @@ describe("embedded EXT_texture_webp", () => {
     expectColours(PNG.sync.read(image).data, 4, 1);
   });
 
+  it("should convert a WebP even when its KTX2 is larger", async () => {
+    // The real-game case: a flat-colour 256x256 WebP costs far fewer bytes than the KTX2
+    // container around it, so the keep-smaller-source guard retained the original and the
+    // cooked model still required `EXT_texture_webp` — which the decoder-free native targets
+    // cannot read. A container only an extension-reading loader understands is never kept.
+    const authored = (await readOutput(await fixtureWithWebp(256)))
+      .getRoot()
+      .listTextures()
+      .find((texture) => texture.getName() === "checker")
+      ?.getImage()?.byteLength;
+
+    const { buffer, entry } = await compiled(await fixtureWithWebp(256));
+    const summary = entry.embeddedTextures as
+      | {
+          readonly bytesAfter: number;
+          readonly bytesBefore: number;
+          readonly formats: Readonly<Record<string, string>>;
+          readonly skippedCompression: Readonly<Record<string, string>>;
+        }
+      | undefined;
+
+    // Proof the not-smaller guard really held here: the cook grew the payload, and the row it
+    // grew is the one the size report already prints.
+    expect(summary?.bytesAfter ?? 0).toBeGreaterThan(summary?.bytesBefore ?? 0);
+    expect(summary?.skippedCompression?.checker).toBeUndefined();
+    expect(summary?.formats.checker).toBe("etc1s");
+
+    const json = JSON.parse(buffer.subarray(20, 20 + buffer.readUInt32LE(12)).toString("utf8")) as {
+      extensionsRequired?: string[];
+      extensionsUsed?: string[];
+      images: { mimeType?: string }[];
+    };
+    expect(json.images.some((image) => image.mimeType === "image/webp")).toBe(false);
+    expect(json.extensionsUsed ?? []).not.toContain("EXT_texture_webp");
+    expect(json.extensionsRequired ?? []).not.toContain("EXT_texture_webp");
+    expect(json.extensionsRequired ?? []).toContain("KHR_texture_basisu");
+    // The image itself, not just the extension name, got bigger: that is the cost this test
+    // buys, and it is the number a reader of the build report sees.
+    const cooked = (await readOutput(buffer))
+      .getRoot()
+      .listTextures()
+      .find((texture) => texture.getName() === "checker");
+    expect(cooked?.getMimeType()).toBe("image/ktx2");
+    expect(cooked?.getImage()?.byteLength ?? 0).toBeGreaterThan(authored ?? 0);
+  });
+
+  it("should still keep a PNG whose KTX2 would be larger", async () => {
+    // The other half of the same rule, and the reason it is a container test rather than a size
+    // test: PNG and JPEG need no extension, so retaining them costs a reader nothing.
+    const { buffer, entry } = await compiled(await fixtureWithTextures({ width: 4 }));
+    const summary = entry.embeddedTextures as {
+      readonly skippedCompression: Readonly<Record<string, string>>;
+    };
+    expect(summary.skippedCompression.checker).toBe("not-smaller");
+    for (const texture of (await readOutput(buffer)).getRoot().listTextures()) {
+      expect(texture.getMimeType()).toBe("image/png");
+    }
+  });
+
   it("should still fail closed on a container that is not an image", async () => {
     const document = buildFixtureDocument();
     document
diff --git a/packages/assets/__tests__/shared-images.spec.ts b/packages/assets/__tests__/shared-images.spec.ts
index 0ad1f1ad55..ff65852103 100644
--- a/packages/assets/__tests__/shared-images.spec.ts
+++ b/packages/assets/__tests__/shared-images.spec.ts
@@ -214,7 +214,12 @@ describe("shared model images", () => {
         sharedImageKey(texture.getImage() ?? new Uint8Array(), {
           colorSpace: getTextureColorSpace(texture),
           slots: [...listTextureSlots(texture)].sort(),
-          textures: { keepSmallerSource: true, maxSize: null, overrides: [], quality: null },
+          textures: {
+            keepSmallerSource: "universal-containers",
+            maxSize: null,
+            overrides: [],
+            quality: null,
+          },
         }),
       );
     const store = createSharedImageStore();
diff --git a/packages/assets/src/passes/model-textures.ts b/packages/assets/src/passes/model-textures.ts
index bddab7cd02..c52e7b249c 100644
--- a/packages/assets/src/passes/model-textures.ts
+++ b/packages/assets/src/passes/model-textures.ts
@@ -104,6 +104,14 @@ const GPU_BYTES_PER_PIXEL: Readonly<Record<string, number>> = {
 /** Slots whose content is a tangent-space normal: data, and ETC1S destroys it. */
 const NORMAL_SLOTS: ReadonlySet<string> = new Set(["clearcoatNormalTexture", "normalTexture"]);
 
+/**
+ * Containers every target of this build decodes on its own, so keeping the authored bytes costs a
+ * reader nothing. `image/webp` is deliberately absent: it is only reachable through
+ * `EXT_texture_webp`, which a target without a WebP decoder cannot satisfy — retaining one would
+ * hand back a model the very requirement this stage removes.
+ */
+const UNIVERSAL_IMAGE_CONTAINERS: ReadonlySet<string> = new Set(["image/jpeg", "image/png"]);
+
 /** The five slots every glTF material declares directly; extension slots are covered by
  * the per-texture `slots` snapshot, which walks whatever parents actually reference it. */
 const CORE_SLOTS = [
@@ -482,23 +490,27 @@ export async function compressEmbeddedTextures(
     }
     if (decoderFree) {
       // No Basis transcoder on this target, so the cap is honoured by resampling and re-emitting
-      // a PNG. An image already within the cap keeps its authored bytes; the file is never
-      // rewritten and KHR_texture_basisu is never declared.
+      // a PNG. An image already within the cap keeps its authored bytes — unless its container is
+      // one only an extension-reading loader understands, where keeping them would ship the very
+      // requirement this path exists to remove. KHR_texture_basisu is never declared.
       const target = cappedSize(decoded.width, decoded.height, maxSize);
-      if (target.width === decoded.width && target.height === decoded.height) {
+      const downsampled = target.width !== decoded.width || target.height !== decoded.height;
+      if (!downsampled && UNIVERSAL_IMAGE_CONTAINERS.has(texture.getMimeType())) {
         bytesAfter += image.byteLength;
         gpuBytesAfter += gpuBytes(decoded.width, decoded.height, "none");
         formats[key] = "none";
         continue;
       }
-      const data = resampleRgba(
-        decoded.data,
-        decoded.width,
-        decoded.height,
-        target.width,
-        target.height,
-        getTextureColorSpace(texture) === "srgb",
-      );
+      const data = downsampled
+        ? resampleRgba(
+            decoded.data,
+            decoded.width,
+            decoded.height,
+            target.width,
+            target.height,
+            getTextureColorSpace(texture) === "srgb",
+          )
+        : decoded.data;
       const png = new PNG({ height: target.height, width: target.width });
       png.data = Buffer.from(data);
       const encoded = PNG.sync.write(png);
@@ -506,7 +518,7 @@ export async function compressEmbeddedTextures(
       bytesAfter += encoded.byteLength;
       gpuBytesAfter += gpuBytes(target.width, target.height, "none");
       formats[key] = "none";
-      resized += 1;
+      if (downsampled) resized += 1;
       continue;
     }
 
@@ -552,12 +564,16 @@ export async function compressEmbeddedTextures(
         : { isUASTC: false, qualityLevel: quality }),
     });
     // A tiny source can cost less than the KTX2 container alone. Keep its exact bytes when
-    // encoding cannot save download bytes; a named codec override still requests GPU compression.
+    // encoding cannot save download bytes *and* the authored container needs no extension to be
+    // read; a WebP costs a decoder-free target the whole model, which is never the smaller cost.
+    // A named codec override still requests GPU compression either way. The size increase is
+    // reported by the existing `bytes before -> after` row of the build report.
     if (
       encoded.byteLength >= image.byteLength &&
       target.width === decoded.width &&
       target.height === decoded.height &&
-      !explicit
+      !explicit &&
+      UNIVERSAL_IMAGE_CONTAINERS.has(texture.getMimeType())
     ) {
       bytesAfter += image.byteLength;
       gpuBytesAfter += gpuBytes(decoded.width, decoded.height, "none");
diff --git a/packages/assets/src/passes/model.ts b/packages/assets/src/passes/model.ts
index 12e3e5003e..d9ebd4fba4 100644
--- a/packages/assets/src/passes/model.ts
+++ b/packages/assets/src/passes/model.ts
@@ -819,7 +819,10 @@ export function modelPass(options: IModelPassOptions = {}): IAssetPass {
               decoderFree: options.textures?.decoderFree ?? false,
               encoder: KTX2_ENCODER_VERSION,
               maxSize: options.textures?.maxSize ?? null,
-              keepSmallerSource: true,
+              // Retention is now conditioned on the container, so it is spelled out rather than
+              // named by a boolean: a warm cache keyed on the old rule would keep shipping the
+              // WebP-requiring models this replaced.
+              keepSmallerSource: "universal-containers",
               overrides: options.textures?.overrides ?? [],
               quality: options.textures?.quality ?? null,
             },
@@ -1079,7 +1082,7 @@ function sharedSettings(
         : {
             decoderFree: textureOptions.decoderFree ?? false,
             encoder: KTX2_ENCODER_VERSION,
-            keepSmallerSource: true,
+            keepSmallerSource: "universal-containers",
             maxSize: textureOptions.maxSize ?? null,
             overrides: textureOptions.overrides ?? [],
             quality: textureOptions.quality ?? null,

From 7ed40dbe5fad46d7c6a48c44662a1d20b10b1258 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 17:07:26 -0700
Subject: [PATCH 21/36] fix(core): a cooked model survives being cloned
 (PRD-485)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

three clones through `new this.constructor().copy(source)`, so `ClusteredMesh`
died in its own constructor's table check before a game drew anything: the
default cook puts a cluster DAG in every model, and lumen-hall's authored
statues stood a second copy of one.

`clone()` now builds from the source's own arguments, and `copy()` completes
the job the three way: the baked table and the vertex attributes are shared —
one copy of the vertices on the GPU, since three keys attributes on the
attribute — while the cut is the copy's own, because the cut lives in the
geometry's index buffer and two meshes on one geometry would overwrite each
other's every frame. `ClusteredBatchRoot.clone()` keeps its batch, so a copied
root is still cut instead of freezing on the cut it was cloned with.

Red: 5 failing specs on `packages/core/__tests__/clustered*.spec.ts`, the
game's TypeError. Green: 49 in those four files, 2322 across packages/core,
plus typecheck, lint and build.
---
 .../core/__tests__/clustered-batch.spec.ts    | 18 ++++
 .../core/__tests__/clustered-mesh.spec.ts     | 79 ++++++++++++++++
 packages/core/src/clustered-batch.ts          | 13 +++
 packages/core/src/clustered-mesh.ts           | 89 +++++++++++++++----
 4 files changed, 181 insertions(+), 18 deletions(-)

diff --git a/packages/core/__tests__/clustered-batch.spec.ts b/packages/core/__tests__/clustered-batch.spec.ts
index ea35b8a52e..0901886385 100644
--- a/packages/core/__tests__/clustered-batch.spec.ts
+++ b/packages/core/__tests__/clustered-batch.spec.ts
@@ -502,4 +502,22 @@ describe("ClusteredBatch", () => {
       }).build({ parent: new Object3D() }),
     ).toThrow(/at least one placed copy/u);
   }, 180_000);
+
+  it("clones into a root that is still cut", () => {
+    // `new this.constructor()` left `batch` undefined, so a cloned root quietly stopped being cut
+    // and drew whatever its bands happened to hold. Detection is structural, so the engine could
+    // not even tell the copy apart from an ordinary object.
+    const parent = new Object3D();
+    const batch = spread();
+    const root = batch.build({ name: "boulders", parent });
+    camera.position.set(0, 0, 0);
+    const triangles = batch.update(camera, 1080);
+
+    const copy = root.clone() as unknown as { batch: ClusteredBatch };
+    expect(copy.batch).toBe(batch);
+    // Still found by the engine's walk, and still drawing: a copy whose `batch` was undefined
+    // returned nothing and was never cut again.
+    expect(updateClusteredMeshes(copy as unknown as Object3D, camera, 1080)).toBeGreaterThan(0);
+    expect(triangles).toBeGreaterThan(0);
+  }, 180_000);
 });
diff --git a/packages/core/__tests__/clustered-mesh.spec.ts b/packages/core/__tests__/clustered-mesh.spec.ts
index f5a9b23b12..ec2769e991 100644
--- a/packages/core/__tests__/clustered-mesh.spec.ts
+++ b/packages/core/__tests__/clustered-mesh.spec.ts
@@ -1,6 +1,7 @@
 import {
   BufferAttribute,
   BufferGeometry,
+  Group,
   MeshBasicMaterial,
   PerspectiveCamera,
   Vector3,
@@ -442,3 +443,81 @@ describe("ClusteredMesh", () => {
     ).toThrow(/needs a perspective camera/u);
   });
 });
+
+describe("ClusteredMesh cloning", () => {
+  const camera = new PerspectiveCamera(60, 16 / 9, 0.1, 1000);
+
+  /** This mesh's triangles, with the camera `z` units out from where it stands. */
+  function cutAt(mesh: ClusteredMesh, z: number): number {
+    camera.position.set(0, 0, z);
+    return mesh.update(camera, 1080);
+  }
+
+  // three clones through `new this.constructor().copy(source)`, so any game that stands a second
+  // copy of a cooked model where it wants a statue used to die in `assertTable` before it drew
+  // anything. Lumen-hall's authored statues did, from the first model the default cook produced.
+  it("clones into a mesh that draws the same thing", () => {
+    const mesh = new ClusteredMesh(geometry(), new MeshBasicMaterial(), table);
+    const triangles = cutAt(mesh, 6);
+    const clone = mesh.clone();
+
+    expect(clone.table).toBe(mesh.table);
+    // A copy starts at the authored detail, exactly as a fresh mesh does, and only gives it up
+    // once something cuts it.
+    expect(clone.drawnTriangles).toBe(body.indices.length / 3);
+    expect(cutAt(clone, 6)).toBe(triangles);
+    expect(clone.geometry.drawRange).toEqual(mesh.geometry.drawRange);
+    expect(clone.geometry.getIndex()?.array).not.toBe(mesh.geometry.getIndex()?.array);
+  });
+
+  it("clones inside a group, which is how a game places a second copy", () => {
+    const figure = new Group();
+    figure.add(new ClusteredMesh(geometry(), new MeshBasicMaterial(), table));
+    const clone = figure.clone(true);
+    const copied = clone.children[0] as ClusteredMesh;
+
+    expect(copied).toBeInstanceOf(ClusteredMesh);
+    expect(copied.table).toBe((figure.children[0] as ClusteredMesh).table);
+  });
+
+  it("keeps the vertices shared and the cut its own, so the two are placed independently", () => {
+    // Sharing the geometry wholesale would be cheaper still and wrong: the cut lives in the
+    // geometry's index buffer, so two meshes on one geometry would overwrite each other's index
+    // every frame and both would draw whichever one spoke last. Sharing the vertex buffers by
+    // reference keeps one copy of them on the GPU — three keys its attributes on the attribute —
+    // and still lets each mesh hold a cut of its own.
+    const mesh = new ClusteredMesh(geometry(), new MeshBasicMaterial(), table);
+    const beside = mesh.clone();
+
+    expect(beside.geometry).not.toBe(mesh.geometry);
+    expect(beside.geometry.attributes.position).toBe(mesh.geometry.attributes.position);
+
+    const near = cutAt(mesh, 6);
+    expect(cutAt(beside, 6)).toBe(near);
+
+    const across = mesh.clone();
+    across.position.set(0, 0, 400);
+    expect(cutAt(across, 6)).toBeLessThan(near);
+    // And cutting the far copy left the near one drawing what it was drawing.
+    expect(cutAt(mesh, 6)).toBe(near);
+  });
+
+  it("disposes without taking the source's shared data with it", () => {
+    // The rule, since sharing is the point: a clone shares the baked table and the vertex
+    // attributes, and the geometry that owns them disposes them for everyone — exactly as three's
+    // own `Mesh.copy` shares geometry and material. What a clone owns outright is its cut.
+    const mesh = new ClusteredMesh(geometry(), new MeshBasicMaterial(), table);
+    const clone = mesh.clone();
+    let sourceDisposed = false;
+    mesh.geometry.addEventListener("dispose", () => {
+      sourceDisposed = true;
+    });
+
+    clone.geometry.dispose();
+
+    expect(sourceDisposed).toBe(false);
+    expect(clone.geometry.attributes.position).toBe(mesh.geometry.attributes.position);
+    expect(mesh.table).toBe(table);
+    expect(mesh.drawnTriangles).toBe(body.indices.length / 3);
+  });
+});
diff --git a/packages/core/src/clustered-batch.ts b/packages/core/src/clustered-batch.ts
index 7bbe0644ca..2b4035b5fd 100644
--- a/packages/core/src/clustered-batch.ts
+++ b/packages/core/src/clustered-batch.ts
@@ -126,6 +126,19 @@ export class ClusteredBatchRoot extends Object3D {
   constructor(readonly batch: ClusteredBatch) {
     super();
   }
+
+  /**
+   * A copy that is still being cut.
+   *
+   * three builds one through `new this.constructor()`, which left the copy's `batch` undefined
+   * and quietly stopped cutting it — a frozen cut that still drew. Sharing the batch is what
+   * keeps a copy alive: the batch owns the bands and their index buffers, so the copy draws the
+   * same cut as the root it was copied from, which is the same thing `Mesh.copy` does with
+   * geometry and `VirtualGeometryPlugin` does with a baked table.
+   */
+  override clone(recursive = true): this {
+    return new ClusteredBatchRoot(this.batch).copy(this, recursive) as this;
+  }
 }
 
 function placementMatrix(placement: IClusteredPlacement): Matrix4 {
diff --git a/packages/core/src/clustered-mesh.ts b/packages/core/src/clustered-mesh.ts
index d9db2111f0..3dc79391b2 100644
--- a/packages/core/src/clustered-mesh.ts
+++ b/packages/core/src/clustered-mesh.ts
@@ -1,11 +1,4 @@
-import {
-  BufferAttribute,
-  type BufferGeometry,
-  type Camera,
-  type Material,
-  Mesh,
-  Vector3,
-} from "three";
+import { BufferAttribute, BufferGeometry, type Camera, type Material, Mesh, Vector3 } from "three";
 
 /**
  * A mesh that draws only the clusters this camera can resolve.
@@ -163,15 +156,15 @@ function finestIndexCount(table: IClusterTable): number {
 }
 
 export class ClusteredMesh extends Mesh {
-  /** The baked payload. Read-only at run time; the bake is the only thing that writes it. */
-  readonly table: IClusterTable;
+  /** The baked payload. The bake is the only thing that writes it; a copy takes the source's. */
+  table!: IClusterTable;
   /** Screen-space error budget in pixels. Writable — it is the game's call. */
   errorPixels: number;
   /** Camera movement, in the mesh's own units, below which the previous cut is kept. */
   recutDistance: number;
 
-  readonly #cut: Uint32Array;
-  readonly #selection: Uint32Array;
+  #cut!: Uint32Array;
+  #selection!: Uint32Array;
   readonly #cameraLocal = new Vector3();
   readonly #lastCut = new Vector3();
   #drawnClusters = 0;
@@ -188,11 +181,21 @@ export class ClusteredMesh extends Mesh {
   ) {
     super(geometry, surface);
     assertTable(table);
-    this.table = table;
     this.errorPixels = options.errorPixels ?? DEFAULT_ERROR_PIXELS;
+    this.recutDistance = options.recutDistance ?? radiusOf(table) * RECUT_FRACTION;
+    this.#load(table, geometry);
+    // Full detail until something cuts it. Virtual geometry ships on by default, so the mesh a
+    // game never touches has to draw exactly what an ordinary `Mesh` would have drawn — a class
+    // that starts invisible and waits to be updated would turn the default into a blank screen.
+    // `update` only ever takes detail away from here.
+    this.#compact(this.#finestCut());
+  }
+
+  /** Points this mesh at `table`, and installs its cut on the geometry it is going to draw. */
+  #load(table: IClusterTable, geometry: BufferGeometry): void {
+    this.table = table;
     this.#cut = new Uint32Array(finestIndexCount(table));
     this.#selection = new Uint32Array(table.ranges.length / 2);
-    this.recutDistance = options.recutDistance ?? radiusOf(table) * RECUT_FRACTION;
     // The geometry draws out of the cut buffer from here on. Its vertex attributes are untouched:
     // every level of the DAG indexes the vertices the mesh already shipped.
     //
@@ -200,11 +203,44 @@ export class ClusteredMesh extends Mesh {
     // are given, so the cut this class writes every frame would never reach the GPU and the mesh
     // would draw a buffer of zeros — degenerate triangles, an empty screen, and no error anywhere.
     geometry.setIndex(new BufferAttribute(this.#cut, 1));
-    // Full detail until something cuts it. Virtual geometry ships on by default, so the mesh a
-    // game never touches has to draw exactly what an ordinary `Mesh` would have drawn — a class
-    // that starts invisible and waits to be updated would turn the default into a blank screen.
-    // `update` only ever takes detail away from here.
+  }
+
+  /**
+   * A second mesh over the same body, cut for its own place in the scene.
+   *
+   * three's `Object3D.clone` builds through `new this.constructor()`, and this class's constructor
+   * wants a table — so every game that stood a second copy of a cooked model where it wanted a
+   * statue died in `assertTable` before drawing anything. The arguments are the source's own,
+   * which is what a copy is.
+   */
+  override clone(recursive = true): this {
+    return new ClusteredMesh(withOwnCut(this.geometry), this.material, this.table, {
+      errorPixels: this.errorPixels,
+      recutDistance: this.recutDistance,
+    }).copy(this, recursive) as this;
+  }
+
+  /**
+   * Becomes a copy of `source`, sharing the bake and the vertices and keeping a cut of its own.
+   *
+   * `Mesh.copy` shares the geometry outright, which this class cannot let it do: the cut lives in
+   * the geometry's index buffer, so two meshes on one geometry would overwrite each other's index
+   * every frame and both would draw whichever spoke last. The copy takes the vertex attributes by
+   * reference instead — one copy of them on the GPU, because three keys its attributes on the
+   * attribute — and the shared table, which is frozen at bake time and cannot go stale.
+   */
+  override copy(source: this, recursive = true): this {
+    super.copy(source, recursive);
+    if (!(source instanceof ClusteredMesh)) return this;
+    const geometry = withOwnCut(source.geometry);
+    this.#load(source.table, geometry);
+    this.geometry = geometry;
+    this.errorPixels = source.errorPixels;
+    this.recutDistance = source.recutDistance;
+    // Nothing this copy has drawn yet, so the next update has to cut it for where it stands.
+    this.#hasCut = false;
     this.#compact(this.#finestCut());
+    return this;
   }
 
   /** Every cluster the bake produced from the source triangles — the mesh as authored. */
@@ -286,6 +322,23 @@ export class ClusteredMesh extends Mesh {
   }
 }
 
+/**
+ * The same vertices under a second geometry, so a second mesh can hold a cut of its own.
+ *
+ * `BufferGeometry.clone()` would do this and would also copy every position, normal and uv — the
+ * memory a cooked model exists not to spend twice. Sharing the `BufferAttribute` objects shares
+ * their GPU buffers too, because three keys its attribute cache on the attribute, not the geometry.
+ */
+function withOwnCut(geometry: BufferGeometry): BufferGeometry {
+  const shell = new BufferGeometry();
+  for (const [name, attribute] of Object.entries(geometry.attributes))
+    shell.setAttribute(name, attribute);
+  shell.boundingSphere = geometry.boundingSphere;
+  shell.boundingBox = geometry.boundingBox;
+  shell.groups = [...geometry.groups];
+  return shell;
+}
+
 function radiusOf(table: IClusterTable): number {
   let radius = 0;
   for (let cluster = 0; cluster * 4 < table.bounds.length; cluster += 1)

From 877991c387eae1711a28038a2e252c139c507e56 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 17:12:45 -0700
Subject: [PATCH 22/36] =?UTF-8?q?docs(PRD-485):=20Phase=201=20done=20?=
 =?UTF-8?q?=E2=80=94=20WebP=20always=20converts,=20lumen-hall=20cooks=20an?=
 =?UTF-8?q?d=20passes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 6341c23779..b1339415af 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -46,11 +46,11 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 ## Execution Phases
 
 #### Phase 1: Embedded WebP cooks
-**Status:** NOT STARTED
+**Status:** DONE 2026-10-03
 **Files:** `packages/assets/src/passes/decode-image.ts`, `packages/assets/src/passes/model-textures.ts`; `packages/assets/__tests__/model-texture-pass.spec.ts`
 - [x] [local] A GLB with an `EXT_texture_webp` image cooks to KTX2 on a decoding target and to a capped PNG on the decoder-free path. No output still requires `EXT_texture_webp`. proof: red-green case in `pnpm exec vitest run packages/assets/__tests__/model-texture-pass.spec.ts`. **Result 2026-10-03 (`5e5ec9829`):** red `TN_ASSETS_TEXTURE_CONTAINER … is not a PNG or JPEG` before; green 3/3 after (KTX2 mip 0 transcodes back to the source within 1, decoder-free capped PNG, unknown container still throws); file 26/26, `packages/assets` 474 passed. **Reopened 2026-10-03:** on `lumen-hall` the cook decodes the WebP but the `not-smaller` guard keeps the original (3× per prop at 1024²), so `lady.glb`/`sanctuary.glb` still require `EXT_texture_webp`. **Closed 2026-10-03:** retention is now conditioned on the container, not only on size — `UNIVERSAL_IMAGE_CONTAINERS` (PNG/JPEG) may keep authored bytes, WebP always converts to KTX2 (KTX2 target) or PNG (decoder-free), so `EXT_texture_webp` always leaves the output and the increase lands in the existing `bytes before -> after` row (+621% on `lady.glb`). Red: 519 -> 519 bytes retained with the extension still required; green: `image/ktx2` only, `extensionsRequired` `[EXT_meshopt_compression, KHR_mesh_quantization, KHR_texture_basisu]`, both GLBs re-verified in `lumen-hall`. `keepSmallerSource` moved from `true` to `"universal-containers"` in the model pass's cache key so a warm cook cannot keep shipping the old output. File 28/28, `packages/assets` 476 passed, `pnpm typecheck` and `pnpm lint` clean.
   Implementation: `sharp` decodes WebP in `decode-image.ts` — the first rung of the decision above, already declared at `packages/assets/package.json:57`, so no dependency is added and no new binary is installed for a game (every template already carries `@gltf-transform/cli`, which drags the same native package). It loads in the pass's worker thread and stays external in `dist`. `compressEmbeddedTextures` disposes `EXT_texture_webp` once no image is left in it, because the glTF writer emits every attached extension. The rule that `decode-image.ts` "must never grow a native dependency" is changed here: this is a Node-only build-time package, and `sharp` is the only native thing in it. Spec: the `embedded EXT_texture_webp` block of `model-texture-pass.spec.ts`, with the KTX2 leg decoding mip 0 through the shipped `basis_transcoder`.
-- [ ] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`. Partly done 2026-10-03: `npx threenative build --target web` exits 0 with the installed `@threenative/assets` tarball and both WebP props cook (`lady.df65302d.glb` 1562 KB, `sanctuary.9353c235.glb` 2546 KB, `image/ktx2` only). The scenario itself was not run in this lane, so the box stays open.
+- [x] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`. Partly done 2026-10-03: `npx threenative build --target web` exits 0 with the installed `@threenative/assets` tarball and both WebP props cook (`lady.df65302d.glb` 1562 KB, `sanctuary.9353c235.glb` 2546 KB, `image/ktx2` only). The scenario itself was not run in this lane, so the box stays open. **Result 2026-10-03:** sandbox branch `prd485/lumen-hall-default-cook` (local worktree, engine tarballs from this branch): `npx threenative build --target web` exit 0, all 6 GLBs cooked (33.96 MB → 8.93 MB, -73.7%); `lady.glb`/`sanctuary.glb` now `image/ktx2`, no `EXT_texture_webp` (`c284f2a70`; lady +621% bytes, block-compressed on GPU). The first scenario run crashed in `ClusteredMesh.clone()` (cooked models carry a cluster DAG; three's `clone()` constructs with no arguments) — fixed in core `7ed40dbe5` with red-green specs. Then `playtests/assets.playtest.json` passes 4/4 on nvidia/turing WebGPU. Same-pose before (`models: "none"` + a temporary uncooked-budget override, same tarballs) vs after: 0.01% of pixels differ (mean abs 0.25). On the new engine `models: "none"` alone no longer builds lumen-hall (`TN_ASSETS_BUDGET_EXCEEDED` 68 MB > 64 MB). Known corner: a WebP that is not a whole number of 4×4 blocks keeps its bytes under the block-size guard.
 
 #### Phase 2: The Fab tree cooks by default
 **Status:** NOT STARTED

From 7ea1f8e5ff471214da0ce473628541bd2542361b Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 17:22:48 -0700
Subject: [PATCH 23/36] test(vq01): the lifecycle cycle is opt-in, and its
 growth was a measurement artefact
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ca1bd9c8e made the fixture leave and re-enter its own scene unconditionally, which broke the
original single-load scenario (state.frames stopped advancing after the first leave) and produced
geometryGrowth 0 -> 6 with ownedGeometries 1 -> 7 on a web WebGPU run. Neither is a leak.

The cycle is now armed by one key. The lifecycle scenario's first step presses it, and both runners
deliver a `press` step as the same keydown — page.keyboard.down on the browser lane and the device
bridge's input.keyDown, which synthesises keydown with `code` into document, window and canvas
(packages/playtest/src/three/device.ts:220). A URL query was not an option: the native host's
document.location is a fixed file:///game.html (packages/runtime-native/src/runtime.cpp:3436).
Nothing else presses it, so vq-native-asset-capabilities.playtest.json runs the fixture exactly as
it did before ca1bd9c8e, and its required capabilities are unchanged.

The growth was the measurement. renderer.info.memory is three's initialised-upload tally: geometries
++ on a geometry's first draw and -- on that geometry's own dispose event
(three.webgpu.js:31404,31841), and it is not reset per frame. The run's baseline read 1 geometry and
2 textures for a scene that holds six geometries (three stage cylinders, one plane, one mesh per GLB)
and samples three — a value below the scene's own live set can only be a sample taken mid-upload,
and every later enter's larger sample then reads as growth. The enter is now read at a tally that has
held still, and the leave follows that read rather than the first measured frame, so growth is a
difference between two settles and not between two arbitrary frames.

Evidence, none of it a GPU run:
- The engine path releases everything. packages/core/__tests__/asset-lifetime.spec.ts drives the real
  defineGame/ctx.goto/ctx.assets mechanism — load two models through ctx.assets, enter, leave via
  ctx.goto, come back — for three cycles and counts 0 live geometries and 0 live textures against a
  render-frame tally built the way three's backends build it. Its counter-probe, the same scene with
  an exit that forgets, reports 12 and 3, so the guard is known to see a leak when there is one.
  A scene change is scene.exit then clearScene (packages/core/src/game.ts:849,864,541), which drops
  references without disposing: the loader's cache is game-lifetime (game.ts:1018) and release/clear
  are its disposal API (packages/core/src/assets.ts:130,173).
- The fixture released everything it owned (vq-assets/src/game.ts:150-165): the four stage meshes'
  geometry and materials, its own configured copy of the PNG, both model entries and the cached
  texture, with disposeModel disposing each model's geometry, materials and material textures once
  (assets.ts:1058).
- The artefact reproduces in node. A tally still climbing through the measurement window reported
  geometryGrowth 5 against an unchanged settled live set; it now reports 0, and the paired case
  where a later enter really does leave more live still reports 6 and 3.

Red first, then green, in packages/create-threenative/__tests__/vq-native-fixture.spec.ts, which
imports the fixture and re-imports it per run because the enter ledger is module scope:
  "stays in its scene unless the lifecycle scenario asks it to leave" failed with left [void] on
  enter 1; "leaves and re-enters once the lifecycle scenario presses its key" failed with the
  leaves on the wrong enters; "reads an enter only once its tally has settled" failed with
  geometryGrowth 5. "still reports growth when a later enter leaves more live" passed before and
  after, which is what keeps the fix from being a measurement that never moves.

Gates: pnpm exec vitest run over the two VQ specs, asset-lifetime, scene-warning, game, assets and
native-asset-capture-proof — 47 and 108 respectively, all passed. pnpm typecheck, pnpm lint (0
errors) and pnpm build passed; pnpm check:docs passed. The scenario still loads through
loadPlaytestScenario and now requires browser.input on both targets, which the Android transport
advertises.

Unrun: no browser or device run of the corrected scenario here, so AC-2 stays open in the PRD with
the verdict and this evidence recorded against it.
---
 .../PRD-VQ-01-native-asset-capabilities.md    |  11 +-
 .../vq-native-asset-lifecycle.playtest.json   |  16 +-
 .../abyss-framework/vq-assets/src/game.ts     |  47 +++-
 .../core/__tests__/asset-lifetime.spec.ts     | 258 ++++++++++++++++++
 .../__tests__/vq-native-fixture.spec.ts       | 148 +++++++++-
 scripts/vq01-lifecycle-proof.sh               |   5 +-
 6 files changed, 465 insertions(+), 20 deletions(-)
 create mode 100644 packages/core/__tests__/asset-lifetime.spec.ts

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index cce6fe035e..5b37017137 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -62,9 +62,14 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 ## Acceptance criteria
 
 - [x] All admitted codecs are demonstrated through the packaged loader, not merely through WASM availability; all refused combinations retain actionable build errors. proof: the completed Phase 3 scenario outputs, with the named fixture, package/cohort and adapter recorded inline here. **Result 2026-10-03:** fixture `examples/abyss-framework/vq-assets` (Meshopt cube, Draco torus, PNG→KTX2 panel). Web: `sh scripts/vq01-web-proof.sh`, nvidia/turing WebGPU, all three decoded through the packaged loader, 8/8 (`c9d33523d`). Android V8 (emulator-5554, API 35 x86_64, APK `com.threenative.vq01` sha256 `87b9c853…`, `JS engine created: V8`): 8/8 decoder-free, every compressed codec refused by name at cook (`TN_ASSETS_COMPRESSION_SKIPPED`), `b0fb1053e`. Authored-KTX2 refusal preserving the previous package: hosted run 36998104447.
-- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario. **Open 2026-10-03:** the spec passes (19/19), but no Phase 3 scenario repeats lifecycle transitions yet; the web/Android runs load once.
-  Scenario added, unrun 2026-10-03: `examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json` gates on `state.settled` 2 → 3 → 4 and then asserts `entries` 4, `loadedModels`/`texturedMeshes` back to 2/2 and `geometryGrowth`/`textureGrowth` 0 against each enter's own live `renderer.info.memory` tally; it loads through `loadPlaytestScenario` but no browser or device run has executed it here, so this box stays open.
-  Runner: `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web` and `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>` generate the authored GLBs/PNG, cook and serve or package the same fixture, then run that scenario instead of the single-load one. The fixture decides when to leave and re-enter (`ctx.goto("void")` after a 30-frame settle window, four enters in all), so the run needs no extra step.
+- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario. **Open 2026-10-03:** the spec passes (19/19), the engine's own leave/re-enter path is proven to release everything, and the scenario's growth measurement is fixed — but no browser or device run of the corrected scenario has executed here, so this box stays open.
+  Scenario added, unrun 2026-10-03: `examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json` gates on `state.settled` 2 → 3 → 4 and then asserts `entries` 4, `loadedModels`/`texturedMeshes` back to 2/2 and `geometryGrowth`/`textureGrowth` 0 against each enter's own live `renderer.info.memory` tally.
+  Runner: `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web` and `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>` generate the authored GLBs/PNG, cook and serve or package the same fixture, then run that scenario instead of the single-load one. The scenario's first step presses the fixture's `lifecycle` key, which both runners deliver as the same `keydown` (`packages/playtest/src/three/device.ts:220`), so the cycle is opt-in, identical on web and on the device, and needs neither a URL (the native host's `document.location` is a fixed `file:///game.html`, `packages/runtime-native/src/runtime.cpp:3436`) nor a harness flag. Nothing else arms it, so `vq-native-asset-capabilities.playtest.json` runs the fixture exactly as it did before the cycle existed.
+
+  **The growth was a measurement artefact, not a leak (2026-10-03).** `renderer.info.memory` is three's initialised-upload tally, incremented in `Geometries.initGeometry` on a geometry's first draw and decremented on that geometry's own `dispose` event (`three.webgpu.js:31404`); the reported baseline read 1 geometry and 2 textures for a scene holding six geometries and sampling three textures, so the baseline was taken mid-upload, and every later enter's larger sample read as growth. Three pieces of evidence, none of them a GPU run:
+  - The engine path releases everything: `packages/core/__tests__/asset-lifetime.spec.ts` drives the real `defineGame`/`ctx.goto`/`ctx.assets` mechanism through three leave/re-enter cycles and counts 0 live geometries and 0 live textures, with a counter-probe proving the same harness reports 12/3 for a scene whose `exit` forgets. A scene change is `scene.exit` then `clearScene` (`packages/core/src/game.ts:849,864,541`), which drops references without disposing — by contract, because the loader's cache is game-lifetime (`packages/core/src/game.ts:1018`) and `release`/`clear` are its disposal API (`packages/core/src/assets.ts:130,173`).
+  - The fixture released everything it owned: `examples/abyss-framework/vq-assets/src/game.ts:150-165` disposes the four stage meshes' geometry and materials, its own copy of the configured PNG, and both model entries plus the cached texture, and `disposeModel` disposes each model's geometry, materials and material textures once (`packages/core/src/assets.ts:1058`).
+  - The artefact reproduces in node: a tally still climbing through the measurement window reported `geometryGrowth` 5 with an unchanged settled live set. The enter is now read at a tally that has held still, and the leave follows that read instead of the first measured frame.
 
 ## Performance and promotion
 
diff --git a/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json b/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
index c3363b7dc5..71535b400d 100644
--- a/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
+++ b/examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json
@@ -8,6 +8,14 @@
   },
   "warmupFrames": 30,
   "steps": [
+    {
+      "press": "KeyV",
+      "release": true,
+      "label": "arm the leave/re-enter cycle"
+    },
+    {
+      "waitTicks": 2
+    },
     {
       "waitForResource": {
         "id": "state",
@@ -61,25 +69,25 @@
         "id": "state",
         "path": "ownedGeometries",
         "gte": 1,
-        "allowTrivial": "The renderer's live geometry tally is only published once a settle window has uploaded the stage."
+        "allowTrivial": "The renderer's live geometry tally is only published once the settle window has measured a settled one; how many a backend initialises for this scene is its own business."
       },
       {
         "id": "state",
         "path": "geometryGrowth",
         "equals": 0,
-        "allowTrivial": "The exit path's disposal is exactly what makes the tally return to the first enter's baseline; the baseline is 0 growth by construction and only a leak can move it."
+        "allowTrivial": "The exit path's disposal is what makes a re-entry's settled tally return to the first enter's settled tally, and only a leak can move the difference between them."
       },
       {
         "id": "state",
         "path": "ownedTextures",
         "gte": 1,
-        "allowTrivial": "The renderer's live texture tally is only published once a settle window has uploaded the KTX2 and panel textures."
+        "allowTrivial": "The renderer's live texture tally is only published once the settle window has measured a settled one, which is after the KTX2 and panel textures have landed."
       },
       {
         "id": "state",
         "path": "textureGrowth",
         "equals": 0,
-        "allowTrivial": "The exit path's disposal is exactly what makes the tally return to the first enter's baseline; the baseline is 0 growth by construction and only a leak can move it."
+        "allowTrivial": "The exit path's disposal is what makes a re-entry's settled tally return to the first enter's settled tally, and only a leak can move the difference between them."
       },
       {
         "id": "state",
diff --git a/examples/abyss-framework/vq-assets/src/game.ts b/examples/abyss-framework/vq-assets/src/game.ts
index f88ff52ab2..e25bdf6f7e 100644
--- a/examples/abyss-framework/vq-assets/src/game.ts
+++ b/examples/abyss-framework/vq-assets/src/game.ts
@@ -28,16 +28,23 @@ type State = {
 type Model = { scene: Group; animations: AnimationClip[] };
 type Owned = { geometries: number; textures: number };
 const names = ["meshopt", "draco"] as const;
-/** Frames an enter is given to upload its geometry and textures before it is measured or left. */
+/** Frames an enter is given to upload its geometry and textures before it is measured at all. */
 const SETTLE_FRAMES = 30;
+/** Sampled frames the tally has to hold still before the enter is read as settled. */
+const QUIET_FRAMES = 15;
+/** The frame an unsettled enter gives up on, so a backend that never goes quiet still cycles. */
+const MAX_FRAMES = 300;
 /** One first load plus three leave/re-enter cycles. */
 const ENTERS = 4;
+/** The action the lifecycle scenario's key step presses to arm the cycle. */
+const ARM = "lifecycle";
 
 // The lifetime ledger, at module scope because only a value that outlives the scene can count its
 // own re-entries: `ctx.goto()` keeps the published state, and every field below is re-derived on
 // each enter from the renderer's live tally.
 let enters = 0;
 let settled = 0;
+let armed = false;
 let baseline: Owned | undefined;
 const growth: Owned = { geometries: 0, textures: 0 };
 
@@ -110,7 +117,15 @@ export class AssetScene extends Scene<State> {
     let frames = 0;
     let maxPoseDelta = 0;
     let left = false;
-    return (_ctx: ICtx<State>, dt: number) => {
+    // This enter's own high-water tally and how long it has held still. `info.memory` counts what
+    // the backend has initialised, which lands over several frames, so the enter is read at the
+    // tally that stopped moving — a baseline taken on the first measured frame is smaller than the
+    // scene's own live set and every later enter reads as growth it never had.
+    const peak: Owned = { geometries: 0, textures: 0 };
+    let previous: Owned | undefined;
+    let quiet = 0;
+    return (ctx: ICtx<State>, dt: number) => {
+      if (ctx.input.justPressed(ARM)) armed = true;
       for (const player of this.#players) player.update(dt);
       for (const [index, node] of animated.entries())
         maxPoseDelta = Math.max(
@@ -119,11 +134,22 @@ export class AssetScene extends Scene<State> {
         );
       frames += 1;
       const owned = frames < SETTLE_FRAMES ? undefined : ownedResources(ctx);
+      let isSettled = false;
       if (owned !== undefined) {
-        baseline ??= owned;
-        growth.geometries = Math.max(growth.geometries, owned.geometries - baseline.geometries);
-        growth.textures = Math.max(growth.textures, owned.textures - baseline.textures);
-        settled = Math.max(settled, entry);
+        peak.geometries = Math.max(peak.geometries, owned.geometries);
+        peak.textures = Math.max(peak.textures, owned.textures);
+        quiet =
+          previous?.geometries === owned.geometries && previous.textures === owned.textures
+            ? quiet + 1
+            : 0;
+        previous = owned;
+        isSettled = quiet >= QUIET_FRAMES || frames >= MAX_FRAMES;
+        if (isSettled) {
+          baseline ??= { ...peak };
+          growth.geometries = Math.max(growth.geometries, peak.geometries - baseline.geometries);
+          growth.textures = Math.max(growth.textures, peak.textures - baseline.textures);
+          settled = Math.max(settled, entry);
+        }
       }
       ctx.state.set({
         frames,
@@ -133,14 +159,14 @@ export class AssetScene extends Scene<State> {
         ...(owned === undefined
           ? {}
           : {
-              ownedGeometries: owned.geometries,
-              ownedTextures: owned.textures,
+              ownedGeometries: peak.geometries,
+              ownedTextures: peak.textures,
               geometryGrowth: growth.geometries,
               textureGrowth: growth.textures,
             }),
       });
       // Leave once this enter has settled, so the next observation is a re-entry's, not this one's.
-      if (frames >= SETTLE_FRAMES && !left && entry < ENTERS) {
+      if (armed && isSettled && !left && entry < ENTERS) {
         left = true;
         void ctx.goto("void");
       }
@@ -185,6 +211,9 @@ export default defineGame<State>({
   scenes: { assets: AssetScene, void: VoidScene },
   start: "assets",
   plugins: [playtest()],
+  // One key arms the leave/re-enter cycle, and only the lifecycle scenario presses it: both runners
+  // deliver a `press` step as the same keydown, so this reads identically on web and on a device.
+  input: { [ARM]: { keys: ["KeyV"] } },
   display: config.display,
   render: config.renderer,
 });
diff --git a/packages/core/__tests__/asset-lifetime.spec.ts b/packages/core/__tests__/asset-lifetime.spec.ts
new file mode 100644
index 0000000000..304d7941a6
--- /dev/null
+++ b/packages/core/__tests__/asset-lifetime.spec.ts
@@ -0,0 +1,258 @@
+import {
+  type BufferGeometry,
+  CylinderGeometry,
+  Group,
+  Mesh,
+  type MeshStandardMaterial,
+  type Object3D,
+  PlaneGeometry,
+  MeshStandardMaterial as StandardMaterial,
+  Texture,
+} from "three";
+import { describe, expect, it } from "vitest";
+import { defineGame } from "../src/game.js";
+import { type ICtx, Scene } from "../src/scene.js";
+
+type State = { frames: number };
+type Model = { scene: Group };
+const names = ["meshopt", "draco"] as const;
+
+/**
+ * The renderer's live tally, counting the way three's backends count: a geometry or texture is
+ * live from the frame that drew it until its own `dispose` event. Registering on draw rather than
+ * on construction is what makes the numbers comparable with `info.memory`, which only grows for
+ * something a frame actually uploaded.
+ */
+class LiveTally {
+  readonly geometries = new Set<BufferGeometry>();
+  readonly textures = new Set<Texture>();
+
+  /** One frame's draw: every visible geometry and every texture a visible material samples. */
+  draw(scene: Object3D): void {
+    scene.traverse((object) => {
+      if (object.visible !== true) return;
+      const mesh = object as Mesh;
+      const geometry = mesh.geometry;
+      if (geometry !== undefined && !this.geometries.has(geometry)) {
+        this.geometries.add(geometry);
+        geometry.addEventListener("dispose", () => this.geometries.delete(geometry));
+      }
+      const material = mesh.material;
+      if (material === undefined || material === null) return;
+      for (const surface of Array.isArray(material) ? material : [material])
+        for (const value of Object.values(surface as unknown as Record<string, unknown>)) {
+          if (!isTexture(value) || this.textures.has(value)) continue;
+          this.textures.add(value);
+          value.addEventListener("dispose", () => this.textures.delete(value));
+        }
+    });
+  }
+
+  /** What is still live, named: the message a failing count has to carry. */
+  get live(): string {
+    const parts: string[] = [];
+    for (const geometry of this.geometries)
+      parts.push(`${geometry.name || "geometry"}#${geometry.id}`);
+    for (const texture of this.textures) parts.push(`${texture.name || "texture"}#${texture.id}`);
+    return parts.join(", ");
+  }
+}
+
+function isTexture(value: unknown): value is Texture {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as { isTexture?: boolean }).isTexture === true
+  );
+}
+
+function testCanvas(): HTMLCanvasElement {
+  const canvas = new EventTarget() as EventTarget & Partial<HTMLCanvasElement>;
+  Object.defineProperties(canvas, {
+    clientHeight: { configurable: true, value: 180 },
+    clientWidth: { configurable: true, value: 320 },
+    parentElement: { configurable: true, value: null },
+  });
+  return canvas as HTMLCanvasElement;
+}
+
+/** The fixture's stage, unchanged in shape: three solid plinths and one textured panel. */
+function stage(scene: Object3D, png: Texture): Mesh[] {
+  const objects: Mesh[] = [];
+  for (const x of [-2.4, 0, 2.4]) {
+    const plinth = new Mesh(
+      new CylinderGeometry(1.03, 1.1, 0.25, 8),
+      new StandardMaterial({ color: 0x263951 }),
+    );
+    plinth.geometry.name = "plinth";
+    plinth.position.x = x;
+    scene.add(plinth);
+    objects.push(plinth);
+  }
+  const panel = new Mesh(new PlaneGeometry(1.6, 1.6), new StandardMaterial({ map: png }));
+  panel.geometry.name = "panel";
+  scene.add(panel);
+  objects.push(panel);
+  return objects;
+}
+
+/** One glb: a group holding a textured mesh, exactly the shape the fixture's models have. */
+function fixtureModel(name: string): Model {
+  const albedo = new StandardMaterial({ name: `${name}-albedo` });
+  const mesh = new Mesh(new PlaneGeometry(1, 1), albedo);
+  mesh.geometry.name = `${name}-mesh`;
+  const scene = new Group();
+  scene.name = name;
+  scene.add(mesh);
+  return { scene };
+}
+
+/** The geometry and every material a stage mesh owns, which is what the game's exit disposes. */
+function disposeMesh(mesh: Mesh): void {
+  mesh.geometry.dispose();
+  for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material])
+    material.dispose();
+}
+
+/**
+ * The fixture's own scene: two models through `ctx.assets`, a stage the game owns, and an `exit`
+ * that releases all of it. `releases: false` is the counter-probe — the same scene with an exit path
+ * that forgets — so the guard below is known to see a leak when there is one.
+ */
+function assetScene(releases: boolean) {
+  return class extends Scene<State> {
+    static override readonly initialState: State = { frames: 0 };
+    #models: Model[] = [];
+    #png: Texture | undefined;
+    #owned: Mesh[] = [];
+
+    override async load(ctx: ICtx<State>): Promise<void> {
+      this.#models = await Promise.all(names.map((name) => ctx.assets.model<Model>(`${name}.glb`)));
+      this.#png = await ctx.assets.texture("checker.png", {});
+    }
+
+    override enter(ctx: ICtx<State>) {
+      if (this.#png === undefined) throw new Error("PNG did not load");
+      this.#owned = stage(ctx.scene, this.#png);
+      for (const model of this.#models) ctx.add(model.scene);
+      let frames = 0;
+      return (_ctx: ICtx<State>) => {
+        ctx.state.set({ frames: ++frames });
+      };
+    }
+
+    override exit(ctx: ICtx<State>): void {
+      for (const mesh of this.#owned) {
+        if (releases) disposeMesh(mesh);
+        mesh.removeFromParent();
+      }
+      this.#owned.length = 0;
+      if (releases) this.#png?.dispose();
+      this.#png = undefined;
+      this.#models.length = 0;
+      if (!releases) return;
+      for (const name of names) ctx.assets.release("model", `${name}.glb`);
+      ctx.assets.release("texture", "checker.png");
+    }
+  };
+}
+
+/** The empty scene the asset scene leaves for, as the lifecycle fixture's `void`. */
+class VoidScene extends Scene<State> {
+  static override readonly initialState: State = { frames: 0 };
+}
+
+/**
+ * The real mechanism: a game's scene loads through `ctx.assets`, is entered, is left through
+ * `ctx.goto`, and is entered again — three times — with the live tally read on a drawn frame each
+ * time. Returns how many geometries and textures the cycles left live.
+ */
+async function countLiveAcrossCycles(
+  releases: boolean,
+): Promise<{ geometries: number; textures: number; live: string }> {
+  const tally = new LiveTally();
+  const canvas = testCanvas();
+  let renderFrame: ((time: number) => void) | undefined;
+  const requestFrame = globalThis.requestAnimationFrame;
+  Object.defineProperty(globalThis, "requestAnimationFrame", {
+    configurable: true,
+    value: (callback: (time: number) => void) => {
+      renderFrame = callback;
+      return 1;
+    },
+  });
+  const game = defineGame<State>({
+    initialState: { frames: 0 },
+    assets: {
+      basePath: "/assets",
+      model: async (url) => fixtureModel(url.replace(/^.*\//u, "").replace(/\.glb$/u, "")),
+      texture: async (url) => {
+        const texture = new Texture();
+        texture.name = url.replace(/^.*\//u, "");
+        return texture;
+      },
+    },
+    renderer: {
+      canvas,
+      preferWebGPU: false,
+      webgl2Factory: () => ({
+        dispose: () => undefined,
+        domElement: canvas,
+        render: (scene: Object3D) => {
+          tally.draw(scene);
+        },
+        setSize: () => undefined,
+      }),
+    },
+    scenes: { assets: assetScene(releases), void: VoidScene },
+    start: "assets",
+  });
+
+  const draw = (): void => {
+    if (renderFrame === undefined) throw new Error("Game did not schedule a frame.");
+    renderFrame(16);
+  };
+
+  try {
+    await game.start();
+    draw();
+    const baseline = { geometries: tally.geometries.size, textures: tally.textures.size };
+    // Leaving must not wait for the next frame's reconcile: every tally below is taken on a drawn
+    // frame, so anything the exit path drops only is gone by the time the next enter draws.
+    for (let cycle = 0; cycle < 3; cycle += 1) {
+      await game.goto("void");
+      await game.goto("assets");
+      draw();
+    }
+    return {
+      geometries: tally.geometries.size - baseline.geometries,
+      textures: tally.textures.size - baseline.textures,
+      live: tally.live,
+    };
+  } finally {
+    game.stop();
+    if (requestFrame === undefined) Reflect.deleteProperty(globalThis, "requestAnimationFrame");
+    else Object.defineProperty(globalThis, "requestAnimationFrame", { value: requestFrame });
+  }
+}
+
+describe("asset lifetime across a scene change", () => {
+  it("leaves no live geometry or texture behind after leave/re-enter cycles", async () => {
+    const { live, ...growth } = await countLiveAcrossCycles(true);
+
+    expect(growth, `still live after 3 leave/re-enter cycles: ${live}`).toEqual({
+      geometries: 0,
+      textures: 0,
+    });
+  });
+
+  it("sees the growth an exit path that does not release leaves behind", async () => {
+    // Without this the guard above could pass by never measuring anything.
+    const { live, ...growth } = await countLiveAcrossCycles(false);
+
+    expect(growth, `still live after 3 leave/re-enter cycles: ${live}`).toEqual({
+      geometries: 12,
+      textures: 3,
+    });
+  });
+});
diff --git a/packages/create-threenative/__tests__/vq-native-fixture.spec.ts b/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
index c1852a86d3..1c418223c3 100644
--- a/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
+++ b/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
@@ -3,8 +3,16 @@ import os from "node:os";
 import path from "node:path";
 import { compileAssets } from "@threenative/assets";
 import { createAssetLoader } from "@threenative/core";
-import { Group, Texture } from "three";
-import { afterEach, expect, test, vi } from "vitest";
+import {
+  AnimationClip,
+  Group,
+  PerspectiveCamera,
+  QuaternionKeyframeTrack,
+  Scene,
+  Texture,
+  type Group as ThreeGroup,
+} from "three";
+import { afterEach, describe, expect, it, test, vi } from "vitest";
 import {
   MODEL_NAMES,
   generateNativeAssetFixture,
@@ -20,6 +28,89 @@ afterEach(async () =>
   Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }))),
 );
 
+/** One glb with the shape the fixture's models have: a node the player can find and a turn clip. */
+function fixtureModel(name: string): { scene: Group; animations: AnimationClip[] } {
+  const scene = new Group();
+  scene.name = name;
+  const node = new Group();
+  node.name = `${name}-animated`;
+  scene.add(node);
+  const turn = new AnimationClip("turn", 2, [
+    new QuaternionKeyframeTrack(
+      `${node.name}.quaternion`,
+      [0, 1, 2],
+      [0, 0, 0, 1, 0, Math.sin(0.3), 0, Math.cos(0.3), 0, 0, 0, 1],
+    ),
+  ]);
+  return { scene, animations: [turn] };
+}
+
+type Owned = { geometries: number; textures: number };
+
+/**
+ * One enter against a stand-in context: `press` is the key the lifecycle scenario's step delivers,
+ * and `tally` is what the renderer's live counts would report for the frame being drawn.
+ */
+function enterOnce(options: { press: () => boolean; tally: () => Owned | undefined }) {
+  const assets = createAssetLoader({
+    model: async (url) => fixtureModel(url.replace(/^.*\//u, "").replace(/\.glb$/u, "")),
+    texture: async () => new Texture(),
+  });
+  const scene = new Scene();
+  const published: Record<string, number> = {};
+  const left: string[] = [];
+  const ctx = {
+    assets,
+    camera: new PerspectiveCamera(),
+    add: (object: ThreeGroup) => scene.add(object),
+    goto: async (name: string) => {
+      left.push(name);
+    },
+    input: {
+      justPressed: (action: string) => action === "lifecycle" && options.press(),
+    },
+    renderer: {
+      get info() {
+        return { memory: options.tally() };
+      },
+    },
+    scene,
+    state: { set: (values: Record<string, number>) => Object.assign(published, values) },
+  } as unknown as Parameters<AssetScene["enter"]>[0];
+  return { ctx, left, published };
+}
+
+/**
+ * The fixture's own leave/re-enter sequence, entered `enters` times in one process. The module is
+ * re-imported per run because the lifetime ledger that counts the enters is module scope — that is
+ * the whole reason only a value outliving the scene can count its own re-entries.
+ */
+async function runLifecycle(options: {
+  enters: number;
+  press: (enter: number) => boolean;
+  tally: (enter: number, drawn: number) => Owned | undefined;
+}): Promise<Array<Record<string, number | boolean>>> {
+  vi.resetModules();
+  const { AssetScene: Scene_ } = await import(
+    "../../../examples/abyss-framework/vq-assets/src/game.js"
+  );
+  const observed: Array<Record<string, number | boolean>> = [];
+  for (let enter = 1; enter <= options.enters; enter += 1) {
+    let drawn = 0;
+    const { ctx, left, published } = enterOnce({
+      press: () => options.press(enter),
+      tally: () => options.tally(enter, drawn++),
+    });
+    const assetScene = new Scene_();
+    await assetScene.load(ctx);
+    const frame = assetScene.enter(ctx);
+    if (typeof frame !== "function") throw new Error("enter() returned no frame function");
+    for (let tick = 0; tick < 900 && left.length === 0; tick += 1) frame(ctx, 1 / 60);
+    observed.push({ ...published, left: left.length > 0 });
+  }
+  return observed;
+}
+
 test("real Meshopt and Draco inputs retain decoded geometry, images and animation through the decoder-free cook", async () => {
   const cwd = await mkdtemp(path.join(os.tmpdir(), "vq01-fixture-"));
   roots.push(cwd);
@@ -98,3 +189,56 @@ test("fixture exit disposes its configured PNG clone and cached original exactly
     assets.clear();
   }
 });
+
+describe("the fixture's leave/re-enter cycle", () => {
+  /** Six geometries and three sampled textures: the fixture's own live set, already uploaded. */
+  const steady = (): Owned => ({ geometries: 6, textures: 3 });
+
+  it("stays in its scene unless the lifecycle scenario asks it to leave", async () => {
+    const observed = await runLifecycle({ enters: 4, press: () => false, tally: steady });
+
+    expect(observed.map((entry) => entry.left)).toEqual([false, false, false, false]);
+    expect(observed.map((entry) => entry.frames)).toEqual([900, 900, 900, 900]);
+  });
+
+  it("leaves and re-enters once the lifecycle scenario presses its key", async () => {
+    const observed = await runLifecycle({ enters: 4, press: () => true, tally: steady });
+
+    expect(observed.map((entry) => entry.entries)).toEqual([1, 2, 3, 4]);
+    // Three leaves, then the fourth enter stays: one load plus three leave/re-enter cycles.
+    expect(observed.map((entry) => entry.left)).toEqual([true, true, true, false]);
+  });
+
+  it("reads an enter only once its tally has settled, so a climbing upload is not a leak", async () => {
+    // `info.memory` counts what the backend has initialised, which lands over several frames: a
+    // baseline read on the first measured frame is smaller than the scene's own live set, and the
+    // next enter's larger sample then reads as growth it never had.
+    const climbing = (enter: number, drawn: number): Owned => ({
+      geometries: Math.min(6, enter === 1 ? 1 + drawn / 20 : 6),
+      textures: 3,
+    });
+    const observed = await runLifecycle({
+      enters: 4,
+      press: (enter) => enter >= 2,
+      tally: climbing,
+    });
+
+    expect(observed[3]?.geometryGrowth).toBe(0);
+    expect(observed[3]?.textureGrowth).toBe(0);
+    expect(observed[3]?.ownedGeometries).toBe(6);
+  });
+
+  it("still reports growth when a later enter leaves more live than the first", async () => {
+    // The half that keeps the measurement honest: a measurement that never reports growth would
+    // pass the case above by refusing to measure at all.
+    const leaking = (enter: number): Owned => ({ geometries: 2 * enter, textures: enter });
+    const observed = await runLifecycle({
+      enters: 4,
+      press: (enter) => enter >= 2,
+      tally: leaking,
+    });
+
+    expect(observed[3]?.geometryGrowth).toBe(6);
+    expect(observed[3]?.textureGrowth).toBe(3);
+  });
+});
diff --git a/scripts/vq01-lifecycle-proof.sh b/scripts/vq01-lifecycle-proof.sh
index dcb05a8b01..035cca7c91 100755
--- a/scripts/vq01-lifecycle-proof.sh
+++ b/scripts/vq01-lifecycle-proof.sh
@@ -1,8 +1,9 @@
 #!/bin/sh
 # PRD-VQ-01 AC-2 lifecycle box: cook the unchanged examples/abyss-framework/vq-assets fixture for one
 # target, then run the leave/re-enter scenario against it. Identical to vq01-web-proof.sh and
-# vq01-android-proof.sh except for the scenario both of those name; the fixture decides when to leave
-# and re-enter, so there is no extra step to drive here.
+# vq01-android-proof.sh except for the scenario both of those name; the scenario's own first step
+# presses the fixture's lifecycle key, and both runners deliver a press step as the same keydown, so
+# the fixture leaves and re-enters on web and on the device without a URL and without a harness flag.
 #
 #   sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web
 #   sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>

From 4949c2530cc3df939e75d2f8545af24699bea5df Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 17:24:22 -0700
Subject: [PATCH 24/36] docs(PRD-VQ-01): AC-2 GPU lifecycle run still grows;
 recorded open

---
 docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
index 5b37017137..ca3f8040bc 100644
--- a/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
+++ b/docs/PRDs/assets/PRD-VQ-01-native-asset-capabilities.md
@@ -62,7 +62,7 @@ The unit proof paths and the desktop fallback scenario now exist. Browser and An
 ## Acceptance criteria
 
 - [x] All admitted codecs are demonstrated through the packaged loader, not merely through WASM availability; all refused combinations retain actionable build errors. proof: the completed Phase 3 scenario outputs, with the named fixture, package/cohort and adapter recorded inline here. **Result 2026-10-03:** fixture `examples/abyss-framework/vq-assets` (Meshopt cube, Draco torus, PNG→KTX2 panel). Web: `sh scripts/vq01-web-proof.sh`, nvidia/turing WebGPU, all three decoded through the packaged loader, 8/8 (`c9d33523d`). Android V8 (emulator-5554, API 35 x86_64, APK `com.threenative.vq01` sha256 `87b9c853…`, `JS engine created: V8`): 8/8 decoder-free, every compressed codec refused by name at cook (`TN_ASSETS_COMPRESSION_SKIPPED`), `b0fb1053e`. Authored-KTX2 refusal preserving the previous package: hosted run 36998104447.
-- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario. **Open 2026-10-03:** the spec passes (19/19), the engine's own leave/re-enter path is proven to release everything, and the scenario's growth measurement is fixed — but no browser or device run of the corrected scenario has executed here, so this box stays open.
+- [ ] The feature preserves its documented inactive/fallback path and releases owned resources after repeated lifecycle transitions. proof: `pnpm exec vitest run packages/create-threenative/__tests__/vq-native-asset-capabilities.spec.ts` plus the Phase 3 lifecycle scenario. **Open 2026-10-03:** the spec passes (19/19), the engine's own leave/re-enter path is proven to release everything, and the scenario's growth measurement is fixed — but no browser or device run of the corrected scenario has executed here, so this box stays open. **GPU run 2026-10-03 (`7ea1f8e5f`, nvidia/turing):** the opt-in lifecycle scenario still reports `geometryGrowth` 6 and `textureGrowth` 3 after 3 re-enters (+2 geometries, +1 texture per enter, read at a settled tally), while `asset-lifetime.spec.ts` drives `ctx.goto`/`ctx.assets` with stubs and sees 0. Unresolved: either a real GPU-side release gap (two model geometries and one texture per enter) or three WebGPU `info.memory` accounting; next probe counts `dispose` events in-page beside `info.memory`. The original scenario is unaffected (8/8).
   Scenario added, unrun 2026-10-03: `examples/abyss-framework/playtests/vq-native-asset-lifecycle.playtest.json` gates on `state.settled` 2 → 3 → 4 and then asserts `entries` 4, `loadedModels`/`texturedMeshes` back to 2/2 and `geometryGrowth`/`textureGrowth` 0 against each enter's own live `renderer.info.memory` tally.
   Runner: `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> web` and `sh scripts/vq01-lifecycle-proof.sh <artifact-dir> android <serial>` generate the authored GLBs/PNG, cook and serve or package the same fixture, then run that scenario instead of the single-load one. The scenario's first step presses the fixture's `lifecycle` key, which both runners deliver as the same `keydown` (`packages/playtest/src/three/device.ts:220`), so the cycle is opt-in, identical on web and on the device, and needs neither a URL (the native host's `document.location` is a fixed `file:///game.html`, `packages/runtime-native/src/runtime.cpp:3436`) nor a harness flag. Nothing else arms it, so `vq-native-asset-capabilities.playtest.json` runs the fixture exactly as it did before the cycle existed.
 

From 81331cce8094ce7f5ae9518308bd36cb3af04618 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 17:36:12 -0700
Subject: [PATCH 25/36] =?UTF-8?q?docs(PRD-485):=20Phase=202=20boxes=201-2?=
 =?UTF-8?q?=20tick=20=E2=80=94=20the=20Fab=20tree=20cooks=20by=20default?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Hornbeam needed no engine fix: on the tarballs packed from this branch the
default cook exits 0 in 163 s (127 MB -> 27 MB, 6 embedded PNGs to KTX2, 0
uncooked bytes) and its trunk primitive gets a 3-rung TN_discrete_lod chain with
a 1,500-triangle far rung. Box 3 (browser + native scenarios) stays open, and
the PRD now records that the 745k-triangle MASK foliage took TN_virtual_geometry
with stalled cluster levels rather than a chain.
---
 .../PRD-485-high-quality-assets-go-through-the-cook.md      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index b1339415af..619af027a5 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -53,10 +53,10 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 - [x] [local] `lumen-hall` builds on web with `models: "none"` deleted, and its asset scenario passes. proof: `npx threenative build` in the game, then `node packages/playtest/dist/runner/cli.js playtests/assets.playtest.json --url <preview> --browser-recipe webgpu`. Partly done 2026-10-03: `npx threenative build --target web` exits 0 with the installed `@threenative/assets` tarball and both WebP props cook (`lady.df65302d.glb` 1562 KB, `sanctuary.9353c235.glb` 2546 KB, `image/ktx2` only). The scenario itself was not run in this lane, so the box stays open. **Result 2026-10-03:** sandbox branch `prd485/lumen-hall-default-cook` (local worktree, engine tarballs from this branch): `npx threenative build --target web` exit 0, all 6 GLBs cooked (33.96 MB → 8.93 MB, -73.7%); `lady.glb`/`sanctuary.glb` now `image/ktx2`, no `EXT_texture_webp` (`c284f2a70`; lady +621% bytes, block-compressed on GPU). The first scenario run crashed in `ClusteredMesh.clone()` (cooked models carry a cluster DAG; three's `clone()` constructs with no arguments) — fixed in core `7ed40dbe5` with red-green specs. Then `playtests/assets.playtest.json` passes 4/4 on nvidia/turing WebGPU. Same-pose before (`models: "none"` + a temporary uncooked-budget override, same tarballs) vs after: 0.01% of pixels differ (mean abs 0.25). On the new engine `models: "none"` alone no longer builds lumen-hall (`TN_ASSETS_BUDGET_EXCEEDED` 68 MB > 64 MB). Known corner: a WebP that is not a whole number of 4×4 blocks keeps its bytes under the block-size guard.
 
 #### Phase 2: The Fab tree cooks by default
-**Status:** NOT STARTED
+**Status:** PARTIAL
 **Files:** `packages/assets/src/lod/eligibility.ts` only if the Hornbeam is declined; `fab-import-proof/threenative.config.ts` (sandbox)
-- [ ] [local] `fab-import-proof` builds on web with `assets` reduced to `exclude`. The build report shows the Hornbeam's six embedded textures encoded and 0 uncooked bytes for its GLB. proof: `npx threenative build`, `dist.build-report.json`.
-- [ ] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB.
+- [x] [local] `fab-import-proof` builds on web with `assets` reduced to `exclude`. The build report shows the Hornbeam's six embedded textures encoded and 0 uncooked bytes for its GLB. proof: `npx threenative build`, `dist.build-report.json`. **Result 2026-10-03:** sandbox branch `prd485/fab-import-default-cook` (local worktree, engine tarballs from this branch), `npx threenative build --target web` exit 0 in 163 s. Hornbeam 126,934,280 -> 26,990,484 B (-78.7%), 6 embedded PNGs -> KTX2 45,378,709 -> 16,382,827 B (GPU 134,217,726 -> 25,165,824 B, 3 ETC1S + 3 UASTC, 0 skipped), budget row `uncooked 0 bytes`, artifact 51,402,535 B. No `packages/` file needed changing.
+- [x] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03:** `TN_discrete_lod` is in `extensionsUsed` and the row reads `1 primitive(s) to 3 level(s), 10349 -> 1500 triangles`; the cooked GLB's `TN_discrete_lod` on that primitive gives `lod0Triangles 10349`, `counts [5190, 2595, 1500]` — far rung 1,500 = 0.2% of 755,677. AutoLOD did not decline: it skipped 2 of 3 primitives, both `virtual-owned`. The two foliage primitives (225,310 + 520,018 triangles, the MASK mask) went to `TN_virtual_geometry` instead of a chain, and their cluster levels report `stopReason: stalled` at ~100% of their triangles, so the trunk chain is the only simplification in the asset.
 - [ ] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`.
 
 #### Phase 3: Android and the cold-agent path

From 84833072f326306af18e9042322d09bc81170d5d Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 17:47:39 -0700
Subject: [PATCH 26/36] =?UTF-8?q?docs(PRD-485):=20reopen=20the=20Hornbeam?=
 =?UTF-8?q?=20LOD=20box=20=E2=80=94=20foliage=20virtual=20geometry=20stall?=
 =?UTF-8?q?s=20at=20~100%?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 619af027a5..e1dc1233fe 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -56,7 +56,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 **Status:** PARTIAL
 **Files:** `packages/assets/src/lod/eligibility.ts` only if the Hornbeam is declined; `fab-import-proof/threenative.config.ts` (sandbox)
 - [x] [local] `fab-import-proof` builds on web with `assets` reduced to `exclude`. The build report shows the Hornbeam's six embedded textures encoded and 0 uncooked bytes for its GLB. proof: `npx threenative build`, `dist.build-report.json`. **Result 2026-10-03:** sandbox branch `prd485/fab-import-default-cook` (local worktree, engine tarballs from this branch), `npx threenative build --target web` exit 0 in 163 s. Hornbeam 126,934,280 -> 26,990,484 B (-78.7%), 6 embedded PNGs -> KTX2 45,378,709 -> 16,382,827 B (GPU 134,217,726 -> 25,165,824 B, 3 ETC1S + 3 UASTC, 0 skipped), budget row `uncooked 0 bytes`, artifact 51,402,535 B. No `packages/` file needed changing.
-- [x] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03:** `TN_discrete_lod` is in `extensionsUsed` and the row reads `1 primitive(s) to 3 level(s), 10349 -> 1500 triangles`; the cooked GLB's `TN_discrete_lod` on that primitive gives `lod0Triangles 10349`, `counts [5190, 2595, 1500]` — far rung 1,500 = 0.2% of 755,677. AutoLOD did not decline: it skipped 2 of 3 primitives, both `virtual-owned`. The two foliage primitives (225,310 + 520,018 triangles, the MASK mask) went to `TN_virtual_geometry` instead of a chain, and their cluster levels report `stopReason: stalled` at ~100% of their triangles, so the trunk chain is the only simplification in the asset.
+- [ ] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03:** `TN_discrete_lod` is in `extensionsUsed` and the row reads `1 primitive(s) to 3 level(s), 10349 -> 1500 triangles`; the cooked GLB's `TN_discrete_lod` on that primitive gives `lod0Triangles 10349`, `counts [5190, 2595, 1500]` — far rung 1,500 = 0.2% of 755,677. AutoLOD did not decline: it skipped 2 of 3 primitives, both `virtual-owned`. The two foliage primitives (225,310 + 520,018 triangles, the MASK mask) went to `TN_virtual_geometry` instead of a chain, and their cluster levels report `stopReason: stalled` at ~100% of their triangles, so the trunk chain is the only simplification in the asset. **Reopened by review 2026-10-03:** the 1,500-triangle far rung belongs to the trunk primitive only (10,349 → 1,500). The two MASK foliage primitives (225,310 + 520,018 = 745,328 of 755,677 triangles) were taken by `TN_virtual_geometry`, whose levels report `stopReason: stalled` at ~100% of triangles, so the asset as a whole has no far rung near 10%. Next: why cluster simplification stalls on alpha-cutout foliage (or let AutoLOD own MASK foliage).
 - [ ] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`.
 
 #### Phase 3: Android and the cold-agent path

From 42e70f77da3475588587ec88b26ab584b0f5d9ad Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 18:08:23 -0700
Subject: [PATCH 27/36] fix(assets): a DAG that reduced nothing hands the
 primitive to AutoLOD (PRD-485)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Hornbeam's two MASK foliage primitives (225,310 + 520,018 = 745,328 of
755,677 triangles) shipped with no coarse representation at all. The cluster
builder simplifies every group with `LockBorder` (dag.ts:259) and every edge of a
disconnected alpha-cutout card is a border, so the first fold simplifies nothing
(dag.ts:461), dag.ts:319 records `stalled`, and every level reports the source
count. The primitive was then `virtual-owned` (eligibility.ts:182), so AutoLOD
declined it and the asset's only chain was the 10,349-triangle trunk.

`bakeVirtualGeometry` now declines a primitive whose DAG stopped `stalled` while
still holding more than 80% of its triangles: no extension is attached, so the
primitive is unowned and the discrete ladder's card + terminal levels — the path
built for exactly this shape (generate.ts:851) — take it. Measured, not assumed: a
DAG that stalls after real folds has shed its triangles and keeps the primitive.

Red: on a 16,384-card MASK fixture the cook emitted `TN_virtual_geometry`,
`lod.reasons ["virtual-owned"]` and no chain; the report named the bake as "no
primitive was dense enough". Green: no extension, `lod.reasons []`, a 3-level card
chain whose far rung is 1,638 triangles = 5.0% of LOD0 with `cellCoverage 1` on
every level, and the alpha cutoff the asset shipped unchanged.

Sandbox proof (fab-import-proof, repacked assets tarball): build exit 0, `lod
...: 3 primitive(s) to 3 level(s), 755677 -> 38767 triangles, 0 skipped`,
`TN_virtual_geometry` gone from extensionsUsed, far total 38,767 = 5.13%, cooked
GLB 26,990,484 -> 26,428,684 B.

Gates: packages/assets 480 passed, pnpm typecheck 0, pnpm lint 0 (1032 warnings,
unchanged), pnpm check:docs 0.
---
 ...high-quality-assets-go-through-the-cook.md |   2 +-
 packages/assets/__tests__/virtual-dag.spec.ts |  28 ++
 .../assets/__tests__/virtual-pass.spec.ts     | 243 +++++++++++++++++-
 packages/assets/src/report.ts                 |  11 +-
 packages/assets/src/virtual/bake.ts           | 116 ++++++---
 5 files changed, 362 insertions(+), 38 deletions(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index e1dc1233fe..e829476b3c 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -56,7 +56,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 **Status:** PARTIAL
 **Files:** `packages/assets/src/lod/eligibility.ts` only if the Hornbeam is declined; `fab-import-proof/threenative.config.ts` (sandbox)
 - [x] [local] `fab-import-proof` builds on web with `assets` reduced to `exclude`. The build report shows the Hornbeam's six embedded textures encoded and 0 uncooked bytes for its GLB. proof: `npx threenative build`, `dist.build-report.json`. **Result 2026-10-03:** sandbox branch `prd485/fab-import-default-cook` (local worktree, engine tarballs from this branch), `npx threenative build --target web` exit 0 in 163 s. Hornbeam 126,934,280 -> 26,990,484 B (-78.7%), 6 embedded PNGs -> KTX2 45,378,709 -> 16,382,827 B (GPU 134,217,726 -> 25,165,824 B, 3 ETC1S + 3 UASTC, 0 skipped), budget row `uncooked 0 bytes`, artifact 51,402,535 B. No `packages/` file needed changing.
-- [ ] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03:** `TN_discrete_lod` is in `extensionsUsed` and the row reads `1 primitive(s) to 3 level(s), 10349 -> 1500 triangles`; the cooked GLB's `TN_discrete_lod` on that primitive gives `lod0Triangles 10349`, `counts [5190, 2595, 1500]` — far rung 1,500 = 0.2% of 755,677. AutoLOD did not decline: it skipped 2 of 3 primitives, both `virtual-owned`. The two foliage primitives (225,310 + 520,018 triangles, the MASK mask) went to `TN_virtual_geometry` instead of a chain, and their cluster levels report `stopReason: stalled` at ~100% of their triangles, so the trunk chain is the only simplification in the asset. **Reopened by review 2026-10-03:** the 1,500-triangle far rung belongs to the trunk primitive only (10,349 → 1,500). The two MASK foliage primitives (225,310 + 520,018 = 745,328 of 755,677 triangles) were taken by `TN_virtual_geometry`, whose levels report `stopReason: stalled` at ~100% of triangles, so the asset as a whole has no far rung near 10%. Next: why cluster simplification stalls on alpha-cutout foliage (or let AutoLOD own MASK foliage).
+- [x] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03 (reopened box, closed):** cause `packages/assets/src/virtual/dag.ts:319` — the group fold simplifies each cluster group with `LockBorder` (`dag.ts:259`), and every edge of a disconnected alpha-cutout card is a border, so the first fold simplifies nothing, every level reports the source count and `stopReason: stalled`; the primitive was then `virtual-owned` (`lod/eligibility.ts:182`) and no ladder could take it. Fix `packages/assets/src/virtual/bake.ts`: the bake *declines* a primitive whose DAG stopped `stalled` while still holding >80% of its triangles (`VIRTUAL_BAKE_VERSION` 3 -> 4) and attaches no extension, so the primitive is unowned and the discrete ladder's card + terminal levels take it. Red on `virtual-pass.spec.ts` "hands cards it cannot reduce to the discrete ladder, which does reduce them" (16,384 MASK cards: `extensionsUsed` had `TN_virtual_geometry`, `lod.reasons ["virtual-owned"]`, far level 50%) and on the report line; green after (no `TN_virtual_geometry`, `lod.reasons []`, far level 1,638 = 5.0% of 32,768, `cellCoverage 1` on every level). Same lane, sandbox `prd485/fab-import-default-cook` with the repacked assets tarball: `npx threenative build --target web` exit 0, report row `lod …: 3 primitive(s) to 3 level(s), 755677 -> 38767 triangles, 7304028 payload bytes, 0 skipped` and `TN_virtual_geometry` gone from `extensionsUsed`. Per primitive: material 0 `225310 -> [113601, 56948, 11266]` (5.00%, absolute far error 0.331), material 1 `520018 -> [260988, 130580, 26001]` (5.00%, 0.253), material 2 `10349 -> [5190, 2595, 1500]` (14.49%, 0.211) — far total 38,767 = 5.13% of 755,677. Cooked GLB 26,990,484 -> 26,428,684 B (-561,800 B, the DAG payload). Known gap: `compile.ts` drops `entry.virtual` when it rebuilds the manifest entry, so the new `declined` count is in the pass summary and `formatModelSizes` but prints in neither CLI lane.
 - [ ] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`.
 
 #### Phase 3: Android and the cold-agent path
diff --git a/packages/assets/__tests__/virtual-dag.spec.ts b/packages/assets/__tests__/virtual-dag.spec.ts
index 8e51dbfcd8..97632d3a65 100644
--- a/packages/assets/__tests__/virtual-dag.spec.ts
+++ b/packages/assets/__tests__/virtual-dag.spec.ts
@@ -41,6 +41,21 @@ function manyShells(count: number): IBody {
   return { indices: Uint32Array.from(indices), positions: Float32Array.from(positions) };
 }
 
+/** Disconnected alpha-cutout cards — the shape a Fab foliage primitive is, and why it stalls. */
+function cards(count: number): IBody {
+  const indices: number[] = [];
+  const positions: number[] = [];
+  const perRow = Math.ceil(Math.sqrt(count));
+  for (let card = 0; card < count; card += 1) {
+    const base = positions.length / 3;
+    const x = (card % perRow) * 2;
+    const y = Math.floor(card / perRow) * 2;
+    positions.push(x, y, 0, x + 0.5, y, 0, x + 0.5, y + 0.5, 0, x, y + 0.5, 0);
+    indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+  }
+  return { indices: Uint32Array.from(indices), positions: Float32Array.from(positions) };
+}
+
 function edgeKey(a: number, b: number): number {
   return a < b ? a * 4294967296 + b : b * 4294967296 + a;
 }
@@ -213,6 +228,19 @@ describe("the cluster DAG", () => {
     expect(dag.roots.length).toBeGreaterThan(1);
   }, 120_000);
 
+  it("AC6 red — a body of alpha-cutout cards stalls on its very first fold, at 100%", async () => {
+    const body = cards(400);
+    const dag = await buildClusterDag(body.indices, body.positions);
+
+    // Not the shells' 64-triangle floor: no collapse at all. Every edge of every card is a border
+    // edge, so `LockBorder` holds the whole body still and the only remaining candidates are the
+    // quads' diagonals, which collapse to nothing. PRD-485's Hornbeam foliage: 745,328 triangles
+    // whose DAG therefore reports every level at the source count, and the bake declines it.
+    expect(dag.stopReason).toBe("stalled");
+    expect(dag.groups).toHaveLength(0);
+    for (const level of dag.levels) expect(level.triangleCount).toBe(body.indices.length / 3);
+  }, 120_000);
+
   it("refuses a malformed mesh rather than baking nonsense", async () => {
     await expect(buildClusterDag(new Uint32Array([0, 1]), new Float32Array(9))).rejects.toThrow(
       /non-empty triangle list/,
diff --git a/packages/assets/__tests__/virtual-pass.spec.ts b/packages/assets/__tests__/virtual-pass.spec.ts
index 6380b75ee6..bea7d59913 100644
--- a/packages/assets/__tests__/virtual-pass.spec.ts
+++ b/packages/assets/__tests__/virtual-pass.spec.ts
@@ -1,7 +1,7 @@
 import { Document, NodeIO } from "@gltf-transform/core";
 import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
 import { MeshoptDecoder } from "meshoptimizer";
-import { TorusKnotGeometry } from "three";
+import { SphereGeometry, TorusKnotGeometry } from "three";
 import { describe, expect, it } from "vitest";
 import { modelPass } from "../src/passes/model.js";
 import { formatModelSizes } from "../src/report.js";
@@ -58,6 +58,77 @@ async function sourceGlb(geometry: TorusKnotGeometry): Promise<Buffer> {
   return Buffer.from(await io.writeBinary(document));
 }
 
+/**
+ * Twelve closed shells that touch nothing, in one primitive: the body whose DAG halves a dozen
+ * times and then floors out above one cluster, which is the `stalled` the decline must not read as
+ * "reduced nothing" (PRD-485).
+ */
+async function shellsGlb(shellCount: number): Promise<Buffer> {
+  const document = new Document();
+  const buffer = document.createBuffer();
+  const scene = document.createScene();
+  const shell = new SphereGeometry(0.5, 32, 16);
+  const positions: number[] = [];
+  const normals: number[] = [];
+  const indices: number[] = [];
+  const source = shell.attributes.position?.array ?? [];
+  const sourceNormals = shell.attributes.normal?.array ?? [];
+  const shellIndices = Array.from(shell.index?.array ?? []);
+  // A three.js sphere leaves two pole vertices no triangle references, and the pass's self-verify
+  // fails a cook that drops them — the same trap `denseGlb` avoids with a torus knot. Compacting to
+  // the used vertices is the whole fix.
+  const used = [...new Set(shellIndices)].sort((left, right) => left - right);
+  const remap = new Map(used.map((vertex, slot) => [vertex, slot]));
+  for (let count = 0; count < shellCount; count += 1) {
+    const base = positions.length / 3;
+    for (const vertex of used) {
+      const slot = vertex * 3;
+      positions.push(
+        (source[slot] as number) + count * 40,
+        source[slot + 1] as number,
+        source[slot + 2] as number,
+      );
+      normals.push(
+        sourceNormals[slot] as number,
+        sourceNormals[slot + 1] as number,
+        sourceNormals[slot + 2] as number,
+      );
+    }
+    for (const vertex of shellIndices) indices.push(base + (remap.get(vertex) as number));
+  }
+  const primitive = document
+    .createPrimitive()
+    .setAttribute(
+      "POSITION",
+      document
+        .createAccessor()
+        .setType("VEC3")
+        .setArray(Float32Array.from(positions))
+        .setBuffer(buffer),
+    )
+    .setAttribute(
+      "NORMAL",
+      document
+        .createAccessor()
+        .setType("VEC3")
+        .setArray(Float32Array.from(normals))
+        .setBuffer(buffer),
+    )
+    .setIndices(
+      document
+        .createAccessor()
+        .setType("SCALAR")
+        .setArray(Uint32Array.from(indices))
+        .setBuffer(buffer),
+    )
+    .setMaterial(document.createMaterial("stone"));
+  scene.addChild(
+    document.createNode("cavern").setMesh(document.createMesh("cavern").addPrimitive(primitive)),
+  );
+  const io = new NodeIO().registerExtensions(ALL_EXTENSIONS);
+  return Buffer.from(await io.writeBinary(document));
+}
+
 async function readBack(buffer: Buffer, registerVirtual: boolean): Promise<Document> {
   await MeshoptDecoder.ready;
   const io = new NodeIO()
@@ -83,6 +154,72 @@ async function compile(virtual: boolean): Promise<{ buffer: Buffer; entry: unkno
   return { buffer: result.buffer, entry: result.entry };
 }
 
+/**
+ * A canopy of disconnected alpha-cutout cards: what a Fab foliage primitive is, and what the
+ * Hornbeam's two of them are (PRD-485).
+ *
+ * Every card is its own connected component with its own four vertices, so the whole rim is a
+ * border edge and the cluster builder — which simplifies each group with the rim locked — has
+ * nothing it is allowed to collapse. The card count is what puts the far level under a tenth of the
+ * source: the ladder's terminal target is `max(1500, 5% of LOD0)`, and only above 30,000 triangles
+ * is the ratio the binding half of that.
+ */
+async function foliageGlb(cardCount: number): Promise<Buffer> {
+  const document = new Document();
+  const buffer = document.createBuffer();
+  const scene = document.createScene();
+  const positions: number[] = [];
+  const normals: number[] = [];
+  const uvs: number[] = [];
+  const indices: number[] = [];
+  const perRow = Math.ceil(Math.sqrt(cardCount));
+  for (let card = 0; card < cardCount; card += 1) {
+    const base = positions.length / 3;
+    const x = (card % perRow) * 2;
+    const y = Math.floor(card / perRow) * 2;
+    const height = 0.5 + ((card * 37) % 11) / 22;
+    positions.push(x, y, 0, x + height, y, 0, x + height, y + height, 0, x, y + height, 0);
+    normals.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1);
+    uvs.push(0, 0, 1, 0, 1, 1, 0, 1);
+    indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+  }
+  const primitive = document
+    .createPrimitive()
+    .setAttribute(
+      "POSITION",
+      document
+        .createAccessor()
+        .setType("VEC3")
+        .setArray(Float32Array.from(positions))
+        .setBuffer(buffer),
+    )
+    .setAttribute(
+      "NORMAL",
+      document
+        .createAccessor()
+        .setType("VEC3")
+        .setArray(Float32Array.from(normals))
+        .setBuffer(buffer),
+    )
+    .setAttribute(
+      "TEXCOORD_0",
+      document.createAccessor().setType("VEC2").setArray(Float32Array.from(uvs)).setBuffer(buffer),
+    )
+    .setIndices(
+      document
+        .createAccessor()
+        .setType("SCALAR")
+        .setArray(Uint32Array.from(indices))
+        .setBuffer(buffer),
+    )
+    .setMaterial(document.createMaterial("Foliage").setAlphaMode("MASK").setAlphaCutoff(0.5));
+  scene.addChild(
+    document.createNode("canopy").setMesh(document.createMesh("canopy").addPrimitive(primitive)),
+  );
+  const io = new NodeIO().registerExtensions(ALL_EXTENSIONS);
+  return Buffer.from(await io.writeBinary(document));
+}
+
 describe("the virtual-geometry pass", () => {
   it('bakes nothing when the config says "none"', async () => {
     const { buffer, entry } = await compile(false);
@@ -219,6 +356,84 @@ describe("the virtual-geometry pass", () => {
     expect(summary.skipped).toBe(1);
   });
 
+  it("hands cards it cannot reduce to the discrete ladder, which does reduce them", async () => {
+    // PRD-485. A body of disconnected alpha-cutout cards is the one shape the cluster builder
+    // refuses: every edge of every card is a border, `LockBorder` holds all of it, and the first
+    // fold simplifies nothing — so a stalled DAG reports 100% of the triangles at every level and
+    // owns 745,328 Hornbeam foliage triangles with no coarse representation at all. The bake hands
+    // that primitive back and the ladder gives it the far level the DAG could not.
+    const result = await modelPass({
+      lod: true,
+      virtual: { minSourceTriangles: 1024 },
+    }).apply(await foliageGlb(16384), "canopy.glb");
+    if (Buffer.isBuffer(result)) throw new Error("model pass returned an unchanged buffer");
+
+    expect(jsonOf(result.buffer).extensionsUsed ?? []).not.toContain("TN_virtual_geometry");
+    const virtual = (
+      result.entry as {
+        virtual: { clusters: number; declined: number; payloadBytes: number; primitives: number };
+      }
+    ).virtual;
+    expect(virtual).toMatchObject({ clusters: 0, declined: 1, payloadBytes: 0, primitives: 0 });
+
+    const lod = (
+      result.entry as {
+        lod: {
+          primitives: {
+            cardLevels: { cellCoverage: number }[];
+            levels: { absoluteError: number; triangles: number }[];
+            strategy: string;
+            trianglesBefore: number;
+          }[];
+          reasons: string[];
+          skipped: number;
+        };
+      }
+    ).lod;
+    // Not `virtual-owned` any more, and not skipped for anything else either.
+    expect(lod.reasons).not.toContain("virtual-owned");
+    expect(lod.skipped).toBe(0);
+    const chain = lod.primitives[0];
+    if (chain === undefined) throw new Error("the declined cards got no chain at all");
+    expect(chain.strategy).toBe("cards");
+
+    const far = chain.levels[chain.levels.length - 1]?.triangles ?? 0;
+    expect(far).toBeGreaterThan(0);
+    expect(far / chain.trianglesBefore).toBeLessThanOrEqual(0.1);
+    // The crown keeps a card in every occupied cell at every level, and each level's error is
+    // wider than the one before it — the two properties the runtime's distance switch reads.
+    for (const level of chain.cardLevels ?? []) expect(level.cellCoverage).toBe(1);
+    for (let level = 1; level < chain.levels.length; level += 1)
+      expect(chain.levels[level]?.absoluteError).toBeGreaterThanOrEqual(
+        chain.levels[level - 1]?.absoluteError ?? 0,
+      );
+
+    // And the cook still decides nothing about how it looks: the alpha cutoff the asset was
+    // authored with is the one that ships.
+    const material = (
+      JSON.parse(
+        result.buffer.subarray(20, 20 + result.buffer.readUInt32LE(12)).toString("utf8"),
+      ) as { materials?: { alphaCutoff?: number; alphaMode?: string }[] }
+    ).materials?.[0];
+    expect(material).toMatchObject({ alphaCutoff: 0.5, alphaMode: "MASK" });
+  }, 300_000);
+
+  it("keeps a DAG that stalled only after it had already shed its triangles", async () => {
+    // The decline is measured, not `stalled => gone`: twelve closed shells cannot become one
+    // cluster — meshoptimizer will not take a shell below about 64 triangles — but the DAG has
+    // halved several times before it floors out, and that payload is worth keeping.
+    const result = await modelPass({ virtual: { minSourceTriangles: 1024 } }).apply(
+      await shellsGlb(12),
+      "cavern.glb",
+    );
+    if (Buffer.isBuffer(result)) throw new Error("model pass returned an unchanged buffer");
+
+    expect(
+      (result.entry as { virtual: { declined: number; primitives: number; stopReason: string } })
+        .virtual,
+    ).toMatchObject({ declined: 0, primitives: 1, stopReason: "stalled" });
+  }, 600_000);
+
   it("AC8 — a reader that has never heard of the extension gets the source mesh", async () => {
     const { buffer } = await compile(true);
     const stock = await readBack(buffer, false);
@@ -264,6 +479,7 @@ describe("the virtual-geometry pass", () => {
         virtual: {
           bakeSeconds: 12.34,
           clusters: 512,
+          declined: 0,
           levels: 6,
           payloadBytes: 4096,
           primitives: 1,
@@ -287,6 +503,7 @@ describe("the virtual-geometry pass", () => {
         virtual: {
           bakeSeconds: 1,
           clusters: 8,
+          declined: 0,
           levels: 2,
           payloadBytes: 64,
           primitives: 1,
@@ -298,4 +515,28 @@ describe("the virtual-geometry pass", () => {
 
     expect(lines.join("\n")).toContain("a DAG hit the level cap and is unfinished");
   });
+
+  it("AC7 — the report names the primitives it handed to the LOD ladder", () => {
+    const lines = formatModelSizes([
+      {
+        after: 900,
+        before: 1000,
+        logicalPath: "canopy.glb",
+        virtual: {
+          bakeSeconds: 0.1,
+          clusters: 0,
+          declined: 2,
+          levels: 0,
+          payloadBytes: 0,
+          primitives: 0,
+          skipped: 1,
+          stopReason: "root",
+        },
+      },
+    ]);
+
+    // "no primitive was dense enough" would be the wrong reason for a body whose cards were dense
+    // enough and whose DAG reduced nothing.
+    expect(lines.join("\n")).toContain("1 skipped, 2 declined to the LOD ladder");
+  });
 });
diff --git a/packages/assets/src/report.ts b/packages/assets/src/report.ts
index b8d203d6c8..dc61d06527 100644
--- a/packages/assets/src/report.ts
+++ b/packages/assets/src/report.ts
@@ -64,6 +64,8 @@ export interface IEmbeddedTextureRow {
 export interface IVirtualRow {
   readonly bakeSeconds: number;
   readonly clusters: number;
+  /** Primitives handed back to the discrete ladder because their DAG reduced nothing. */
+  readonly declined: number;
   readonly levels: number;
   readonly payloadBytes: number;
   readonly primitives: number;
@@ -409,19 +411,22 @@ function simplifyLine(row: IModelSizeRow): readonly string[] {
  * Names what the DAG cost and where it stopped.
  *
  * A `cap` stop is called out because it means a DAG ran out of levels rather than finishing, and a
- * bake that clustered nothing says so rather than leaving the reader to infer it from a zero.
+ * bake that clustered nothing says so rather than leaving the reader to infer it from a zero. A
+ * declined primitive is named too: "no primitive was dense enough" is the wrong reason for a body
+ * whose foliage is dense enough and whose DAG reduced nothing.
  */
 function virtualLine(row: IModelSizeRow): readonly string[] {
   const virtual = row.virtual;
   if (virtual === undefined) return [];
+  const declined = virtual.declined > 0 ? `, ${virtual.declined} declined to the LOD ladder` : "";
   if (virtual.primitives === 0)
     return [
-      `virtual ${row.logicalPath}: no primitive was dense enough to cluster (${virtual.skipped} skipped)`,
+      `virtual ${row.logicalPath}: no primitive was dense enough to cluster (${virtual.skipped} skipped${declined})`,
     ];
   const warning =
     virtual.stopReason === "cap" ? " — a DAG hit the level cap and is unfinished" : "";
   return [
-    `virtual ${row.logicalPath}: ${virtual.clusters} cluster(s) over ${virtual.levels} level(s) on ${virtual.primitives} primitive(s), ${virtual.skipped} skipped, ${virtual.payloadBytes} payload bytes, bake ${virtual.bakeSeconds.toFixed(1)} s, stopped at ${virtual.stopReason}${warning}`,
+    `virtual ${row.logicalPath}: ${virtual.clusters} cluster(s) over ${virtual.levels} level(s) on ${virtual.primitives} primitive(s), ${virtual.skipped} skipped${declined}, ${virtual.payloadBytes} payload bytes, bake ${virtual.bakeSeconds.toFixed(1)} s, stopped at ${virtual.stopReason}${warning}`,
   ];
 }
 function compactLine(row: IModelSizeRow): readonly string[] {
diff --git a/packages/assets/src/virtual/bake.ts b/packages/assets/src/virtual/bake.ts
index 5f9c061205..210acd3f3f 100644
--- a/packages/assets/src/virtual/bake.ts
+++ b/packages/assets/src/virtual/bake.ts
@@ -1,7 +1,12 @@
 // The pipeline's side of the DAG bake: which primitives get one, and what the report says about it.
 
 import type { Document, Primitive } from "@gltf-transform/core";
-import { type IClusterDagOptions, buildClusterDag } from "./dag.js";
+import {
+  type IClusterDag,
+  type IClusterDagOptions,
+  type IVirtualLevel,
+  buildClusterDag,
+} from "./dag.js";
 import { TNVirtualGeometry, attachVirtualGeometry, virtualGeometryBytes } from "./extension.js";
 
 /**
@@ -52,6 +57,11 @@ export interface IModelVirtualOptions {
 export interface IModelVirtualSummary {
   readonly bakeSeconds: number;
   readonly clusters: number;
+  /**
+   * Primitives the bake looked at and handed back because their DAG reduced nothing — left for the
+   * discrete ladder, which is named here because "no clusters" alone reads as a bug.
+   */
+  readonly declined: number;
   readonly levels: number;
   readonly payloadBytes: number;
   readonly primitives: number;
@@ -61,7 +71,37 @@ export interface IModelVirtualSummary {
 }
 
 /** Bumped when the bake's output changes for the same input. Part of the compile cache key. */
-export const VIRTUAL_BAKE_VERSION = 3;
+export const VIRTUAL_BAKE_VERSION = 4;
+
+/**
+ * The share of its own triangles a DAG has to shed before it keeps the primitive.
+ *
+ * Below that the payload is three to four times the primitive's compiled bytes (see
+ * {@link IModelVirtualOptions.minSourceTriangles}) for a cut that draws the same triangles, and the
+ * discrete ladder's terminal level reaches 5% of LOD0 on the same geometry.
+ */
+const DECLINE_KEEP_RATIO = 0.8;
+
+/**
+ * Whether the bake hands this primitive back instead of owning it (PRD-485).
+ *
+ * A `stalled` DAG whose coarsest level still holds most of the source has no coarse representation
+ * to offer. meshoptimizer will not collapse a body of disconnected alpha-cutout cards with every
+ * border locked — each card's whole rim is a border — so the first fold simplifies nothing
+ * (`virtual/dag.ts:461`), every level reports the source count, and every threshold draws LOD0: the
+ * Hornbeam's two foliage primitives, 745,328 triangles with no coarse step at all. Owning them
+ * anyway costs 3–4x their bytes and leaves them `virtual-owned` (`lod/eligibility.ts:182`), so the
+ * bake declines them and the discrete ladder — whose terminal pass exists for exactly this shape,
+ * `lod/generate.ts:851` — gets the primitive instead.
+ *
+ * Measured, not assumed: a DAG that stalls *after* real folds has shed its triangles and keeps the
+ * primitive, and so does every stop reason but `stalled`.
+ */
+function declines(dag: IClusterDag, sourceTriangles: number): boolean {
+  if (dag.stopReason !== "stalled") return false;
+  const coarsest = dag.levels[dag.levels.length - 1] as IVirtualLevel;
+  return coarsest.triangleCount > sourceTriangles * DECLINE_KEEP_RATIO;
+}
 
 /**
  * The density at which a cluster DAG starts paying for its own bytes. See
@@ -117,49 +157,59 @@ export async function bakeVirtualGeometry(
 
   let extension: TNVirtualGeometry | null = null;
   let clusters = 0;
+  let declined = 0;
   let levels = 0;
   let payloadBytes = 0;
   let primitives = 0;
   let skipped = 0;
   let stopReason = "root";
 
-  for (const mesh of document.getRoot().listMeshes()) {
-    for (const primitive of mesh.listPrimitives()) {
-      const indices = primitive.getIndices();
-      const positions = positionsOf(primitive);
-      // A skinned body ships whole: the loader's clustered mesh is a plain `Mesh`, so a baked
-      // primitive would lose its skin (and the rig would not clone).
-      if (
-        indices === null ||
-        positions === null ||
-        primitive.getMode() !== 4 ||
-        primitive.getAttribute("JOINTS_0") !== null
-      ) {
-        skipped += 1;
-        continue;
-      }
-      if (indices.getCount() / 3 < minSourceTriangles) {
-        skipped += 1;
-        continue;
-      }
-      const dag = await buildClusterDag(
-        Uint32Array.from(indices.getArray() as ArrayLike<number>),
-        positions,
-        dagOptions,
-      );
-      extension ??= document.createExtension(TNVirtualGeometry).setRequired(false);
-      const virtual = attachVirtualGeometry(document, extension, primitive, dag);
-      clusters += dag.clusters.length;
-      levels = Math.max(levels, dag.levels.length);
-      payloadBytes += virtualGeometryBytes(virtual);
-      primitives += 1;
-      stopReason = worse(stopReason, dag.stopReason);
+  for (const primitive of document
+    .getRoot()
+    .listMeshes()
+    .flatMap((mesh) => mesh.listPrimitives())) {
+    const indices = primitive.getIndices();
+    const positions = positionsOf(primitive);
+    // A skinned body ships whole: the loader's clustered mesh is a plain `Mesh`, so a baked
+    // primitive would lose its skin (and the rig would not clone).
+    if (
+      indices === null ||
+      positions === null ||
+      primitive.getMode() !== 4 ||
+      primitive.getAttribute("JOINTS_0") !== null
+    ) {
+      skipped += 1;
+      continue;
+    }
+    const sourceTriangles = indices.getCount() / 3;
+    if (sourceTriangles < minSourceTriangles) {
+      skipped += 1;
+      continue;
+    }
+    const dag = await buildClusterDag(
+      Uint32Array.from(indices.getArray() as ArrayLike<number>),
+      positions,
+      dagOptions,
+    );
+    // No extension is created for a declined primitive, so a document whose every primitive is
+    // card soup never declares `TN_virtual_geometry` at all.
+    if (declines(dag, sourceTriangles)) {
+      declined += 1;
+      continue;
     }
+    extension ??= document.createExtension(TNVirtualGeometry).setRequired(false);
+    const virtual = attachVirtualGeometry(document, extension, primitive, dag);
+    clusters += dag.clusters.length;
+    levels = Math.max(levels, dag.levels.length);
+    payloadBytes += virtualGeometryBytes(virtual);
+    primitives += 1;
+    stopReason = worse(stopReason, dag.stopReason);
   }
 
   return {
     bakeSeconds: (now() - started) / 1000,
     clusters,
+    declined,
     levels,
     payloadBytes,
     primitives,

From 73ce0f45d444ac2badfd0de25bf5c23b253b6e8d Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 18:31:36 -0700
Subject: [PATCH 28/36] docs(PRD-485): Hornbeam far rung 5.13%, web scenario
 passes

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index e829476b3c..8e3fa63cf8 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -57,7 +57,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 **Files:** `packages/assets/src/lod/eligibility.ts` only if the Hornbeam is declined; `fab-import-proof/threenative.config.ts` (sandbox)
 - [x] [local] `fab-import-proof` builds on web with `assets` reduced to `exclude`. The build report shows the Hornbeam's six embedded textures encoded and 0 uncooked bytes for its GLB. proof: `npx threenative build`, `dist.build-report.json`. **Result 2026-10-03:** sandbox branch `prd485/fab-import-default-cook` (local worktree, engine tarballs from this branch), `npx threenative build --target web` exit 0 in 163 s. Hornbeam 126,934,280 -> 26,990,484 B (-78.7%), 6 embedded PNGs -> KTX2 45,378,709 -> 16,382,827 B (GPU 134,217,726 -> 25,165,824 B, 3 ETC1S + 3 UASTC, 0 skipped), budget row `uncooked 0 bytes`, artifact 51,402,535 B. No `packages/` file needed changing.
 - [x] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03 (reopened box, closed):** cause `packages/assets/src/virtual/dag.ts:319` — the group fold simplifies each cluster group with `LockBorder` (`dag.ts:259`), and every edge of a disconnected alpha-cutout card is a border, so the first fold simplifies nothing, every level reports the source count and `stopReason: stalled`; the primitive was then `virtual-owned` (`lod/eligibility.ts:182`) and no ladder could take it. Fix `packages/assets/src/virtual/bake.ts`: the bake *declines* a primitive whose DAG stopped `stalled` while still holding >80% of its triangles (`VIRTUAL_BAKE_VERSION` 3 -> 4) and attaches no extension, so the primitive is unowned and the discrete ladder's card + terminal levels take it. Red on `virtual-pass.spec.ts` "hands cards it cannot reduce to the discrete ladder, which does reduce them" (16,384 MASK cards: `extensionsUsed` had `TN_virtual_geometry`, `lod.reasons ["virtual-owned"]`, far level 50%) and on the report line; green after (no `TN_virtual_geometry`, `lod.reasons []`, far level 1,638 = 5.0% of 32,768, `cellCoverage 1` on every level). Same lane, sandbox `prd485/fab-import-default-cook` with the repacked assets tarball: `npx threenative build --target web` exit 0, report row `lod …: 3 primitive(s) to 3 level(s), 755677 -> 38767 triangles, 7304028 payload bytes, 0 skipped` and `TN_virtual_geometry` gone from `extensionsUsed`. Per primitive: material 0 `225310 -> [113601, 56948, 11266]` (5.00%, absolute far error 0.331), material 1 `520018 -> [260988, 130580, 26001]` (5.00%, 0.253), material 2 `10349 -> [5190, 2595, 1500]` (14.49%, 0.211) — far total 38,767 = 5.13% of 755,677. Cooked GLB 26,990,484 -> 26,428,684 B (-561,800 B, the DAG payload). Known gap: `compile.ts` drops `entry.virtual` when it rebuilds the manifest entry, so the new `declined` count is in the pass summary and `formatModelSizes` but prints in neither CLI lane.
-- [ ] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`.
+- [ ] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`. **Web leg 2026-10-03:** `playtests/hornbeam.playtest.json` passes on nvidia/turing WebGPU (4 Fab imports, Hornbeam height in range, 5 textures, 755,677 LOD0 triangles near, 0 console/network/runtime errors). An earlier bridge-missing failure was the sandbox worktree lacking the gitignored `assets/fab/soul-cave` GLBs (engine failed closed naming the asset). Native desktop leg pending.
 
 #### Phase 3: Android and the cold-agent path
 **Status:** NOT STARTED

From 5b1479460b6594ef593663132641dba398ec9f28 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 18:36:15 -0700
Subject: [PATCH 29/36] =?UTF-8?q?docs(PRD-485):=20Phase=202=20done=20?=
 =?UTF-8?q?=E2=80=94=20Hornbeam=20passes=20web=20and=20native=20desktop?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 8e3fa63cf8..b19f3856f4 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -57,7 +57,7 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 **Files:** `packages/assets/src/lod/eligibility.ts` only if the Hornbeam is declined; `fab-import-proof/threenative.config.ts` (sandbox)
 - [x] [local] `fab-import-proof` builds on web with `assets` reduced to `exclude`. The build report shows the Hornbeam's six embedded textures encoded and 0 uncooked bytes for its GLB. proof: `npx threenative build`, `dist.build-report.json`. **Result 2026-10-03:** sandbox branch `prd485/fab-import-default-cook` (local worktree, engine tarballs from this branch), `npx threenative build --target web` exit 0 in 163 s. Hornbeam 126,934,280 -> 26,990,484 B (-78.7%), 6 embedded PNGs -> KTX2 45,378,709 -> 16,382,827 B (GPU 134,217,726 -> 25,165,824 B, 3 ETC1S + 3 UASTC, 0 skipped), budget row `uncooked 0 bytes`, artifact 51,402,535 B. No `packages/` file needed changing.
 - [x] [local] The cooked Hornbeam carries a `TN_discrete_lod` chain whose far rung is at most 10% of 755,677 triangles. proof: the build report's LOD row for the GLB. **Result 2026-10-03 (reopened box, closed):** cause `packages/assets/src/virtual/dag.ts:319` — the group fold simplifies each cluster group with `LockBorder` (`dag.ts:259`), and every edge of a disconnected alpha-cutout card is a border, so the first fold simplifies nothing, every level reports the source count and `stopReason: stalled`; the primitive was then `virtual-owned` (`lod/eligibility.ts:182`) and no ladder could take it. Fix `packages/assets/src/virtual/bake.ts`: the bake *declines* a primitive whose DAG stopped `stalled` while still holding >80% of its triangles (`VIRTUAL_BAKE_VERSION` 3 -> 4) and attaches no extension, so the primitive is unowned and the discrete ladder's card + terminal levels take it. Red on `virtual-pass.spec.ts` "hands cards it cannot reduce to the discrete ladder, which does reduce them" (16,384 MASK cards: `extensionsUsed` had `TN_virtual_geometry`, `lod.reasons ["virtual-owned"]`, far level 50%) and on the report line; green after (no `TN_virtual_geometry`, `lod.reasons []`, far level 1,638 = 5.0% of 32,768, `cellCoverage 1` on every level). Same lane, sandbox `prd485/fab-import-default-cook` with the repacked assets tarball: `npx threenative build --target web` exit 0, report row `lod …: 3 primitive(s) to 3 level(s), 755677 -> 38767 triangles, 7304028 payload bytes, 0 skipped` and `TN_virtual_geometry` gone from `extensionsUsed`. Per primitive: material 0 `225310 -> [113601, 56948, 11266]` (5.00%, absolute far error 0.331), material 1 `520018 -> [260988, 130580, 26001]` (5.00%, 0.253), material 2 `10349 -> [5190, 2595, 1500]` (14.49%, 0.211) — far total 38,767 = 5.13% of 755,677. Cooked GLB 26,990,484 -> 26,428,684 B (-561,800 B, the DAG payload). Known gap: `compile.ts` drops `entry.virtual` when it rebuilds the manifest entry, so the new `declined` count is in the pass summary and `formatModelSizes` but prints in neither CLI lane.
-- [ ] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`. **Web leg 2026-10-03:** `playtests/hornbeam.playtest.json` passes on nvidia/turing WebGPU (4 Fab imports, Hornbeam height in range, 5 textures, 755,677 LOD0 triangles near, 0 console/network/runtime errors). An earlier bridge-missing failure was the sandbox worktree lacking the gitignored `assets/fab/soul-cave` GLBs (engine failed closed naming the asset). Native desktop leg pending.
+- [x] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`. **Web leg 2026-10-03:** `playtests/hornbeam.playtest.json` passes on nvidia/turing WebGPU (4 Fab imports, Hornbeam height in range, 5 textures, 755,677 LOD0 triangles near, 0 console/network/runtime errors). An earlier bridge-missing failure was the sandbox worktree lacking the gitignored `assets/fab/soul-cave` GLBs (engine failed closed naming the asset). **Native desktop leg 2026-10-03:** `native-playtests/fab-import-native.playtest.json --target desktop` exit 0, 6/6 (4 imports, 8 textured, 5 masked, movement 4.97 m, 0 errors), 690 frames, adapter `native:vulkan/nvidia/NVIDIA GeForce RTX 2080/turing`, packaged from the installed `@threenative/runtime-native` 0.3.4 prebuilt; screenshot shows the Hornbeam canopy. Its first red was stale counts in the scenario (written before the Hornbeam import), corrected in the game branch.
 
 #### Phase 3: Android and the cold-agent path
 **Status:** NOT STARTED

From a281d7ee8e4afc0b5bc5ba6eb9c882337534038e Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 18:45:37 -0700
Subject: [PATCH 30/36] docs(PRD-485): the Fab import step names the default
 cook, not `"none"`

Phase 3 box 3. `finding-assets.md` already said the cook picks imported
GLBs up with no configuration; it now says what the cook does with them and
why `models: "none"` / `textures: "none"` is the wrong repair: a converted
Fab pack's embedded PNG/WebP maps become KTX2, its attributes are quantized
and Meshopt-compressed, and a `MASK` primitive gets a discrete LOD chain.
Turning a pass off ships every source byte verbatim and counts it all
against `assets.budget.uncooked`, which is what raises
TN_ASSETS_BUDGET_EXCEEDED. Measured on the Hornbeam: 126,934,280 ->
26,428,684 B, six embedded PNGs 45.4 MB -> 16.4 MB, 755,677 triangles to a
5.1% far rung.

Also names the three cook outputs a content-addressed glob cannot match
(`public/basis/`, `public/shared/`, `public/bake.receipt.json`), found by
building metahuman-lab's 301 MB tree through the cook.

The Phase 3 box 2 build leg is recorded beside its box, unticked: the cook
is exit 0 with 0 uncooked bytes, and the playtest is for the browser lane.

Proof: `pnpm exec vitest run scripts/__tests__/primary-docs.spec.ts` 7/7,
`pnpm check:docs` 2,229 links, plus check-doc-links/sync-agent-docs/
evidence-citations 30/30. No template file changed, so no scaffold hash moved.
---
 ...5-high-quality-assets-go-through-the-cook.md |  5 +++--
 .../agent-docs/references/finding-assets.md     | 17 +++++++++++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index b19f3856f4..20d9722067 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -60,8 +60,9 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 - [x] [local] The Hornbeam scenario passes on web and on native desktop from installed tarballs. proof: `playtests/hornbeam.playtest.json --browser-recipe webgpu` and `native-playtests/fab-import-native.playtest.json --target desktop`. **Web leg 2026-10-03:** `playtests/hornbeam.playtest.json` passes on nvidia/turing WebGPU (4 Fab imports, Hornbeam height in range, 5 textures, 755,677 LOD0 triangles near, 0 console/network/runtime errors). An earlier bridge-missing failure was the sandbox worktree lacking the gitignored `assets/fab/soul-cave` GLBs (engine failed closed naming the asset). **Native desktop leg 2026-10-03:** `native-playtests/fab-import-native.playtest.json --target desktop` exit 0, 6/6 (4 imports, 8 textured, 5 masked, movement 4.97 m, 0 errors), 690 frames, adapter `native:vulkan/nvidia/NVIDIA GeForce RTX 2080/turing`, packaged from the installed `@threenative/runtime-native` 0.3.4 prebuilt; screenshot shows the Hornbeam canopy. Its first red was stale counts in the scenario (written before the Hornbeam import), corrected in the game branch.
 
 #### Phase 3: Android and the cold-agent path
-**Status:** NOT STARTED
+**Status:** PARTIAL
 **Files:** `metahuman-lab` asset layout (sandbox); `packages/create-threenative/agent-docs/references/finding-assets.md`
 - [ ] [local] `fab-import-proof` packages its cooked KTX2 and Meshopt output for Android V8 and renders the Hornbeam on the emulator. proof: `native-playtests/fab-import-native.playtest.json --target android` on the local emulator.
 - [ ] [local] `metahuman-lab` serves `content/` from `assets/` through the cook with no `assets` block, and `face-controls.playtest.json` passes on web. proof: `npx threenative build` plus that scenario with `--browser-recipe webgpu`.
-- [ ] [local] `finding-assets.md`'s Fab import step says the default cook handles imported packs and that `"none"` is not a fix. proof: `pnpm exec vitest run scripts/__tests__/primary-docs.spec.ts` and `pnpm check:docs`.
+  Build leg 2026-10-03: sandbox branch `prd485/metahuman-lab-cook` (local worktree, engine tarballs from this branch). `npx threenative build --target web` exit 0 in 189 s, `threenative.config.ts` still carries no `assets` block. The 301 MB moved from `public/content/` to `assets/content/`, and the hand-written vite middleware that served it verbatim (`specimenContentPlugin`) is gone: `ctx.assets.resolve` reads `public/assets.manifest.json` and every load asks for the cooked name. `.dna` and `.strands.bin` are copied through as `kind: "other"` byte for byte (`head.dna` 4,829,103 B, `hair.strands.bin` 85,202,464 B) — an extension no pass owns gets a manifest entry like any other file. `specimen.glb` cooks 26,267,896 -> 16,104,464 B (-38.7%): 5 embedded PNGs 7,801,033 -> 2,957,889 B (3 uastc/etc1s, `T_MH_BentNormal_AO` and `T_Eye_N` kept under the existing `not-smaller` guard), 101,518 triangles and all 821 LOD0 morph targets intact, `EXT_meshopt_compression` + `KHR_mesh_quantization` + `KHR_texture_basisu` on the output, and `lod.reasons ["deforming", "authored-lod"]` — a skinned morph-target head is PRD-486's subject, not this one. `shirt.glb` 50,367,028 -> 543,040 B (-98.9%), `body.glb` 1,215,524 -> 349,680 B, 30 PNGs to KTX2 (total 162,186,687 B from 314,889,680 B of source). Budget `uncooked 0 bytes` against the 64,000,000 default ceiling — first time this game had a manifest at all. The scenario was not run in this lane, so the box stays open: `node packages/playtest/dist/runner/cli.js metahuman-lab/playtests/face-controls.playtest.json --url http://127.0.0.1:5197 --server-command "pnpm exec vite preview --host 127.0.0.1 --port 5197 --strictPort" --browser-recipe webgpu`.
+- [x] [local] `finding-assets.md`'s Fab import step says the default cook handles imported packs and that `"none"` is not a fix. proof: `pnpm exec vitest run scripts/__tests__/primary-docs.spec.ts` and `pnpm check:docs`. **Result 2026-10-03:** the Fab import step now states what the default cook does to a converted pack (embedded PNG and WebP to KTX2, quantization and Meshopt, a discrete LOD chain for a `MASK` primitive) with the measured Hornbeam numbers, and that `models: "none"`/`textures: "none"` are not a fix — they ship every source byte, count it all against `assets.budget.uncooked`, and are what makes the build fail with `TN_ASSETS_BUDGET_EXCEEDED`. Green: `primary-docs.spec.ts` 7/7, `check:docs` 2,229 links, `check-doc-links` + `sync-agent-docs` + `evidence-citations` 30/30. No template file changed, so no scaffold hash moved.
diff --git a/packages/create-threenative/agent-docs/references/finding-assets.md b/packages/create-threenative/agent-docs/references/finding-assets.md
index aefade4aee..cb4bc6386f 100644
--- a/packages/create-threenative/agent-docs/references/finding-assets.md
+++ b/packages/create-threenative/agent-docs/references/finding-assets.md
@@ -135,6 +135,23 @@ Then load the returned path the ordinary way:
 `ctx.assets.model("fab/soul-cave/.../SM_S_Soul_Statue.glb")`. The normal asset compiler picks the
 GLBs up from `assets/` with no extra configuration.
 
+**Cook the pack with the default settings. `models: "none"` and `textures: "none"` in
+`threenative.config.ts` are not a fix, and a reason to reach for them is a bug report, not a
+workaround.** A converted Fab pack is ordinary input to that cook, and the cook is where an
+expensive import stops being expensive: embedded PNG and WebP maps are transcoded to KTX2 and
+capped, mesh attributes are quantized and Meshopt-compressed, and a `MASK` (alpha-cutout)
+primitive is handed a discrete LOD chain, so the LOD0 triangle count in the GLB is not the
+triangle count the scene pays for. One measured tree: `SM_EuropeanHornbeam_Forest_01.glb` cooks
+126,934,280 → 26,428,684 B, its six embedded PNGs → KTX2 (45.4 MB → 16.4 MB), and its
+755,677-triangle foliage primitive down to a 5.1% far rung. Turning a pass off ships every source
+byte verbatim instead, counts all of them against `assets.budget.uncooked`, and is precisely what
+makes `threenative build` fail with `TN_ASSETS_BUDGET_EXCEEDED` — read `dist.build-report.json`
+before you conclude a pack is too big. An extension the cook owns no pass for (`.dna`,
+`.strands.bin`, a vendor data file) is copied through and still resolves through the same manifest
+entry, so nothing needs `public/` to serve it. Ignore what the cook writes beside the manifest —
+`public/basis/`, `public/shared/` and `public/bake.receipt.json` are outputs too, and a
+content-addressed name is not the only output name.
+
 What the import will and will not do:
 
 - **A pack of uncooked editor assets cannot be converted at all**, and this is the common case for

From d219c5e5601724512ab003d510e415984db89d22 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 19:28:27 -0700
Subject: [PATCH 31/36] fix(assets): deforming geometry keeps its vertex order
 through the cook (PRD-485)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`packages/assets/src/passes/model.ts:925` called the library's `reorder` on the
whole document, which renumbers the vertices of every primitive it finds. That is
the cheapest transmission-size win in the cook and it is invisible until
something outside the file holds a vertex index: the metahuman-lab's
`brows.skin.json` names the head vertex each brow strand root rides and reads its
position back every frame, and after the cook it indexed a different vertex
(`brow root 0 indexes head vertex 11498, which is not where it was prepared`).
Measured on the 26.3 MB Ada specimen, 87 of 24408 head-primitive slots survived
the reorder.

The cook cannot know who holds an index, so the rule is the broader one: **any
primitive whose vertex indices can be addressed from outside is undeclarable**,
and deforming — skinned, morph-targeted, or joint-bound — is the measurable proxy,
because it is the one case detectable from the file alone and a rig is where
index-addressed data comes from. `deforming()` in `lod/eligibility.ts` is now the
single definition of that word, shared with the discrete-LOD and joined-rung
rules that already refused the same geometry.

`reorder-static.ts` runs the remap per shared index buffer and skips any group
holding a deforming primitive. Compression is untouched:
`EXT_meshopt_compression` encodes whatever order it is handed, and `quantize`
renumbers nothing — `specimen.glb` cooks 16,104,464 -> 16,114,804 B (+0.06%), the
price of leaving the head's 24408 vertices where the sidecar expects them.
`MODEL_REORDER_VERSION` joins the pass configuration, or a warm compile entry
would keep serving the renumbered files this replaces.

Red/green in `packages/assets/__tests__/model-pass.spec.ts`: a skinned primitive
and a morph-targeted one come out of the cook with position k exactly where it
started and the same vertex count, while a static mesh in the same document is
still reordered (and still only reordered). `packages/assets/__tests__` 481
passed, `pnpm typecheck` and `pnpm lint` clean.
---
 packages/assets/__tests__/model-pass.spec.ts |  90 ++++++++++++
 packages/assets/src/lod/eligibility.ts       |  14 ++
 packages/assets/src/passes/model.ts          |  16 ++-
 packages/assets/src/passes/reorder-static.ts | 136 +++++++++++++++++++
 4 files changed, 254 insertions(+), 2 deletions(-)
 create mode 100644 packages/assets/src/passes/reorder-static.ts

diff --git a/packages/assets/__tests__/model-pass.spec.ts b/packages/assets/__tests__/model-pass.spec.ts
index 212e0969dc..a97bcfad86 100644
--- a/packages/assets/__tests__/model-pass.spec.ts
+++ b/packages/assets/__tests__/model-pass.spec.ts
@@ -151,6 +151,96 @@ describe("modelPass", () => {
     }
   });
 
+  it("should keep a deforming primitive's vertex order and still reorder a static one", async () => {
+    // A vertex index is an address, and something outside this cook may already hold one: a
+    // MetaHuman sidecar records the head vertex each brow strand root rides, and reads the position
+    // back at that index every frame. The cook cannot know who holds an index, so deforming
+    // geometry — skinned, morph-targeted, or carrying joint data — keeps its exact vertex order and
+    // count, and everything else is still reordered for transmission size.
+    const document = buildFixtureDocument({ textured: false });
+    const root = document.getRoot();
+    const character = root.listMeshes()[0];
+    const cloth = character?.listPrimitives()[0];
+    const head = character?.listPrimitives()[1];
+    if (cloth === undefined || head === undefined) throw new Error("Fixture lost a primitive.");
+    // Both reasons in one cook: the cloth stays skinned-only, the head also gains a morph target.
+    const buffer = head.getAttribute("POSITION")?.getBuffer() ?? null;
+    head.addTarget(
+      document.createPrimitiveTarget("head-jaw-open").setAttribute(
+        "POSITION",
+        document
+          .createAccessor("head-jaw-open-deltas")
+          .setBuffer(buffer)
+          .setType("VEC3")
+          .setArray(new Float32Array(Array.from({ length: 18 }, (_, index) => (index % 3) * 0.01))),
+      ),
+    );
+    // A static mesh whose index buffer is not already in draw order, so the reorder has real work
+    // to do on it: the jumbled order below is a non-identity meshoptimizer remap.
+    const staticIndices = [6, 1, 8, 0, 7, 3, 2, 4, 5];
+    const prop = document
+      .createPrimitive()
+      .setIndices(
+        document
+          .createAccessor("prop-indices")
+          .setBuffer(buffer)
+          .setType("SCALAR")
+          .setArray(Uint32Array.from(staticIndices)),
+      )
+      .setAttribute(
+        "POSITION",
+        document
+          .createAccessor("prop-positions")
+          .setBuffer(buffer)
+          .setType("VEC3")
+          .setArray(new Float32Array(Array.from({ length: 27 }, (_, index) => index))),
+      );
+    root
+      .listScenes()[0]
+      ?.addChild(
+        document.createNode("prop-root").setMesh(document.createMesh("prop").addPrimitive(prop)),
+      );
+
+    const source = (meshName: string, primitive: number): number[] => [
+      ...(root
+        .listMeshes()
+        .find((mesh) => mesh.getName() === meshName)
+        ?.listPrimitives()
+        [primitive]?.getAttribute("POSITION")
+        ?.getArray() ?? []),
+    ];
+    const before = {
+      cloth: source("character", 0),
+      head: source("character", 1),
+      prop: source("prop", 0),
+    };
+    // Lossless options, so the only stage that can move a vertex is `reorder` itself.
+    const result = await modelPass({
+      compact: false,
+      passes: { quantize: false },
+      textures: "none",
+      virtual: "none",
+    }).apply(Buffer.from(await new NodeIO().writeBinary(document)), "character.glb");
+    if (Buffer.isBuffer(result)) throw new Error("model pass returned an unchanged buffer");
+    const output = await readVerified(result.buffer);
+    const cooked = (meshName: string, primitive: number): number[] => [
+      ...(output
+        .listMeshes()
+        .find((mesh) => mesh.getName() === meshName)
+        ?.listPrimitives()
+        [primitive]?.getAttribute("POSITION")
+        ?.getArray() ?? []),
+    ];
+
+    expect(cooked("character", 0)).toEqual(before.cloth);
+    expect(cooked("character", 1)).toEqual(before.head);
+    // And the static half of the rule: reordered, and nothing but reordered.
+    expect(cooked("prop", 0)).not.toEqual(before.prop);
+    expect([...cooked("prop", 0)].sort((a, b) => a - b)).toEqual(
+      [...before.prop].sort((a, b) => a - b),
+    );
+  });
+
   it("decodes normalized ushort joint weights by their own component type in reachableStats", async () => {
     // External exporters ship WEIGHTS_0 as normalized UNSIGNED_SHORT. reachableStats must
     // decode them /65535 like the GPU does; the hardcoded ubyte scale (/255) reads raw
diff --git a/packages/assets/src/lod/eligibility.ts b/packages/assets/src/lod/eligibility.ts
index f3790f9cf3..88227a8cf9 100644
--- a/packages/assets/src/lod/eligibility.ts
+++ b/packages/assets/src/lod/eligibility.ts
@@ -55,6 +55,20 @@ function sharedByLevels(semantic: string): boolean {
 
 const DEFORMING_ATTRIBUTES: ReadonlySet<string> = new Set(["JOINTS_0", "WEIGHTS_0"]);
 
+/**
+ * Whether a primitive is deforming: skinned, morph-targeted, or carrying per-vertex joint data.
+ *
+ * The one definition of the word, shared by every rule that declines to rewrite geometry a rig
+ * drives — no discrete chain, no joined far rung, and no vertex reordering in the cook. A vertex
+ * index into deforming geometry is an address something outside the file may already hold, and a
+ * rig is where index-addressed data is most likely to come from: a MetaHuman sidecar records the
+ * head vertex each brow strand root rides and reads its position back every frame.
+ */
+export function deforming(primitive: Primitive, skinned: boolean): boolean {
+  if (skinned || primitive.listTargets().length > 0) return true;
+  return primitive.listSemantics().some((semantic) => DEFORMING_ATTRIBUTES.has(semantic));
+}
+
 const TRIANGLES_MODE = 4;
 
 const TRIANGLE = 3;
diff --git a/packages/assets/src/passes/model.ts b/packages/assets/src/passes/model.ts
index d9ebd4fba4..8f4d5dc0ed 100644
--- a/packages/assets/src/passes/model.ts
+++ b/packages/assets/src/passes/model.ts
@@ -18,7 +18,6 @@ import {
   listTextureSlots,
   prune,
   quantize,
-  reorder,
   simplify,
 } from "@gltf-transform/functions";
 import { MeshoptEncoder, MeshoptSimplifier } from "meshoptimizer";
@@ -71,6 +70,7 @@ import {
   textureBindings,
   textureKeys,
 } from "./model-textures.js";
+import { reorderStaticPrimitives } from "./reorder-static.js";
 import {
   type ISharedImage,
   type ISharedImageStore,
@@ -243,6 +243,12 @@ const MATERIAL_MERGE_VERSION = 1;
  * which the compile digest already hashes, so it invalidates model outputs and nothing else.
  */
 const MODEL_DEDUPE_VERSION = 1;
+/**
+ * Bumped when `reorder-static.ts` changes what it emits: every model cooked before this fix had its
+ * deforming geometry renumbered, and a warm cache entry keyed on the pass switches alone would keep
+ * serving those files. 1 = deforming primitives keep their authored vertex order and count.
+ */
+const MODEL_REORDER_VERSION = 1;
 
 /** Relative bounding-box tolerance of the self-verify check (PRD: 0.1%). */
 const BBOX_TOLERANCE = 0.001;
@@ -803,6 +809,9 @@ export function modelPass(options: IModelPassOptions = {}): IAssetPass {
       // content-identical sources, so a bake published before this key existed named one output
       // per copy and must not be re-served as if it had deduped.
       dedupe: MODEL_DEDUPE_VERSION,
+      // Same reason: which primitives `reorder` declines to renumber is part of the output, and a
+      // warm entry from before it declined would hand a game geometry its sidecars cannot address.
+      reorderVersion: MODEL_REORDER_VERSION,
       // `"none"` and "absent" are different cache keys on purpose: absent bakes with defaults.
       virtual:
         options.virtual === "none"
@@ -922,7 +931,10 @@ export function modelPass(options: IModelPassOptions = {}): IAssetPass {
         })(document);
       }
       if (enabled.reorder || enabled.meshopt) await MeshoptEncoder.ready;
-      if (enabled.reorder) await reorder({ encoder: MeshoptEncoder })(document);
+      // The last stage that moves a vertex, and the only one that does so selectively: deforming
+      // geometry keeps its authored vertex order because a vertex index into it is an address
+      // something outside this file may already hold. `reorder-static.ts`.
+      if (enabled.reorder) reorderStaticPrimitives(document, MeshoptEncoder);
       // After `reorder`, which is the last stage that moves a vertex, and before `quantize`, which
       // changes what a position is but never which vertex it is.
       const virtual =
diff --git a/packages/assets/src/passes/reorder-static.ts b/packages/assets/src/passes/reorder-static.ts
new file mode 100644
index 0000000000..7e4551dca1
--- /dev/null
+++ b/packages/assets/src/passes/reorder-static.ts
@@ -0,0 +1,136 @@
+// The model pass's `reorder` stage, over the primitives whose vertex order nothing else owns.
+//
+// `reorder` from `@gltf-transform/functions` walks the whole document and renumbers the vertices
+// of every primitive it finds, which is the cheapest transmission-size win in the cook — and it
+// breaks every file that addresses a vertex by index. A MetaHuman sidecar names the head vertex
+// each brow strand root rides and reads that position back every frame; after an unconditional
+// reorder it indexes a different vertex (`brow root 0 indexes head vertex 11498, which is not where
+// it was prepared`). The cook cannot know who holds an index, so the general rule is that any
+// primitive whose indices can be addressed from outside is undeclarable, and *deforming* — skinned,
+// morph-targeted, or joint-bound — is the measurable proxy: a rig is where index-addressed data
+// comes from, and it is the one case detectable from the file alone.
+//
+// So the vertex-cache remap is applied per index-buffer group, and a group holding any deforming
+// primitive is left exactly as authored. Compression is unaffected: `EXT_meshopt_compression` encodes
+// whatever order it is handed, and `quantize` renumbers nothing.
+//
+// ponytail: the library's `reorder` has no per-primitive switch, so the remap is its own ~30 lines.
+// Replace with the library's whole-document `reorder` the day it takes a predicate.
+
+import { type Accessor, type Document, type Mesh, Primitive } from "@gltf-transform/core";
+import type { MeshoptEncoder } from "meshoptimizer";
+import { deforming } from "../lod/eligibility.js";
+
+/** One index buffer, the attributes that read through it, and the primitives that draw it. */
+interface IVertexGroup {
+  readonly attributes: Accessor[];
+  readonly members: { readonly primitive: Primitive; readonly skinned: boolean }[];
+}
+
+/** meshoptimizer's own 16-bit index ceiling, as the library's `reorder` measures it. */
+const MAX_UINT16 = 65534;
+
+/**
+ * Reorder every non-deforming primitive's vertices for transmission size, in place. Returns how
+ * many index-buffer groups were rewritten.
+ *
+ * Grouped by shared index buffer rather than by primitive, because primitives sharing one index
+ * buffer share the renumbering: remapping one and not the other desynchronises them. Mirrors the
+ * library's own `reorder` for the groups it does touch, minus its cleanup prune — the pass's `prune`
+ * runs before this stage, and the writer emits reachable properties only.
+ */
+export function reorderStaticPrimitives(
+  document: Document,
+  encoder: typeof MeshoptEncoder,
+): number {
+  let reordered = 0;
+  for (const [indices, group] of vertexGroups(document)) {
+    if (group.members.some((member) => deforming(member.primitive, member.skinned))) continue;
+    remapGroup(indices, group, encoder);
+    reordered += 1;
+  }
+  return reordered;
+}
+
+/** Every index buffer in the document, with the attributes and primitives that read through it. */
+function vertexGroups(document: Document): Map<Accessor, IVertexGroup> {
+  const skinned = skinnedMeshes(document);
+  const groups = new Map<Accessor, IVertexGroup>();
+  for (const mesh of document.getRoot().listMeshes())
+    for (const primitive of mesh.listPrimitives()) {
+      const indices = primitive.getIndices();
+      if (indices === null) continue;
+      const group = groups.get(indices) ?? { attributes: [], members: [] };
+      group.members.push({ primitive, skinned: skinned.has(mesh) });
+      for (const semantic of primitive.listSemantics()) {
+        const attribute = primitive.getAttribute(semantic);
+        if (attribute !== null && !group.attributes.includes(attribute))
+          group.attributes.push(attribute);
+      }
+      groups.set(indices, group);
+    }
+  return groups;
+}
+
+/** The meshes a skin is bound to: everything under one of those nodes is deforming. */
+function skinnedMeshes(document: Document): Set<Mesh> {
+  const skinned = new Set<Mesh>();
+  for (const node of document.getRoot().listNodes()) {
+    const mesh = node.getMesh();
+    if (mesh !== null && node.getSkin() !== null) skinned.add(mesh);
+  }
+  return skinned;
+}
+
+/** Renumber one group's vertices, and every primitive that draws them, in place. */
+function remapGroup(indices: Accessor, group: IVertexGroup, encoder: typeof MeshoptEncoder): void {
+  const source = indices.getArray();
+  const triangles = group.members.every(
+    (member) => member.primitive.getMode() === Primitive.Mode.TRIANGLES,
+  );
+  // The encoder renumbers the array it is handed in place and returns the old-to-new table, so the
+  // copy is the destination index buffer and `source` still reads the authored one.
+  const remapped = source instanceof Uint32Array ? source.slice() : new Uint32Array(source);
+  const [remap, unique] = encoder.reorderMesh(remapped, triangles, true);
+  const dstIndices = indices
+    .clone()
+    .setArray(unique <= MAX_UINT16 ? new Uint16Array(remapped) : remapped);
+  const dstAttributes = new Map<Accessor, Accessor>();
+  for (const attribute of group.attributes)
+    dstAttributes.set(attribute, compactAttribute(attribute, source, remap, unique));
+  for (const member of group.members) {
+    for (const semantic of member.primitive.listSemantics()) {
+      const attribute = member.primitive.getAttribute(semantic);
+      if (attribute === null) continue;
+      member.primitive.setAttribute(semantic, dstAttributes.get(attribute) ?? attribute);
+    }
+    member.primitive.setIndices(dstIndices);
+  }
+  for (const attribute of group.attributes)
+    if (attribute.listParents().length === 0) attribute.dispose();
+  if (indices.listParents().length === 0) indices.dispose();
+}
+
+/** One attribute rewritten into the renumbered vertex stream, dropping what no triangle reaches. */
+function compactAttribute(
+  attribute: Accessor,
+  source: ArrayLike<number>,
+  remap: Uint32Array,
+  unique: number,
+): Accessor {
+  const array = attribute.getArray();
+  const width = attribute.getElementSize();
+  const compact = new array.constructor(unique * width);
+  // One write per destination vertex: a vertex several triangles reference is copied once.
+  const written = new Uint8Array(unique);
+  for (let index = 0; index < source.length; index += 1) {
+    const from = source[index] ?? 0;
+    const to = remap[from];
+    if (to === undefined || written[to] === 1) continue;
+    written[to] = 1;
+    for (let component = 0; component < width; component += 1)
+      compact[to * width + component] = array[from * width + (component ?? 0)];
+  }
+  // Sparse is cleared: it indexes the source's vertex stream and this one has been renumbered.
+  return attribute.clone().setArray(compact).setSparse(false);
+}

From f27cb22997df60bef84a9603a660d1c670ee638e Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <joaopaulofurtado@live.com>
Date: Sat, 3 Oct 2026 20:20:43 -0700
Subject: [PATCH 32/36] fix(assets): deforming geometry keeps its positions in
 source metres through the cook (PRD-485)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`packages/assets/src/passes/model.ts:964` handed the whole document to the library's
`quantize`, which rewrites POSITION into normalized int16 snapped to a grid whose step is
the mesh's own bounding volume and then folds that shift into the node holding the mesh, the
skin's inverse bind matrices, GPU instancing batches and any volumetric material. Exact for a
static mesh; for a rigged one it breaks the invariant this repo holds, one metre is one metre.
The metahuman-lab's `brows.skin.json` names the head vertex each brow strand root rides and
reads its position back every frame, and the sidecar was prepared against the source file to
1e-5 m — the 16-bit grid over a head-sized volume is micrometres away from every vertex it
recorded, and the shift that would undo it lives in a node transform the sidecar never sees.

So the same `deforming()` rule that stopped the cook renumbering a rigged vertex now stops it
quantizing one: a deforming mesh keeps POSITION and its morph-target POSITION deltas as the
float32 values the author wrote, at every requested depth. `quantize-static.ts` holds those
meshes across the stage and spends the window with each mesh detached from its nodes, so the
library's node, skin, instancing and thickness compensation is never applied and there is
nothing to undo; normals, UVs, colours and every static primitive still quantize, and
`EXT_meshopt_compression` still encodes whatever the accessors hold (its `QUANTIZE` encoder
method only names the pre-processing, which is this stage). The unit of source space is the
mesh, because the compensation is per mesh — one deforming primitive holds the whole thing.
An index buffer the stage replaced fails the cook by name rather than shipping a mesh whose
vertices have quietly moved, and `snapPositions` skips rigged meshes for the same reason it
exists to snap them. `MODEL_QUANTIZE_VERSION` joins the pass configuration so a warm compile
entry cannot keep serving the quantized files this replaces.

Red/green in `packages/assets/__tests__/model-pass.spec.ts`: a skinned primitive that also
carries a morph target comes out of the cook with float32 POSITION equal to the source within
1e-6, float32 deltas, and its skin's inverse bind matrices untouched, while a static mesh in
the same document still quantizes to normalized int16 under KHR_mesh_quantization. The 4-bit
floor test now states what is true of it: that request used to land on the fixture's skinned
head and trip the self-verify at 0.167% drift; it no longer reaches deforming geometry at all,
and the fail-closed comparison is covered directly by the drift-kind test. `packages/assets/
__tests__` 482 passed | 2 skipped, `pnpm typecheck` clean, biome clean on the four files.
---
 packages/assets/__tests__/model-pass.spec.ts  | 183 +++++++++++++++++-
 packages/assets/src/lod/eligibility.ts        |  25 ++-
 packages/assets/src/passes/model.ts           |  43 ++--
 packages/assets/src/passes/quantize-static.ts | 160 +++++++++++++++
 packages/assets/src/passes/reorder-static.ts  |  14 +-
 5 files changed, 393 insertions(+), 32 deletions(-)
 create mode 100644 packages/assets/src/passes/quantize-static.ts

diff --git a/packages/assets/__tests__/model-pass.spec.ts b/packages/assets/__tests__/model-pass.spec.ts
index a97bcfad86..deda4921ea 100644
--- a/packages/assets/__tests__/model-pass.spec.ts
+++ b/packages/assets/__tests__/model-pass.spec.ts
@@ -89,14 +89,68 @@ describe("modelPass", () => {
     }
   });
 
-  it("should throw naming bounding-box drift when positions quantize to 4 bits", async () => {
-    const input = Buffer.from(await buildFixtureGlb());
-    await expect(
-      modelPass({ quantize: { normalBits: 16, positionBits: 4, uvBits: 12 } }).apply(
-        input,
-        "character.glb",
-      ),
-    ).rejects.toThrow(/TN_ASSETS_MODEL_DRIFT.*bounding box drifted/u);
+  it("should leave deforming positions alone at a depth below the quantization floor", async () => {
+    // Four bits is the destructive pre-round the library refuses to express: the pass snaps floats
+    // onto a 15-level grid over each accessor's own bounds and lets the self-verify reject the
+    // result. That request used to land on the fixture's skinned head — and used to trip the
+    // self-verify at 0.167% drift. Deforming geometry is now held in source space at every depth,
+    // so the request never reaches it and there is nothing left to reject; the fail-closed path
+    // itself is covered by the drift-kind comparison further down. The static half of the document
+    // still quantizes, which is what keeps the two halves of the rule honest.
+    const document = buildFixtureDocument({ textured: false });
+    const root = document.getRoot();
+    const head = root.listMeshes()[0]?.listPrimitives()[1];
+    const buffer = head?.getAttribute("POSITION")?.getBuffer() ?? null;
+    if (head === undefined || buffer === null) throw new Error("Fixture lost its rig.");
+    const prop = document
+      .createPrimitive()
+      .setIndices(
+        document
+          .createAccessor("prop-indices")
+          .setBuffer(buffer)
+          .setType("SCALAR")
+          .setArray(
+            Uint32Array.from([
+              0, 10, 20, 1, 11, 21, 2, 12, 22, 3, 13, 23, 4, 14, 24, 5, 15, 25, 6, 16, 26, 7, 17, 8,
+              18, 19, 9,
+            ]),
+          ),
+      )
+      .setAttribute(
+        "POSITION",
+        document
+          .createAccessor("prop-positions")
+          .setBuffer(buffer)
+          .setType("VEC3")
+          .setArray(new Float32Array(Array.from({ length: 81 }, (_, index) => index))),
+      );
+    root
+      .listScenes()[0]
+      ?.addChild(
+        document.createNode("prop-root").setMesh(document.createMesh("prop").addPrimitive(prop)),
+      );
+    const positions = [...(head.getAttribute("POSITION")?.getArray() ?? [])];
+    const result = await modelPass({
+      compact: false,
+      quantize: { normalBits: 16, positionBits: 4, uvBits: 12 },
+      textures: "none",
+      virtual: "none",
+    }).apply(Buffer.from(await new NodeIO().writeBinary(document)), "character.glb");
+    expect(Buffer.isBuffer(result)).toBe(false);
+    if (Buffer.isBuffer(result)) return;
+    const output = await readVerified(result.buffer);
+    expect([
+      ...(output.listMeshes()[0]?.listPrimitives()[1]?.getAttribute("POSITION")?.getArray() ?? []),
+    ]).toEqual(positions);
+    expect(
+      output
+        .listMeshes()
+        .find((mesh) => mesh.getName() === "prop")
+        ?.listPrimitives()[0]
+        ?.getAttribute("POSITION")
+        ?.getComponentSize(),
+      // Eight bits is the floor the request resolves to, and it lands as normalized Int8.
+    ).toBe(1);
   });
 
   it("should declare EXT_meshopt_compression and not Draco", async () => {
@@ -241,6 +295,119 @@ describe("modelPass", () => {
     );
   });
 
+  it("should keep a deforming primitive's positions in source metres and still quantize a static one", async () => {
+    // One metre is one metre. `quantize` snaps POSITION onto a grid whose step is the mesh's own
+    // volume over 2^bits, so a head cooked at 16 bits over half a metre lands within ~8 µm of
+    // where the author put it — and the metahuman-lab sidecar, which names the head vertex each
+    // brow strand root rides and reads that position back every frame, was prepared to 1e-5 m.
+    // Quantization also compensates by folding a shift into the node, the skin's inverse bind
+    // matrices and any volumetric material, so the whole mesh stays in source space instead:
+    // deforming POSITION and its morph-target deltas keep float32, everything else still quantizes.
+    const document = buildFixtureDocument({ textured: false });
+    const root = document.getRoot();
+    const character = root.listMeshes().find((mesh) => mesh.getName() === "character");
+    const cloth = character?.listPrimitives()[0];
+    const head = character?.listPrimitives()[1];
+    const skin = root.listSkins()[0];
+    const buffer = head?.getAttribute("POSITION")?.getBuffer() ?? null;
+    if (cloth === undefined || head === undefined || skin === undefined || buffer === null)
+      throw new Error("Fixture lost its rig.");
+    // Both reasons in one cook, as in the vertex-order twin: the head is skinned and morph-targeted.
+    const deltas = new Float32Array(Array.from({ length: 18 }, (_, index) => (index % 3) * 0.004));
+    head.addTarget(
+      document
+        .createPrimitiveTarget("jaw-open")
+        .setAttribute(
+          "POSITION",
+          document
+            .createAccessor("jaw-open-deltas")
+            .setBuffer(buffer)
+            .setType("VEC3")
+            .setArray(deltas),
+        ),
+    );
+    // A static mesh in the same document, on its own node: the half of the rule that must not regress.
+    const prop = document
+      .createPrimitive()
+      .setIndices(
+        document
+          .createAccessor("prop-indices")
+          .setBuffer(buffer)
+          .setType("SCALAR")
+          .setArray(
+            // Every vertex referenced exactly once, so the library's own vertex compaction inside
+            // `quantize` has nothing to drop and the bbox the self-verify reads is the authored one.
+            Uint32Array.from([
+              0, 10, 20, 1, 11, 21, 2, 12, 22, 3, 13, 23, 4, 14, 24, 5, 15, 25, 6, 16, 26, 7, 17, 8,
+              18, 19, 9,
+            ]),
+          ),
+      )
+      .setAttribute(
+        "POSITION",
+        document
+          .createAccessor("prop-positions")
+          .setBuffer(buffer)
+          .setType("VEC3")
+          // 27 vertices, every one of them referenced by the indices above.
+          .setArray(new Float32Array(Array.from({ length: 81 }, (_, index) => index))),
+      );
+    root
+      .listScenes()[0]
+      ?.addChild(
+        document.createNode("prop-root").setMesh(document.createMesh("prop").addPrimitive(prop)),
+      );
+
+    const positions = [...(head.getAttribute("POSITION")?.getArray() ?? [])];
+    const binds = [...(skin.getInverseBindMatrices()?.getArray() ?? [])];
+    const result = await modelPass({ compact: false, textures: "none", virtual: "none" }).apply(
+      Buffer.from(await new NodeIO().writeBinary(document)),
+      "character.glb",
+    );
+    if (Buffer.isBuffer(result)) throw new Error("model pass returned an unchanged buffer");
+    const output = await readVerified(result.buffer);
+    const cookedHead = output
+      .listMeshes()
+      .find((mesh) => mesh.getName() === "character")
+      ?.listPrimitives()[1];
+    const cookedCloth = output
+      .listMeshes()
+      .find((mesh) => mesh.getName() === "character")
+      ?.listPrimitives()[0];
+    const cookedProp = output
+      .listMeshes()
+      .find((mesh) => mesh.getName() === "prop")
+      ?.listPrimitives()[0];
+
+    const cookedPositions = cookedHead?.getAttribute("POSITION");
+    expect(cookedPositions?.getComponentType()).toBe(5126);
+    const after = [...(cookedPositions?.getArray() ?? [])];
+    expect(after.length).toBe(positions.length);
+    for (const [index, value] of after.entries())
+      expect(Math.abs((value as number) - (positions[index] as number))).toBeLessThan(1e-6);
+    // The deltas ride the same space, so they keep their float32 metres too.
+    const cookedDeltas = cookedHead?.listTargets()[0]?.getAttribute("POSITION");
+    expect(cookedDeltas?.getComponentType()).toBe(5126);
+    expect([...(cookedDeltas?.getArray() ?? [])]).toEqual([...deltas]);
+    // Nothing moved to compensate: the bind poses the deformation is measured against are the
+    // authored ones, and the normals that do not address a vertex still quantized.
+    const cookedBinds = [...(output.listSkins()[0]?.getInverseBindMatrices()?.getArray() ?? [])];
+    expect(cookedBinds.length).toBe(binds.length);
+    for (const [index, value] of cookedBinds.entries())
+      expect(Math.abs((value as number) - (binds[index] as number))).toBeLessThan(1e-6);
+    expect(cookedCloth?.getAttribute("POSITION")?.getComponentType()).toBe(5126);
+    expect(cookedCloth?.getAttribute("NORMAL")?.getComponentSize()).toBeLessThan(4);
+    // And the static half of the rule, unchanged: quantized, normalized, KHR_mesh_quantization on.
+    expect(cookedProp?.getAttribute("POSITION")?.getComponentSize()).toBe(2);
+    expect(cookedProp?.getAttribute("POSITION")?.getNormalized()).toBe(true);
+    expect(
+      output
+        .listExtensionsUsed()
+        .map((extension) => extension.extensionName)
+        .includes("KHR_mesh_quantization"),
+    ).toBe(true);
+  });
+
   it("decodes normalized ushort joint weights by their own component type in reachableStats", async () => {
     // External exporters ship WEIGHTS_0 as normalized UNSIGNED_SHORT. reachableStats must
     // decode them /65535 like the GPU does; the hardcoded ubyte scale (/255) reads raw
diff --git a/packages/assets/src/lod/eligibility.ts b/packages/assets/src/lod/eligibility.ts
index 88227a8cf9..3cbf54077d 100644
--- a/packages/assets/src/lod/eligibility.ts
+++ b/packages/assets/src/lod/eligibility.ts
@@ -4,7 +4,13 @@
 // structurally intact is declined with a named reason rather than forced to a triangle target. An
 // inability to reduce safely is a normal skip, not a failure.
 
-import type { Material, Primitive } from "@gltf-transform/core";
+import {
+  type Document,
+  type Material,
+  type Mesh,
+  Node,
+  type Primitive,
+} from "@gltf-transform/core";
 
 /** The stable reason codes reported for a primitive that gets no automatic discrete chain. */
 export type DiscreteLodSkipReason =
@@ -69,6 +75,23 @@ export function deforming(primitive: Primitive, skinned: boolean): boolean {
   return primitive.listSemantics().some((semantic) => DEFORMING_ATTRIBUTES.has(semantic));
 }
 
+/** The mesh-level half of {@link deforming}: the node compensation quantization applies is per mesh,
+ * so one deforming primitive is enough to hold every position the mesh carries. */
+export function deformingMesh(mesh: Mesh, skinned: ReadonlySet<Mesh>): boolean {
+  const isSkinned = skinned.has(mesh);
+  return isSkinned || mesh.listPrimitives().some((primitive) => deforming(primitive, isSkinned));
+}
+
+/** The meshes a skin is bound to, shared by every rule that asks whether a rig drives a mesh. */
+export function skinnedMeshes(document: Document): Set<Mesh> {
+  const skinned = new Set<Mesh>();
+  for (const node of document.getRoot().listNodes()) {
+    const mesh = node.getMesh();
+    if (mesh !== null && node.getSkin() !== null) skinned.add(mesh);
+  }
+  return skinned;
+}
+
 const TRIANGLES_MODE = 4;
 
 const TRIANGLE = 3;
diff --git a/packages/assets/src/passes/model.ts b/packages/assets/src/passes/model.ts
index 8f4d5dc0ed..15bae8175b 100644
--- a/packages/assets/src/passes/model.ts
+++ b/packages/assets/src/passes/model.ts
@@ -4,6 +4,7 @@ import {
   Accessor,
   type Document,
   type GLTF,
+  type Mesh as GltfMesh,
   type Node as GltfNode,
   type Primitive as GltfPrimitive,
   NodeIO,
@@ -30,6 +31,7 @@ import {
 import { type IMaterialMergeSummary, mergeIdenticalMaterials } from "../foliage.js";
 import { createGltfReader, readGltfDocument } from "../gltf-io.js";
 import { KTX2_ENCODER_VERSION } from "../ktx2-encoder.js";
+import { deformingMesh, skinnedMeshes } from "../lod/eligibility.js";
 import { TNDiscreteLod } from "../lod/extension.js";
 import {
   type IModelLodOptions,
@@ -70,6 +72,7 @@ import {
   textureBindings,
   textureKeys,
 } from "./model-textures.js";
+import { quantizeStaticGeometry } from "./quantize-static.js";
 import { reorderStaticPrimitives } from "./reorder-static.js";
 import {
   type ISharedImage,
@@ -249,6 +252,13 @@ const MODEL_DEDUPE_VERSION = 1;
  * serving those files. 1 = deforming primitives keep their authored vertex order and count.
  */
 const MODEL_REORDER_VERSION = 1;
+/**
+ * Bumped when `quantize-static.ts` changes what it emits: every model cooked before this fix had its
+ * deforming positions snapped onto a quantization grid, and a warm cache entry keyed on the pass
+ * switches alone would keep serving those files. 1 = deforming POSITION and morph-target deltas
+ * stay float32 in the source metre space.
+ */
+const MODEL_QUANTIZE_VERSION = 1;
 
 /** Relative bounding-box tolerance of the self-verify check (PRD: 0.1%). */
 const BBOX_TOLERANCE = 0.001;
@@ -710,11 +720,14 @@ export function assertSimplifiedWithinBounds(
  * Snaps every scene-reachable POSITION accessor onto a uniform `2^bits` grid spanning its
  * own bounds — the destructive low-precision quantization the underlying library refuses
  * to express. Used only for configured depths below its 8-bit floor; the self-verify is
- * expected to reject the result.
+ * expected to reject the result. Deforming meshes are skipped for the same reason the
+ * quantization stage skips them: a grid that coarse moves vertices a sidecar already
+ * addresses, and holding them is the rule rather than the bit depth.
  */
-function snapPositions(root: RootOf, bits: number): void {
+function snapPositions(root: RootOf, bits: number, skinned: ReadonlySet<GltfMesh>): void {
   const levels = 2 ** bits - 1;
   for (const mesh of root.listMeshes()) {
+    if (deformingMesh(mesh, skinned)) continue;
     for (const primitive of mesh.listPrimitives()) {
       const position = primitive.getAttribute("POSITION");
       if (position === null || position.getNormalized()) continue;
@@ -812,6 +825,9 @@ export function modelPass(options: IModelPassOptions = {}): IAssetPass {
       // Same reason: which primitives `reorder` declines to renumber is part of the output, and a
       // warm entry from before it declined would hand a game geometry its sidecars cannot address.
       reorderVersion: MODEL_REORDER_VERSION,
+      // Same reason again: which positions keep their source metres is part of the output, and a
+      // warm entry from before they did would hand a game geometry its sidecars cannot address.
+      quantizeVersion: MODEL_QUANTIZE_VERSION,
       // `"none"` and "absent" are different cache keys on purpose: absent bakes with defaults.
       virtual:
         options.virtual === "none"
@@ -957,18 +973,23 @@ export function modelPass(options: IModelPassOptions = {}): IAssetPass {
         // Depths below the library's 8-bit floor are honoured by pre-rounding the floats
         // onto the coarser grid first; the self-verify then fails the build on the drift.
         const requestedBits = options.quantize?.positionBits ?? DEFAULT_POSITION_BITS;
-        if (requestedBits < 8) snapPositions(document.getRoot(), requestedBits);
+        if (requestedBits < 8)
+          snapPositions(document.getRoot(), requestedBits, skinnedMeshes(document));
         // Joint indices and weights are excluded outright: quantizing them below the
         // exporter's declaration is where skinned meshes visibly break, and the library's
         // own default narrows weights to 8 bits unless told otherwise.
-        await quantize({
-          quantizeColor: 8,
-          quantizeNormal: options.quantize?.normalBits ?? DEFAULT_NORMAL_BITS,
-          quantizePosition: Math.max(requestedBits, 8),
-          quantizeTexcoord: options.quantize?.uvBits ?? DEFAULT_UV_BITS,
-          pattern: /^(?!JOINTS|WEIGHTS)/u,
-          normalizeWeights: false,
-        })(document);
+        // Deforming geometry keeps float32 POSITION in the source metre space on top of
+        // that, so nothing a sidecar addresses moves: `quantize-static.ts`.
+        await quantizeStaticGeometry(document, () =>
+          quantize({
+            quantizeColor: 8,
+            quantizeNormal: options.quantize?.normalBits ?? DEFAULT_NORMAL_BITS,
+            quantizePosition: Math.max(requestedBits, 8),
+            quantizeTexcoord: options.quantize?.uvBits ?? DEFAULT_UV_BITS,
+            pattern: /^(?!JOINTS|WEIGHTS)/u,
+            normalizeWeights: false,
+          })(document),
+        );
       }
       // Taken after every geometry stage and before compression, so what it proves is that
       // *this* stage plus the writer preserved each binding — prune's documented drops of
diff --git a/packages/assets/src/passes/quantize-static.ts b/packages/assets/src/passes/quantize-static.ts
new file mode 100644
index 0000000000..487454044d
--- /dev/null
+++ b/packages/assets/src/passes/quantize-static.ts
@@ -0,0 +1,160 @@
+// The model pass's `quantize` stage, over the primitives whose positions nothing else may move.
+//
+// `quantize` from `@gltf-transform/functions` walks the whole document and rewrites POSITION into
+// 16-bit integers snapped to a grid whose step is the mesh's own bounding volume — the largest size
+// win in the cook — and then compensates by folding that shift into the node holding the mesh, the
+// skin's inverse bind matrices, GPU instancing batches and any volumetric material.
+//
+// That is exact for static geometry. For geometry a rig drives it breaks the invariant this repo
+// holds: one metre is one metre. The metahuman-lab's `brows.skin.json` names the head vertex each
+// brow strand root rides and reads its position back every frame, prepared against the source file
+// to within 1e-5 m; a head snapped onto a 16-bit grid over its own volume is micrometres away from
+// every vertex the sidecar recorded, and the shift that would undo it lives in a node transform the
+// sidecar never sees.
+//
+// So a deforming mesh is held in source space across the stage: POSITION and the morph-target
+// deltas riding it keep the exact values their author wrote, and the mesh spends the stage detached
+// from its nodes, so there is no compensation to undo — the skin, the node matrices, the instancing
+// batch and a volume material's thickness are simply never touched. Everything else still quantizes,
+// and `EXT_meshopt_compression` still encodes whatever the accessors hold.
+//
+// ponytail: the library's `quantize` takes one document-wide pattern with no per-mesh switch, and
+// its node compensation is inseparable from the positions it shifts, so holding is its own ~60
+// lines. Replace with the library's own `quantize` the day it takes a deforming predicate.
+
+import type {
+  Accessor,
+  Document,
+  ExtensionProperty,
+  Material,
+  Mesh,
+  Primitive,
+  PrimitiveTarget,
+  TypedArray,
+} from "@gltf-transform/core";
+import { Node } from "@gltf-transform/core";
+import { deformingMesh, skinnedMeshes } from "../lod/eligibility.js";
+
+/** What a primitive and a morph target both expose for one attribute, so one call serves both. */
+type IAttributeOwner = {
+  getAttribute(semantic: string): Accessor | null;
+  setAttribute(semantic: string, accessor: Accessor | null): unknown;
+};
+
+/** One attribute's authored values, copied out before the stage overwrites them. */
+interface IHeldAttribute {
+  readonly array: TypedArray;
+  readonly normalized: boolean;
+}
+
+/** One primitive's authored positions, kept while the stage tries to rewrite them. */
+interface IHeldPrimitive {
+  readonly primitive: Primitive;
+  /** The index buffer as authored: a remap here would renumber what a sidecar addresses. */
+  readonly indices: Accessor | null;
+  readonly position: IHeldAttribute | null;
+  readonly targets: readonly {
+    readonly target: PrimitiveTarget;
+    readonly position: IHeldAttribute | null;
+  }[];
+}
+
+/** One deforming mesh: how it was held, and how to put it back. */
+interface IHeldMesh {
+  readonly mesh: Mesh;
+  readonly nodes: readonly Node[];
+  readonly primitives: readonly IHeldPrimitive[];
+  readonly volumes: readonly { readonly material: Material; readonly volume: ExtensionProperty }[];
+}
+
+/**
+ * Runs `quantize` with every deforming mesh held in the metre space its author wrote it in, and
+ * puts the held geometry back whether the stage returns or throws.
+ */
+export async function quantizeStaticGeometry(
+  document: Document,
+  quantize: () => unknown,
+): Promise<void> {
+  const held = holdDeformingMeshes(document);
+  try {
+    await quantize();
+  } finally {
+    releaseDeformingMeshes(held);
+  }
+}
+
+function holdDeformingMeshes(document: Document): IHeldMesh[] {
+  const skinned = skinnedMeshes(document);
+  const held: IHeldMesh[] = [];
+  for (const mesh of document.getRoot().listMeshes()) {
+    // The mesh is the unit of source space, because the compensation is per mesh: one deforming
+    // primitive in it holds the whole thing, or the shift would land on half of it.
+    if (!deformingMesh(mesh, skinned)) continue;
+    const nodes: Node[] = [];
+    for (const parent of mesh.listParents()) {
+      if (!(parent instanceof Node)) continue;
+      nodes.push(parent);
+      parent.setMesh(null);
+    }
+    const primitives = mesh.listPrimitives().map((primitive) => ({
+      primitive,
+      indices: primitive.getIndices(),
+      position: holdAttribute(primitive.getAttribute("POSITION")),
+      targets: primitive.listTargets().map((target) => ({
+        target,
+        position: holdAttribute(target.getAttribute("POSITION")),
+      })),
+    }));
+    const volumes: { material: Material; volume: ExtensionProperty }[] = [];
+    for (const primitive of mesh.listPrimitives()) {
+      const material = primitive.getMaterial();
+      const volume = material?.getExtension("KHR_materials_volume") ?? null;
+      if (material === null || volume === null) continue;
+      // Thickness is given in local units, so the stage would scale it by the shift it is not
+      // applying to this mesh's positions.
+      material.setExtension("KHR_materials_volume", null);
+      volumes.push({ material, volume });
+    }
+    held.push({ mesh, nodes, primitives, volumes });
+  }
+  return held;
+}
+
+function releaseDeformingMeshes(held: readonly IHeldMesh[]): void {
+  for (const { mesh, nodes, primitives, volumes } of held) {
+    for (const node of nodes) node.setMesh(mesh);
+    for (const { material, volume } of volumes)
+      material.setExtension("KHR_materials_volume", volume);
+    for (const { primitive, indices, position, targets } of primitives) {
+      // The stage may rewrite what a sidecar already addresses, but never renumber it: an index
+      // buffer it replaced means the held positions no longer line up, so fail instead of shipping
+      // a mesh whose every vertex has quietly moved.
+      if (primitive.getIndices() !== indices)
+        throw new Error(
+          "TN_ASSETS_MODEL_DEFORMING_RENUMBERED: quantization rewrote the index buffer of a deforming primitive; its positions were held in source space and can no longer be addressed by index.",
+        );
+      releaseAttribute(primitive, position);
+      for (const { target, position: delta } of targets) releaseAttribute(target, delta);
+    }
+  }
+}
+
+function holdAttribute(accessor: Accessor | null): IHeldAttribute | null {
+  const array = accessor?.getArray() ?? null;
+  if (accessor === null || array === null) return null;
+  // A copy, because the stage replaces this accessor with its own and prunes the original: a
+  // disposed property cannot be re-attached, and the values have to outlive the stage.
+  const copy = array.slice();
+  return { array: copy, normalized: accessor.getNormalized() };
+}
+
+/**
+ * Writes the authored values back over whatever the stage left in the attribute. The accessor the
+ * stage installed is reused rather than replaced, so the mesh keeps the attribute it was drawn
+ * with and no orphan is left for the writer to emit.
+ */
+function releaseAttribute(owner: IAttributeOwner, held: IHeldAttribute | null): void {
+  const accessor = owner.getAttribute("POSITION");
+  if (held === null || accessor === null) return;
+  accessor.setArray(held.array).setNormalized(held.normalized).setSparse(false);
+}
diff --git a/packages/assets/src/passes/reorder-static.ts b/packages/assets/src/passes/reorder-static.ts
index 7e4551dca1..d8c1ffffe3 100644
--- a/packages/assets/src/passes/reorder-static.ts
+++ b/packages/assets/src/passes/reorder-static.ts
@@ -17,9 +17,9 @@
 // ponytail: the library's `reorder` has no per-primitive switch, so the remap is its own ~30 lines.
 // Replace with the library's whole-document `reorder` the day it takes a predicate.
 
-import { type Accessor, type Document, type Mesh, Primitive } from "@gltf-transform/core";
+import { type Accessor, type Document, Primitive } from "@gltf-transform/core";
 import type { MeshoptEncoder } from "meshoptimizer";
-import { deforming } from "../lod/eligibility.js";
+import { deforming, skinnedMeshes } from "../lod/eligibility.js";
 
 /** One index buffer, the attributes that read through it, and the primitives that draw it. */
 interface IVertexGroup {
@@ -72,16 +72,6 @@ function vertexGroups(document: Document): Map<Accessor, IVertexGroup> {
   return groups;
 }
 
-/** The meshes a skin is bound to: everything under one of those nodes is deforming. */
-function skinnedMeshes(document: Document): Set<Mesh> {
-  const skinned = new Set<Mesh>();
-  for (const node of document.getRoot().listNodes()) {
-    const mesh = node.getMesh();
-    if (mesh !== null && node.getSkin() !== null) skinned.add(mesh);
-  }
-  return skinned;
-}
-
 /** Renumber one group's vertices, and every primitive that draws them, in place. */
 function remapGroup(indices: Accessor, group: IVertexGroup, encoder: typeof MeshoptEncoder): void {
   const source = indices.getArray();

From 7876e4b7bc0caf853650965ed3b0513deb877506 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sat, 3 Oct 2026 20:28:08 -0700
Subject: [PATCH 33/36] docs(PRD-485): metahuman-lab cooks and its face
 controls pass

---
 .../PRD-485-high-quality-assets-go-through-the-cook.md          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
index 20d9722067..817e2d2d5c 100644
--- a/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
+++ b/docs/PRDs/open-world/PRD-485-high-quality-assets-go-through-the-cook.md
@@ -63,6 +63,6 @@ Uncooked UE5 Megascans import as LOD0 only. The importer decompresses the larges
 **Status:** PARTIAL
 **Files:** `metahuman-lab` asset layout (sandbox); `packages/create-threenative/agent-docs/references/finding-assets.md`
 - [ ] [local] `fab-import-proof` packages its cooked KTX2 and Meshopt output for Android V8 and renders the Hornbeam on the emulator. proof: `native-playtests/fab-import-native.playtest.json --target android` on the local emulator.
-- [ ] [local] `metahuman-lab` serves `content/` from `assets/` through the cook with no `assets` block, and `face-controls.playtest.json` passes on web. proof: `npx threenative build` plus that scenario with `--browser-recipe webgpu`.
+- [x] [local] `metahuman-lab` serves `content/` from `assets/` through the cook with no `assets` block, and `face-controls.playtest.json` passes on web. proof: `npx threenative build` plus that scenario with `--browser-recipe webgpu`. **Result 2026-10-03:** sandbox branch `prd485/metahuman-lab-cook` (local): 301 MB `public/content/` → `assets/content/`, no `assets` block, `npx threenative build --target web` exit 0, uncooked 0 bytes; `.dna`/`.strands.bin` copied through by manifest, 30 PNGs → KTX2. Two engine fixes the cook exposed, each red-green: deforming geometry keeps its vertex order (`d219c5e56`, the library `reorder` renumbered 24,321 of 24,408 head vertices the DNA/brow sidecars address) and its float32 metre positions (`f27cb2299`, quantization had moved the scale into the inverse bind matrices); `specimen.glb` 26.3 MB → 22.5 MB with all 821 morph targets. `playtests/face-controls.playtest.json` passes 15/15 on WebGPU, 0 console errors; the frame shows jaw/smile/blink/brow controls driving the face with hair and skin intact.
   Build leg 2026-10-03: sandbox branch `prd485/metahuman-lab-cook` (local worktree, engine tarballs from this branch). `npx threenative build --target web` exit 0 in 189 s, `threenative.config.ts` still carries no `assets` block. The 301 MB moved from `public/content/` to `assets/content/`, and the hand-written vite middleware that served it verbatim (`specimenContentPlugin`) is gone: `ctx.assets.resolve` reads `public/assets.manifest.json` and every load asks for the cooked name. `.dna` and `.strands.bin` are copied through as `kind: "other"` byte for byte (`head.dna` 4,829,103 B, `hair.strands.bin` 85,202,464 B) — an extension no pass owns gets a manifest entry like any other file. `specimen.glb` cooks 26,267,896 -> 16,104,464 B (-38.7%): 5 embedded PNGs 7,801,033 -> 2,957,889 B (3 uastc/etc1s, `T_MH_BentNormal_AO` and `T_Eye_N` kept under the existing `not-smaller` guard), 101,518 triangles and all 821 LOD0 morph targets intact, `EXT_meshopt_compression` + `KHR_mesh_quantization` + `KHR_texture_basisu` on the output, and `lod.reasons ["deforming", "authored-lod"]` — a skinned morph-target head is PRD-486's subject, not this one. `shirt.glb` 50,367,028 -> 543,040 B (-98.9%), `body.glb` 1,215,524 -> 349,680 B, 30 PNGs to KTX2 (total 162,186,687 B from 314,889,680 B of source). Budget `uncooked 0 bytes` against the 64,000,000 default ceiling — first time this game had a manifest at all. The scenario was not run in this lane, so the box stays open: `node packages/playtest/dist/runner/cli.js metahuman-lab/playtests/face-controls.playtest.json --url http://127.0.0.1:5197 --server-command "pnpm exec vite preview --host 127.0.0.1 --port 5197 --strictPort" --browser-recipe webgpu`.
 - [x] [local] `finding-assets.md`'s Fab import step says the default cook handles imported packs and that `"none"` is not a fix. proof: `pnpm exec vitest run scripts/__tests__/primary-docs.spec.ts` and `pnpm check:docs`. **Result 2026-10-03:** the Fab import step now states what the default cook does to a converted pack (embedded PNG and WebP to KTX2, quantization and Meshopt, a discrete LOD chain for a `MASK` primitive) with the measured Hornbeam numbers, and that `models: "none"`/`textures: "none"` are not a fix — they ship every source byte, count it all against `assets.budget.uncooked`, and are what makes the build fail with `TN_ASSETS_BUDGET_EXCEEDED`. Green: `primary-docs.spec.ts` 7/7, `check:docs` 2,229 links, `check-doc-links` + `sync-agent-docs` + `evidence-citations` 30/30. No template file changed, so no scaffold hash moved.

From 06751c2624a3f54989b1dee5283f529b5c8869bb Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <jfurtado141@gmail.com>
Date: Sun, 4 Oct 2026 00:33:39 -0700
Subject: [PATCH 34/36] fix(tests): the VQ native fixture registers its temp
 directory

The leak guard requires every test-owned temporary directory to go through
test-support/temp-dir, and this spec called mkdtemp directly with its own
roots array. Use the helper, which registers the cleanup the guard reads.
---
 .../__tests__/vq-native-fixture.spec.ts            | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/packages/create-threenative/__tests__/vq-native-fixture.spec.ts b/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
index 1c418223c3..e9a3cf2751 100644
--- a/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
+++ b/packages/create-threenative/__tests__/vq-native-fixture.spec.ts
@@ -1,5 +1,4 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { compileAssets } from "@threenative/assets";
 import { createAssetLoader } from "@threenative/core";
@@ -12,7 +11,7 @@ import {
   Texture,
   type Group as ThreeGroup,
 } from "three";
-import { afterEach, describe, expect, it, test, vi } from "vitest";
+import { describe, expect, it, test, vi } from "vitest";
 import {
   MODEL_NAMES,
   generateNativeAssetFixture,
@@ -20,14 +19,10 @@ import {
 } from "../../../examples/abyss-framework/vq-assets/generate.js";
 import { AssetScene } from "../../../examples/abyss-framework/vq-assets/src/game.js";
 import config from "../../../examples/abyss-framework/vq-assets/threenative.config.js";
+import { makeTempDir } from "../../../test-support/temp-dir.js";
 import { assertNativeAssetsCompatible } from "../src/build.js";
 import { loadConfig } from "../src/config.js";
 
-const roots: string[] = [];
-afterEach(async () =>
-  Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }))),
-);
-
 /** One glb with the shape the fixture's models have: a node the player can find and a turn clip. */
 function fixtureModel(name: string): { scene: Group; animations: AnimationClip[] } {
   const scene = new Group();
@@ -112,8 +107,7 @@ async function runLifecycle(options: {
 }
 
 test("real Meshopt and Draco inputs retain decoded geometry, images and animation through the decoder-free cook", async () => {
-  const cwd = await mkdtemp(path.join(os.tmpdir(), "vq01-fixture-"));
-  roots.push(cwd);
+  const cwd = await makeTempDir("vq01-fixture-");
   const source = path.join(cwd, config.assets.source);
   const ktx2 = await generateNativeAssetFixture(source);
   await writeFile(path.join(cwd, "package.json"), '{"name":"vq-fixture","type":"module"}');

From 226121be4c4665b9b91b4270c3a2fa648916eebf Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <joaopaulofurtado@live.com>
Date: Sun, 4 Oct 2026 01:18:17 -0700
Subject: [PATCH 35/36] test: make native asset cook ordering fixture hermetic

---
 .../__tests__/build-assets.spec.ts            | 51 ++++++++++++++++---
 1 file changed, 45 insertions(+), 6 deletions(-)

diff --git a/packages/create-threenative/__tests__/build-assets.spec.ts b/packages/create-threenative/__tests__/build-assets.spec.ts
index 2ececfe10c..d305c0a443 100644
--- a/packages/create-threenative/__tests__/build-assets.spec.ts
+++ b/packages/create-threenative/__tests__/build-assets.spec.ts
@@ -17,9 +17,14 @@ vi.mock("node:child_process", async (importOriginal) => {
   const actual = await importOriginal<typeof import("node:child_process")>();
   const { EventEmitter } = await import("node:events");
   const spawn = ((command: string, args: readonly string[]) => {
-    calls.push(`spawn:${path.basename(command)}`);
+    const script = path.basename(args[0] ?? command);
+    calls.push(`spawn:${script}`);
     const child = new EventEmitter();
     queueMicrotask(async () => {
+      if (script === "bundle.mjs") {
+        child.emit("exit", 23);
+        return;
+      }
       // A real Vite build creates the outDir it was pointed at, and the web build refuses to
       // publish one that is still missing — so the stub has to be as complete as what it replaces.
       const index = args.indexOf("--outDir");
@@ -29,7 +34,11 @@ vi.mock("node:child_process", async (importOriginal) => {
     });
     return child;
   }) as typeof actual.spawn;
-  return { ...actual, spawn };
+  const spawnSync = (() => ({
+    status: 0,
+    stdout: "fixture + v8 build",
+  })) as typeof actual.spawnSync;
+  return { ...actual, spawn, spawnSync };
 });
 
 afterEach(() => {
@@ -42,6 +51,21 @@ async function writeProject(root: string): Promise<void> {
   await writeFile(path.join(root, "src/game.ts"), "export default { start: async () => {} };\n");
 }
 
+async function writeRuntime(root: string, available = true): Promise<void> {
+  const runtime = path.join(root, "node_modules/@threenative/runtime-native");
+  await mkdir(path.join(runtime, "scripts"), { recursive: true });
+  const binary = path.join(runtime, "fixture-runtime");
+  await writeFile(binary, "fixture runtime identity");
+  await writeFile(
+    path.join(runtime, "package.json"),
+    JSON.stringify({ name: "@threenative/runtime-native", type: "module" }),
+  );
+  await writeFile(
+    path.join(runtime, "scripts/package-desktop.mjs"),
+    `export async function resolveDesktopRuntime() { ${available ? `return ${JSON.stringify(binary)};` : 'throw new Error("TN_TEST_RUNTIME_UNAVAILABLE");'} }\n`,
+  );
+}
+
 describe("threenative build asset compilation", () => {
   it("should compile assets before invoking vite", async () => {
     const root = await makeTempDir("threenative-build-assets-web-");
@@ -55,13 +79,28 @@ describe("threenative build asset compilation", () => {
     expect(spawnIndex).toBeGreaterThan(compileIndex);
   });
 
+  it("should reject an unavailable desktop runtime before cooking assets", async () => {
+    const root = await makeTempDir("threenative-build-assets-unavailable-runtime-");
+    await writeProject(root);
+    await writeRuntime(root, false);
+
+    await expect(build({ cwd: root, target: "desktop" })).rejects.toThrow(
+      "TN_TEST_RUNTIME_UNAVAILABLE",
+    );
+    expect(calls).toEqual([]);
+  });
+
   it("should compile assets before native packaging", async () => {
     const root = await makeTempDir("threenative-build-assets-native-");
     await writeProject(root);
 
-    // Packaging cannot finish in a temp project (no runtime bundle output), but wherever it
-    // stops, the asset compile must already have run.
-    await expect(build({ cwd: root, target: "desktop" })).rejects.toThrow();
-    expect(calls[0]).toBe("compile");
+    await writeRuntime(root);
+
+    // Runtime preflight succeeds; the controlled bundler failure must happen after cooking,
+    // before packaging, rather than an unrelated missing-runtime error satisfying the test.
+    await expect(build({ cwd: root, target: "desktop" })).rejects.toThrow(
+      `${path.basename(process.execPath)} exited with code 23.`,
+    );
+    expect(calls).toEqual(["compile", "spawn:bundle.mjs"]);
   });
 });

From 6503086326178c62383114b91578843782dd313f Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <joaopaulofurtado@live.com>
Date: Sun, 4 Oct 2026 01:35:34 -0700
Subject: [PATCH 36/36] test: return complete typed native runtime probe
 fixture

---
 .../create-threenative/__tests__/build-assets.spec.ts    | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/packages/create-threenative/__tests__/build-assets.spec.ts b/packages/create-threenative/__tests__/build-assets.spec.ts
index d305c0a443..68edce4822 100644
--- a/packages/create-threenative/__tests__/build-assets.spec.ts
+++ b/packages/create-threenative/__tests__/build-assets.spec.ts
@@ -1,3 +1,4 @@
+import type { SpawnSyncReturns } from "node:child_process";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
@@ -34,10 +35,14 @@ vi.mock("node:child_process", async (importOriginal) => {
     });
     return child;
   }) as typeof actual.spawn;
-  const spawnSync = (() => ({
+  const spawnSync = (): SpawnSyncReturns<string> => ({
+    pid: 0,
+    output: [null, "fixture + v8 build", ""],
+    signal: null,
     status: 0,
+    stderr: "",
     stdout: "fixture + v8 build",
-  })) as typeof actual.spawnSync;
+  });
   return { ...actual, spawn, spawnSync };
 });