@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/ifc/ifc_grid_placement.test.d.ts

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

package/compiled/src/ifc/ifc_grid_placement.test.d.ts.map

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

package/compiled/src/ifc/ifc_grid_placement.test.js

@@ -0,0 +1,261 @@
+import fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { IfcGeometryExtraction } from "./ifc_geometry_extraction.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import IfcStepParser from "./ifc_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import { ExtractResult } from "../core/shared_constants.js";
+import { StepBufferNotResidentError } from "../step/step_buffer_provider.js";
+import { IfcGrid } from "./ifc4_gen/index.js";
+import Logger, { LogLevel } from "../logging/logger.js";
+/* Express IDs in data/grid_placement.ifc — see that file for the geometry
+ * each of them describes and where the expectations below come from. */
+const PLACEMENT_A = 201;
+const PLACEMENT_B = 301;
+const PLACEMENT_C = 501;
+const PLACEMENT_D = 601;
+const PLACEMENT_E = 701;
+const CIRCULAR_AXIS = 410;
+/* Where the two supported placements land in world space, derived in the
+ * comments beside each product in the fixture. */
+const A_WORLD_X = 8;
+const A_WORLD_Y = 17;
+const A_WORLD_Z = 9;
+const B_WORLD_X = 4;
+const B_WORLD_Y = 25;
+const B_WORLD_Z = 5;
+const D_WORLD_X = 8;
+const D_WORLD_Y = 17;
+const D_WORLD_Z = 10;
+const E_WORLD_X = 10;
+const E_WORLD_Y = 20;
+const E_WORLD_Z = 5;
+/* Column-major offsets into a 4x4 transform's values. */
+const X_AXIS = 0;
+const TRANSLATION = 12;
+let extraction;
+let extractResult;
+/**
+ * Parse data/grid_placement.ifc and extract its geometry.
+ *
+ * @param mutateModel Optional hook run on the parsed model before extraction,
+ * for the windowed-source tests that need a specific read to throw.
+ * @return {Promise<ExtractResult>} The result of the extraction.
+ */
+async function extractGridModel(mutateModel) {
+    const parser = IfcStepParser.Instance;
+    const input = new ParsingBuffer(fs.readFileSync("data/grid_placement.ifc"));
+    if (parser.parseHeader(input)[1] !== ParseResult.COMPLETE) {
+        return ExtractResult.INCOMPLETE;
+    }
+    const conwayGeometry = new ConwayGeometry();
+    if (!await conwayGeometry.initialize()) {
+        return ExtractResult.INCOMPLETE;
+    }
+    const [, model] = parser.parseDataToModel(input);
+    if (model === void 0) {
+        return ExtractResult.INCOMPLETE;
+    }
+    mutateModel?.(model);
+    extraction = new IfcGeometryExtraction(conwayGeometry, model);
+    return extraction.extractIFCGeometryData()[0];
+}
+/**
+ * The scene transform registered for an object placement.
+ *
+ * @param expressID The express ID of the placement.
+ * @return {IfcSceneTransform | undefined} Its transform, or undefined when
+ * the extraction registered none for it.
+ */
+function placementTransform(expressID) {
+    const placement = extraction.model.getElementByExpressID(expressID);
+    expect(placement).toBeDefined();
+    return extraction.scene.getTransform(placement.localID);
+}
+/**
+ * Find a buffered warning by the start of its message.
+ *
+ * @param prefix The leading text of the message to look for.
+ * @return {LogEntry | undefined} The matching entry.
+ */
+function warningStartingWith(prefix) {
+    return Logger.getLogs().find((entry) => entry.level === "warning" && entry.message.startsWith(prefix));
+}
+beforeAll(async () => {
+    Logger.clearLogs();
+    // The unsupported-axis product warns by design here, and the echo would be
+    // noise in the test console. The buffer these tests read is filled
+    // regardless of the console threshold.
+    const threshold = Logger.getLogLevel();
+    Logger.setLogLevel(LogLevel.OFF);
+    try {
+        extractResult = await extractGridModel();
+    }
+    finally {
+        Logger.setLogLevel(threshold);
+    }
+});
+describe("IfcGridPlacement extraction", () => {
+    test("the model extracts", () => {
+        expect(extractResult).toBe(ExtractResult.COMPLETE);
+    });
+    test("a grid placement composes onto the grid's own placement", () => {
+        const transform = placementTransform(PLACEMENT_A);
+        expect(transform).toBeDefined();
+        const values = transform.absoluteTransform;
+        // Grid intersection (-3,2,4) carried through the grid's placement — a
+        // quarter turn about +Z, then (10,20,5). Landing at the origin is the
+        // defect this covers, and landing at (7,22,9) would mean the grid's
+        // rotation had been added rather than composed.
+        expect(values[TRANSLATION]).toBeCloseTo(A_WORLD_X);
+        expect(values[TRANSLATION + 1]).toBeCloseTo(A_WORLD_Y);
+        expect(values[TRANSLATION + 2]).toBeCloseTo(A_WORLD_Z);
+        // No PlacementRefDirection, so the x axis is the first axis' tangent
+        // (+X in the grid), which the grid's quarter turn takes to world +Y.
+        expect(values[X_AXIS]).toBeCloseTo(0);
+        expect(values[X_AXIS + 1]).toBeCloseTo(1);
+        expect(values[X_AXIS + 2]).toBeCloseTo(0);
+    });
+    test("two offsets and an explicit reference direction", () => {
+        const transform = placementTransform(PLACEMENT_B);
+        expect(transform).toBeDefined();
+        const values = transform.absoluteTransform;
+        // Grid intersection (5,6), with no third offset, so z stays on the grid.
+        expect(values[TRANSLATION]).toBeCloseTo(B_WORLD_X);
+        expect(values[TRANSLATION + 1]).toBeCloseTo(B_WORLD_Y);
+        expect(values[TRANSLATION + 2]).toBeCloseTo(B_WORLD_Z);
+        // PlacementRefDirection is +Y in the grid, which the quarter turn takes
+        // to world -X.
+        expect(values[X_AXIS]).toBeCloseTo(-1);
+        expect(values[X_AXIS + 1]).toBeCloseTo(0);
+        expect(values[X_AXIS + 2]).toBeCloseTo(0);
+    });
+    test("a local placement measured from a grid placement composes onto it", () => {
+        const transform = placementTransform(PLACEMENT_D);
+        expect(transform).toBeDefined();
+        const values = transform.absoluteTransform;
+        // 1m up from product A's grid placement, which is where an
+        // IfcLocalPlacement whose PlacementRelTo is an IfcGridPlacement lands
+        // once that placement registers a transform to be relative to.
+        expect(values[TRANSLATION]).toBeCloseTo(D_WORLD_X);
+        expect(values[TRANSLATION + 1]).toBeCloseTo(D_WORLD_Y);
+        expect(values[TRANSLATION + 2]).toBeCloseTo(D_WORLD_Z);
+    });
+    test("an axis curve that is not a line warns rather than dropping silently", () => {
+        expect(placementTransform(PLACEMENT_C)).toBeUndefined();
+        const warning = warningStartingWith("IfcGridPlacement: unsupported grid axis curve");
+        expect(warning).toBeDefined();
+        expect(warning.message).toContain("IFCCIRCLE");
+        expect(warning.expressIDs.has(String(CIRCULAR_AXIS))).toBe(true);
+    });
+    test("a reference direction along the placement z falls back to the tangent", () => {
+        const transform = placementTransform(PLACEMENT_E);
+        expect(transform).toBeDefined();
+        const values = transform.absoluteTransform;
+        // The failure this covers is not a wrong number but a poisoned one:
+        // unguarded, normalising a reference direction that lies along the forced
+        // z gives NaN, and addTransform carries it into every descendant. Asserted
+        // over the whole matrix rather than the x axis alone, since that is how it
+        // spreads.
+        expect(Array.from(values).every((value) => Number.isFinite(value)))
+            .toBe(true);
+        // Axes A and 1 with no offsets meet at the grid origin.
+        expect(values[TRANSLATION]).toBeCloseTo(E_WORLD_X);
+        expect(values[TRANSLATION + 1]).toBeCloseTo(E_WORLD_Y);
+        expect(values[TRANSLATION + 2]).toBeCloseTo(E_WORLD_Z);
+        // The schema default the guard falls back to: the first axis' tangent,
+        // +X in the grid, taken to world +Y by the grid's quarter turn - so the
+        // same x axis product A gets from having no reference direction at all.
+        expect(values[X_AXIS]).toBeCloseTo(0);
+        expect(values[X_AXIS + 1]).toBeCloseTo(1);
+        expect(values[X_AXIS + 2]).toBeCloseTo(0);
+        const warning = warningStartingWith("IfcGridPlacement: the placement reference direction is parallel");
+        expect(warning).toBeDefined();
+        expect(warning.expressIDs.has(String(PLACEMENT_E))).toBe(true);
+    });
+    test("nothing in this model is left unimplemented", () => {
+        // The arm this covers used to be a no-op; a supported placement that
+        // still warns would mean the implementation had not been reached.
+        expect(warningStartingWith("IfcGridPlacement: unimplemented")).toBeUndefined();
+    });
+});
+describe("IfcGridPlacement on a windowed source", () => {
+    test("non-resident grid records degrade to the intersection, not a dropped product", async () => {
+        // A store-backed model pages a product's forward-reference closure,
+        // which reaches the axes but never the IfcGrid that back-references
+        // them — so the gridByAxis scan is the one read here that can throw
+        // StepBufferNotResidentError. Simulate exactly that read failing.
+        const threshold = Logger.getLogLevel();
+        Logger.setLogLevel(LogLevel.OFF);
+        let result;
+        try {
+            result = await extractGridModel((model) => {
+                const originalTypes = model.types.bind(model);
+                model.types = ((...requested) => {
+                    if (requested.length === 1 && requested[0] === IfcGrid) {
+                        throw new StepBufferNotResidentError(0, 0);
+                    }
+                    return originalTypes(...requested);
+                });
+            });
+        }
+        finally {
+            Logger.setLogLevel(threshold);
+        }
+        // The product survives - dropping it entirely would be strictly worse
+        // than the pre-implementation rendered-at-origin state.
+        expect(result).toBe(ExtractResult.COMPLETE);
+        const transform = placementTransform(PLACEMENT_A);
+        expect(transform).toBeDefined();
+        const values = transform.absoluteTransform;
+        // The grid-frame intersection with its offsets, WITHOUT the grid's
+        // own placement composed on: the degraded-but-warned state.
+        expect(values[TRANSLATION]).toBeCloseTo(-3);
+        expect(values[TRANSLATION + 1]).toBeCloseTo(2);
+        expect(values[TRANSLATION + 2]).toBeCloseTo(4);
+        const warning = warningStartingWith("IfcGridPlacement: grid records are not resident");
+        expect(warning).toBeDefined();
+        expect(warning.expressIDs.has(String(PLACEMENT_A))).toBe(true);
+    });
+    test("a partially resident grid placement chain warns about the partial frame", async () => {
+        // The other residency miss on this path, and the reason the guard is
+        // two regions rather than one: the grid IS found, and the read that
+        // fails is its own placement chain. extractPlacement pushes a
+        // transform per level as it unwinds, so a miss part way up leaves
+        // ancestors applied - which the scan-failure message would describe
+        // wrongly. Patched on the prototype because the failing read is a
+        // generated accessor, not a model call the mutator hook can reach.
+        const placementProperty = "ObjectPlacement";
+        const threshold = Logger.getLogLevel();
+        // The buffer is file-wide, and the preceding test deliberately fires
+        // the scan-failure warning this one asserts the ABSENCE of.
+        Logger.clearLogs();
+        Logger.setLogLevel(LogLevel.OFF);
+        Object.defineProperty(IfcGrid.prototype, placementProperty, {
+            configurable: true,
+            /** @return {never} Always throws, as a non-resident read would. */
+            get() {
+                throw new StepBufferNotResidentError(0, 0);
+            },
+        });
+        let result;
+        try {
+            result = await extractGridModel();
+        }
+        finally {
+            delete IfcGrid.prototype[placementProperty];
+            Logger.setLogLevel(threshold);
+        }
+        expect(result).toBe(ExtractResult.COMPLETE);
+        // Still placed, and still not dropped.
+        expect(placementTransform(PLACEMENT_A)).toBeDefined();
+        const warning = warningStartingWith("IfcGridPlacement: the grid's own placement chain is not fully " +
+            "resident");
+        expect(warning).toBeDefined();
+        expect(warning.expressIDs.has(String(PLACEMENT_A))).toBe(true);
+        // The scan succeeded, so the message that says the grid records were
+        // never reached must NOT be the one reported.
+        expect(warningStartingWith("IfcGridPlacement: grid records are not resident")).toBeUndefined();
+    });
+});

