@bldrs-ai/conway 1.470.1390 → 1.471.1405

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.470.1390";
+var versionString = "Conway v1.471.1405";
 
 // 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.470.1390";
+var versionString = "Conway v1.471.1405";
 
 // 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.470.1390";
+var versionString = "Conway v1.471.1405";
 
 // 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.470.1390";
+var versionString = "Conway v1.471.1405";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/src/scripts/model_report_displacement.test.d.ts

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

package/compiled/src/scripts/model_report_displacement.test.d.ts.map

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

package/compiled/src/scripts/model_report_displacement.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, test } from '@jest/globals';
+// @ts-expect-error -- an untyped .mjs helper beside the CLI it serves.
+import { localCentre, placeCentre, robustCentre } from '../../../scripts/debug/displacement.mjs';
+/* eslint-disable no-magic-numbers -- these are synthetic coordinates and
+   distances chosen to mirror the real model in conway#456. Naming each one
+   would obscure the shape the cases exist to express: a tight cluster near
+   the site origin plus one part flung far away. */
+/**
+ * The scoring behind model_report.mjs's `displacement` stage (conway#456).
+ *
+ * The stage answers "which parts are flung away from where they belong",
+ * which the `mesh` stage cannot: `mesh` measures extent in MESH-LOCAL
+ * coordinates, so on an export that writes geometry directly in site
+ * coordinates every honest part looks displaced by its distance from the
+ * file origin.
+ *
+ * These cases use synthetic centres rather than a model, because the
+ * motivating file is 256 MB and private. What is worth pinning is the
+ * scoring, and the scoring is pure — which is why it lives in
+ * displacement.mjs rather than in the CLI script, whose module body runs
+ * the whole tool on import.
+ */
+/**
+ * Column-major 4x4 translation, matching the walk tuple's layout.
+ *
+ * @param x Translation along x.
+ * @param y Translation along y.
+ * @param z Translation along z.
+ * @return The 16-element matrix.
+ */
+function translation(x, y, z) {
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1];
+}
+/**
+ * A stub geometry over a fixed point list.
+ *
+ * @param points One [x, y, z] per vertex.
+ * @return Something with the getPoint() shape worldCentre reads.
+ */
+function geometryOf(points) {
+    return {
+        getPoint: (i) => ({ x: points[i][0], y: points[i][1], z: points[i][2] }),
+    };
+}
+describe('displacement scoring', () => {
+    test('the robust centre ignores outliers rather than chasing them', () => {
+        // Nine parts clustered near the site origin, one flung far away — the
+        // shape of the motivating model, scaled down.
+        const centres = [
+            ...Array.from({ length: 9 }, (_, i) => [578 + i, 763, 3]),
+            [-751, 1075, 1377],
+        ];
+        const centre = robustCentre(centres);
+        // A MEAN would sit ~130 units off in x and ~137 in z, dragged by the
+        // single outlier; every honest part would then score as displaced and
+        // the outlier's own score would shrink. That inversion is the reason
+        // this is a median.
+        expect(centre[0]).toBeGreaterThan(577);
+        expect(centre[0]).toBeLessThan(587);
+        expect(centre[2]).toBeCloseTo(3, 6);
+        const distances = centres.map((each) => Math.hypot(each[0] - centre[0], each[1] - centre[1], each[2] - centre[2]));
+        const cluster = distances.slice(0, 9);
+        const outlier = distances[9];
+        // The signal the stage's `factor x median` threshold consumes: the
+        // outlier has to clear 8x the median by a wide margin, or it would be
+        // reported as ordinary.
+        const median = [...cluster].sort((a, b) => a - b)[Math.floor(cluster.length / 2)];
+        expect(outlier).toBeGreaterThan(median * 8);
+    });
+    test('a mesh centre is placed by its transform, not left local', () => {
+        // The defect this stage exists to fix in one assertion: identical local
+        // geometry at two different placements must score differently. Reading
+        // local coordinates would make these indistinguishable.
+        const unitBox = [[-1, -1, -1], [1, 1, 1]];
+        const local = localCentre(geometryOf(unitBox), 2);
+        const atOrigin = placeCentre(local, translation(0, 0, 0));
+        const farAway = placeCentre(local, translation(1000, 0, 0));
+        expect(atOrigin).toEqual([0, 0, 0]);
+        expect(farAway).toEqual([1000, 0, 0]);
+    });
+    test('an undefined transform means identity, not a skipped mesh', () => {
+        expect(placeCentre(localCentre(geometryOf([[2, 4, 6], [4, 8, 12]]), 2), undefined))
+            .toEqual([3, 6, 9]);
+    });
+    test('a wrong walk-tuple index throws rather than scoring NaN', () => {
+        // conway#456 names the transform as walked[1]; it is walked[0].
+        // Following the issue verbatim handed this an object, every
+        // multiplication produced NaN, Stage.record silently discarded every
+        // non-finite value, and the stage reported "N calls, 0 measured" — a
+        // clean-looking result manufactured by a bug. That is hazard 1 from the
+        // script's own header, so it has to be loud.
+        const notATransform = { someObject: true };
+        expect(() => placeCentre([0, 0, 0], notATransform)).toThrow(/walk tuple index/);
+    });
+    test('non-finite vertex data yields no centre rather than a NaN score', () => {
+        expect(localCentre(geometryOf([[0, 0, 0], [NaN, 0, 0]]), 2)).toBeUndefined();
+    });
+    test('a right-shaped transform holding NaN drops the mesh, and does not throw', () => {
+        // Data, not a programming error: one unusable placement must not take
+        // down the whole run and discard the other stages' reports.
+        const nanTransform = translation(NaN, 0, 0);
+        expect(placeCentre([1, 1, 1], nanTransform)).toBeUndefined();
+    });
+});

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.470.1390';
+const versionString = 'Conway v1.471.1405';
 export { versionString };