@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

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

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

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

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

@@ -0,0 +1,129 @@
+/* eslint-disable no-magic-numbers */
+// Integration tests for OpenModelStreamed (streamed columnar open).
+//
+// Parity requirement: a model opened through the streaming columnar
+// indexer must be indistinguishable downstream from a classic
+// OpenModel — same meshes (ids, placements, colors), same property
+// reads, same spatial structure — and SpillModelSource must work
+// afterwards exactly as it does on a classic open. The fallback
+// contract (never worse than OpenModelAsync) is pinned via a factory
+// spy: a successful streamed open must not have silently taken the
+// classic path.
+import * as fs from "fs";
+import { beforeAll, describe, expect, jest, test } from "@jest/globals";
+import { InMemoryStepByteStore } from "../../step/step_buffer_provider.js";
+import { IfcAPI } from "./ifc_api.js";
+import { IfcApiModelPassthroughFactory } from "./ifc_api_model_passthrough_factory.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+let api;
+let buffer;
+/**
+ * Capture StreamAllMeshes output as plain comparable objects.
+ *
+ * @param modelID The model to stream.
+ * @return {object[]} One entry per mesh with its placed geometries.
+ */
+function captureMeshes(modelID) {
+    const captured = [];
+    api.StreamAllMeshes(modelID, (mesh) => {
+        const geometries = [];
+        for (let where = 0; where < mesh.geometries.size(); ++where) {
+            const placed = mesh.geometries.get(where);
+            geometries.push({
+                color: placed.color,
+                geometryExpressID: placed.geometryExpressID,
+                flatTransformation: [...placed.flatTransformation],
+            });
+        }
+        captured.push({ expressID: mesh.expressID, geometries });
+    });
+    return captured;
+}
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+    buffer = new Uint8Array(fs.readFileSync("data/index.ifc"));
+}, 120000);
+describe("OpenModelStreamed", () => {
+    test("meshes and properties match a classic OpenModel exactly", async () => {
+        const fallback = jest.spyOn(IfcApiModelPassthroughFactory, "fromAsync");
+        const streamedID = await api.OpenModelStreamed(buffer, SETTINGS);
+        // A successful streamed open must be the streamed path, not a
+        // silent fallback (which would make the parity below vacuous).
+        expect(streamedID).toBeGreaterThanOrEqual(0);
+        expect(fallback).not.toHaveBeenCalled();
+        fallback.mockRestore();
+        const classicID = api.OpenModel(buffer, SETTINGS);
+        expect(classicID).toBeGreaterThanOrEqual(0);
+        // Mesh parity: ids, placements, colors.
+        expect(captureMeshes(streamedID)).toEqual(captureMeshes(classicID));
+        // Property parity across every record.
+        const classicPassthrough = api.getPassthrough(classicID);
+        const lineIDs = classicPassthrough.getAllLines();
+        expect(lineIDs.size()).toBeGreaterThan(10);
+        expect(api.getPassthrough(streamedID).getAllLines().size())
+            .toBe(lineIDs.size());
+        for (let where = 0; where < lineIDs.size(); ++where) {
+            const expressID = lineIDs.get(where);
+            expect(await api.properties.getItemProperties(streamedID, expressID))
+                .toEqual(await api.properties.getItemProperties(classicID, expressID));
+        }
+        // Spatial structure parity (names mode — Share's consumption).
+        expect(await api.properties.getSpatialStructure(streamedID, "names"))
+            .toEqual(await api.properties.getSpatialStructure(classicID, "names"));
+        api.CloseModel(streamedID);
+        api.CloseModel(classicID);
+    }, 240000);
+    test("SpillModelSource works after a streamed open", async () => {
+        const modelID = await api.OpenModelStreamed(buffer, SETTINGS);
+        const passthrough = api.getPassthrough(modelID);
+        // Snapshot a spread of records through the resident path.
+        const lineIDs = passthrough.getAllLines();
+        const sampled = new Map();
+        for (let where = 0; where < lineIDs.size(); where += 7) {
+            const expressID = lineIDs.get(where);
+            sampled.set(expressID, await api.properties.getItemProperties(modelID, expressID));
+        }
+        // Tiny windows force straddles + LRU eviction on the fixture.
+        const spilled = api.SpillModelSource(modelID, new InMemoryStepByteStore(buffer), 512, 3);
+        expect(spilled).toBe(true);
+        for (const [expressID, expected] of sampled) {
+            expect(await api.properties.getItemProperties(modelID, expressID))
+                .toEqual(expected);
+        }
+        api.CloseModel(modelID);
+    }, 240000);
+    test("unparseable input returns -1 (streamed and fallback both refuse)", async () => {
+        const garbage = new Uint8Array([0, 1, 2, 3, 42, 255, 254, 253]);
+        expect(await api.OpenModelStreamed(garbage, SETTINGS)).toBe(-1);
+    }, 120000);
+    test("OpenModelStream parses from a store without a resident buffer", async () => {
+        const store = new InMemoryStepByteStore(buffer);
+        const modelID = await api.OpenModelStream(store, SETTINGS);
+        expect(modelID).toBeGreaterThanOrEqual(0);
+        const passthrough = api.getPassthrough(modelID);
+        expect(passthrough.sourceIsExternal).toBe(true);
+        const streamedID = await api.OpenModelStreamed(buffer, SETTINGS);
+        expect(captureMeshes(modelID)).toEqual(captureMeshes(streamedID));
+        api.CloseModel(modelID);
+        api.CloseModel(streamedID);
+    }, 240000);
+    test("OpenModelStream + DEFER_GEOMETRY pumps via ExtractGeometryBatchAsync", async () => {
+        const store = new InMemoryStepByteStore(buffer);
+        const deferredID = await api.OpenModelStream(store, { ...SETTINGS, DEFER_GEOMETRY: true });
+        expect(deferredID).toBeGreaterThanOrEqual(0);
+        const captured = [];
+        for (;;) {
+            const { extracted, remaining } = await api.ExtractGeometryBatchAsync(deferredID, 8, (mesh) => {
+                captured.push({ expressID: mesh.expressID });
+            });
+            if (remaining === 0 && extracted === 0) {
+                break;
+            }
+        }
+        expect(captured.length).toBeGreaterThan(0);
+        expect(() => api.ExtractGeometryBatch(deferredID, 8))
+            .toThrow(/ExtractGeometryBatchAsync/);
+        api.CloseModel(deferredID);
+    }, 240000);
+});

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

