@bldrs-ai/conway 1.502.1421 → 1.509.1435

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.502.1421";
+var versionString = "Conway v1.509.1435";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -4696,7 +4696,18 @@ var StepVtableBuilder = class {
 };
 
 // compiled/src/step/parsing/uint32_sink.js
+var OPEN_PAREN3 = parsing_constants_default.OPEN_PAREN;
+var CLOSE_PAREN3 = parsing_constants_default.CLOSE_PAREN;
+var COMMA3 = parsing_constants_default.COMMA;
+var ZERO5 = parsing_constants_default.ZERO;
+var WHITESPACE4 = parsing_constants_default.WHITE_SPACE_SET;
 function extractIntegerArrayAt(buffer, cursor, endCursor, sink) {
+  const marked = sink.length;
+  const fast = extractUnsignedIntegerListAt(buffer, cursor, endCursor, sink);
+  if (fast !== void 0) {
+    return fast;
+  }
+  sink.truncate(marked);
   if (stepExtractOptional(buffer, cursor, endCursor) === null) {
     return 0;
   }
@@ -4716,6 +4727,68 @@ function extractIntegerArrayAt(buffer, cursor, endCursor, sink) {
   }
   return count;
 }
+function extractUnsignedIntegerListAt(buffer, cursor, endCursor, sink) {
+  const marked = sink.length;
+  while (cursor < endCursor && WHITESPACE4.has(buffer[cursor])) {
+    ++cursor;
+  }
+  if (cursor >= endCursor) {
+    return void 0;
+  }
+  if (buffer[cursor] === parsing_constants_default.DOLLAR) {
+    return 0;
+  }
+  if (buffer[cursor] !== OPEN_PAREN3) {
+    return void 0;
+  }
+  ++cursor;
+  let count = 0;
+  while (cursor < endCursor) {
+    while (cursor < endCursor && WHITESPACE4.has(buffer[cursor])) {
+      ++cursor;
+    }
+    if (cursor >= endCursor) {
+      sink.truncate(marked);
+      return void 0;
+    }
+    if (buffer[cursor] === CLOSE_PAREN3) {
+      return count;
+    }
+    if (count > 0) {
+      if (buffer[cursor] !== COMMA3) {
+        sink.truncate(marked);
+        return void 0;
+      }
+      ++cursor;
+      while (cursor < endCursor && WHITESPACE4.has(buffer[cursor])) {
+        ++cursor;
+      }
+      if (cursor >= endCursor) {
+        sink.truncate(marked);
+        return void 0;
+      }
+    }
+    const digit = buffer[cursor] - ZERO5;
+    if (digit < 0 || digit > 9) {
+      sink.truncate(marked);
+      return void 0;
+    }
+    let value = digit;
+    ++cursor;
+    while (cursor < endCursor) {
+      const next = buffer[cursor] - ZERO5;
+      if (next < 0 || next > 9) {
+        break;
+      }
+      value = value * 10 + next;
+      ++cursor;
+    }
+    sink.push(value);
+    ++count;
+  }
+  sink.truncate(marked);
+  return void 0;
+}
 
 // compiled/src/indexing/index_set_constants.js
 var IndexSetConstants = class {
@@ -5268,43 +5341,63 @@ var StepModelBase = class {
     }
   }
   /**
-   * Populate a raw vtable entry for a particular element, extra
+   * Resolve an express ID to a local ID, using `hintLocalID + 1` when
+   * the next record is the one we want. Tessellated Faces lists are
+   * sequential (PSB: every faceset), so this turns 9.1M interpolation
+   * searches into one per faceset.
    *
-   * @param element The raw elment to populate the vtable entry for.
-   * @return {boolean} Did the vtable entry populate correctly?
+   * @param expressID The referenced record.
+   * @param hintLocalID Local ID of the previous resolve, if any.
+   * @return {number | undefined} The local ID, or undefined if unknown.
    */
