feat(geometry,wasm,cache): representation-item identity crosses the boundary, disjoint from material ids (#3199) (#3210)

* feat(geometry,wasm,cache): representation-item identity crosses the boundary, disjoint from material ids (#3199)

The router already kept each representation item's STEP id, and it already
reached the server REST payload. `MeshDataJs::from_mesh_data` did not copy it,
so the browser never saw it and a host could not drill from a rendered piece to
the entity that produced it -- an `IfcWindow`'s pane or frame -- and navigate
there in source (#2985).

AND IT WAS WRONG FOR LAYERED WALLS. `router/layers.rs` pushes
`SubMesh::new(layer.material_id, slab)`, so for material-layered walls and slabs
the same field carried an `IfcMaterial` id. Following it to source landed on the
wrong entity, with nothing to tell the caller which kind of id it had.

TWO DISJOINT FIELDS, never both: `geometry_item_id` is always a representation
item, `material_layer_id` is always an `IfcMaterial`. `with_style_metadata`
takes the DISCRIMINATOR rather than the destination field, so a caller cannot
put a material id in the wrong one by picking the wrong setter -- a two-setter
API would leave the confusion one typo away.

THE DISCRIMINATOR LIVES ON `SubMeshCollection`, set where the layered slabs are
built, because it is a property of how the collection was built and is uniform
across it. `geometry_class == GEOM_CLASS_LAYER_SLICE` cannot answer it, and this
was checked rather than assumed: that class is stamped in `element.rs` from
`is_material_layer_sliceable`, a static material-index check made BEFORE the
geometry runs, while `try_layered_sub_meshes` can still return `None` at several
points and fall through to the representation-item path. Rep-item ids can carry
class 3.

The voided rebuild in `voids/mod.rs` INHERITS the flag rather than hard-coding
rep-item. It is false there today, but hard-coding would let a future layered
producer be silently relabelled -- the exact confusion this removes.

CACHE FORMAT v14, because `sections/geometry.ts` writes `MeshData` field by
field and a cache-restored session would otherwise lose the identity. Bumped
rather than read leniently: the record is positional, so a v13 reader handed a
v14 record would take the origin's first f64 out of the two new u32 and every
field after it would be garbage. A v14 reader still reads v13 records -- the
fields are version-gated and degrade to `undefined`, the same state the runtime
uses where identity is genuinely merged away, so an old cache degrades to
"unknown" and never to a WRONG id.

THE ABSENT SENTINEL IS 0xFFFFFFFF, NOT 0, and a test caught me getting this
wrong. `layers.rs` uses `0` for a layer with no material -- an air gap -- so 0
is a REAL value that must round trip. The first version treated it as absent,
which is the valid-but-falsy trap and would have dropped exactly the layers
hardest to notice missing. Every read now compares against the sentinel or
`undefined`; nothing tests these ids for truthiness.

MODULE SIZE. Five Rust rows are raised with a per-row justification and the
digest re-pinned, because adding a field to a boundary struct necessarily grows
the boundary file and `zero_copy/mesh.rs` cannot absorb 2 fields + 2 getters + a
paired setter + propagation at three clone sites within its budget. The TS
allowlist forbids raises outright, so `types.ts` was SPLIT instead: the
self-contained symbolic-representation family moves to `symbolic-types.ts` (it
is re-exported, so the public surface is unchanged), taking types.ts from 459 to
381 and letting its row be DELETED -- which is what the gate asks for. The
worker was brought back to exactly its budget.

VERIFIED AT THE REAL BOUNDARY, not by reading:

  duplex.ifc through processGeometryBatch:
    436 meshes with geometryItemId, 186 with materialLayerId,
    BOTH = 0, neither = 0

  Paired probe: conflating the two fields (setting both, as before the fix)
  turns the new contract test red with "186 meshes carried BOTH".

The contract test asserts non-vacuity in both directions -- some mesh must carry
each field -- because "never both" is satisfied trivially by never setting
either.

One instrument bug found on the way: `scripts/lib/mesh-via-prepass.mjs` mirrors
`convertMeshCollectionToBatch` field by field, so it silently dropped the new
ids and my first probe read zeros through it. A field the real converter carries
and that facade drops is invisible to every script that reads through it.

2162 Rust tests, clippy -D warnings clean, 621 script tests, 106 cache tests,
73 wasm-contract assertions, typecheck clean.

Closes #3199

* fix(3199): never emit a source id of 0, mirror the ids on the REST wire, and rename material_layer_id (#3210 review)

Review round on #3210. The three defects below were raised by the peer session
that filed and claimed #3199 and had built its own branch for it; the rest came
from Codex, CodeRabbit and a /simplify + /code-review pass. Three of these are defects in
the change as first written.

A SOURCE ID OF 0 IS NOT AN ENTITY, and the first version shipped one.
`IfcMaterialLayer.Material` is OPTIONAL, so `material_layer_index.rs` reads it
as `get_ref(0).unwrap_or(0)` and an air gap arrives with `material_id == 0`.
That is the DECODER'S ABSENCE SENTINEL, not an id -- STEP instance names start
at #1. Storing it made the slab claim to be a slice of `IfcMaterial #0`, and a
host following it landed on nothing, which is the exact defect #3199 exists to
remove, one field over. MEASURED at the real boundary: 12 slabs of duplex.ifc
reported `IfcMaterial #0` before the filter. `with_style_metadata` now maps 0 to
`None` on BOTH fields, at the setter rather than at each producer, so the next
producer does not have to remember.

This makes my earlier reasoning WRONG, not just incomplete: I had argued 0 was a
real value that must round trip, and built the cache's 0xFFFFFFFF sentinel on
that. The sentinel is still right -- an absence marker the domain can produce is
one upstream change from being wrong again -- but its stated REASON was false in
three places (the writer, the v14 ledger, and a cache test citing a measurement
the same PR had invalidated). All three now tell one story.

THE REST MIRROR was untouched. `apps/server/src/types/mesh.rs` re-exports the
very struct that changed, so the server had started sending `material_id` while
`packages/server-client/src/types.ts` declared no such field and
`convertServerMesh` dropped it -- the REST path's identity died at the
converter. Both are fixed, with a Rust test pinning the wire NAMES and the
ABSENT ENCODING: `skip_serializing_if` makes `None` a MISSING KEY, and a TS
optional means absent rather than nullable, so the two agree only while that
attribute stays on.

RENAMED `material_layer_id` -> `material_id`. It holds an `IfcMaterial` express
id, not an `IfcMaterialLayer` one, and `IfcMaterialLayer` is a real and
different entity -- so the old name did not merely abbreviate, it pointed at the
wrong schema type. AGENTS.md: "New surface still gets the EXPRESS name, once."
Cheaper now than after it ships as public API on four packages.

TESTS THAT COULD NOT FAIL, found by mutation rather than by reading:

  - Deleting BOTH spreads from `convertMeshCollectionToBatch` left
    packages/geometry at 353/353 green. That converter is the only path by
    which the viewer's main thread sees the ids, and every other #3199 test
    reads the raw MeshCollection, which is upstream of it. Three tests added;
    they fail with the spreads removed.
  - The block header claimed "one test below reads through the facade on
    purpose" and none did, so the `mesh-via-prepass.mjs` fix shipped with no
    coverage -- the facade being the thing that actually went wrong. Added, and
    it cross-checks against the raw collection rather than a fixed count, so it
    cannot go vacuous when the fixture changes.
  - `voided_submesh_entry_reports_layer_ids_as_material_ids` claimed to cover
    the sub-mesh-by-sub-mesh rebuild. It does not: a layered wall returns at the
    `try_layered_sub_meshes` early exit and never reaches it, and replacing the
    inheritance with a hard-coded `false` leaves everything green. The comment
    now says so. The code stays an inheritance deliberately; it is defensive and
    honestly untested rather than dishonestly claimed.

MODULE SIZE, redone: the TS allowlist now has NO raises at all. Splitting the
self-contained symbolic wire shapes out of `server-client/src/types.ts` (the
same split already made in `@ifc-lite/geometry`, re-exported so the surface is
unchanged) ratchets that row 772 -> 627, and `packages/geometry/src/types.ts`'s
row is deleted. Both directions the gate asks for, neither a raise.

STATED, NOT SILENTLY SHIPPED -- three things this PR does not fix:

  #3211  five style lookups in element.rs still read a sub-mesh id as a
         representation item on the layered path; safe only because express ids
         are unique per file, which is an accident doing load-bearing work
  #3215  the Parquet transport carries neither id, so drill-to-source works on
         JSON and not on the binary path
  #3216  npm drives the Cargo version, so this change -- breaking for the
         published `ifc-lite-processing` crate -- ships as a minor bump, with no
         cargo-semver-checks anywhere to catch it

BYTE IDENTITY, verified independently rather than inherited: duplex.ifc through
scripts/perf/ab.sh gives fingerprintDrift=false, 486/486 meshes, 52053/52053
vertices, 30264/30264 triangles. motif-ifc-ad measured the same on
schependomlaan (6057/423949/257790). Neither of us has a trustworthy TIMING
verdict: ab.sh refused one both times with tooNoisy, this machine running five
Claude sessions at load ~10.

2164 Rust tests, clippy -D warnings clean, 73 wasm-contract assertions, 106
cache tests, 356 geometry tests, viewer shard 2 at 1374, typecheck and lint
clean, module-size gate green.

Author: louistrue

.changeset/rep-item-identity-across-boundary.md

@@ -0,0 +1,20 @@
+---
+"@ifc-lite/geometry": minor
+"@ifc-lite/wasm": minor
+"@ifc-lite/cache": minor
+"@ifc-lite/server-client": minor
+---
+
+Carry representation-item identity across the wasm boundary, and stop delivering material ids in the same field.
+
+`MeshData` gains two DISJOINT fields. `geometryItemId` is always the `IfcRepresentationItem` a mesh was tessellated from, so a host can drill from a rendered piece into an `IfcWindow`'s pane or frame and navigate to that entity in source. `materialId` is always the `IfcMaterial` whose layer a mesh slices. Never both — a consumer that ignores the distinction still cannot read one as the other.
+
+The router already kept each item's STEP id and it already reached the server REST payload; `MeshDataJs::from_mesh_data` did not copy it, so the browser never saw it. And for material-layered walls and slabs the same field carried the layer's `IfcMaterial` id, so following it to source landed on the wrong entity with nothing to warn the caller.
+
+`geometryClass === 3` cannot discriminate the two: it is stamped from a static material-index check made before the geometry runs, while the layered path can bail at runtime and emit representation-item submeshes under that class. The discriminator therefore lives on `SubMeshCollection`, set where the layered slabs are built.
+
+Neither field is ever `0`. `IfcMaterialLayer.Material` is optional, so an air gap reaches the mesher as `material_id 0` — that is the decoder's "no reference" sentinel, not an entity, and STEP instance names start at `#1`. Twelve slabs of `duplex.ifc` reported `IfcMaterial #0` before this was filtered at the setter. An air-gap slab is still meshed; it simply reports no material.
+
+Both fields cross the boundary, both wasm converters carry them, the REST wire shape and `convertServerMesh` carry them, and the cache format gains them at v14 — without that, a cache-restored session silently lost the identity.
+
+BREAKING FOR THE RUST CRATE, and this changeset cannot express it. `ifc-lite-processing` is published to crates.io (`scripts/release-crates.mjs`), `MeshData` gains a public field, and `with_style_metadata` goes from two arguments to three — both break a struct literal or a call downstream, which `rust/export/src/usd/tests.rs` demonstrates in-repo. `scripts/sync-versions.js` derives the Cargo workspace version from the highest npm package version, so a `minor` here ships 6.0.0 → 6.1.0 and a consumer pinned to `ifc-lite-processing = "6"` breaks on `cargo update`. Nothing gates this: there is no `cargo-semver-checks` anywhere in the repo.

apps/viewer/src/utils/coldGeometryProvider.test.ts

@@ -5,7 +5,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 import type { CoordinateInfo, MeshData } from '@ifc-lite/geometry';
-import { buildGeometrySectionV13, openGeometryChunksV13 } from '@ifc-lite/cache';
+import { buildGeometrySectionV13, openGeometryChunksV13, FORMAT_VERSION } from '@ifc-lite/cache';
 import { makeColdGeometryProvider } from './coldGeometryProvider.js';
 
 const coordInfo: CoordinateInfo = {
@@ -32,7 +32,15 @@ async function makeFixture() {
   // Two far-apart cells → at least two chunks with disjoint AABBs.
   const meshes = [mesh(1, [1, 1, 1]), mesh(2, [2, 2, 2]), mesh(3, [1000, 0, 0])];
   const section = await buildGeometrySectionV13(meshes, coordInfo);
-  const open = openGeometryChunksV13(section, 0, 13);
+  // The reader version is "whatever the writer just emitted", not a literal.
+  // It was pinned to 13 and went stale at the #3199 bump: the writer gained 8
+  // bytes per mesh record, a v13 reader skipped them, and every record after
+  // the first was misaligned -- which `decodeGeometryChunk`'s exact-consumption
+  // check caught, but only here, because the cache package's own suite does not
+  // run this file. `buildGeometrySectionV13` takes NO version argument: it
+  // always writes current, so any literal paired with it is a bet on the
+  // format never moving.
+  const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
   return { section, chunks: open.chunks };
 }
 
@@ -43,7 +51,7 @@ describe('makeColdGeometryProvider', () => {
       source: section,
       geometrySectionOffset: 0,
       chunks,
-      version: 13,
+      version: FORMAT_VERSION,
     });
     const near = await provider.loadMeshesInBounds([0, 0, 0], [10, 10, 10]);
     assert.deepStrictEqual(near.map((m) => m.expressId).sort(), [1, 2]);
@@ -62,7 +70,7 @@ describe('makeColdGeometryProvider', () => {
       source: blob,
       geometrySectionOffset: 128,
       chunks,
-      version: 13,
+      version: FORMAT_VERSION,
     });
     const near = await provider.loadMeshesInBounds([0, 0, 0], [10, 10, 10]);
     assert.deepStrictEqual(near.map((m) => m.expressId).sort(), [1, 2]);

apps/viewer/src/utils/serverMesh.test.ts

@@ -50,3 +50,33 @@ test('keeps an origin that is zero on only some axes', () => {
   const out = convertServerMesh({ ...base, origin: [0, 0, -20] });
   assert.deepEqual(out.origin, [0, 0, -20]);
 });
+
+test('forwards the representation-item id, so a REST-loaded pick can reach source (#3199)', () => {
+  const out = convertServerMesh({ ...base, geometry_item_id: 1234 });
+  assert.equal(out.geometryItemId, 1234);
+  assert.equal('materialId' in out, false);
+});
+
+test('forwards the material id, disjoint from the representation-item id (#3199)', () => {
+  const out = convertServerMesh({ ...base, material_id: 3876 });
+  assert.equal(out.materialId, 3876);
+  assert.equal('geometryItemId' in out, false);
+});
+
+test('omits both source ids when the server sent neither', () => {
+  const out = convertServerMesh(base);
+  assert.equal('geometryItemId' in out, false);
+  assert.equal('materialId' in out, false);
+});
+
+// The other two optionals in this converter are truthiness-gated on purpose: a
+// zero origin and class 0 are both the default, so carrying them would make the
+// same mesh decode differently per transport. A source id is not like that --
+// it is an express instance name, and this converter must not invent a rule
+// about which values are "real". The server already drops 0 (`#0` is not an
+// entity), so if one ever arrives the honest thing is to pass it through and
+// let the id-provenance tests catch it, not to silently swallow it here.
+test('does not truthiness-gate the source ids the way it gates origin and class', () => {
+  const out = convertServerMesh({ ...base, geometry_item_id: 0 });
+  assert.equal(out.geometryItemId, 0, 'a 0 id was dropped by a truthiness check');
+});

apps/viewer/src/utils/serverMesh.ts

@@ -34,5 +34,18 @@ export function convertServerMesh(m: ServerMeshData): MeshData {
     // make the same mesh decode to a different shape depending on transport.
     ...(m.origin?.some((v) => v !== 0) ? { origin: m.origin } : {}),
     ...(m.geometry_class ? { geometryClass: m.geometry_class } : {}),
+    // The two DISJOINT source ids (#3199). Tested against `undefined`, never for
+    // truthiness -- unlike the two optionals above, which are correctly
+    // truthiness-gated because a zero origin and class 0 are both the default.
+    //
+    // The server never sends `0` for either id (`#0` is not a STEP instance
+    // name; an air-gap layer is sent as absent), so this converter would be
+    // gating on a value it can never see. That is exactly why it must NOT gate:
+    // a converter enforcing a producer's invariant turns a future producer bug
+    // into silent data loss here instead of a visible wrong id upstream, and
+    // dropping an id is how the REST path keeps rendering identically while a
+    // host loses the ability to drill from a picked piece to its source.
+    ...(m.geometry_item_id !== undefined ? { geometryItemId: m.geometry_item_id } : {}),
+    ...(m.material_id !== undefined ? { materialId: m.material_id } : {}),
   };
 }

packages/cache/src/sections/geometry-chunks.test.ts

@@ -13,7 +13,14 @@ import {
   inflateRaw,
   decodeGeometryChunk,
 } from './geometry-chunks.js';
-import { GeometryChunkFlags, type GeometryChunkInfo } from '../types.js';
+import { FORMAT_VERSION, GeometryChunkFlags, type GeometryChunkInfo } from '../types.js';
+
+// These suites all read back what `buildGeometrySectionV13` just wrote, so the
+// reader version is "whatever the writer emits", not a literal. It was pinned
+// to 13 and went stale at the #3199 bump: the writer added 8 bytes per mesh
+// record, a v13 reader skipped them, and every record after the first was
+// misaligned. The on-disk version literal is pinned in header.test.ts, which
+// is where a silent bump should be caught.
 
 const coordInfo = (overrides: Partial<CoordinateInfo> = {}): CoordinateInfo => ({
   originShift: { x: 1.5, y: -2.5, z: 1e6 },
@@ -131,7 +138,7 @@ describe('v13 geometry section round-trip', () => {
   it('round-trips meshes, counts and coordinateInfo (compressed)', async () => {
     const info = coordInfo({ wasmRtcOffset: { x: 1, y: 2, z: 3 }, buildingRotation: 0.25 });
     const section = await buildGeometrySectionV13(meshes, info);
-    const result = await readGeometryV13(section, 0, 13);
+    const result = await readGeometryV13(section, 0, FORMAT_VERSION);
     expectMeshesEqual(result.meshes, meshes);
     expect(result.totalVertices).toBe(12);
     expect(result.totalTriangles).toBe(4);
@@ -140,13 +147,13 @@ describe('v13 geometry section round-trip', () => {
 
   it('round-trips with compression disabled', async () => {
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
-    const result = await readGeometryV13(section, 0, 13);
+    const result = await readGeometryV13(section, 0, FORMAT_VERSION);
     expectMeshesEqual(result.meshes, meshes);
   });
 
   it('exposes a directory with valid AABBs and per-chunk decode', async () => {
     const section = await buildGeometrySectionV13(meshes, coordInfo());
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     expect(open.chunks.length).toBeGreaterThanOrEqual(2);
     let total = 0;
     for (let i = 0; i < open.chunks.length; i++) {
@@ -171,7 +178,7 @@ describe('v13 geometry section round-trip', () => {
   it('small chunks skip compression; a large repetitive chunk compresses', async () => {
     // Small: below the 64KiB floor → raw.
     const small = await buildGeometrySectionV13([mesh(1, [0, 0, 0])], coordInfo());
-    const openSmall = openGeometryChunksV13(small, 0, 13);
+    const openSmall = openGeometryChunksV13(small, 0, FORMAT_VERSION);
     expect(openSmall.chunks[0].flags & GeometryChunkFlags.DeflateRaw).toBe(0);
 
     // Large + repetitive: one 100k-vertex mesh of zeros → compresses well.
@@ -181,7 +188,7 @@ describe('v13 geometry section round-trip', () => {
       indices: new Uint32Array(300_000),
     });
     const section = await buildGeometrySectionV13([big], coordInfo());
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     expect(open.chunks[0].flags & GeometryChunkFlags.DeflateRaw).toBe(GeometryChunkFlags.DeflateRaw);
     expect(open.chunks[0].byteLength).toBeLessThan(open.chunks[0].uncompressedLength / 4);
     const decoded = await open.readChunk(0);
@@ -190,7 +197,7 @@ describe('v13 geometry section round-trip', () => {
 
   it('handles empty mesh lists', async () => {
     const section = await buildGeometrySectionV13([], coordInfo());
-    const result = await readGeometryV13(section, 0, 13);
+    const result = await readGeometryV13(section, 0, FORMAT_VERSION);
     expect(result.meshes).toEqual([]);
     expect(result.totalVertices).toBe(0);
   });
@@ -223,19 +230,19 @@ describe('corrupt geometry chunk directory', () => {
     const meshes = [mesh(1, [0, 0, 0]), mesh(2, [5000, 5000, 5000])]; // forced into separate chunks
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
     const bytes = new Uint8Array(section);
-    const info0 = openGeometryChunksV13(section, 0, 13).chunks[0];
+    const info0 = openGeometryChunksV13(section, 0, FORMAT_VERSION).chunks[0];
     const entry = findDirectoryEntry(bytes, info0.byteOffset, info0.byteLength);
     const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     dv.setUint32(entry + 28, info0.byteLength + 10_000, true); // byteLength: reach past the buffer end
 
-    expect(() => openGeometryChunksV13(section, 0, 13)).toThrow(/not contiguous/);
+    expect(() => openGeometryChunksV13(section, 0, FORMAT_VERSION)).toThrow(/not contiguous/);
   });
 
   it('rejects a chunk whose inflated byteLength/meshCount/uncompressedLength consistently absorb the next chunk', async () => {
     const meshes = [mesh(1, [0, 0, 0]), mesh(2, [5000, 5000, 5000])];
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
     const bytes = new Uint8Array(section);
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     expect(open.chunks.length).toBe(2); // control: the fixture really did split into 2 chunks
     const info0 = open.chunks[0];
     const info1 = open.chunks[1];
@@ -250,13 +257,13 @@ describe('corrupt geometry chunk directory', () => {
     dv.setUint32(entry + 32, absorbedLength, true); // uncompressedLength
     dv.setUint32(entry + 36, info0.meshCount + info1.meshCount, true); // meshCount
 
-    expect(() => openGeometryChunksV13(section, 0, 13)).toThrow(/not contiguous/);
+    expect(() => openGeometryChunksV13(section, 0, FORMAT_VERSION)).toThrow(/not contiguous/);
   });
 
   it('bounding control: a valid multi-chunk directory (ranges reaching exactly to the next chunk) still decodes', async () => {
     const meshes = [mesh(1, [0, 0, 0]), mesh(2, [5000, 5000, 5000])];
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     expect(open.chunks.length).toBe(2);
     const decoded0 = await open.readChunk(0);
     const decoded1 = await open.readChunk(1);
@@ -271,7 +278,7 @@ describe('corrupt geometry chunk directory', () => {
     const meshes = [mesh(1, [0, 0, 0]), mesh(2, [5000, 5000, 5000])];
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
     const bytes = new Uint8Array(section);
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 
     // Shift EVERY chunk's byteOffset by the same delta. Relative spacing —
@@ -282,7 +289,7 @@ describe('corrupt geometry chunk directory', () => {
       dv.setUint32(entry + 24, info.byteOffset + SHIFT, true);
     }
 
-    expect(() => openGeometryChunksV13(section, 0, 13)).toThrow(
+    expect(() => openGeometryChunksV13(section, 0, FORMAT_VERSION)).toThrow(
       /chunk 0 byteOffset .* does not start at the end of the head/,
     );
   });
@@ -299,7 +306,7 @@ describe('corrupt geometry chunk directory', () => {
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
     const bytes = new Uint8Array(section);
     const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     const info0 = open.chunks[0];
     const trueHeadLength = dv.getUint32(0, true);
     const entry = findDirectoryEntry(bytes, info0.byteOffset, info0.byteLength);
@@ -310,7 +317,7 @@ describe('corrupt geometry chunk directory', () => {
     dv.setUint32(0, forgedHeadLength, true);
     dv.setUint32(entry + 24, 4 + forgedHeadLength, true);
 
-    expect(() => openGeometryChunksV13(section, 0, 13)).toThrow(/headLength/);
+    expect(() => openGeometryChunksV13(section, 0, FORMAT_VERSION)).toThrow(/headLength/);
   });
 
   // `readChunk`'s own end-of-buffer check was unreachable from the tests
@@ -322,15 +329,15 @@ describe('corrupt geometry chunk directory', () => {
     const meshes = [mesh(1, [0, 0, 0]), mesh(2, [5000, 5000, 5000])];
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
     const bytes = new Uint8Array(section);
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     const last = open.chunks[open.chunks.length - 1];
     const entry = findDirectoryEntry(bytes, last.byteOffset, last.byteLength);
     const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     dv.setUint32(entry + 28, last.byteLength + 10_000, true);
 
     // The directory still validates: chunk 0 is anchored, and the last chunk
     // has no successor for the contiguity loop to compare against.
-    const reopened = openGeometryChunksV13(section, 0, 13);
+    const reopened = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     await expect(reopened.readChunk(open.chunks.length - 1)).rejects.toThrow(
       /exceeds buffer length/,
     );
@@ -348,7 +355,7 @@ describe('decodeGeometryChunk length verification', () => {
   it('throws when the stored bytes decode to a length that disagrees with the directory', async () => {
     const meshes = [mesh(1, [0, 0, 0])];
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     const realInfo = open.chunks[0];
     expect(realInfo.flags & GeometryChunkFlags.DeflateRaw).toBe(0); // uncompressed: raw === stored
 
@@ -357,7 +364,7 @@ describe('decodeGeometryChunk length verification', () => {
 
     // Directory claims one more byte than the record actually decodes to.
     const lyingInfo: GeometryChunkInfo = { ...realInfo, uncompressedLength: realInfo.uncompressedLength + 1 };
-    await expect(decodeGeometryChunk(stored, lyingInfo, 13)).rejects.toThrow(
+    await expect(decodeGeometryChunk(stored, lyingInfo, FORMAT_VERSION)).rejects.toThrow(
       /Invalid cache: chunk decoded to \d+ bytes, directory says \d+/,
     );
 
@@ -366,7 +373,7 @@ describe('decodeGeometryChunk length verification', () => {
     // the decoded content itself (mesh count + expressId), not mere
     // truthiness: an empty array is also truthy and would satisfy a
     // `resolves.toBeTruthy()` check whether or not any mesh actually decoded.
-    const decoded = await decodeGeometryChunk(stored, realInfo, 13);
+    const decoded = await decodeGeometryChunk(stored, realInfo, FORMAT_VERSION);
     expectMeshesEqual(decoded, meshes);
   });
 
@@ -383,7 +390,7 @@ describe('decodeGeometryChunk length verification', () => {
   it('throws when a mesh record under-consumes the declared chunk length (meshCount and uncompressedLength are both truthful)', async () => {
     const meshes = [mesh(1, [0, 0, 0])];
     const section = await buildGeometrySectionV13(meshes, coordInfo(), { compress: false });
-    const open = openGeometryChunksV13(section, 0, 13);
+    const open = openGeometryChunksV13(section, 0, FORMAT_VERSION);
     const realInfo = open.chunks[0];
     expect(realInfo.flags & GeometryChunkFlags.DeflateRaw).toBe(0); // uncompressed: raw === stored
     expect(realInfo.meshCount).toBe(1);
@@ -402,14 +409,14 @@ describe('decodeGeometryChunk length verification', () => {
     expect(realVertexCount).toBe(3);
     dv.setUint32(4, realVertexCount - 1, true);
 
-    await expect(decodeGeometryChunk(stored, realInfo, 13)).rejects.toThrow(
+    await expect(decodeGeometryChunk(stored, realInfo, FORMAT_VERSION)).rejects.toThrow(
       /Invalid cache: chunk claims \d+ mesh record\(s\) but consumed \d+ of \d+ bytes/,
     );
 
     // Control: restoring the true vertexCount round-trips fine — the throw
     // above is caused by the corruption, not some unrelated fixture bug.
     dv.setUint32(4, realVertexCount, true);
-    const decoded = await decodeGeometryChunk(stored, realInfo, 13);
+    const decoded = await decodeGeometryChunk(stored, realInfo, FORMAT_VERSION);
     expectMeshesEqual(decoded, meshes);
   });
 });