From e82e842e0f933d11943f1ff2e1391899773f0860 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <admin@coldstartlabs.ca>
Date: Thu, 8 Oct 2026 09:35:08 -0700
Subject: [PATCH 1/6] fix(assets): a lone LOD-named mesh gets a generated chain

The cook skipped any mesh whose node or mesh name carries a level
token (`hull_LOD1`) as hand-authored LOD. A Fab pack's `_LOD2` exported
as a model of its own has no sibling level, so nothing selects it and
the skip left it at full detail. On Machinefall map-walk these trees
(`*_far_0_001`, mesh `*_far_LOD2`) are about 9.4 M of the 9.8 M
main-pass triangles in the early route, and the adaptive LOD bias
cannot coarsen a slot with one level.

An asset is an authored chain only when it holds two or more
level-named nodes. LOD_GENERATOR_VERSION goes to 4 so a stale cook
cache cannot serve the old skip.

Filed with PRD-539, which also makes card levels keep their coverage:
a chain on these trees thins the needles visibly until it does.
---
 ...PRD-539-card-lod-levels-keep-the-canopy.md | 59 +++++++++++++++++++
 .../assets/__tests__/lod-generation.spec.ts   | 29 +++++++--
 packages/assets/src/lod/eligibility.ts        |  5 +-
 packages/assets/src/lod/generate.ts           | 14 ++++-
 4 files changed, 97 insertions(+), 10 deletions(-)
 create mode 100644 docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md

diff --git a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
new file mode 100644
index 0000000000..17170983a9
--- /dev/null
+++ b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
@@ -0,0 +1,59 @@
+# PRD-539 — Card LOD levels keep the canopy
+
+**Status:** IN PROGRESS
+**Priority:** P1 — Open: PRD-478's walking GPU p95 on Machinefall needs these trees to have a chain, and today a chain thins their needles visibly.
+**Complexity:** 5 (MEDIUM) — one cook stage (`packages/assets/src/lod/`), the model pass's self-check, a Machinefall re-cook with timing and blind raters
+**Owner:** João
+**Depends on:** none. [PRD-478](../open-world/PRD-478-open-world-frame-architecture.md)'s AC-2 and AC-3 depend on this PRD.
+
+## Context
+
+Measured on Machinefall `map-walk`, desktop RTX 2080, quiet desktop (load under 10), 2026-10-08:
+
+| Fact | Value |
+| --- | --- |
+| Early-route GPU p95 (route windows 1–2) | 9.2–9.8 ms; `gpuMain` p50 8.6 ms, 8.2 M main-pass triangles at the adaptive bias cap 2.5 |
+| Single-level trees in that window | 9.4 M of 9.8 M triangles; `map_tree_kite_scotspinetall_01_far_0_001` alone is 545 instances x 8.9 k |
+| Why single-level | the GLB's only mesh is the Fab pack's `*_far_LOD2`, and the cook skips any level-named mesh as `authored-lod` |
+| With a chain (re-cook, same JS bundle) | route GPU p95 max 7.73 ms; the pooled walking bound has 1.6 % of frames over 8.3 ms (pass is 5 %) |
+| What the chain costs | blind look: mid-distance pines read as bare trunks. The needle part takes the `cards` strategy, which keeps 50 % then 25 % of the cards **unscaled**, so canopy area falls to the keep ratio (`cards.ts`, PRD-458 AC-4) |
+
+Keeping the needles at full cards is not an option: with every card part at LOD0 the early route goes to 11–13 M triangles, more than today.
+
+## Solution
+
+1. **A lone level name is not an authored chain.** The cook counts an asset as authored LOD only when it holds two or more level-named nodes. A lone `_LOD2` has no sibling for anything to select, so it is that asset's LOD0. Already written and red-green on PRD-478's branch (`d65fa1eab`); it moves here so it never ships without step 2.
+2. **Card levels keep their coverage.** A card level appends a copy of each kept card, scaled about its centroid by `sqrt(1 / keep)`, to the primitive's own vertex arrays. The level's indices point at those copies. LOD0's indices do not change, and no schema changes: `TN_discrete_lod` stays index-only, and both readers (core's `model-lod.ts` and the world's `chainLevelParts`) already copy the base attributes and swap only the index buffer.
+3. **The self-check measures what LOD0 draws.** `reachableStats` counts the vertices and the bounds that LOD0's indices reference. Appended level vertices are then not drift, and a real drift in LOD0 still fails.
+
+Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the keep ratio, which the reducer already owns.
+
+## Acceptance Criteria
+
+- [ ] AC-1: every card level ships ≥ 0.95 of LOD0's card area, read back from the cooked bytes. proof: `foliage-lod.spec.ts`
+- [ ] AC-2: Machinefall `map-walk` route GPU p95 passes the pooled walking bound (≤ 5 % of walking frames over 8.3 ms) on 3 quiet runs. proof: `TN_FRAME_BUDGET` windows, quiet desktop RTX 2080
+- [ ] AC-3: no visual loss against PRD-478's tip. proof: 3 fresh blind raters at or above on the 4 `map-walk` and 4 `map-views` poses, and a pop series with no candidate-only late object
+
+## Execution Phases
+
+#### Phase 1: The cook
+**Status:** IN PROGRESS
+**Files:** `packages/assets/src/lod/{cards,generate,eligibility}.ts`, `packages/assets/src/passes/model.ts`, `packages/assets/__tests__/`
+
+- [ ] A lone level-named mesh gets a generated chain; two or more level-named nodes stay `authored-lod`. proof: red-green `lod-generation.spec.ts`
+- [ ] Card levels index scaled copies of their kept cards, LOD0 indices unchanged. proof: red-green `foliage-lod.spec.ts` (AC-1)
+- [ ] The model pass's self-check counts what LOD0 draws, so a card chain cooks without `TN_ASSETS_MODEL_DRIFT` and a LOD0 drift still throws. proof: `model-pass` specs
+
+#### Phase 2: Both runtimes draw it
+**Status:** NOT STARTED
+**Files:** `packages/core/__tests__/`
+
+- [ ] Core builds a card level whose geometry draws the scaled copies. proof: a core spec that loads a cooked card GLB
+- [ ] The native desktop host draws the same chain. proof: PRD-377's native consumer playtest on a cooked card asset
+
+#### Phase 3: Machinefall
+**Status:** NOT STARTED
+**Files:** none in the engine
+
+- [ ] Re-cook and time it. proof: AC-2's quiet runs
+- [ ] Blind raters and the pop series. proof: AC-3's sheets on the PR
diff --git a/packages/assets/__tests__/lod-generation.spec.ts b/packages/assets/__tests__/lod-generation.spec.ts
index e3c414c6b9..d35955c9b8 100644
--- a/packages/assets/__tests__/lod-generation.spec.ts
+++ b/packages/assets/__tests__/lod-generation.spec.ts
@@ -57,6 +57,8 @@ async function torusGlb(
     joints?: boolean;
     morph?: boolean;
     name?: string;
+    /** One node and mesh per name, each with its own copy of the primitive. */
+    names?: readonly string[];
     noIndices?: boolean;
   } = {},
 ): Promise<Buffer> {
@@ -114,10 +116,14 @@ async function torusGlb(
       accessor(document, buffer, "VEC4", new Float32Array(count * 4)),
     );
   if (options.morph === true) primitive.addTarget(document.createPrimitiveTarget());
-  const name = options.name ?? "hull";
-  scene.addChild(
-    document.createNode(name).setMesh(document.createMesh(name).addPrimitive(primitive)),
-  );
+  for (const [index, name] of (options.names ?? [options.name ?? "hull"]).entries())
+    scene.addChild(
+      document
+        .createNode(name)
+        .setMesh(
+          document.createMesh(name).addPrimitive(index === 0 ? primitive : primitive.clone()),
+        ),
+    );
   return Buffer.from(await new NodeIO().registerExtensions(ALL_EXTENSIONS).writeBinary(document));
 }
 
@@ -746,6 +752,17 @@ describe("automatic discrete LOD generation", () => {
     expect(summary.reasons).toContain("already-cooked");
   }, 120_000);
 