+  resolveExpressID(expressID, hintLocalID) {
+    if (hintLocalID !== void 0) {
+      const next = hintLocalID + 1;
+      if (next < this.firstInlineElement_ && this.expressID_[next] === expressID) {
+        return next;
+      }
+    }
+    return this.expressIDMap_.get(expressID);
+  }
   /**
-   * Append a referenced record's unsigned-integer list field into `sink`
-   * without materialising the referenced entity.
-   *
-   * This is the reference-level twin of
+   * Append a local record's unsigned-integer list field into `sink`
+   * without an express-ID lookup. The reference-level twin of
    * `StepEntityBase.extractIntegerArrayInto`, for hot loops that walk
    * millions of small records (tessellated facesets) where constructing
    * an entity per record dominates. It deliberately handles only the
    * simple case and reports failure otherwise, so callers keep a
    * correct fallback rather than this growing subtle special cases:
-   * the reference must resolve, be single-class (no multi-mapping),
-   * and be exactly `expectedTypeID` — which is what makes reading
-   * `offset` as a plain vtable slot equivalent to the generated
-   * getter's `getOffsetCursor( offset, _, _ )` (that only subtracts a
-   * base offset for multi-mapped records).
+   * the record must be single-class (no multi-mapping) and exactly
+   * `expectedTypeID`.
    *
-   * @param expressID The referenced record's express ID.
-   * @param offset The field's vtable offset within the record.
+   * Field 0 is the data-block start the parser stored in `address_`
+   * (after `TYPE(`). Reading it from the columns skips the descriptor
+   * and vtable `entry()` would retain — on a 9 M-face model those are
+   * the objects the faceset path is trying not to build. Non-zero
+   * offsets still go through a vtable, because only field 0 has that
+   * address identity.
+   *
+   * @param localID The record's local ID.
+   * @param offset The field's vtable offset.
    * @param expectedTypeID The type the record must be.
    * @param sink Receives the appended values.
    * @return {number | undefined} Count appended, or undefined when the
-   * fast path does not apply and the caller must fall back.
+   * fast path does not apply.
    */
