@bldrs-ai/conway 1.469.1386 → 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.469.1386";
+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.469.1386";
+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.469.1386";
+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.469.1386";
+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/scripts/render_glb_paths.test.d.ts

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

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

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

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

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { describe, expect, test, beforeAll, afterAll } from '@jest/globals';
+import { createRequire } from 'module';
+/* eslint-disable @typescript-eslint/no-explicit-any -- render_glb.cjs is an
+   untyped CommonJS CLI script, loaded here through createRequire. */
+/**
+ * Path resolution in scripts/render_glb.cjs (conway#457).
+ *
+ * The script accepts a comma-joined chunk list, and used to split on comma
+ * unconditionally — which tore a real path containing a comma into fragments
+ * and reported the first fragment as missing. Several models we ship are
+ * named that way, and `-g` keeps the source basename, so following
+ * scripts/debug/README.md on one of them failed.
+ */
+const require_ = createRequire(import.meta.url);
+// Resolved from the repo root rather than relative to this file: the test
+// runs from compiled/src/scripts, where a relative hop would land in
+// compiled/scripts, which does not exist (scripts/ is not part of the tsc
+// build). Jest's rootDir is the repo root.
+const { resolveGlbPaths } = require_(path.resolve(process.cwd(), 'scripts/render_glb.cjs'));
+let workDir;
+/** A name in the shape that broke: a comma inside a single real filename. */
+const COMMA_NAME = 'Wiesenplatz 7, 4057 Basel_test0.glb';
+beforeAll(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'render-glb-paths-'));
+    fs.writeFileSync(path.join(workDir, COMMA_NAME), 'not-a-real-glb');
+    fs.writeFileSync(path.join(workDir, 'chunk0.glb'), 'not-a-real-glb');
+    fs.writeFileSync(path.join(workDir, 'chunk1.glb'), 'not-a-real-glb');
+});
+afterAll(() => {
+    fs.rmSync(workDir, { recursive: true, force: true });
+});
+describe('render_glb path resolution', () => {
+    test('a real path containing a comma resolves to itself (issue #457)', () => {
+        const target = path.join(workDir, COMMA_NAME);
+        // The regression: this used to come back as ['<dir>/Wiesenplatz 7',
+        // ' 4057 Basel_test0.glb'] and fail on the first, which reads as a
+        // missing file rather than as a parsing decision.
+        expect(resolveGlbPaths(target)).toEqual([target]);
+    });
+    test('a genuine chunk list still splits', () => {
+        const chunks = [
+            path.join(workDir, 'chunk0.glb'),
+            path.join(workDir, 'chunk1.glb'),
+        ];
+        expect(resolveGlbPaths(chunks.join(','))).toEqual(chunks);
+    });
+    test('a JSON array resolves chunks whose names contain commas', () => {
+        // The case the literal-path rule alone cannot reach: a comma-named model
+        // large enough that the CLI splits it, so no single file bears the name.
+        // visual_diff_report.cjs passes this form.
+        const chunks = [
+            path.join(workDir, COMMA_NAME),
+            path.join(workDir, 'chunk0.glb'),
+        ];
+        expect(resolveGlbPaths(JSON.stringify(chunks))).toEqual(chunks);
+    });
+    test('a JSON array with a missing member fails rather than rendering part', () => {
+        const chunks = [path.join(workDir, 'chunk0.glb'), path.join(workDir, 'gone.glb')];
+        expect(() => resolveGlbPaths(JSON.stringify(chunks))).toThrow(/gone\.glb/);
+    });
+    test('a trailing comma from a shell-built list still resolves', () => {
+        const target = path.join(workDir, 'chunk0.glb');
+        expect(resolveGlbPaths(`${target},`)).toEqual([target]);
+    });
+    test('a missing path names both readings rather than one fragment', () => {
+        const missing = path.join(workDir, 'Nowhere 1, 2345 Somewhere.glb');
+        // What the error says is the whole point of the issue: the old failure
+        // surfaced as ENOENT on "Nowhere 1", a string the caller never typed.
+        expect(() => resolveGlbPaths(missing)).toThrow(/No such GLB/);
+        expect(() => resolveGlbPaths(missing)).toThrow(/2-chunk list/);
+    });
+    test('a CLI failure surfaces its own message to visual_diff_report', () => {
+        // This contract spans two files and has no other guard. render_glb.cjs
+        // prints "Error: <message>"; visual_diff_report.cjs's
+        // childFailureDiagnostic picks the FIRST stderr line matching its regex
+        // and puts it in the PR comment's table cell. Letting Node throw
+        // uncaught instead degrades every render-failure cell to a source code
+        // frame, with the whole suite otherwise green.
+        //
+        // Scope, honestly: this pins the END-TO-END result, not each mechanism.
+        // Removing the "Error:" prefix alone keeps it passing, because the stack
+        // printed after the message opens with an "Error:" line that matches the
+        // same regex. Both are kept because a non-Error throw has no stack.
+        const script = path.resolve(process.cwd(), 'scripts/render_glb.cjs');
+        const missing = path.join(workDir, 'Nowhere 1, 2345 Somewhere.glb');
+        let stderr = '';
+        try {
+            execFileSync(process.execPath, [script, missing, path.join(workDir, 'out.png')], { stdio: 'pipe' });
+        }
+        catch (err) {
+            stderr = (err.stderr ?? '').toString();
+        }
+        // The regex is copied from visual_diff_report.cjs:138 deliberately — the
+        // point is to fail here if either side drifts.
+        const picked = stderr.split('\n').filter(Boolean).find((line) => /error|cannot|not found|bad option|unexpected/i.test(line));
+        expect(picked).toMatch(/No such GLB/);
+        expect(picked).toContain('Nowhere 1, 2345 Somewhere.glb');
+        // And the stack still reaches the job log, which is a separate consumer.
+        expect(stderr).toMatch(/at resolveGlbPaths/);
+    });
+    test('a chunk list with one missing member does not silently render the rest', () => {
+        const spec = [
+            path.join(workDir, 'chunk0.glb'),
+            path.join(workDir, 'absent.glb'),
+        ].join(',');
+        // Rendering the surviving chunk would drop part of the model and look
+        // like a geometry regression in the visual diff, which is worse than
+        // failing.
+        expect(() => resolveGlbPaths(spec)).toThrow(/absent\.glb/);
+    });
+});

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