@@ -0,0 +1,134 @@
+import type IfcStepModel from "../../ifc/ifc_step_model.js";
+import type { PreviewMeshPayload } from "./streamed_preview_channel.js";
+/** Black, almost transparent — Share honours `w` as opacity. */
+export declare const SPATIAL_IMPOSTER_COLOR: {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+/** An axis-aligned box in raw IFC source-unit space (Z-up). */
+export interface Aabb3 {
+    min: [
+        number,
+        number,
+        number
+    ];
+    max: [
+        number,
+        number,
+        number
+    ];
+}
+/**
+ * Column-major 4x4 mapping a centred unit cube onto `aabb`, entirely in
+ * RAW IFC space: `translate(centre) * scale(size)`.
+ *
+ * Deliberately carries NO Z-up -> Y-up flip and NO unit scaling: both of
+ * those live in the coordination matrix this is composed under (see
+ * {@link emitSpatialStructureImposters}), exactly as they do for real
+ * meshes. Baking the flip here — which the parse-time point-list
+ * imposter this replaced used to do — put the plates in a frame the
+ * durable geometry never shares (conway#515).
+ *
+ * @param aabb The IFC-space bounds.
+ * @return {number[]} 16-element matrix.
+ */
+export declare function aabbBoxMatrix(aabb: Aabb3): number[];
+/**
+ * Deepest spatial depth we still emit (never Spaces). Halfway down the
+ * tree, plus every BuildingStorey — floor plates are the useful cut.
+ *
+ * @param maxDepth Deepest spatial node (spaces included).
+ * @return {number} Inclusive depth cap for non-storey nodes.
+ */
+export declare function spatialImposterDepthCap(maxDepth: number): number;
+/**
+ * Whether this spatial node should become a box.
+ *
+ * @param depth Node depth from the project root.
+ * @param maxDepth Tree depth.
+ * @param typeID Schema type.
+ * @return {boolean} True to emit.
+ */
+export declare function shouldEmitSpatialNode(depth: number, maxDepth: number, typeID: number): boolean;
+/**
+ * True when two AABBs are within `rel` of each other on every axis
+ * (used to drop Project/Site wrappers that match the Building).
+ *
+ * @param a First box.
+ * @param b Second box.
+ * @param rel Relative slack.
+ * @param minEdge Span floor, in the same source units as `a` and `b`.
+ * The walk always passes {@link minEdgeSourceUnits}' converted value;
+ * the default is the unconverted MIN_EDGE_M, which is only correct on a
+ * metre model — a caller that omits it on a millimetre one gets a
+ * one-millimetre floor, the very bug MIN_EDGE_M removed.
+ * @return {boolean} True if they match.
+ */
+export declare function aabbMostlyEqual(a: Aabb3, b: Aabb3, rel?: number, minEdge?: number): boolean;
+/**
+ * Union of boxes; ignores undefined.
+ *
+ * @param boxes Boxes to join.
+ * @return {Aabb3 | undefined} The union.
+ */
+export declare function unionAabb(...boxes: (Aabb3 | undefined)[]): Aabb3 | undefined;
+/**
+ * Walk the IFC spatial tree and emit AABB imposters for Share.
+ *
+ * Project → Site → Building → Storey → Space. Spaces are never
+ * drawn (too dense). Everything else is drawn down to half the tree
+ * depth, and storeys are always drawn when present. Nested wrappers
+ * whose box matches their only child are collapsed.
+ *
+ * **Frame.** Every box is measured in raw IFC source units and Z-up,
+ * because that is what the placement chains this walk reads carry. The
+ * emitted `flatTransformation` is `C * M_box`, where `M_box` is that raw
+ * box ({@link aabbBoxMatrix}) and `C` is the durable coordination frame —
+ * metres, Y-up, recentred per the quantized model-zero policy. So the
+ * plates land exactly where the real meshes do, which they did not
+ * before (raw units, a locally baked axis flip, no coordination: on a
+ * millimetre model the plates came out 1000x too big, and a
+ * georeferenced one put them a site-offset away — conway#515).
+ * `payload.aabb` stays in raw IFC space as the consumer's reference.
+ *
+ * **Call it after `prepareDemandExtraction()`, never before.** The frame
+ * needs `getLinearScalingFactor()`, which reads 1 until the extraction
+ * maps — and with them the unit assignment — are prepared, and
+ * `extractLinearScalingFactor()` is `*=`-accumulating, so it cannot be
+ * pulled forward on its own without squaring the unit prefix. The cost
+ * is latency on the model's first visible feedback: on the resident path
+ * the plates now follow the prep instead of preceding it, and on the
+ * store-backed path they also follow an awaited
+ * `ensureResidentForDemandPrep()`, so on a large model they land
+ * measurably later than they used to. Accepted deliberately — a plate at
+ * 1000x the model's scale is worse than a plate slightly late.
+ *
+ * **The latched frame is adopted, not guaranteed.** The deferred durable
+ * pump re-derives its own when the composed placement overruns
+ * LARGE_COORDINATE_BUDGET_M (`validatePreviewFrame`, Share#1634). Plates
+ * emitted here are not re-emitted, so on that path they keep the
+ * rejected frame and sit a site-offset from the durable meshes — the
+ * conway#515 symptom again, now confined to a case the preview meshes
+ * beside them share, and to scenery Share tears down at load end.
+ * Re-emitting on rejection is the fix if it ever shows up live.
+ *
+ * @param model Parsed IFC model (windowed or resident).
+ * @param onMesh Preview consumer.
+ * @param coordinationMatrix The frame already latched by the preview
+ * channel (the one the durable pump adopts). When it is `undefined` — no
+ * preview instance was ever captured — the walk derives the same frame
+ * from an identity placement anchored on the root spatial box's centre.
+ * That is best-effort by construction: below LARGE_COORDINATE_BUDGET_M
+ * the policy recentres nothing, so it agrees with the durable derivation
+ * exactly; above it, both snap to COORDINATION_SNAP_M and agree as long
+ * as the spatial root and the first geometry share a grid cell.
+ * @param linearScalingFactor Source units -> metres, from
+ * `IfcGeometryExtraction.getLinearScalingFactor()`. Only consulted for
+ * the fallback derivation and the minimum-edge padding; when
+ * `coordinationMatrix` is supplied its own scaling is already baked in.
+ * @return {Promise<number>} Boxes emitted.
+ */
+export declare function emitSpatialStructureImposters(model: IfcStepModel, onMesh: (mesh: PreviewMeshPayload) => void, coordinationMatrix?: ArrayLike<number>, linearScalingFactor?: number): Promise<number>;
+//# sourceMappingURL=spatial_imposter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spatial_imposter.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/spatial_imposter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAgBxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAKpE,gEAAgE;AAChE,eAAO,MAAM,sBAAsB;;;;;CAA+B,CAAA;AAqBlE,+DAA+D;AAC/D,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B;AA0BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAE,IAAI,EAAE,KAAK,GAAI,MAAM,EAAE,CAerD;AA6DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAE,QAAQ,EAAE,MAAM,GAAI,MAAM,CAGlE;AAGD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GAAI,OAAO,CAW5B;AAGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,GAAG,GAAE,MAAqB,EAC1B,OAAO,GAAE,MAAmB,GAAI,OAAO,CAiB1C;AAGD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAE,GAAG,KAAK,EAAE,CAAE,KAAK,GAAG,SAAS,CAAE,EAAE,GAAI,KAAK,GAAG,SAAS,CA4BhF;AAoWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAsB,6BAA6B,CAC/C,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,CAAE,IAAI,EAAE,kBAAkB,KAAM,IAAI,EAC5C,kBAAkB,CAAC,EAAE,SAAS,CAAE,MAAM,CAAE,EACxC,mBAAmB,GAAE,MAAU,GAAI,OAAO,CAAE,MAAM,CAAE,CAkevD"}