-  extractIntegerArrayByExpressIDInto(expressID, offset, expectedTypeID, sink) {
-    const localID = this.expressIDMap_.get(expressID);
-    if (localID === void 0 || localID >= this.count_) {
+  extractIntegerArrayByLocalIDInto(localID, offset, expectedTypeID, sink) {
+    if (localID >= this.count_) {
       return void 0;
     }
-    const element = this.entry(localID);
-    if (element.multiMapping !== void 0 || element.typeID !== expectedTypeID) {
+    if (this.complexEntries_?.has(localID) || this.typeID_[localID] !== expectedTypeID) {
       return void 0;
     }
+    if (offset === 0) {
+      const address = this.address_[localID];
+      const acquisition = this.bufferProvider_.acquire(address, this.length_[localID]);
+      const viewAddress = address - acquisition.offset;
+      return extractIntegerArrayAt(acquisition.buffer, viewAddress, acquisition.buffer.length, sink);
+    }
+    const element = this.entry(localID);
     if (element.vtableIndex === void 0 && !this.populateVtableEntryRaw(element)) {
       return void 0;
     }
@@ -5315,6 +5408,24 @@ var StepModelBase = class {
     }
     return extractIntegerArrayAt(buffer, vtable[element.vtableIndex + offset], buffer.length, sink);
   }
+  /**
+   * Append a referenced record's unsigned-integer list field into `sink`
+   * without materialising the referenced entity.
+   *
+   * @param expressID The referenced record's express ID.
+   * @param offset The field's vtable offset within the record.
+   * @param expectedTypeID The type the record must be.
+   * @param sink Receives the appended values.
+   * @return {number | undefined} Count appended, or undefined when the
+   * fast path does not apply.
+   */
+  extractIntegerArrayByExpressIDInto(expressID, offset, expectedTypeID, sink) {
+    const localID = this.expressIDMap_.get(expressID);
+    if (localID === void 0) {
+      return void 0;
+    }
+    return this.extractIntegerArrayByLocalIDInto(localID, offset, expectedTypeID, sink);
+  }
   populateVtableEntryRaw(element) {
     if (element.vtableIndex !== void 0 || element.typeID === 0) {
       return true;

package/compiled/src/compat/web-ifc/coordination_export_order.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coordination_export_order.test.d.ts.map

package/compiled/src/compat/web-ifc/coordination_export_order.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination_export_order.test.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/coordination_export_order.test.ts"],"names":[],"mappings":""}

package/compiled/src/compat/web-ifc/coordination_export_order.test.js

@@ -0,0 +1,110 @@
+/* eslint-disable no-magic-numbers */
+// Export-order independence of the COORDINATE_TO_ORIGIN frame (Share#1749).
+//
+// The recentre anchors on the first geometry the walk reaches, which is
+// whichever element the file happens to declare first. Unsnapped, that
+// makes a model's rendered position a function of its element order:
+// Share shipped the Bldrs logo as both `index.ifc` and `index.step`, and
+// the STEP rendered 76m off the IFC because the two files disagree about
+// which block comes first. Every camera permalink spanning the pair was
+// wrong, and auto-framing hid it — the models look identical until a
+// `#c:` camera pins them.
+//
+// This drives the same surface Share does (the compat IfcAPI, not the
+// CLI's native writer, which has its own recentre convention) and pins
+// the properties the snap has to hold together: a near-origin model
+// keeps the coordinates its file authored — which is what makes two
+// exports of one object coincide — a georeferenced model still
+// recentres, and the classic and streamed opens agree.
+//
+// Not covered here: the AP214 arm. Its placements come back at the
+// origin with the geometry carrying the world transform, so neither
+// placement bounds nor a fixture pair in two element orders reproduces
+// the defect through this surface; the cross-format claim is pinned
+// Share-side instead (`src/Containers/indexStepLogo.spec.ts`, which
+// compares the rendered bounds of `index.ifc` and `index.step`).
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { LARGE_COORDINATE_BUDGET_M, COORDINATION_SNAP_M } from "./coordination_f64.js";
+import { IfcAPI } from "./ifc_api.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+let api;
+let local;
+let georeferenced;
+/**
+ * World-space bounds of every placed geometry in a model, as the
+ * consumer sees them: the placement translation is what Share stamps
+ * onto its instances.
+ *
+ * @param modelID An open model.
+ * @return {{min: number[], max: number[]}} Translation bounds.
+ */
+function placementBounds(modelID) {
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    api.StreamAllMeshes(modelID, (mesh) => {
+        for (let where = 0; where < mesh.geometries.size(); ++where) {
+            const t = mesh.geometries.get(where).flatTransformation;
+            for (let axis = 0; axis < 3; ++axis) {
+                min[axis] = Math.min(min[axis], t[12 + axis]);
+                max[axis] = Math.max(max[axis], t[12 + axis]);
+            }
+        }
+    });
+    return { min, max };
+}
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+    local = new Uint8Array(fs.readFileSync("data/index.ifc"));
+    georeferenced = new Uint8Array(fs.readFileSync("data/index_georeferenced.ifc"));
+}, 120000);
+describe("COORDINATE_TO_ORIGIN export-order independence (Share#1749)", () => {
+    test("a near-origin model keeps its authored coordinates", async () => {
+        const modelID = await api.OpenModel(local, { ...SETTINGS });
+        const { min, max } = placementBounds(modelID);
+        expect(Number.isFinite(min[0])).toBe(true);
+        // The logo's first-declared block sits at x=76, so the unsnapped
+        // frame used to drag the whole model 76m negative. Snapped, the
+        // anchor lands in the origin cell and the model stays where the file
+        // put it — which is what makes a second export of the same object
+        // coincide with it regardless of element order.
+        expect(Math.max(...min.map(Math.abs), ...max.map(Math.abs)))
+            .toBeLessThan(COORDINATION_SNAP_M);
+        expect(min[0]).toBeGreaterThanOrEqual(0);
+        api.CloseModel(modelID);
+    }, 120000);
+    test("a georeferenced model still recentres, inside the budget", async () => {
+        const modelID = await api.OpenModel(georeferenced, { ...SETTINGS });
+        const { min, max } = placementBounds(modelID);
+        // Snapping costs at most half a cell on top of the model's own
+        // extent; the budget is the threshold above which float32 jitter
+        // becomes visible (Share#1631).
+        expect(Math.max(...min.map(Math.abs), ...max.map(Math.abs)))
+            .toBeLessThan(LARGE_COORDINATE_BUDGET_M);
+        // The applied-frame report (Share#1634) is not asserted here: only
+        // the deferred pump records it, and
+        // `ifc_api_preview_coordination.test.ts` already covers that path.
+        api.CloseModel(modelID);
+    }, 120000);
+    test("the classic and streamed opens agree on the frame", async () => {
+        // Both paths derive through deriveCoordinationF64, so the snap has
+        // to leave them identical — otherwise one model renders in two
+        // places depending on which open Share happened to take. Compared
+        // through the emitted placements rather than
+        // GetAppliedCoordinationMatrix, which only the deferred pump fills
+        // in: on these two opens it reports the identity contract for both,
+        // so comparing it would pass no matter what the frames did.
+        const classicID = await api.OpenModel(georeferenced, { ...SETTINGS });
+        const classic = placementBounds(classicID);
+        api.CloseModel(classicID);
+        const streamedID = await api.OpenModelStreamed(georeferenced, { ...SETTINGS });
+        const streamed = placementBounds(streamedID);
+        api.CloseModel(streamedID);
+        expect(Number.isFinite(classic.min[0])).toBe(true);
+        for (let axis = 0; axis < 3; ++axis) {
+            expect(streamed.min[axis]).toBeCloseTo(classic.min[axis], 6);
+            expect(streamed.max[axis]).toBeCloseTo(classic.max[axis], 6);
+        }
+    }, 120000);
+});

package/compiled/src/compat/web-ifc/coordination_f64.d.ts

@@ -45,10 +45,69 @@ export interface Point3Like {
  * @return {number[]} The product as a fresh 16-element `number[]`.
  */
 export declare function mat4MultiplyF64(a: ArrayLike<number>, b: ArrayLike<number>): number[];
+/**
+ * Grid (metres) a recentre snaps to once it is needed at all.
+ *
+ * The anchor a recentre is derived from is the *first geometry* the walk
+ * reaches, which is an arbitrary interior element: whichever one the file
+ * happens to declare first. Left as-is, that makes a model's world
+ * position a function of its element order, with two consequences users
+ * see (conway#87, "not a sound basis for a camera in the permalink"):
+ *
+ *  - Two exports of one object — the same logo as IFC and as STEP, a part
+ *    re-exported by a different CAD kernel — land in different places,
+ *    because they disagree about which element comes first. Share#1749
+ *    hit exactly this: `index.step` sat 76m off `index.ifc` because the
+ *    IFC declares the x=76 block first and the STEP the x=0 one.
+ *  - Re-exporting a model with the element order shuffled moves it, so
+ *    every camera permalink saved against it is silently wrong.
+ *
+ * `quantizeRecentre` answers that in two stages, because the two ranges
+ * want different things:
+ *
+ *  - **Inside LARGE_COORDINATE_BUDGET_M, do not recentre at all.** There
+ *    is no float32 benefit below the budget — that constant *is* the
+ *    threshold where quantization becomes visible — so a model within
+ *    10km of the origin simply keeps the coordinates its file authored.
+ *    That is model-zero, conway#87's proposal, and it makes the frame
+ *    exactly order-independent for the overwhelming majority of models
+ *    rather than order-independent-per-cell.
+ *  - **Above it, snap to this grid.** A georeferenced model has to come
+ *    back near the origin, and snapping keeps that repeatable across
+ *    exports. Half a cell (500m) out of a 1e4 m budget costs ~0.05mm of
+ *    float32 resolution, and a whole-kilometre translation is exactly
+ *    representable where the raw anchor was not, so the recentre itself
+ *    stops contributing rounding.
+ *
+ * **Quantizing cannot remove the discontinuity, only move it**, and it
+ * is worth being precise about where this one sits, because it is not
+ * where you would guess. Snapping *everything* to the grid would put a
+ * 1km step at every cell edge, including around the near-origin models
+ * that make up almost the whole corpus. Staging moves it to the budget:
+ * inside, every anchor derives model-zero and there is no edge at all;
+ * the single remaining edge is the budget itself, where the step is
+ * `LARGE_COORDINATE_BUDGET_M` (1e4), not the grid (1e3) — an anchor at
+ * 9900 derives zero and one at 10100 derives -10000.
+ *
+ * That edge is also invisible to the adopted-preview-frame gate, which
+ * re-derives only when a durable placement lands beyond the budget: a
+ * preview anchored at 10100 and a durable first placement at 9900 probe
+ * at ~100m, so the preview frame is kept and the model renders 10km off
+ * a classic open. The trade is deliberate — one edge that a georeferenced
+ * model may sit near, rather than an edge every kilometre through the
+ * range where nearly every model lives — but it is a real residual, not
+ * an eliminated one. design/new/coordination-frame.md tracks it, and
+ * conway#87's relative-to-centre direction is what removes it properly.
+ */
+export declare const COORDINATION_SNAP_M = 1000;
 /**
  * Derive the coordination (recentre) matrix in float64, matching the
  * gl-matrix op sequence exactly:
- * `scale * NormalizeMat * translate(-(placement * point))`.
+ * `scale * NormalizeMat * translate(-quantize(placement * point))`.
+ *
+ * The quantization is what keeps the derived frame independent of which
+ * element a file declares first — see COORDINATION_SNAP_M for why that
+ * matters, and why it is staged around LARGE_COORDINATE_BUDGET_M.
  *
  * @param placement The native placement (16 elements, column-major
  * float64 from `getValues()`); `undefined` is treated as identity.

package/compiled/src/compat/web-ifc/coordination_f64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coordination_f64.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/coordination_f64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAiDH;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC3B,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAkBxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACjC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,EACxC,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC,EAC/B,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CA0BjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAC/B,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC,EAC/B,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,EACxC,UAAU,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,CAerC;AAGD,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAA;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,QAAM,CAAA"}
+{"version":3,"file":"coordination_f64.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/coordination_f64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAiDH;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC3B,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAkBxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,mBAAmB,OAAM,CAAA;AAoCtC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACjC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,EACxC,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC,EAC/B,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAC/B,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC,EAC/B,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,EACxC,UAAU,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,CAerC;AAGD,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAA;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAA;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,QAAM,CAAA"}

package/compiled/src/compat/web-ifc/coordination_f64.js

@@ -92,10 +92,99 @@ export function mat4MultiplyF64(a, b) {
     }
     return out;
 }
+/**
+ * Grid (metres) a recentre snaps to once it is needed at all.
+ *
+ * The anchor a recentre is derived from is the *first geometry* the walk
+ * reaches, which is an arbitrary interior element: whichever one the file
+ * happens to declare first. Left as-is, that makes a model's world
+ * position a function of its element order, with two consequences users
+ * see (conway#87, "not a sound basis for a camera in the permalink"):
+ *
+ *  - Two exports of one object — the same logo as IFC and as STEP, a part
+ *    re-exported by a different CAD kernel — land in different places,
+ *    because they disagree about which element comes first. Share#1749
+ *    hit exactly this: `index.step` sat 76m off `index.ifc` because the
+ *    IFC declares the x=76 block first and the STEP the x=0 one.
+ *  - Re-exporting a model with the element order shuffled moves it, so
+ *    every camera permalink saved against it is silently wrong.
+ *
+ * `quantizeRecentre` answers that in two stages, because the two ranges
+ * want different things:
+ *
+ *  - **Inside LARGE_COORDINATE_BUDGET_M, do not recentre at all.** There
+ *    is no float32 benefit below the budget — that constant *is* the
+ *    threshold where quantization becomes visible — so a model within
+ *    10km of the origin simply keeps the coordinates its file authored.
+ *    That is model-zero, conway#87's proposal, and it makes the frame
+ *    exactly order-independent for the overwhelming majority of models
+ *    rather than order-independent-per-cell.
+ *  - **Above it, snap to this grid.** A georeferenced model has to come
+ *    back near the origin, and snapping keeps that repeatable across
+ *    exports. Half a cell (500m) out of a 1e4 m budget costs ~0.05mm of
+ *    float32 resolution, and a whole-kilometre translation is exactly
+ *    representable where the raw anchor was not, so the recentre itself
+ *    stops contributing rounding.
+ *
+ * **Quantizing cannot remove the discontinuity, only move it**, and it
+ * is worth being precise about where this one sits, because it is not
+ * where you would guess. Snapping *everything* to the grid would put a
+ * 1km step at every cell edge, including around the near-origin models
+ * that make up almost the whole corpus. Staging moves it to the budget:
+ * inside, every anchor derives model-zero and there is no edge at all;
+ * the single remaining edge is the budget itself, where the step is
+ * `LARGE_COORDINATE_BUDGET_M` (1e4), not the grid (1e3) — an anchor at
+ * 9900 derives zero and one at 10100 derives -10000.
+ *
+ * That edge is also invisible to the adopted-preview-frame gate, which
+ * re-derives only when a durable placement lands beyond the budget: a
+ * preview anchored at 10100 and a durable first placement at 9900 probe
+ * at ~100m, so the preview frame is kept and the model renders 10km off
+ * a classic open. The trade is deliberate — one edge that a georeferenced
+ * model may sit near, rather than an edge every kilometre through the
+ * range where nearly every model lives — but it is a real residual, not
+ * an eliminated one. design/new/coordination-frame.md tracks it, and
+ * conway#87's relative-to-centre direction is what removes it properly.
+ */
+export const COORDINATION_SNAP_M = 1e3;
+/**
+ * The recentre for an anchor: all zeros while the anchor is close enough
+ * to the origin not to need one, else each component snapped to
+ * COORDINATION_SNAP_M.
+ *
+ * The stage decision is made **once, on the anchor's distance from the
+ * origin**, and applied to all three components together. Deciding per
+ * component would leave a model offset diagonally — say (9km, 9km, 9km),
+ * 15.6km out and well past the budget — with no recentre at all, since
+ * no single component crosses the threshold. That silently regresses the
+ * float32 jitter fix (Share#1631) the budget exists to enforce.
+ *
+ * Works in source units: the values are pre-scale, so both the budget
+ * and the grid convert by the same `scaleFactor` the caller is about to
+ * apply (a millimetre model snaps every 1e6 source units, a metre model
+ * every 1e3).
+ *
+ * @param values The three translation components, in source units.
+ * @param scaleFactor The linear scaling factor to metres; already
+ * sanitized by the caller.
+ * @return {number[]} The recentre per component, in source units.
+ */
+function quantizeRecentre(values, scaleFactor) {
+    const finite = values.map((v) => (Number.isFinite(v) ? v : 0));
+    if (Math.hypot(...finite) * scaleFactor <= LARGE_COORDINATE_BUDGET_M) {
+        return [0, 0, 0];
+    }
+    const gridSourceUnits = COORDINATION_SNAP_M / scaleFactor;
+    return finite.map((v) => Math.round(v / gridSourceUnits) * gridSourceUnits);
+}
 /**
  * Derive the coordination (recentre) matrix in float64, matching the
  * gl-matrix op sequence exactly:
- * `scale * NormalizeMat * translate(-(placement * point))`.
+ * `scale * NormalizeMat * translate(-quantize(placement * point))`.
+ *
+ * The quantization is what keeps the derived frame independent of which
+ * element a file declares first — see COORDINATION_SNAP_M for why that
+ * matters, and why it is staged around LARGE_COORDINATE_BUDGET_M.
  *
  * @param placement The native placement (16 elements, column-major
  * float64 from `getValues()`); `undefined` is treated as identity.
@@ -107,20 +196,26 @@ export function mat4MultiplyF64(a, b) {
 export function deriveCoordinationF64(placement, point, normalizeMat, scaleFactor) {
     const p = placement !== undefined ? sanitize16(placement) : IDENTITY;
     const { x, y, z } = point;
+    // Sanitized once, here, so the promise the rest of this function makes
+    // about degenerate input actually holds: a NaN/Infinite factor from a
+    // malformed unit-assignment chain would otherwise pass the recentre
+    // guard and then poison every component through the scale matrix below.
+    const scale1 = Number.isFinite(scaleFactor) && scaleFactor > 0 ? scaleFactor : 1;
     // transformedPt = placement * (x, y, z, 1)
     const tx = p[0] * x + p[4] * y + p[8] * z + p[12];
     const ty = p[1] * x + p[5] * y + p[9] * z + p[13];
     const tz = p[2] * x + p[6] * y + p[10] * z + p[14];
-    // translate(-transformedPt)
+    // translate(-quantize(transformedPt))
+    const recentre = quantizeRecentre([-tx, -ty, -tz], scale1);
     const translate = IDENTITY.slice();
-    translate[12] = -tx;
-    translate[13] = -ty;
-    translate[14] = -tz;
+    translate[12] = recentre[0];
+    translate[13] = recentre[1];
+    translate[14] = recentre[2];
     // scale(scaleFactor)
     const scale = [
-        scaleFactor, 0, 0, 0,
-        0, scaleFactor, 0, 0,
-        0, 0, scaleFactor, 0,
+        scale1, 0, 0, 0,
+        0, scale1, 0, 0,
+        0, 0, scale1, 0,
         0, 0, 0, 1,
     ];
     // scale * (NormalizeMat * translate)