@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/ifc/ifc4_gen/IfcRelInterferesElements.gen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IfcRelInterferesElements.gen.d.ts","sourceRoot":"","sources":["../../../../src/ifc/ifc4_gen/IfcRelInterferesElements.gen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAI/C,OAAO,cAAc,MAAM,wBAAwB,CAAA;AACnD,OAAO,2BAA2B,MAAM,2CAA2C,CAAA;AACnF,OAAO,cAAc,MAAM,6BAA6B,CAAA;AACxD,OAAO,aAAa,MAAM,4BAA4B,CAAA;AAItD,qBAAc,wBAAyB,SAAQ,cAAc;IAC3D,IAAW,IAAI,IAAI,cAAc,CAEhC;IACD,OAAO,CAAC,gBAAgB,CAAC,CAAa;IACtC,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,qBAAqB,CAAC,CAA+B;IAC7D,OAAO,CAAC,iBAAiB,CAAC,CAAgB;IAC1C,OAAO,CAAC,aAAa,CAAC,CAAU;IAEhC,IAAW,eAAe,IAAK,UAAU,CAMxC;IAED,IAAW,cAAc,IAAK,UAAU,CAMvC;IAED,IAAW,oBAAoB,IAAK,qBAAqB,GAAG,IAAI,CAM/D;IAED,IAAW,gBAAgB,IAAK,MAAM,GAAG,IAAI,CAM5C;IAED,IAAW,YAAY,IAAK,OAAO,CAMlC;gBAEC,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,2BAA2B,CAAE,cAAc,CAAE,EAChE,KAAK,EAAE,aAAa,CAAE,cAAc,EAAE,cAAc,CAAE,cAAc,CAAE,CAAE,EACxE,cAAc,CAAC,EAAE,2BAA2B,CAAE,cAAc,CAAE,EAAE;IAKlE,gBAAuB,KAAK,mBACiB;IAE7C,gBAAuB,YAAY,EAAE,cAAc,CACV;CAC1C"}
+{"version":3,"file":"IfcRelInterferesElements.gen.d.ts","sourceRoot":"","sources":["../../../../src/ifc/ifc4_gen/IfcRelInterferesElements.gen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAI/C,OAAO,cAAc,MAAM,wBAAwB,CAAA;AACnD,OAAO,2BAA2B,MAAM,2CAA2C,CAAA;AACnF,OAAO,cAAc,MAAM,6BAA6B,CAAA;AACxD,OAAO,aAAa,MAAM,4BAA4B,CAAA;AAItD,qBAAc,wBAAyB,SAAQ,cAAc;IAC3D,IAAW,IAAI,IAAI,cAAc,CAEhC;IACD,OAAO,CAAC,gBAAgB,CAAC,CAAa;IACtC,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,qBAAqB,CAAC,CAA+B;IAC7D,OAAO,CAAC,iBAAiB,CAAC,CAAgB;IAC1C,OAAO,CAAC,aAAa,CAAC,CAAiB;IAEvC,IAAW,eAAe,IAAK,UAAU,CAMxC;IAED,IAAW,cAAc,IAAK,UAAU,CAMvC;IAED,IAAW,oBAAoB,IAAK,qBAAqB,GAAG,IAAI,CAM/D;IAED,IAAW,gBAAgB,IAAK,MAAM,GAAG,IAAI,CAM5C;IAED,IAAW,YAAY,IAAK,OAAO,GAAG,IAAI,CAMzC;gBAEC,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,2BAA2B,CAAE,cAAc,CAAE,EAChE,KAAK,EAAE,aAAa,CAAE,cAAc,EAAE,cAAc,CAAE,cAAc,CAAE,CAAE,EACxE,cAAc,CAAC,EAAE,2BAA2B,CAAE,cAAc,CAAE,EAAE;IAKlE,gBAAuB,KAAK,mBACiB;IAE7C,gBAAuB,YAAY,EAAE,cAAc,CACV;CAC1C"}

package/compiled/src/ifc/ifc4_gen/IfcRelInterferesElements.gen.js

@@ -35,7 +35,7 @@ export class IfcRelInterferesElements extends IfcRelConnects {
     }
     get ImpliedOrder() {
         if (this.ImpliedOrder_ === void 0) {
-            this.ImpliedOrder_ = this.extractBoolean(8, 4, 3, false);
+            this.ImpliedOrder_ = this.extractLogical(8, 4, 3, false);
         }
         return this.ImpliedOrder_;
     }

package/compiled/src/ifc/ifc4_gen/schema_ifc.gen.js

@@ -29290,7 +29290,7 @@ let descriptions = [
             },
             ImpliedOrder: {
                 kind: f.BOOLEAN,
-                optional: false,
+                optional: true,
                 derived: false,
                 offset: 8,
             },
@@ -34262,7 +34262,7 @@ let descriptions = [
         fields: {
             Value: {
                 kind: f.BOOLEAN,
-                optional: false,
+                optional: true,
                 derived: false,
                 offset: 0,
             },

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

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

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

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

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

@@ -0,0 +1,251 @@
+/* eslint-disable no-magic-numbers, @typescript-eslint/no-explicit-any */
+// Phase B2: per-product demand extraction must produce the same meshes the
+// whole-model walk produces — same products with geometry, same vertex and
+// index counts per product — since both now run the same deduplicated
+// per-product body (extractProductGeometry).
+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 IfcStepModel from "./ifc_step_model.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import { ExtractResult } from "../core/shared_constants.js";
+import { IfcProduct, IfcStyledItem } from "./ifc4_gen/index.js";
+import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
+import { openStreamedIfcModelFromStore } from "./ifc_stream_open.js";
+import { InMemoryStepByteStore, WindowedStepBufferProvider, } from "../step/step_buffer_provider.js";
+let conwayGeometry;
+/**
+ * Parse a fresh model from index.ifc (models are stateful; each extraction
+ * mode gets its own).
+ *
+ * @return {IfcStepModel} The parsed model.
+ */
+function freshModel() {
+    const bytes = fs.readFileSync("data/index.ifc");
+    const input = new ParsingBuffer(bytes);
+    expect(IfcStepParser.Instance.parseHeader(input)[1])
+        .toBe(ParseResult.COMPLETE);
+    const [, model] = IfcStepParser.Instance.parseDataToModel(input);
+    expect(model).toBeDefined();
+    return model;
+}
+/**
+ * Collect per-localID mesh signatures (vertex + triangle counts) from a
+ * model's extracted geometry.
+ *
+ * @param extraction The extraction whose model geometry to summarise.
+ * @return {Map<number, string>} localID → "vertexCount/triangleCount".
+ */
+function meshSignatures(extraction) {
+    const signatures = new Map();
+    for (const mesh of extraction.model.geometry) {
+        const geometry = mesh.geometry;
+        if (geometry === void 0 || typeof geometry.getVertexCount !== "function") {
+            continue;
+        }
+        signatures.set(mesh.localID, `${geometry.getVertexCount()}/${geometry.getTriangleCount()}`);
+    }
+    return signatures;
+}
+beforeAll(async () => {
+    conwayGeometry = new ConwayGeometry();
+    expect(await conwayGeometry.initialize()).toBe(true);
+});
+describe("per-product demand extraction (Phase B2)", () => {
+    test("demand extraction over all products matches the whole-model walk", () => {
+        // Whole-model walk (the CI-anchored path).
+        const wholeExtraction = new IfcGeometryExtraction(conwayGeometry, freshModel());
+        expect(wholeExtraction.extractIFCGeometryData()[0])
+            .toBe(ExtractResult.COMPLETE);
+        const wholeSignatures = meshSignatures(wholeExtraction);
+        expect(wholeSignatures.size).toBeGreaterThan(0);
+        // Demand path: prepare once, then extract every product individually.
+        const demandModel = freshModel();
+        const demandExtraction = new IfcGeometryExtraction(conwayGeometry, demandModel);
+        demandExtraction.prepareDemandExtraction();
+        let extractedProducts = 0;
+        for (const product of demandModel.types(IfcProduct)) {
+            if (demandExtraction.extractProductGeometryByLocalID(product.localID)) {
+                ++extractedProducts;
+            }
+        }
+        expect(extractedProducts).toBeGreaterThan(0);
+        const demandSignatures = meshSignatures(demandExtraction);
+        // Same set of products with geometry, same mesh shape per product.
+        expect(demandSignatures).toEqual(wholeSignatures);
+    });
+    test("a single product extracts on demand without the whole-model walk", () => {
+        // Whole-model reference signatures (mesh localIDs key representation
+        // items, not products — so parity is checked per matching key).
+        const reference = new IfcGeometryExtraction(conwayGeometry, freshModel());
+        reference.extractIFCGeometryData();
+        const referenceSignatures = meshSignatures(reference);
+        const model = freshModel();
+        const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+        // Extract single products on the fresh model until one yields a mesh —
+        // proving a lone product materialises without the whole-model walk.
+        let produced = 0;
+        for (const product of model.types(IfcProduct)) {
+            extraction.extractProductGeometryByLocalID(product.localID);
+            produced = meshSignatures(extraction).size;
+            if (produced > 0) {
+                break;
+            }
+        }
+        expect(produced).toBeGreaterThan(0);
+        expect(produced).toBeLessThan(referenceSignatures.size);
+        // Every mesh the single extraction produced matches the reference's
+        // mesh for the same key exactly.
+        for (const [localID, signature] of meshSignatures(extraction)) {
+            expect(referenceSignatures.get(localID)).toBe(signature);
+        }
+    });
+    test("a non-product local ID is refused", () => {
+        const model = freshModel();
+        const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+        // localID 0 in index.ifc is not an IfcProduct (first record is a root
+        // non-product entity in this fixture; the assertion below guards that).
+        const first = model.getElementByLocalID(0);
+        expect(first instanceof IfcProduct).toBe(false);
+        expect(extraction.extractProductGeometryByLocalID(0)).toBe(false);
+    });
+    test("styled-item Item local IDs resolve without hydrating the item", () => {
+        const model = freshModel();
+        let checked = 0;
+        for (const styledItem of model.types(IfcStyledItem)) {
+            const viaIndex = styledItem.extractReferenceLocalID(0, 0, 1, true);
+            const viaItem = styledItem.Item?.localID ?? null;
+            expect(viaIndex).toBe(viaItem);
+            ++checked;
+        }
+        expect(checked).toBeGreaterThan(0);
+    });
+});
+// conway#526. `extractGeometryBatchAsync` prefetches a batch of products
+// through one Promise.all over ONE shared `seen` set, so the closure walk
+// skips any record a sibling product already claimed — that sibling has
+// pinned the range, but a pin reserves a chunk against eviction, it does
+// not make it resident, and its read may still be in flight. The faceset
+// payload pass then scanned the shared set and synchronously acquired a
+// record nobody had finished reading:
+//
+//   StepBufferNotResidentError: STEP source range [164128495, 164187850)
+//   is not resident — call ensureResident before synchronous extraction
+//
+// which escaped the prefetch and aborted the whole load on a large model.
+describe("concurrent windowed product prefetch (conway#526)", () => {
+    const CHUNK = 4 * 1024;
+    /**
+     * A store-backed model over a deliberately cramped window: 4 KiB
+     * chunks with 2 resident, so a sibling's chunks are gone by the time
+     * anyone else looks for them.
+     *
+     * @param store The backing store.
+     * @return {Promise<IfcStepModel>} The windowed model.
+     */
+    async function windowedModel(store) {
+        const open = await openStreamedIfcModelFromStore(store, { pool: CHUNK });
+        expect(open.model).toBeDefined();
+        return new IfcStepModel(void 0, open.columns, new WindowedStepBufferProvider(store, CHUNK, 2));
+    }
+    test("a shared seen set does not make one product read records it never paged", async () => {
+        const store = new InMemoryStepByteStore(new Uint8Array(fs.readFileSync("data/index.ifc")));
+        const model = await windowedModel(store);
+        const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+        extraction.quietRecoverableLogging = true;
+        extraction.deferDanglingPlacements = true;
+        const prepPins = await extraction.ensureResidentForDemandPrep();
+        try {
+            extraction.prepareDemandExtraction(true);
+        }
+        finally {
+            model.releaseSourceViews(prepPins);
+            model.unpinLocalIDs(prepPins);
+        }
+        const products = [...model.types(IfcProduct)].map((p) => p.localID);
+        expect(products.length).toBeGreaterThan(1);
+        // The pump's shape: one shared pin set across the batch.
+        const pins = new Set();
+        const leafSpans = [];
+        // Seed the shared set until it holds facesets — not every
+        // product carries tessellated geometry, and the payload pass is
+        // what this is about.
+        let seeded = 0;
+        let claimedFacesets = [];
+        while (seeded < products.length && claimedFacesets.length === 0) {
+            await extraction.ensureResidentForProductExtract(products[seeded++], pins, leafSpans);
+            claimedFacesets = [...pins].filter((id) => model.typeIDOf(id) === EntityTypesIfc.IFCPOLYGONALFACESET);
+        }
+        expect(claimedFacesets.length).toBeGreaterThan(0);
+        expect(seeded).toBeLessThan(products.length);
+        // Now force the state the production race produced by timing:
+        // records that are IN the shared set but NOT resident from the
+        // next caller's point of view. Dropping the pins and filling the
+        // 2-chunk window with an unrelated range evicts them, which is
+        // the same invariant violation as a sibling's read still being
+        // in flight — and unlike the race, it happens every run.
+        model.releaseSourceViews(pins);
+        model.unpinLocalIDs(pins);
+        for (const span of leafSpans) {
+            model.unpinAddressRange(span.address, span.length);
+        }
+        leafSpans.length = 0;
+        const facesetAt = model.recordAddress(claimedFacesets[0]);
+        const far = facesetAt >= CHUNK * 4 ? 0 : store.byteLength - CHUNK * 2;
+        await model.ensureResidentRange(far, CHUNK * 2);
+        // Pre-#526 the payload pass walked the shared set, synchronously
+        // acquired those evicted facesets and threw
+        // StepBufferNotResidentError out of the prefetch, killing the load.
+        await expect(Promise.all(products.slice(seeded).map((localID) => extraction.ensureResidentForProductExtract(localID, pins, leafSpans)))).resolves.toBeDefined();
+        expect(pins.size).toBeGreaterThan(0);
+        model.releaseSourceViews(pins);
+        model.unpinLocalIDs(pins);
+        for (const span of leafSpans) {
+            model.unpinAddressRange(span.address, span.length);
+        }
+    }, 120000);
+    test("the closure walk reports only what THIS call claimed", async () => {
+        const model = await windowedModel(new InMemoryStepByteStore(new Uint8Array(fs.readFileSync("data/index.ifc"))));
+        const products = [...model.types(IfcProduct)].map((p) => p.localID);
+        expect(products.length).toBeGreaterThan(1);
+        // The invariant the payload pass now rests on: with a shared set,
+        // a second walk claims only what the first left unclaimed, so
+        // `claimed` is what this call has actually awaited residency for.
+        const shared = new Set();
+        const firstClaimed = new Set();
+        const secondClaimed = new Set();
+        await model.ensureResidentClosureByLocalID(products[0], void 0, shared, void 0, void 0, void 0, firstClaimed);
+        await model.ensureResidentClosureByLocalID(products[0], void 0, shared, void 0, void 0, void 0, secondClaimed);
+        expect(firstClaimed.size).toBeGreaterThan(0);
+        expect(secondClaimed.size).toBe(0);
+        for (const id of firstClaimed) {
+            expect(shared.has(id)).toBe(true);
+        }
+        model.unpinLocalIDs(shared);
+    }, 120000);
+    test("a product whose paging fails is skipped, not fatal to the batch", async () => {
+        const model = await windowedModel(new InMemoryStepByteStore(new Uint8Array(fs.readFileSync("data/index.ifc"))));
+        const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+        const products = [...model.types(IfcProduct)].map((p) => p.localID);
+        const failing = products[0];
+        // A store read that rejects for one product's closure must not take
+        // the batch — the pump's Promise.all would otherwise reject and the
+        // load dies where a missing product would do.
+        const realEnsure = model.ensureResidentClosureByLocalID.bind(model);
+        model.ensureResidentClosureByLocalID =
+            (localID, ...rest) => {
+                if (localID === failing) {
+                    return Promise.reject(new Error("simulated store read failure"));
+                }
+                return realEnsure(localID, ...rest);
+            };
+        const pins = new Set();
+        await expect(Promise.all(products.slice(0, 4).map((localID) => extraction.ensureResidentForProductExtract(localID, pins)))).resolves.toBeDefined();
+        model.ensureResidentClosureByLocalID = realEnsure;
+        model.releaseSourceViews(pins);
+        model.unpinLocalIDs(pins);
+    }, 120000);
+});