@bldrs-ai/conway 1.502.1421 → 1.507.1429

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.502.1421";
+var versionString = "Conway v1.507.1429";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.502.1421";
+var versionString = "Conway v1.507.1429";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

package/compiled/examples/cli-step-bundled.cjs

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.502.1421";
+var versionString = "Conway v1.507.1429";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

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.507.1429";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

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)

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

@@ -1,7 +1,7 @@
 /* eslint-disable no-magic-numbers */
 import { describe, expect, test } from "@jest/globals";
 import * as glmatrix from "gl-matrix";
-import { composeTransformF64, deriveCoordinationF64, mat4MultiplyF64, } from "./coordination_f64.js";
+import { COORDINATION_SNAP_M, LARGE_COORDINATE_BUDGET_M, TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z, composeTransformF64, deriveCoordinationF64, mat4MultiplyF64, } from "./coordination_f64.js";
 // The Z-up -> Y-up normalize matrix the proxies pass in (column-major).
 const NORMALIZE_MAT = [
     1,
@@ -51,36 +51,121 @@ describe("coordination_f64", () => {
             }
         }
     });
-    test("recentres a LV95-magnitude reference exactly where float32 mis-lands it", () => {
-        // The georeferencing jitter mechanism: the recentre translation
-        // negates a reference point at Swiss LV95 magnitude (~2.6M easting).
-        // Stored in a Float32Array it quantizes to the ~0.31 m grid (float32
-        // ULP at 2.6M), so the reference lands cm-to-dm off the origin — a
-        // per-model positional error baked into every emitted transform. The
-        // float64 recentre lands it exactly.
-        const identity = glmatrix.mat4.create(); // placement; world via the point
+    test("below the budget every anchor derives model-zero (export-order independence)", () => {
+        // The Share#1749 shape: two exports of one object disagree about
+        // which element comes first, so the walk anchors on points 76m
+        // apart. Both must derive the same frame, or the two files render
+        // 76m apart and no camera permalink spans them.
+        const identity = glmatrix.mat4.create();
+        const first = deriveCoordinationF64(identity, { x: 76, y: -11.4504049888, z: 0 }, NORMALIZE_MAT, 1);
+        const second = deriveCoordinationF64(identity, { x: 0, y: -11.4504049888, z: 0 }, NORMALIZE_MAT, 1);
+        expect(second).toEqual(first);
+        // Model-zero (conway#87): the frame is the bare Y-up normalize and
+        // the model keeps the coordinates its file authored.
+        expect(first[TRANSLATION_X]).toBe(0);
+        expect(first[TRANSLATION_Y]).toBe(0);
+        expect(first[TRANSLATION_Z]).toBe(0);
+    });
+    test("anchors either side of a grid line below the budget still agree", () => {
+        // Why the recentre is staged rather than snapped everywhere: a
+        // straight snap turns a small anchor disagreement into a full-cell
+        // one. A site-grid model at x ~ 500m whose preview channel anchors
+        // at 480 and whose durable walk anchors at 520 would derive frames
+        // 1km apart — and the adopted-frame gate only re-derives past
+        // LARGE_COORDINATE_BUDGET_M, so it would keep the wrong one and
+        // render 1km off a classic open. Below the budget both are zero.
+        const identity = glmatrix.mat4.create();
+        const below = deriveCoordinationF64(identity, { x: 480, y: 0, z: 0 }, NORMALIZE_MAT, 1);
+        const above = deriveCoordinationF64(identity, { x: 520, y: 0, z: 0 }, NORMALIZE_MAT, 1);
+        expect(above).toEqual(below);
+        expect(below[TRANSLATION_X]).toBe(0);
+    });
+    test("recentres only once past the budget, on the same metre grid whatever the source unit", () => {
+        // Same object, one file in metres and one in millimetres: the
+        // millimetre file's anchor is 1000x larger and its scaleFactor
+        // 1000x smaller, so both must land on the same metre frame.
+        const identity = glmatrix.mat4.create();
+        const metres = deriveCoordinationF64(identity, { x: 2600076, y: 412, z: 0 }, NORMALIZE_MAT, 1);
+        const millimetres = deriveCoordinationF64(identity, { x: 2600076000, y: 412000, z: 0 }, NORMALIZE_MAT, 0.001);
+        for (const i of [TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z]) {
+            expect(millimetres[i]).toBeCloseTo(metres[i], 6);
+        }
+        expect(metres[TRANSLATION_X]).toBe(-2600000);
+    });
+    test("keeps a georeferenced model inside the recentre budget", () => {
+        // Above the budget the recentre engages and snapping trades
+        // exactness for order-independence. Once engaged every component is
+        // snapped, so each keeps at most half a cell and the anchor lands
+        // within half a cell in each axis — measured as a distance so the
+        // bound is a property of the anchor, like the stage decision itself.
+        // The outer bound that matters is LARGE_COORDINATE_BUDGET_M, the
+        // threshold above which a frame counts as not having recentred.
+        const identity = glmatrix.mat4.create();
+        const ref = { x: 2600000.31, y: 1200000.17, z: 412.5 };
+        const coord = deriveCoordinationF64(identity, ref, NORMALIZE_MAT, 1);
+        // NORMALIZE_MAT is Z-up -> Y-up, so the source y/z components land in
+        // the frame's z/y translation slots.
+        const residual = Math.hypot(ref.x + coord[TRANSLATION_X], ref.z + coord[TRANSLATION_Y], ref.y - coord[TRANSLATION_Z]);
+        // sqrt(3) half-cells is the true worst case; assert both it and the
+        // budget so a future edit that widens either is caught.
+        expect(residual).toBeLessThanOrEqual(COORDINATION_SNAP_M);
+        expect(residual).toBeLessThan(LARGE_COORDINATE_BUDGET_M);
+    });
+    test("recentres a model whose offset is spread across axes", () => {
+        // The stage decision is the anchor's distance from the origin, not
+        // any one component: (9km, 9km, 9km) is 15.6km out — past the budget
+        // — while no single component crosses it. Deciding per component
+        // would leave this model in file coordinates and quietly undo the
+        // float32 jitter fix the budget exists to enforce.
+        const identity = glmatrix.mat4.create();
+        const coord = deriveCoordinationF64(identity, { x: 9000, y: 9000, z: 9000 }, NORMALIZE_MAT, 1);
+        const residual = Math.hypot(9000 + coord[TRANSLATION_X], 9000 + coord[TRANSLATION_Y], 9000 - coord[TRANSLATION_Z]);
+        expect(coord[TRANSLATION_X]).not.toBe(0);
+        expect(residual).toBeLessThan(LARGE_COORDINATE_BUDGET_M);
+    });
+    test("places a LV95-magnitude element exactly where float32 mis-lands it", () => {
+        // The georeferencing jitter mechanism (Share#1631): an element placed
+        // at Swiss LV95 magnitude (~2.6M easting) is composed against the
+        // recentre frame, and float32 ULP at 2.6M is ~0.31m. Run through
+        // gl-matrix's Float32Array that composition quantizes, and the
+        // element lands cm-to-dm from where the frame says — a positional
+        // error baked into every emitted transform. The float64 path lands it
+        // exactly.
+        //
+        // Note the frame's own translation is now snapped to whole kilometres
+        // (COORDINATION_SNAP_M), which happens to be exactly representable in
+        // float32 — so the loss this pins is in the composition against the
+        // element's full-precision placement, which is where it always
+        // mattered: that product is what becomes the FlatMesh transform.
         const ref = { x: 2600000.31, y: 1200000.17, z: 412.5 };
-        /**
-         * Apply a column-major 4x4 to a point.
-         *
-         * @param m 16-element matrix.
-         * @param p The point.
-         * @return {number} The transformed point's distance from origin.
-         */
-        const originDist = (m) => Math.hypot(m[0] * ref.x + m[4] * ref.y + m[8] * ref.z + m[12], m[1] * ref.x + m[5] * ref.y + m[9] * ref.z + m[13], m[2] * ref.x + m[6] * ref.y + m[10] * ref.z + m[14]);
-        // float64 recentre (the fix).
-        const distF64 = originDist(deriveCoordinationF64(identity, ref, NORMALIZE_MAT, 1));
-        // Old float32 gl-matrix recentre: the translation is stored in a
-        // Float32Array, quantizing the -2.6M component.
-        const tp = glmatrix.vec4.create();
-        glmatrix.vec4.transformMat4(tp, [ref.x, ref.y, ref.z, 1], identity);
-        const coordF32 = glmatrix.mat4.create();
-        glmatrix.mat4.fromTranslation(coordF32, [-tp[0], -tp[1], -tp[2]]);
-        glmatrix.mat4.multiply(coordF32, NORMALIZE_MAT, coordF32);
-        const distF32 = originDist(coordF32);
-        // float64 lands sub-micron; float32 is off by cm+.
-        expect(distF64).toBeLessThan(0.000001);
-        expect(distF32).toBeGreaterThan(0.01);
+        const frame = deriveCoordinationF64(glmatrix.mat4.create(), ref, NORMALIZE_MAT, 1);
+        // An element sitting on that reference point.
+        const placement = glmatrix.mat4.create();
+        glmatrix.mat4.identity(placement);
+        const placementF64 = Array.from(placement);
+        placementF64[TRANSLATION_X] = ref.x;
+        placementF64[TRANSLATION_Y] = ref.y;
+        placementF64[TRANSLATION_Z] = ref.z;
+        // Where it must land: the within-cell remainder of every component.
+        // The stage decision is made once on the whole anchor, and this one
+        // is far past the budget, so all three components snap — including
+        // z=412.5, whose nearest grid multiple is 0 and which therefore
+        // keeps its full value. (A per-component budget test would leave z
+        // untouched for a different reason and agree here by coincidence;
+        // this mirrors what quantizeRecentre actually does.)
+        const rem = (v) => v - Math.round(v / COORDINATION_SNAP_M) * COORDINATION_SNAP_M;
+        const expected = [rem(ref.x), rem(ref.z), -rem(ref.y)];
+        const f64 = composeTransformF64(frame, placementF64);
+        // The old path's loss: the placement crosses the wasm boundary as a
+        // glm::dmat4 but was rebuilt with gl-matrix `mat4.fromValues`, i.e.
+        // stored in a Float32Array — quantizing its 2.6M component to the
+        // ~0.31m float32 grid before anything is composed. Snapping the frame
+        // does not rescue that; only keeping the placement in float64 does.
+        const f32 = composeTransformF64(frame, new Float32Array(placementF64));
+        const errF64 = Math.max(Math.abs(f64[TRANSLATION_X] - expected[0]), Math.abs(f64[TRANSLATION_Y] - expected[1]), Math.abs(f64[TRANSLATION_Z] - expected[2]));
+        const errF32 = Math.max(Math.abs(f32[TRANSLATION_X] - expected[0]), Math.abs(f32[TRANSLATION_Y] - expected[1]), Math.abs(f32[TRANSLATION_Z] - expected[2]));
+        expect(errF64).toBeLessThan(0.000001);
+        expect(errF32).toBeGreaterThan(0.01);
     });
     test("near origin float64 and float32 agree (fixtures unaffected)", () => {
         const placement = pseudoMat(99);

package/compiled/src/version/version.js

@@ -5,5 +5,5 @@
 // only the first segment (major) is meaningful and is the one CI carries forward.
 // Must stay in `vN.N.N` shape: the CI stamp regex, scripts/updateVersion.mjs, and
 // statistics.ts all match `v\d+\.\d+\.\d+`.
-const versionString = 'Conway v1.502.1421';
+const versionString = 'Conway v1.507.1429';
 export { versionString };