package/compiled/src/ifc/ifc_model_geometry.d.ts

@@ -30,6 +30,18 @@ export declare class IfcModelGeometry implements ModelGeometry {
     /**
      * Add a mesh to the geometry cache.
      *
+     * Freezes the native float vertex mirror at add time (one
+     * GetVertexData call): consumers (the compat GetGeometry surface)
+     * read float vertices whose frame must match the scene transforms,
+     * which are authored against the geometry AS CREATED. Later native
+     * mutations that keep the vertex count (normalize's centering)
+     * deliberately do NOT refresh the mirror, so every extraction path —
+     * whole-model walk, per-product demand pump, parse-time preview —
+     * serves the same creation-frame floats. Without this, paths that
+     * first read vertices only after a centering mutation serve
+     * per-geometry-shifted vertices against unshifted transforms
+     * (Share's demand-path "scatter").
+     *
      * @param mesh
      */
     add(mesh: CanonicalMesh): void;

package/compiled/src/ifc/ifc_model_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ifc_model_geometry.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_model_geometry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAqB,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAoB,8BAA8B,EAAE,MAAM,YAAY,CAAA;AAC7E,OAAO,EAAE,iBAAiB,EAAmB,MAAM,4BAA4B,CAAA;AAG/E;;GAEG;AACH,qBAAa,gBAAiB,YAAW,aAAa;aAUvB,KAAK,EAAE,YAAY;aAAkB,MAAM,EAAE,OAAO;IARjF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAE3D;;;;;OAKG;gBAC0B,KAAK,EAAE,YAAY,EAAkB,MAAM,GAAE,OAAe;IAEzF;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;OAEG;IACI,iBAAiB,IAAI,IAAI;IAgBhC;;;;OAIG;IACI,GAAG,CAAC,IAAI,EAAE,aAAa;IAK9B;;;;OAIG;IACI,MAAM,CAAC,OAAO,EAAE,MAAM;IAe7B;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D;;;;OAIG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI3D;;;;OAIG;IACI,qBAAqB,IAAI,MAAM;IAqBtC;;;;OAIG;IACK,IAAI,IAAK,gBAAgB,CAAE;QACjC,8BAA8B;QAC9B,MAAM;QACN,iBAAiB;QACjB,MAAM;KAAC,GAAG;QACV,8BAA8B;QAC9B,MAAM;QACN,SAAS;QACT,SAAS;KAAC,CAAC;CAqDd"}
+{"version":3,"file":"ifc_model_geometry.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_model_geometry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAqB,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAoB,8BAA8B,EAAE,MAAM,YAAY,CAAA;AAC7E,OAAO,EAAE,iBAAiB,EAAmB,MAAM,4BAA4B,CAAA;AAG/E;;GAEG;AACH,qBAAa,gBAAiB,YAAW,aAAa;aAUvB,KAAK,EAAE,YAAY;aAAkB,MAAM,EAAE,OAAO;IARjF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAE3D;;;;;OAKG;gBAC0B,KAAK,EAAE,YAAY,EAAkB,MAAM,GAAE,OAAe;IAEzF;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;OAEG;IACI,iBAAiB,IAAI,IAAI;IAgBhC;;;;;;;;;;;;;;;;OAgBG;IACI,GAAG,CAAC,IAAI,EAAE,aAAa;IAS9B;;;;OAIG;IACI,MAAM,CAAC,OAAO,EAAE,MAAM;IAe7B;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAI/D;;;;OAIG;IACI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI3D;;;;OAIG;IACI,qBAAqB,IAAI,MAAM;IAqBtC;;;;OAIG;IACK,IAAI,IAAK,gBAAgB,CAAE;QACjC,8BAA8B;QAC9B,MAAM;QACN,iBAAiB;QACjB,MAAM;KAAC,GAAG;QACV,8BAA8B;QAC9B,MAAM;QACN,SAAS;QACT,SAAS;KAAC,CAAC;CAqDd"}

package/compiled/src/ifc/ifc_model_geometry.js

@@ -40,9 +40,24 @@ export class IfcModelGeometry {
     /**
      * Add a mesh to the geometry cache.
      *
+     * Freezes the native float vertex mirror at add time (one
+     * GetVertexData call): consumers (the compat GetGeometry surface)
+     * read float vertices whose frame must match the scene transforms,
+     * which are authored against the geometry AS CREATED. Later native
+     * mutations that keep the vertex count (normalize's centering)
+     * deliberately do NOT refresh the mirror, so every extraction path —
+     * whole-model walk, per-product demand pump, parse-time preview —
+     * serves the same creation-frame floats. Without this, paths that
+     * first read vertices only after a centering mutation serve
+     * per-geometry-shifted vertices against unshifted transforms
+     * (Share's demand-path "scatter").
+     *
      * @param mesh
      */
     add(mesh) {
+        if (mesh.type === CanonicalMeshType.BUFFER_GEOMETRY) {
+            mesh.geometry.GetVertexData();
+        }
         this.meshes_.set(mesh.localID, mesh);
     }
     /**