+  it("generates a chain for a lone LOD-named mesh, which no authored chain selects", async () => {
+    // A pack's `_LOD2` scattered as a tree of its own: no sibling level exists in the asset, so
+    // skipping it as authored left Machinefall's 545 nearest pines at 8,900 triangles each.
+    const summary = await cook(await mediumGlb({ name: "pine_far_LOD2" }), {
+      lod: GENERATE,
+      virtual: "none",
+    });
+    expect(summary.reasons).not.toContain("authored-lod");
+    expect(summary.generated).toBeGreaterThan(0);
+  }, 120_000);
+
   it("reports each structural skip reason on a fixture that triggers it", async () => {
     const cases: readonly {
       reason: string;
@@ -773,7 +790,7 @@ describe("automatic discrete LOD generation", () => {
       // of LOD0's fragments, so a chain keeps its silhouette. `foliage-lod.spec.ts` proves the
       // foliage half; `BLEND` is still refused, because a simplified blended card is a hole.
       { build: () => smallGlb({ alpha: "BLEND" }), reason: "material-unsupported" },
-      { build: () => smallGlb({ name: "hull_LOD1" }), reason: "authored-lod" },
+      { build: () => smallGlb({ names: ["hull_LOD0", "hull_LOD1"] }), reason: "authored-lod" },
       {
         // Edge (0,1) is shared by three triangles: a non-manifold fan. A tiny floor is needed so
         // the fixture is not declined as too-small first.
@@ -1143,7 +1160,7 @@ describe("terminal coarse level (PRD-473)", () => {
     // The chain layout did not change, so a file cooked before this feature still reads. The cache
     // identity moved instead, which is what makes a re-cook pick the terminal level up.
     expect(LOD_SCHEMA_VERSION).toBe(1);
-    expect(LOD_GENERATOR_VERSION).toBe(3);
+    expect(LOD_GENERATOR_VERSION).toBe(4);
     const document = await readWithLod(await oldChainGlb());
     const primitive = document
       .getRoot()
diff --git a/packages/assets/src/lod/eligibility.ts b/packages/assets/src/lod/eligibility.ts
index 3cbf54077d..d9ff657510 100644
--- a/packages/assets/src/lod/eligibility.ts
+++ b/packages/assets/src/lod/eligibility.ts
@@ -99,7 +99,7 @@ const TRIANGLE = 3;
 export interface IEligibilityFlags {
   /** The primitive already carries a `TN_discrete_lod` payload from an earlier cook. */
   readonly alreadyCooked: boolean;
-  /** A node or mesh name marks this as a hand-authored LOD variant (`hull_LOD1`). */
+  /** The asset is an authored chain: two or more of its nodes carry a level name (`hull_LOD1`). */
   readonly authoredLod: boolean;
   /** `assets.models.simplify` is declared for this asset. */
   readonly legacySimplify: boolean;
@@ -290,7 +290,8 @@ export function classifyJoinCandidate(
 /**
  * Authored LOD detection: a node or mesh whose name carries a level suffix (`hull_LOD1`,
  * `hull-lod2`) is a hand-authored variant, and generating on top of it would stack two owners on
- * one primitive (PRD-377 §4.2).
+ * one primitive (PRD-377 §4.2). The cook counts it as authored only when the asset holds two or
+ * more level-named nodes; a lone one is that asset's LOD0.
  */
 export function authoredLodName(name: string): boolean {
   return /(^|[_\-.\s])lod[0-9]+($|[_\-.\s])/i.test(name);
diff --git a/packages/assets/src/lod/generate.ts b/packages/assets/src/lod/generate.ts
index b5a2a484a4..a8cf67c422 100644
--- a/packages/assets/src/lod/generate.ts
+++ b/packages/assets/src/lod/generate.ts
@@ -126,7 +126,7 @@ export const LOD_GENERATOR = "threenative-discrete-lod";
  * Bumped when the *generated levels* change, so a stale cook cache cannot serve the old chain. The
  * artifact schema stays put: a chain with or without the terminal level reads the same.
  */
-export const LOD_GENERATOR_VERSION = 3;
+export const LOD_GENERATOR_VERSION = 4;
 /** Bumped with the output layout so a stale cache entry cannot hide a schema change. */
 export const LOD_ARTIFACT_SCHEMA_VERSION = 1;
 /** The pinned simplifier this artifact's error metric was produced with. */
@@ -970,15 +970,25 @@ function animatedNodes(document: Document): Set<GltfNode> {
 
 function meshFlags(document: Document, animated: Set<GltfNode>): Map<Mesh, IMeshFlags> {
   const flags = new Map<Mesh, IMeshFlags>();
+  const levelNamed = new Set<Mesh>();
+  let levelNodes = 0;
   for (const node of reachableNodes(document)) {
     const mesh = node.getMesh();
     if (mesh === null) continue;
     const current = flags.get(mesh) ?? { animated: false, authoredLod: false, skinned: false };
     current.skinned ||= node.getSkin() !== null;
     current.animated ||= animated.has(node);
-    current.authoredLod ||= authoredLodName(node.getName()) || authoredLodName(mesh.getName());
+    if (authoredLodName(node.getName()) || authoredLodName(mesh.getName())) {
+      levelNamed.add(mesh);
+      levelNodes += 1;
+    }
     flags.set(mesh, current);
   }
+  // An authored chain is two or more level-named nodes in one asset. A lone level name (a pack's
+  // `_LOD2` exported as a model of its own) has no sibling for anything to select, so it is this
+  // asset's LOD0 and gets a generated chain like any other mesh.
+  if (levelNodes > 1)
+    for (const mesh of levelNamed) (flags.get(mesh) as IMeshFlags).authoredLod = true;
   return flags;
 }
 

From 6280d03e7df01e5099ec806cbd1b13087ee50670 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <admin@coldstartlabs.ca>
Date: Thu, 8 Oct 2026 09:44:37 -0700
Subject: [PATCH 2/6] fix(assets): card LOD levels keep the canopy covered

A card level kept 50 % then 25 % of a crown's needle cards unscaled, so
its card area fell to the keep ratio. On Machinefall, once the Fab
`_LOD2` pines got a chain, mid-distance trees read as bare trunks.

Each level now appends copies of its kept cards, scaled about their
centroids by sqrt(LOD0 area / kept area) (at most 2), to the
primitive's own vertex arrays, and its indices point at them. The chain
stays index-only and LOD0's indices never reach a copy, so a stock
loader and both runtime readers need no change.

The model pass's self-check now counts the vertices LOD0's indices
draw, so the copies are not drift; a LOD0 drift still throws.

foliage-lod.spec.ts: red `expected 0.5162100266415837 to be greater
than or equal to 0.95`, then 8 passed; packages/assets 485 passed.
---
 ...PRD-539-card-lod-levels-keep-the-canopy.md |  14 ++-
 packages/assets/__tests__/foliage-lod.spec.ts |  55 +++++++---
 packages/assets/src/lod/cards.ts              | 102 +++++++++++++++---
 packages/assets/src/lod/generate.ts           |  43 +++++++-
 packages/assets/src/passes/model.ts           |  27 ++++-
 5 files changed, 204 insertions(+), 37 deletions(-)

diff --git a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
index 17170983a9..80da2c8e11 100644
--- a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
+++ b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
@@ -28,21 +28,25 @@ Keeping the needles at full cards is not an option: with every card part at LOD0
 
 Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the keep ratio, which the reducer already owns.
 
+## Decisions
+
+- 2026-10-08, agent: a kept card scales by at most 2. The ratio levels (keep ≥ 0.25) reach full coverage under it. The terminal level keeps far fewer cards, and scaling them further would grow cards past the crown's silhouette, so it covers `4 × keep` of LOD0.
+
 ## Acceptance Criteria
 
-- [ ] AC-1: every card level ships ≥ 0.95 of LOD0's card area, read back from the cooked bytes. proof: `foliage-lod.spec.ts`
+- [x] AC-1: every ratio card level ships ≥ 0.95 of LOD0's card area, read back from the cooked bytes; the terminal level ships min(1, 4 × keep). proof: `foliage-lod.spec.ts` — 8 passed; red before the change: `expected 0.5162100266415837 to be greater than or equal to 0.95`
 - [ ] AC-2: Machinefall `map-walk` route GPU p95 passes the pooled walking bound (≤ 5 % of walking frames over 8.3 ms) on 3 quiet runs. proof: `TN_FRAME_BUDGET` windows, quiet desktop RTX 2080
 - [ ] AC-3: no visual loss against PRD-478's tip. proof: 3 fresh blind raters at or above on the 4 `map-walk` and 4 `map-views` poses, and a pop series with no candidate-only late object
 
 ## Execution Phases
 
 #### Phase 1: The cook
-**Status:** IN PROGRESS
+**Status:** DONE
 **Files:** `packages/assets/src/lod/{cards,generate,eligibility}.ts`, `packages/assets/src/passes/model.ts`, `packages/assets/__tests__/`
 
-- [ ] A lone level-named mesh gets a generated chain; two or more level-named nodes stay `authored-lod`. proof: red-green `lod-generation.spec.ts`
-- [ ] Card levels index scaled copies of their kept cards, LOD0 indices unchanged. proof: red-green `foliage-lod.spec.ts` (AC-1)
-- [ ] The model pass's self-check counts what LOD0 draws, so a card chain cooks without `TN_ASSETS_MODEL_DRIFT` and a LOD0 drift still throws. proof: `model-pass` specs
+- [x] A lone level-named mesh gets a generated chain; two or more level-named nodes stay `authored-lod`. proof: red-green `lod-generation.spec.ts` — red `expected [ 'authored-lod' ] to not include 'authored-lod'`, then 44 passed (`e82e842e0`)
+- [x] Card levels index scaled copies of their kept cards, LOD0 indices unchanged. proof: red-green `foliage-lod.spec.ts` (AC-1)
+- [x] The model pass's self-check counts what LOD0 draws, so a card chain cooks without `TN_ASSETS_MODEL_DRIFT` and a LOD0 drift still throws. proof: `model-pass.spec.ts` drift cases green; the conifer cook threw `vertices 5997 -> 7573; bounding box drifted 2.109%` before; `vitest run packages/assets` 485 passed, 2 skipped
 
 #### Phase 2: Both runtimes draw it
 **Status:** NOT STARTED
diff --git a/packages/assets/__tests__/foliage-lod.spec.ts b/packages/assets/__tests__/foliage-lod.spec.ts
index 1feebee446..fec9d96e60 100644
--- a/packages/assets/__tests__/foliage-lod.spec.ts
+++ b/packages/assets/__tests__/foliage-lod.spec.ts
@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { Document, Logger, NodeIO } from "@gltf-transform/core";
+import { type Accessor, Document, Logger, NodeIO } from "@gltf-transform/core";
 import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
 import { MeshoptDecoder } from "meshoptimizer";
 import { describe, expect, it } from "vitest";
@@ -60,6 +60,31 @@ async function cookConifer(lod: IModelPassOptions["lod"] = true): Promise<ICooke
   return { buffer: result.buffer, document: await readWithLod(result.buffer), summary };
 }
 
+/** Summed triangle area the index list draws from `position`, in the accessor's own units. */
+function drawnArea(position: Accessor, indices: Uint32Array): number {
+  const a: number[] = [];
+  const b: number[] = [];
+  const c: number[] = [];
+  let area = 0;
+  for (let at = 0; at + 2 < indices.length; at += 3) {
+    position.getElement(indices[at] as number, a);
+    position.getElement(indices[at + 1] as number, b);
+    position.getElement(indices[at + 2] as number, c);
+    const [ux, uy, uz] = [
+      (b[0] as number) - (a[0] as number),
+      (b[1] as number) - (a[1] as number),
+      (b[2] as number) - (a[2] as number),
+    ];
+    const [vx, vy, vz] = [
+      (c[0] as number) - (a[0] as number),
+      (c[1] as number) - (a[1] as number),
+      (c[2] as number) - (a[2] as number),
+    ];
+    area += Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx) / 2;
+  }
+  return area;
+}
+
 /**
  * Material name per LOD0 primitive, in document order, and each primitive's level triangle counts.
  *
@@ -221,30 +246,32 @@ describe("foliage cutout conversion and LOD (PRD-458 AC-4)", () => {
         expect(card.cards).toBeGreaterThan(0);
         expect(card.keep).toBeGreaterThan(0);
         // The crown: no occupied cell of LOD0's stratification grid is emptied at any level, which
-        // is the property that separates a grid from a random or index-order sample. Cell coverage
-        // is the ≥ 70% figure; card *area* coverage cannot be, because `TN_discrete_lod` is
-        // index-only and cannot carry the per-level scale step (`cards.ts` says so at the top) — it
-        // is the keep ratio up to the per-cell rounding, asserted here so the number cannot drift
-        // into a claim it never met.
+        // is the property that separates a grid from a random or index-order sample. And the kept
+        // cards are scaled up about their centroids, so the level covers LOD0's card area rather
+        // than the keep ratio of it, which read as bare trunks on Machinefall (PRD-539).
         expect(card.cellCoverage).toBeGreaterThanOrEqual(0.7);
-        expect(card.areaCoverage).toBeCloseTo(card.keep, 1);
+        expect(card.areaCoverage).toBeGreaterThanOrEqual(0.95);
       }
     }
 
-    // Read back out of the *shipped* bytes: the cards really are a subset of LOD0's own indices, so
-    // a stock loader draws the crown and a level, and the chain validated against the written file.
+    // Read back out of the *shipped* bytes: each level draws at least 95 % of LOD0's card area
+    // from the primitive's own vertex arrays, so a stock loader still draws LOD0 and the runtime's
+    // index swap draws a covered crown.
     const leaves = document
       .getRoot()
       .listMeshes()
       .find((mesh) => mesh.getName() === "leaves");
     const primitive = leaves?.listPrimitives()[0];
-    const lod0 = Uint32Array.from(primitive?.getIndices()?.getArray() as ArrayLike<number>);
-    const chain = primitive?.getExtension<DiscreteLod>(TN_DISCRETE_LOD);
+    const position = primitive?.getAttribute("POSITION");
+    if (primitive === undefined || position === null || position === undefined)
+      throw new Error("no needle primitive");
+    const lod0 = Uint32Array.from(primitive.getIndices()?.getArray() as ArrayLike<number>);
+    const chain = primitive.getExtension<DiscreteLod>(TN_DISCRETE_LOD);
     expect(chain?.getStrategy()).toBe("cards");
     for (const accessor of chain?.getIndices() ?? []) {
       const level = Uint32Array.from(accessor.getArray() as ArrayLike<number>);
       expect(level.length).toBeGreaterThan(0);
-      for (const index of level) expect(lod0).toContain(index);
+      expect(drawnArea(position, level) / drawnArea(position, lod0)).toBeGreaterThanOrEqual(0.95);
     }
   }, 300_000);
 
@@ -327,14 +354,14 @@ describe("foliage cutout conversion and LOD (PRD-458 AC-4)", () => {
       .listMeshes()
       .find((mesh) => mesh.getName() === "leaves")
       ?.listPrimitives()[0];
-    const lod0 = Uint32Array.from(primitive?.getIndices()?.getArray() as ArrayLike<number>);
+    const vertices = primitive?.getAttribute("POSITION")?.getCount() ?? 0;
     const chain = primitive?.getExtension<DiscreteLod>(TN_DISCRETE_LOD);
     const accessors = chain?.getIndices() ?? [];
     expect(accessors).toHaveLength(entry.levels.length);
     for (const accessor of accessors) {
       const level = Uint32Array.from(accessor.getArray() as ArrayLike<number>);
       expect(level.length).toBeGreaterThan(0);
-      for (const index of level) expect(lod0).toContain(index);
+      for (const index of level) expect(index).toBeLessThan(vertices);
     }
   }, 300_000);
 
diff --git a/packages/assets/src/lod/cards.ts b/packages/assets/src/lod/cards.ts
index 7553390a6c..d3ec079f92 100644
--- a/packages/assets/src/lod/cards.ts
+++ b/packages/assets/src/lod/cards.ts
@@ -22,16 +22,13 @@
  *   hash of their own centroid. The same input bytes always produce the same levels, which is what
  *   `determinism.spec.ts` and a cache keyed on a generation fingerprint both depend on.
  *
- * **No scaling, and why.** A kept card is normally scaled about its centroid by `sqrt(1 / keep)`, so
- * the surviving cards cover the area the dropped ones did. That needs *new vertex positions*, and
- * `TN_discrete_lod` is index-only by construction: a level's POSITION/NORMAL/UV come from the
- * primitive's own accessors and the runtime reader (`packages/core/src/model-lod.ts`) builds each
- * derived level by copying the base's attributes and swapping in only an index buffer. So the scale
- * step is not representable in the chain as it is specified today, and the levels shipped here are
- * the un-scaled subset. The consequence is stated rather than hidden: card *area* coverage falls to
- * the keep ratio, and what the grid buys is cell coverage — every occupied cell still holds a card.
- * Lifting it needs a per-level vertex buffer in the chain (a core schema change, PRD-458 §4), not a
- * different selection.
+ * **Scaled, so the crown stays covered.** Each kept card is scaled about its centroid by
+ * `sqrt(lod0Area / keptArea)`, so the survivors cover the area the dropped cards did. Un-scaled, a
+ * level's card area falls to the keep ratio, and on Machinefall the mid-distance pines read as bare
+ * trunks (PRD-539). `TN_discrete_lod` stays index-only: a level's scaled cards are *copies* appended
+ * to the primitive's own vertex arrays (see {@link ICardCopies}), and the level's indices point at
+ * them. LOD0's indices never reference a copy, so a stock loader draws LOD0 unchanged, and both
+ * runtime readers already build a level by copying the base attributes and swapping the index buffer.
  */
 
 /**
@@ -54,6 +51,12 @@ export const CARD_KEEP_RATIOS: readonly number[] = [0.5, 0.25];
 
 const TRIANGLE = 3;
 
+/**
+ * The largest scale a kept card takes. Above it, a card grows past the crown's own silhouette; the
+ * terminal level, which keeps far fewer cards than this restores, then covers `keep * 4` of LOD0.
+ */
+const MAX_CARD_SCALE = 2;
+
 /** One card: the triangles of one connected component, its centroid and its area. */
 export interface ICard {
   /** Indices into the primitive's index buffer, one entry per triangle of this card. */
@@ -64,18 +67,32 @@ export interface ICard {
 
 /** What one derived level kept, and what it cost the crown. Reported, never inferred. */
 export interface ICardLevelSummary {
-  /** Kept card area as a fraction of LOD0's total card area — the un-scaled coverage, honestly low. */
+  /** Kept card area after scaling, as a fraction of LOD0's total card area. */
   readonly areaCoverage: number;
   readonly cards: number;
   /** Fraction of LOD0's occupied grid cells that still hold at least one kept card. */
   readonly cellCoverage: number;
   /** The fraction of LOD0's cards this level kept. */
   readonly keep: number;
+  /** The factor every kept card was scaled by about its centroid; `1` keeps it as authored. */
+  readonly scale: number;
+}
+
+/**
+ * One level's scaled cards, appended after the primitive's vertices (and any earlier level's copies)
+ * in level order. Copy `i` repeats every attribute of LOD0 vertex `source[i]`, except its position,
+ * which is `positions[3i..3i+2]`.
+ */
+export interface ICardCopies {
+  readonly positions: Float32Array;
+  readonly source: Uint32Array;
 }
 
 /** A card-thinned chain, shaped like the triangle chain so both take the same attachment path. */
 export interface ICardChain {
   readonly absoluteErrors: readonly number[];
+  /** Per derived level, aligned with `counts`: the scaled copies its indices point at. */
+  readonly copies: readonly ICardCopies[];
   readonly counts: readonly number[];
   readonly errors: readonly number[];
   readonly indices: readonly Uint32Array[];
@@ -283,6 +300,7 @@ function thinLevel(
       cards: kept.length,
       cellCoverage: lod0Cells === 0 ? 1 : cells / lod0Cells,
       keep,
+      scale: 1,
     },
   };
 }
@@ -303,6 +321,49 @@ function indicesOf(cards: readonly ICard[], source: Uint32Array): Uint32Array {
   return out;
 }
 
+/**
+ * A level drawn from scaled copies of its cards: the copies, numbered from `base`, and the index
+ * buffer over them in {@link indicesOf}'s order. The scale restores LOD0's card area, capped at
+ * {@link MAX_CARD_SCALE}; a card's vertices belong to that card alone, so each is copied once.
+ */
+function scaledLevel(
+  level: { readonly cards: readonly ICard[]; readonly summary: ICardLevelSummary },
+  indices: Uint32Array,
+  positions: Float32Array,
+  base: number,
+): { copies: ICardCopies; indices: Uint32Array; summary: ICardLevelSummary } {
+  const covered = level.summary.areaCoverage;
+  const scale = covered > 0 ? Math.min(MAX_CARD_SCALE, Math.sqrt(1 / covered)) : 1;
+  const copyOf = new Map<number, number>();
+  const source: number[] = [];
+  const moved: number[] = [];
+  const out = indicesOf(level.cards, indices);
+  let at = 0;
+  for (const card of level.cards) {
+    const [cx, cy, cz] = card.centroid;
+    for (let corner = 0; corner < card.triangles.length * TRIANGLE; corner += 1, at += 1) {
+      const vertex = out[at] as number;
+      let copy = copyOf.get(vertex);
+      if (copy === undefined) {
+        copy = base + source.length;
+        copyOf.set(vertex, copy);
+        source.push(vertex);
+        moved.push(
+          cx + ((positions[vertex * 3] as number) - cx) * scale,
+          cy + ((positions[vertex * 3 + 1] as number) - cy) * scale,
+          cz + ((positions[vertex * 3 + 2] as number) - cz) * scale,
+        );
+      }
+      out[at] = copy;
+    }
+  }
+  return {
+    copies: { positions: Float32Array.from(moved), source: Uint32Array.from(source) },
+    indices: out,
+    summary: { ...level.summary, areaCoverage: Math.min(1, covered * scale * scale), scale },
+  };
+}
+
 /** Triangles a card submits (one entry in `triangles` per triangle). */
 function cardTriangles(card: ICard): number {
   return card.triangles.length;
@@ -377,6 +438,7 @@ function terminalCardLevel(
       cards: kept.length,
       cellCoverage: lod0Cells === 0 ? 1 : covered.size / lod0Cells,
       keep: kept.length / cards.length,
+      scale: 1,
     },
   };
 }
@@ -439,6 +501,9 @@ export function generateCardChain(
   const errors: number[] = [];
   const absoluteErrors: number[] = [];
   const buffers: Uint32Array[] = [];
+  const copies: ICardCopies[] = [];
+  // Where the next level's copies start: after LOD0's vertices and every earlier level's copies.
+  let base = Math.floor(positions.length / 3);
   let previousTriangles = lod0Triangles;
   for (const keep of keepRatios.slice(0, Math.max(0, maxLevels - 1))) {
     if (levels.length >= Math.max(0, maxLevels - 1)) break;
@@ -450,11 +515,14 @@ export function generateCardChain(
     if (triangles >= previousTriangles) continue;
     if ((previousTriangles - triangles) / previousTriangles < minSaving) continue;
     const absoluteError = cellSize * (1 - keep);
-    levels.push(level.summary);
+    const scaled = scaledLevel(level, indices, positions, base);
+    base += scaled.copies.source.length;
+    levels.push(scaled.summary);
     counts.push(triangles);
     absoluteErrors.push(absoluteError);
     errors.push(absoluteError / Math.max(scale, 1e-6));
-    buffers.push(buffer);
+    buffers.push(scaled.indices);
+    copies.push(scaled.copies);
     previousTriangles = triangles;
   }
   if (levels.length === 0) return null;
@@ -477,17 +545,21 @@ export function generateCardChain(
       const triangles = Math.floor(buffer.length / TRIANGLE);
       if (triangles > 0 && triangles < previousTriangles) {
         const absoluteError = cellSize * terminal.factor;
-        levels.push(terminal.summary);
+        const scaled = scaledLevel(terminal, indices, positions, base);
+        base += scaled.copies.source.length;
+        levels.push(scaled.summary);
         counts.push(triangles);
         absoluteErrors.push(absoluteError);
         errors.push(absoluteError / Math.max(scale, 1e-6));
-        buffers.push(buffer);
+        buffers.push(scaled.indices);
+        copies.push(scaled.copies);
         previousTriangles = triangles;
       }
     }
   }
   return {
     absoluteErrors,
+    copies,
     counts,
     errors,
     indices: buffers,
diff --git a/packages/assets/src/lod/generate.ts b/packages/assets/src/lod/generate.ts
index a8cf67c422..523c69d80e 100644
--- a/packages/assets/src/lod/generate.ts
+++ b/packages/assets/src/lod/generate.ts
@@ -7,12 +7,14 @@
 
 import { createHash } from "node:crypto";
 import type {
+  Accessor,
   Document,
   Node as GltfNode,
   Material,
   Mesh,
   Primitive,
   Scene,
+  TypedArray,
 } from "@gltf-transform/core";
 import {
   compactPrimitive,
@@ -24,7 +26,7 @@ import { MeshoptSimplifier } from "meshoptimizer";
 import { Matrix4 } from "three";
 import { type IFoliageCutoutSummary, convertFoliageCutout } from "../foliage.js";
 import { TN_VIRTUAL_GEOMETRY } from "../virtual/extension.js";
-import { type ICardLevelSummary, generateCardChain } from "./cards.js";
+import { type ICardCopies, type ICardLevelSummary, generateCardChain } from "./cards.js";
 import {
   type DiscreteLodSkipReason,
   type LodMinTrianglesScope,
@@ -629,6 +631,8 @@ interface IGeneratedChain {
   readonly errors: number[];
   readonly indices: Uint32Array[];
   readonly lod0Triangles: number;
+  /** Scaled card copies the levels' indices point at, appended in level order; card chains only. */
+  readonly vertexCopies?: readonly ICardCopies[];
 }
 
 /**
@@ -926,9 +930,45 @@ function generateCardsChain(
     errors: [...chain.errors],
     indices: [...chain.indices],
     lod0Triangles: chain.lod0Triangles,
+    vertexCopies: chain.copies,
   };
 }
 
+/**
+ * Appends a card chain's scaled copies to every attribute of `primitive`, in level order, so the
+ * levels' indices resolve. Each attribute gets a new accessor: another primitive sharing the old one
+ * keeps its own vertex count. LOD0's indices are untouched and never reach a copy.
+ */
+function appendCardCopies(primitive: Primitive, copies: readonly ICardCopies[]): void {
+  const base = primitive.getAttribute("POSITION")?.getCount() ?? 0;
+  let added = 0;
+  for (const level of copies) added += level.source.length;
+  if (added === 0) return;
+  for (const semantic of primitive.listSemantics()) {
+    const accessor = primitive.getAttribute(semantic) as Accessor;
+    const size = accessor.getElementSize();
+    const array = accessor.getArray() as TypedArray;
+    const grown = new (array.constructor as new (length: number) => TypedArray)(
+      (base + added) * size,
+    );
+    grown.set(array.subarray(0, base * size));
+    let at = base;
+    for (const level of copies)
+      for (const vertex of level.source) {
+        grown.set(array.subarray(vertex * size, vertex * size + size), at * size);
+        at += 1;
+      }
+    const extended = accessor.clone().setArray(grown);
+    if (semantic === "POSITION") {
+      at = base;
+      for (const level of copies)
+        for (let copy = 0; copy < level.source.length; copy += 1, at += 1)
+          extended.setElement(at, Array.from(level.positions.subarray(copy * 3, copy * 3 + 3)));
+    }
+    primitive.setAttribute(semantic, extended);
+  }
+}
+
 function reachableNodes(document: Document): GltfNode[] {
   const visited = new Set<GltfNode>();
   const nodes: GltfNode[] = [];
@@ -1424,6 +1464,7 @@ export async function generateDiscreteLod(
         trianglesAfter += before;
         continue;
       }
+      if (chain.vertexCopies !== undefined) appendCardCopies(primitive, chain.vertexCopies);
       extension ??= document.createExtension(TNDiscreteLod).setRequired(false);
       const property = attachDiscreteLod(document, extension, primitive, {
         ...chain,
diff --git a/packages/assets/src/passes/model.ts b/packages/assets/src/passes/model.ts
index 15bae8175b..c2aefb88d9 100644
--- a/packages/assets/src/passes/model.ts
+++ b/packages/assets/src/passes/model.ts
@@ -486,6 +486,28 @@ function multiplyMatrices(a: readonly number[], b: readonly number[]): number[]
 
 const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
+/**
+ * The vertices a primitive draws: all of them when it has no index buffer, otherwise the distinct
+ * ones its indices name. A card LOD chain appends scaled copies of its cards that only the levels'
+ * indices reach (PRD-539); LOD0 never draws them, so they are not drift.
+ */
+function drawnVertices(primitive: GltfPrimitive, count: number): Uint32Array {
+  const indices = primitive.getIndices()?.getArray();
+  if (indices === null || indices === undefined)
+    return Uint32Array.from({ length: count }, (_, at) => at);
+  const seen = new Uint8Array(count);
+  let distinct = 0;
+  for (const index of indices)
+    if (index < count && seen[index] === 0) {
+      seen[index] = 1;
+      distinct += 1;
+    }
+  const out = new Uint32Array(distinct);
+  let at = 0;
+  for (let index = 0; index < count; index += 1) if (seen[index] === 1) out[at++] = index;
+  return out;
+}
+
 /**
  * Stats over scene-reachable content only; DCC leftovers dropped by prune are not drift.
  * The bounding box is taken over bind-pose vertex positions evaluated the way the GPU
@@ -540,8 +562,9 @@ export function reachableStats(root: RootOf): IModelStats {
           triangles += primitiveTriangles(primitive);
           const position = primitive.getAttribute("POSITION");
           if (position === null) continue;
-          vertices += position.getCount();
-          for (let index = 0; index < position.getCount(); index += 1) {
+          const drawn = drawnVertices(primitive, position.getCount());
+          vertices += drawn.length;
+          for (const index of drawn) {
             const [wx, wy, wz] = evaluateVertex(
               position,
               index,

From 86033313bed83d4d26dce642e00dc52242d290c9 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <admin@coldstartlabs.ca>
Date: Thu, 8 Oct 2026 09:47:51 -0700
Subject: [PATCH 3/6] test(core): a cooked level that draws appended vertex
 copies loads and selects

The card cook now appends scaled copies after LOD0 and indexes them
from the level (PRD-539). The loader and per-frame selection draw them
with no core change.
---
 ...PRD-539-card-lod-levels-keep-the-canopy.md |  4 +-
 .../core/__tests__/model-lod-loader.spec.ts   | 49 ++++++++++++++++---
 2 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
index 80da2c8e11..8ad3faa53b 100644
--- a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
+++ b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
@@ -49,10 +49,10 @@ Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the ke
 - [x] The model pass's self-check counts what LOD0 draws, so a card chain cooks without `TN_ASSETS_MODEL_DRIFT` and a LOD0 drift still throws. proof: `model-pass.spec.ts` drift cases green; the conifer cook threw `vertices 5997 -> 7573; bounding box drifted 2.109%` before; `vitest run packages/assets` 485 passed, 2 skipped
 
 #### Phase 2: Both runtimes draw it
-**Status:** NOT STARTED
+**Status:** IN PROGRESS
 **Files:** `packages/core/__tests__/`
 
-- [ ] Core builds a card level whose geometry draws the scaled copies. proof: a core spec that loads a cooked card GLB
+- [x] Core builds a card level whose geometry draws the scaled copies. proof: `model-lod-loader.spec.ts` "draws a level whose indices reach vertex copies appended after LOD0's" — 5 passed; no core change was needed
 - [ ] The native desktop host draws the same chain. proof: PRD-377's native consumer playtest on a cooked card asset
 
 #### Phase 3: Machinefall
diff --git a/packages/core/__tests__/model-lod-loader.spec.ts b/packages/core/__tests__/model-lod-loader.spec.ts
index b1b040f655..cb6c21b673 100644
--- a/packages/core/__tests__/model-lod-loader.spec.ts
+++ b/packages/core/__tests__/model-lod-loader.spec.ts
@@ -33,8 +33,9 @@ function gridIndices(triangles: number): number[] {
  * `TN_discrete_lod` extension on the primitive. Written by hand so the loader — not the asset
  * package the pipeline owns — is what this test exercises.
  */
-function cookedGlb(): Buffer {
-  const positions = new Float32Array((QUADS + 1) * 2 * 3);
+function cookedGlb(options: { copies?: boolean } = {}): Buffer {
+  const lod0Vertices = (QUADS + 1) * 2;
+  let positions = new Float32Array(lod0Vertices * 3);
   for (let vertex = 0; vertex <= QUADS; vertex += 1) {
     positions[vertex * 6] = (vertex / QUADS) * 2 - 1;
     positions[vertex * 6 + 1] = -1;
@@ -44,7 +45,19 @@ function cookedGlb(): Buffer {
     positions[vertex * 6 + 5] = 0;
   }
   const baseIndices = new Uint32Array(gridIndices(LOD0_TRIANGLES));
-  const levelIndices = new Uint32Array(gridIndices(COARSE_TRIANGLES));
+  let levelIndices = new Uint32Array(gridIndices(COARSE_TRIANGLES));
+  if (options.copies === true) {
+    // The card cook's shape (PRD-539): the level draws copies of its vertices, scaled and appended
+    // after LOD0's, which LOD0's own indices never reach.
+    const source = [...new Set(levelIndices)];
+    const grown = new Float32Array((lod0Vertices + source.length) * 3);
+    grown.set(positions);
+    for (const [copy, vertex] of source.entries())
+      for (let axis = 0; axis < 3; axis += 1)
+        grown[(lod0Vertices + copy) * 3 + axis] = (positions[vertex * 3 + axis] as number) * 2;
+    positions = grown;
+    levelIndices = levelIndices.map((vertex) => lod0Vertices + source.indexOf(vertex));
+  }
   const binPadded = padTo4(
     Buffer.concat([
       Buffer.from(positions.buffer, positions.byteOffset, positions.byteLength),
@@ -60,9 +73,9 @@ function cookedGlb(): Buffer {
       {
         bufferView: 0,
         componentType: 5126,
-        count: (QUADS + 1) * 2,
-        max: [1, 1, 0],
-        min: [-1, -1, 0],
+        count: positions.length / 3,
+        max: options.copies === true ? [2, 2, 0] : [1, 1, 0],
+        min: options.copies === true ? [-2, -2, 0] : [-1, -1, 0],
         type: "VEC3",
       },
       { bufferView: 1, componentType: 5125, count: baseIndices.length, type: "SCALAR" },
@@ -186,6 +199,30 @@ describe("createAssetLoader with a cooked TN_discrete_lod model", () => {
     expect(baseGeometryOf(mesh)).toBe(base);
   }, 120_000);
 
+  it("draws a level whose indices reach vertex copies appended after LOD0's", async () => {
+    stubFetch(cookedGlb({ copies: true }));
+    const loader = createAssetLoader({ basePath: "" });
+    const value = await loader.model<{ scene: Object3D }>("cards.glb");
+    const mesh = firstMesh(value.scene);
+    const lod0Vertices = (QUADS + 1) * 2;
+    const scene = new Scene();
+    scene.add(mesh);
+    const camera = new PerspectiveCamera(60, 1, 0.1, 1000);
+    camera.position.set(0, 0, 100);
+    camera.updateMatrixWorld(true);
+    expect(updateModelLods(scene, camera, 1080)).toBe(COARSE_TRIANGLES);
+    const level = Array.from(mesh.geometry.index?.array ?? []);
+    expect(level.length).toBe(COARSE_TRIANGLES * 3);
+    // Every corner the level draws is a copy, and the copy is in the shared position buffer.
+    for (const vertex of level) expect(vertex).toBeGreaterThanOrEqual(lod0Vertices);
+    const position = mesh.geometry.getAttribute("position");
+    expect(position).toBe(baseGeometryOf(mesh).getAttribute("position"));
+    expect(Math.max(...level)).toBeLessThan(position.count);
+    // LOD0 never reaches a copy.
+    const lod0 = Array.from(baseGeometryOf(mesh).index?.array ?? []);
+    expect(Math.max(...lod0)).toBeLessThan(lod0Vertices);
+  }, 120_000);
+
   it("shares the base's bounds with every level, so bounds padded after load reach them", async () => {
     // A vertex-displacement material makes a game pad the base's bounds after the model loads, so
     // the renderer does not cull the object the shader pushed out of shape. Every level shares the

From db390dc2d31dfaa56c4c0f5ce0324432cb2acd03 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <admin@coldstartlabs.ca>
Date: Thu, 8 Oct 2026 11:15:52 -0700
Subject: [PATCH 4/6] fix(core): a streamed world's chained levels cast shadows
 by default

`shadows.castLevels` defaulted to 1 on the reasoning that a far level's
shadow is sub-texel. That holds only past the shadow window, and a
shadow level draws only the caster clusters its own window covers.
Inside it the shadow is visible: once Machinefall's pines got a chain,
every pine past its first switch, tens of metres out, lost its shadow,
and 3 blind raters preferred the base on 6 of 8 poses ("weak shadows,
flatter"). With every level casting they prefer this build on 20 of 24
votes and tie on 4.

The default is now every level; a number still caps it.
world-cells.spec.ts: red `a far level minted no caster cluster`, then
green; packages/core + packages/assets 3086 passed.
---
 ...PRD-539-card-lod-levels-keep-the-canopy.md | 10 ++++--
 packages/core/__tests__/world-cells.spec.ts   | 32 ++++++++++++++++---
 .../world-shared-batch-clusters.spec.ts       |  5 ++-
 packages/core/src/world-cells.ts              | 12 ++++---
 4 files changed, 45 insertions(+), 14 deletions(-)

diff --git a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
index 8ad3faa53b..13677e809d 100644
--- a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
+++ b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
@@ -24,7 +24,8 @@ Keeping the needles at full cards is not an option: with every card part at LOD0
 
 1. **A lone level name is not an authored chain.** The cook counts an asset as authored LOD only when it holds two or more level-named nodes. A lone `_LOD2` has no sibling for anything to select, so it is that asset's LOD0. Already written and red-green on PRD-478's branch (`d65fa1eab`); it moves here so it never ships without step 2.
 2. **Card levels keep their coverage.** A card level appends a copy of each kept card, scaled about its centroid by `sqrt(1 / keep)`, to the primitive's own vertex arrays. The level's indices point at those copies. LOD0's indices do not change, and no schema changes: `TN_discrete_lod` stays index-only, and both readers (core's `model-lod.ts` and the world's `chainLevelParts`) already copy the base attributes and swap only the index buffer.
-3. **The self-check measures what LOD0 draws.** `reachableStats` counts the vertices and the bounds that LOD0's indices reference. Appended level vertices are then not drift, and a real drift in LOD0 still fails.
+3. **Every chained level casts.** `shadows.castLevels` defaulted to 1 because a far level's shadow was taken to be sub-texel. That holds only outside the shadow window, and a shadow level draws only the caster clusters its window covers, so the default is now every level.
+4. **The self-check measures what LOD0 draws.** `reachableStats` counts the vertices and the bounds that LOD0's indices reference. Appended level vertices are then not drift, and a real drift in LOD0 still fails.
 
 Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the keep ratio, which the reducer already owns.
 
@@ -32,6 +33,10 @@ Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the ke
 
 - 2026-10-08, agent: a kept card scales by at most 2. The ratio levels (keep ≥ 0.25) reach full coverage under it. The terminal level keeps far fewer cards, and scaling them further would grow cards past the crown's silhouette, so it covers `4 × keep` of LOD0.
 
+## Findings
+
+- 2026-10-08 blind raters, PRD-478 tip vs this PRD's cook plus every level casting (same JS bundle except the cast default, laptop Intel GPU): 3 fresh raters, 8 poses, the candidate at or above on 24 of 24 votes (20 prefer, 4 ties, all ties on the bridge pose). All three note a few dark needle specks above the treetops on the highway pose: the bark part's one derived level drops the top 19 % of the trunk (top 0.920 → 0.746 of the quantized height) while the needles keep theirs, because a shallower part follows the deepest part's switch (`chainDistances`).
+
 ## Acceptance Criteria
 
 - [x] AC-1: every ratio card level ships ≥ 0.95 of LOD0's card area, read back from the cooked bytes; the terminal level ships min(1, 4 × keep). proof: `foliage-lod.spec.ts` — 8 passed; red before the change: `expected 0.5162100266415837 to be greater than or equal to 0.95`
@@ -50,9 +55,10 @@ Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the ke
 
 #### Phase 2: Both runtimes draw it
 **Status:** IN PROGRESS
-**Files:** `packages/core/__tests__/`
+**Files:** `packages/core/src/world-cells.ts`, `packages/core/__tests__/`
 
 - [x] Core builds a card level whose geometry draws the scaled copies. proof: `model-lod-loader.spec.ts` "draws a level whose indices reach vertex copies appended after LOD0's" — 5 passed; no core change was needed
+- [x] A streamed world's chained levels cast shadows by default (`shadows.castLevels` defaults to every level; a number still caps it). Under the old default of 1, every pine past its first switch, tens of metres out, lost its shadow, and 3 blind raters preferred the base on 6 of 8 poses ("weak shadows, flatter"). proof: red-green `world-cells.spec.ts` (`a far level minted no caster cluster: expected 0 to be greater than 0`); `vitest run packages/core packages/assets` 3086 passed, 1 load timeout that passes alone
 - [ ] The native desktop host draws the same chain. proof: PRD-377's native consumer playtest on a cooked card asset
 
 #### Phase 3: Machinefall
diff --git a/packages/core/__tests__/world-cells.spec.ts b/packages/core/__tests__/world-cells.spec.ts
index 9e7c2583bd..ac65d06ffb 100644
--- a/packages/core/__tests__/world-cells.spec.ts
+++ b/packages/core/__tests__/world-cells.spec.ts
@@ -2033,7 +2033,7 @@ describe("WorldCells", () => {
     }
   });
 
-  it("casts shadows from the near levels and receives them everywhere only when asked", async () => {
+  it("casts shadows from every level and receives them everywhere only when asked", async () => {
     stubFixtureFetch();
     const follow = followAt(-64, -64);
     const plain = await loadWorld({
@@ -2062,9 +2062,10 @@ describe("WorldCells", () => {
     });
     shaded.update();
     await flushed(shaded);
-    // Only the finest level casts by default: a far LOD's shadow is sub-texel and every caster is
-    // redrawn per shadow level. The main mesh casts nothing — its records reach the shadow maps
-    // through the caster cluster, which is what a level culls (PRD-458).
+    // Every level casts by default: a shadow level draws only the clusters its own window covers, so
+    // a far level's caster costs nothing outside it, and inside it its shadow is visible (PRD-539).
+    // The main mesh casts nothing — its records reach the shadow maps through the caster cluster,
+    // which is what a level culls (PRD-458).
     expect((levelMesh(shaded, "pine", 0, 0) as InstancedMesh).castShadow).toBe(false);
     expect((levelMesh(shaded, "pine", 1, 0) as InstancedMesh).receiveShadow).toBe(true);
     const casters = clustersOf(shaded, "pine", 0, 0);
@@ -2073,7 +2074,10 @@ describe("WorldCells", () => {
       expect(caster.castShadow, "the finest level's caster cluster does not cast").toBe(true);
       expect(caster.layers.mask, "a caster is not alone on the caster layer").toBe(1 << 28);
     }
-    expect(clustersOf(shaded, "pine", 1, 0), "a far level minted a caster cluster").toEqual([]);
+    expect(
+      clustersOf(shaded, "pine", 1, 0).length,
+      "a far level minted no caster cluster",
+    ).toBeGreaterThan(0);
     const terrain: Mesh[] = [];
     shaded.traverse((object) => {
       // A mesh alone on a caster layer is a shadow-only proxy: it casts, and by construction it
@@ -2087,6 +2091,24 @@ describe("WorldCells", () => {
     for (const mesh of terrain) expect(mesh.receiveShadow).toBe(true);
     shaded.dispose();
 
+    // A cap still holds: `castLevels: 1` keeps the far level out of every shadow map.
+    const capped = await loadWorld({
+      budgets: largeBudgets,
+      follow,
+      loadModel: treeLoader().load,
+      ring: 0,
+      shadows: { cast: true, castLevels: 1 },
+      surface,
+      url: "/world/world.json",
+    });
+    capped.update();
+    await flushed(capped);
+    expect(clustersOf(capped, "pine", 0, 0).length).toBeGreaterThan(0);
+    expect(clustersOf(capped, "pine", 1, 0), "a capped far level minted a caster cluster").toEqual(
+      [],
+    );
+    capped.dispose();
+
     await expect(
       loadWorld({
         budgets: largeBudgets,
diff --git a/packages/core/__tests__/world-shared-batch-clusters.spec.ts b/packages/core/__tests__/world-shared-batch-clusters.spec.ts
index db2d05d305..5f2b900db8 100644
--- a/packages/core/__tests__/world-shared-batch-clusters.spec.ts
+++ b/packages/core/__tests__/world-shared-batch-clusters.spec.ts
@@ -329,10 +329,9 @@ describe("WorldCells clustered shadow casters", () => {
       const { key } = squareOf(name);
       expect(mesh.layers.mask, `${name} is not alone on the caster layer`).toBe(1 << 28);
       expect(mesh.frustumCulled, `${name} is not cullable`).toBe(true);
+      // Every level casts by default; the window bounds which clusters a shadow level draws (PRD-539).
       const level = Number(key.split(":")[1]);
-      expect(mesh.castShadow, `${name} (level ${String(level)}) cast the wrong way`).toBe(
-        level === 0,
-      );
+      expect(mesh.castShadow, `${name} (level ${String(level)}) does not cast`).toBe(true);
       expect(mesh.receiveShadow, `${name} receives, and no camera it draws with will`).toBe(false);
     }
     // Every castable key is split into more than one cluster, or nothing was clustered.
diff --git a/packages/core/src/world-cells.ts b/packages/core/src/world-cells.ts
index b45b5a2bf6..03f1e0a8ea 100644
--- a/packages/core/src/world-cells.ts
+++ b/packages/core/src/world-cells.ts
@@ -399,9 +399,11 @@ export interface IWorldCellsLoadOptions {
   readonly transparentScatter?: "cutout" | "blend";
   /**
    * Shadows for the streamed world, all off by default. `cast` makes scattered batches cast into
-   * the scene's shadow map, but only their `castLevels` finest distance levels (default 1: the
-   * near shape), since a far LOD's shadow is sub-texel in any open-world shadow window and every
-   * caster is redrawn per shadow level. `receive` lets scatter and terrain receive shadows.
+   * the scene's shadow map, every distance level by default: a shadow level draws only the caster
+   * clusters its own window covers, so a far level costs nothing past the window, and inside it its
+   * shadow is visible — a chain whose first switch is tens of metres out lost its trees' shadows
+   * there under the old default of 1 (PRD-539). `castLevels` caps it to the finest N levels.
+   * `receive` lets scatter and terrain receive shadows.
    */
   readonly shadows?: {
     readonly cast?: boolean;
@@ -4108,7 +4110,9 @@ export class WorldCells extends Group implements IComputeDriven {
     this.#gpuTally = init.gpuSceneTally === true;
     this.#castShadowLevels =
       init.shadows?.cast === true
-        ? positiveInteger(init.shadows.castLevels ?? 1, "shadows.castLevels")
+        ? init.shadows.castLevels === undefined
+          ? Number.POSITIVE_INFINITY
+          : positiveInteger(init.shadows.castLevels, "shadows.castLevels")
         : 0;
     this.#receiveShadow = init.shadows?.receive === true;
     this.#smallCasterMetres = positiveMetres(

From f88c4129cecf127ceeed2206c40e7093a04afa13 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <admin@coldstartlabs.ca>
Date: Thu, 8 Oct 2026 11:43:07 -0700
Subject: [PATCH 5/6] test(auto-lod): a card crown proves both runtimes draw
 scaled card levels

examples/auto-lod gains a generated 1,200-card crown (cards.glb, from
scripts/make-cards.mjs). The scene reports the crown's drawn triangles
and whether the drawn level reaches a vertex LOD0 never indexes, which
is a scaled copy (PRD-539). Far scenarios require it; near scenarios
drive it back to LOD0. Native desktop: far and near pass
(cardCopies 1 -> 0, cardTriangles 1252 -> 2400).
---
 examples/auto-lod/assets/cards.glb            | Bin 0 -> 87268 bytes
 .../playtests/lod-far-desktop.playtest.json   |  12 ++
 .../auto-lod/playtests/lod-far.playtest.json  |  12 ++
 .../playtests/lod-near-desktop.playtest.json  |  26 +++-
 .../auto-lod/playtests/lod-near.playtest.json |  26 +++-
 examples/auto-lod/scripts/make-cards.mjs      | 118 ++++++++++++++++++
 examples/auto-lod/src/scenes/Lod.ts           |  38 +++++-
 7 files changed, 223 insertions(+), 9 deletions(-)
 create mode 100644 examples/auto-lod/assets/cards.glb
 create mode 100644 examples/auto-lod/scripts/make-cards.mjs

diff --git a/examples/auto-lod/assets/cards.glb b/examples/auto-lod/assets/cards.glb
new file mode 100644
index 0000000000000000000000000000000000000000..dd0de1c82d7e82dfd3784e1b91035b765eb29276
GIT binary patch
literal 87268
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
Qz^y%qLkK~rTN{S|0}-2$lmGw#

literal 0
HcmV?d00001

diff --git a/examples/auto-lod/playtests/lod-far-desktop.playtest.json b/examples/auto-lod/playtests/lod-far-desktop.playtest.json
index c50a884914..6b9203c252 100644
--- a/examples/auto-lod/playtests/lod-far-desktop.playtest.json
+++ b/examples/auto-lod/playtests/lod-far-desktop.playtest.json
@@ -27,6 +27,18 @@
         "id": "GameState",
         "lte": 4096,
         "path": "triangles"
+      },
+      {
+        "id": "GameState",
+        "path": "cardCopies",
+        "gte": 1,
+        "allowTrivial": "The scene starts on the far route and holds it, so the far level is selected before the run; the matching near scenario drives cardCopies to 0 and cardTriangles to 2400 to prove the selection follows the camera."
+      },
+      {
+        "id": "GameState",
+        "path": "cardTriangles",
+        "lte": 1800,
+        "allowTrivial": "The scene starts on the far route and holds it, so the far level is selected before the run; the matching near scenario drives cardCopies to 0 and cardTriangles to 2400 to prove the selection follows the camera."
       }
     ],
     "sceneNodes": [
diff --git a/examples/auto-lod/playtests/lod-far.playtest.json b/examples/auto-lod/playtests/lod-far.playtest.json
index 4604dc57f6..4038ffe336 100644
--- a/examples/auto-lod/playtests/lod-far.playtest.json
+++ b/examples/auto-lod/playtests/lod-far.playtest.json
@@ -36,6 +36,18 @@
         "id": "GameState",
         "lte": 4096,
         "path": "triangles"
+      },
+      {
+        "id": "GameState",
+        "path": "cardCopies",
+        "gte": 1,
+        "allowTrivial": "The scene starts on the far route and holds it, so the far level is selected before the run; the matching near scenario drives cardCopies to 0 and cardTriangles to 2400 to prove the selection follows the camera."
+      },
+      {
+        "id": "GameState",
+        "path": "cardTriangles",
+        "lte": 1800,
+        "allowTrivial": "The scene starts on the far route and holds it, so the far level is selected before the run; the matching near scenario drives cardCopies to 0 and cardTriangles to 2400 to prove the selection follows the camera."
       }
     ],
     "sceneNodes": [
diff --git a/examples/auto-lod/playtests/lod-near-desktop.playtest.json b/examples/auto-lod/playtests/lod-near-desktop.playtest.json
index 4aac079974..5a194a8e0c 100644
--- a/examples/auto-lod/playtests/lod-near-desktop.playtest.json
+++ b/examples/auto-lod/playtests/lod-near-desktop.playtest.json
@@ -3,9 +3,15 @@
   "schemaVersion": 1,
   "subject": "the native host's near camera selects LOD0 for the model",
   "target": "desktop",
-  "viewport": { "width": 1280, "height": 720 },
+  "viewport": {
+    "width": 1280,
+    "height": 720
+  },
   "warmupFrames": 90,
-  "artifacts": { "screenshots": false, "console": true },
+  "artifacts": {
+    "screenshots": false,
+    "console": true
+  },
   "steps": [
     {
       "kind": "input",
@@ -28,11 +34,25 @@
         "gte": 8000,
         "id": "GameState",
         "path": "triangles"
+      },
+      {
+        "changed": true,
+        "id": "GameState",
+        "lte": 0,
+        "path": "cardCopies"
+      },
+      {
+        "changed": true,
+        "gte": 2400,
+        "id": "GameState",
+        "path": "cardTriangles"
       }
     ],
     "sceneNodes": [
       {
-        "select": { "nameContains": "hull-mesh" },
+        "select": {
+          "nameContains": "hull-mesh"
+        },
         "minCount": 1,
         "minTriangles": 8000,
         "visible": true
diff --git a/examples/auto-lod/playtests/lod-near.playtest.json b/examples/auto-lod/playtests/lod-near.playtest.json
index 7b6f8ae8aa..4846ea9fd5 100644
--- a/examples/auto-lod/playtests/lod-near.playtest.json
+++ b/examples/auto-lod/playtests/lod-near.playtest.json
@@ -3,9 +3,15 @@
   "schemaVersion": 1,
   "subject": "the near camera selects LOD0 for the model",
   "target": "web",
-  "viewport": { "width": 1280, "height": 720 },
+  "viewport": {
+    "width": 1280,
+    "height": 720
+  },
   "warmupFrames": 90,
-  "artifacts": { "screenshots": true, "console": true },
+  "artifacts": {
+    "screenshots": true,
+    "console": true
+  },
   "steps": [
     {
       "kind": "input",
@@ -34,11 +40,25 @@
         "gte": 8000,
         "id": "GameState",
         "path": "triangles"
+      },
+      {
+        "changed": true,
+        "id": "GameState",
+        "lte": 0,
+        "path": "cardCopies"
+      },
+      {
+        "changed": true,
+        "gte": 2400,
+        "id": "GameState",
+        "path": "cardTriangles"
       }
     ],
     "sceneNodes": [
       {
-        "select": { "nameContains": "hull-mesh" },
+        "select": {
+          "nameContains": "hull-mesh"
+        },
         "minCount": 1,
         "minTriangles": 8000,
         "visible": true
diff --git a/examples/auto-lod/scripts/make-cards.mjs b/examples/auto-lod/scripts/make-cards.mjs
new file mode 100644
index 0000000000..460365a636
--- /dev/null
+++ b/examples/auto-lod/scripts/make-cards.mjs
@@ -0,0 +1,118 @@
+// Builds the example's card crown: 1,200 alpha-tested quads (2,400 triangles) scattered through a
+// sphere, written as a dependency-free GLB. The cook gives it a `cards` chain whose levels draw
+// scaled copies of the kept cards appended after LOD0's vertices (PRD-539), which is the shape the
+// desktop scenarios prove the native host draws.
+import { writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const CARDS = 1200;
+const HALF = 0.09;
+
+// A fixed LCG, so the file is the same bytes on every run.
+let seed = 7;
+const random = () => {
+  seed = (seed * 1664525 + 1013904223) >>> 0;
+  return seed / 2 ** 32;
+};
+
+const positions = new Float32Array(CARDS * 4 * 3);
+const indices = new Uint32Array(CARDS * 6);
+for (let card = 0; card < CARDS; card += 1) {
+  let x;
+  let y;
+  let z;
+  do {
+    x = random() * 2 - 1;
+    y = random() * 2 - 1;
+    z = random() * 2 - 1;
+  } while (x * x + y * y + z * z > 1);
+  const angle = random() * Math.PI;
+  const ux = Math.cos(angle) * HALF;
+  const uz = Math.sin(angle) * HALF;
+  const corners = [
+    [x - ux, y - HALF, z - uz],
+    [x + ux, y - HALF, z + uz],
+    [x + ux, y + HALF, z + uz],
+    [x - ux, y + HALF, z - uz],
+  ];
+  for (const [corner, point] of corners.entries()) positions.set(point, (card * 4 + corner) * 3);
+  const a = card * 4;
+  indices.set([a, a + 1, a + 2, a, a + 2, a + 3], card * 6);
+}
+
+const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+for (let vertex = 0; vertex < positions.length / 3; vertex += 1) {
+  for (let axis = 0; axis < 3; axis += 1) {
+    min[axis] = Math.min(min[axis], positions[vertex * 3 + axis]);
+    max[axis] = Math.max(max[axis], positions[vertex * 3 + axis]);
+  }
+}
+
+const pad = (buffer, fill) =>
+  buffer.length % 4 === 0
+    ? buffer
+    : Buffer.concat([buffer, Buffer.alloc(4 - (buffer.length % 4), fill)]);
+const positionBuffer = Buffer.from(positions.buffer);
+const indexBuffer = Buffer.from(indices.buffer);
+const bin = pad(Buffer.concat([positionBuffer, indexBuffer]), 0);
+const json = pad(
+  Buffer.from(
+    JSON.stringify({
+      accessors: [
+        {
+          bufferView: 0,
+          componentType: 5126,
+          count: positions.length / 3,
+          max,
+          min,
+          type: "VEC3",
+        },
+        { bufferView: 1, componentType: 5125, count: indices.length, type: "SCALAR" },
+      ],
+      asset: { generator: "examples/auto-lod make-cards", version: "2.0" },
+      bufferViews: [
+        { buffer: 0, byteLength: positionBuffer.length, byteOffset: 0, target: 34962 },
+        {
+          buffer: 0,
+          byteLength: indexBuffer.length,
+          byteOffset: positionBuffer.length,
+          target: 34963,
+        },
+      ],
+      buffers: [{ byteLength: bin.length }],
+      materials: [
+        {
+          alphaCutoff: 0.5,
+          alphaMode: "MASK",
+          doubleSided: true,
+          name: "leaf",
+          pbrMetallicRoughness: { baseColorFactor: [0.2, 0.45, 0.15, 1], metallicFactor: 0 },
+        },
+      ],
+      meshes: [
+        // biome-ignore lint/style/useNamingConvention: `POSITION` is the glTF attribute semantic, fixed by the spec.
+        { primitives: [{ attributes: { POSITION: 0 }, indices: 1, material: 0, mode: 4 }] },
+      ],
+      nodes: [{ mesh: 0 }],
+      scene: 0,
+      scenes: [{ nodes: [0] }],
+    }),
+  ),
+  0x20,
+);
+
+const total = 12 + 8 + json.length + 8 + bin.length;
+const glb = Buffer.alloc(total);
+glb.writeUInt32LE(0x46546c67, 0);
+glb.writeUInt32LE(2, 4);
+glb.writeUInt32LE(total, 8);
+glb.writeUInt32LE(json.length, 12);
+glb.writeUInt32LE(0x4e4f534a, 16);
+json.copy(glb, 20);
+glb.writeUInt32LE(bin.length, 20 + json.length);
+glb.writeUInt32LE(0x004e4942, 24 + json.length);
+bin.copy(glb, 28 + json.length);
+writeFileSync(resolve(here, "../assets/cards.glb"), glb);
diff --git a/examples/auto-lod/src/scenes/Lod.ts b/examples/auto-lod/src/scenes/Lod.ts
index 62f3d87633..4526cfb105 100644
--- a/examples/auto-lod/src/scenes/Lod.ts
+++ b/examples/auto-lod/src/scenes/Lod.ts
@@ -1,4 +1,4 @@
-import { type ICtx, Scene, type SceneFrame } from "@threenative/core";
+import { type ICtx, Scene, type SceneFrame, baseGeometryOf } from "@threenative/core";
 import { AmbientLight, DirectionalLight, type Group, Mesh, type PerspectiveCamera } from "three";
 
 /** Close enough that the model's own error projects past a one-pixel budget. */
@@ -16,10 +16,17 @@ const FAR = 140;
  * engine swaps `mesh.geometry` before the render, so a frame after a settle reads the selected level.
  */
 export class Lod extends Scene {
-  static override readonly initialState = { camera: "far", triangles: 0 };
+  static override readonly initialState = {
+    camera: "far",
+    cardCopies: 0,
+    cardTriangles: 0,
+    triangles: 0,
+  };
 
   #loaded = false;
   readonly #meshes: Mesh[] = [];
+  /** The card crown: its levels draw scaled copies appended after LOD0's vertices (PRD-539). */
+  readonly #cards: Mesh[] = [];
 
   override async load(ctx: ICtx): Promise<void> {
     const model = await ctx.assets.model<{ scene: Group }>("hull.glb");
@@ -30,6 +37,15 @@ export class Lod extends Scene {
       this.#meshes.push(object);
     });
     ctx.scene.add(model.scene);
+    const crown = await ctx.assets.model<{ scene: Group }>("cards.glb");
+    crown.scene.name = "cards";
+    crown.scene.position.set(3, 0, 0);
+    crown.scene.traverse((object) => {
+      if (!(object instanceof Mesh)) return;
+      object.name = "cards-mesh";
+      this.#cards.push(object);
+    });
+    ctx.scene.add(crown.scene);
     this.#loaded = true;
   }
 
@@ -54,7 +70,23 @@ export class Lod extends Scene {
         const drawn = mesh.geometry.index?.count ?? mesh.geometry.getAttribute("position")?.count;
         triangles += Math.floor((drawn ?? 0) / 3);
       }
-      frameCtx.state.set({ triangles });
+      // A level that reaches a vertex LOD0 never indexes is drawing the scaled card copies.
+      let cardTriangles = 0;
+      let cardCopies = 0;
+      for (const mesh of this.#cards) {
+        const drawn = mesh.geometry.index;
+        const lod0 = baseGeometryOf(mesh).index;
+        if (drawn === null || lod0 === null) continue;
+        cardTriangles += Math.floor(drawn.count / 3);
+        let lod0Max = 0;
+        for (let at = 0; at < lod0.count; at += 1) lod0Max = Math.max(lod0Max, lod0.getX(at));
+        for (let at = 0; at < drawn.count; at += 1)
+          if (drawn.getX(at) > lod0Max) {
+            cardCopies = 1;
+            break;
+          }
+      }
+      frameCtx.state.set({ cardCopies, cardTriangles, triangles });
       if (!frameCtx.input.justPressed("toggleNear")) return;
       // Toggle, so a scenario can drive the value and prove the selection follows the camera
       // rather than reporting a number that never changed.

From d54a368047fb10a7a61e89c1a173a059b4aa46a1 Mon Sep 17 00:00:00 2001
From: Joao Paulo Furtado <admin@coldstartlabs.ca>
Date: Thu, 8 Oct 2026 11:43:46 -0700
Subject: [PATCH 6/6] docs(prd-539): both runtimes draw the scaled card levels

Native desktop and web far scenarios pass on the auto-lod card crown.
Web lod-near is red on develop too, so it carries no card check.
---
 ...PRD-539-card-lod-levels-keep-the-canopy.md |  4 +--
 .../auto-lod/playtests/lod-near.playtest.json | 26 +++----------------
 2 files changed, 5 insertions(+), 25 deletions(-)

diff --git a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
index 13677e809d..c1149c9685 100644
--- a/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
+++ b/docs/PRDs/assets/PRD-539-card-lod-levels-keep-the-canopy.md
@@ -54,12 +54,12 @@ Layer: the cook (`packages/assets/`). The game sets nothing; the scale is the ke
 - [x] The model pass's self-check counts what LOD0 draws, so a card chain cooks without `TN_ASSETS_MODEL_DRIFT` and a LOD0 drift still throws. proof: `model-pass.spec.ts` drift cases green; the conifer cook threw `vertices 5997 -> 7573; bounding box drifted 2.109%` before; `vitest run packages/assets` 485 passed, 2 skipped
 
 #### Phase 2: Both runtimes draw it
-**Status:** IN PROGRESS
+**Status:** DONE
 **Files:** `packages/core/src/world-cells.ts`, `packages/core/__tests__/`
 
 - [x] Core builds a card level whose geometry draws the scaled copies. proof: `model-lod-loader.spec.ts` "draws a level whose indices reach vertex copies appended after LOD0's" — 5 passed; no core change was needed
 - [x] A streamed world's chained levels cast shadows by default (`shadows.castLevels` defaults to every level; a number still caps it). Under the old default of 1, every pine past its first switch, tens of metres out, lost its shadow, and 3 blind raters preferred the base on 6 of 8 poses ("weak shadows, flatter"). proof: red-green `world-cells.spec.ts` (`a far level minted no caster cluster: expected 0 to be greater than 0`); `vitest run packages/core packages/assets` 3086 passed, 1 load timeout that passes alone
-- [ ] The native desktop host draws the same chain. proof: PRD-377's native consumer playtest on a cooked card asset
+- [x] The native desktop host draws the same chain. proof: `examples/auto-lod` gains a 1,200-card crown (`scripts/make-cards.mjs`); cooked to `cards` levels 2,400 → 1,252 → 646 triangles over 4,800 → 8,596 vertices. `lod-far-desktop` and `lod-near-desktop` pass on the native host built by `threenative build --target desktop` (prebuilt runtime): `cardCopies` 1 → 0 and `cardTriangles` 1,252 → 2,400 across the camera toggle. Web `lod-far` passes (`cardCopies` 0 → 1, `cardTriangles` 2,400 → 1,252, RTX 2080). Web `lod-near` is red on develop too (`triangles` 8192 → 8192, the first observation precedes selection), so it carries no card check.
 
 #### Phase 3: Machinefall
 **Status:** NOT STARTED
diff --git a/examples/auto-lod/playtests/lod-near.playtest.json b/examples/auto-lod/playtests/lod-near.playtest.json
index 4846ea9fd5..7b6f8ae8aa 100644
--- a/examples/auto-lod/playtests/lod-near.playtest.json
+++ b/examples/auto-lod/playtests/lod-near.playtest.json
@@ -3,15 +3,9 @@
   "schemaVersion": 1,
   "subject": "the near camera selects LOD0 for the model",
   "target": "web",
-  "viewport": {
-    "width": 1280,
-    "height": 720
-  },
+  "viewport": { "width": 1280, "height": 720 },
   "warmupFrames": 90,
-  "artifacts": {
-    "screenshots": true,
-    "console": true
-  },
+  "artifacts": { "screenshots": true, "console": true },
   "steps": [
     {
       "kind": "input",
@@ -40,25 +34,11 @@
         "gte": 8000,
         "id": "GameState",
         "path": "triangles"
-      },
-      {
-        "changed": true,
-        "id": "GameState",
-        "lte": 0,
-        "path": "cardCopies"
-      },
-      {
-        "changed": true,
-        "gte": 2400,
-        "id": "GameState",
-        "path": "cardTriangles"
       }
     ],
     "sceneNodes": [
       {
-        "select": {
-          "nameContains": "hull-mesh"
-        },
+        "select": { "nameContains": "hull-mesh" },
         "minCount": 1,
         "minTriangles": 8000,
         "visible": true