@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/ifc/ifc_spatial_skeleton.js

@@ -0,0 +1,266 @@
+import { RecordFieldCursor } from "../step/parsing/record_field_cursor.js";
+import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
+import { IfcContext, IfcObjectDefinition, IfcRelAggregates, IfcRelContainedInSpatialStructure, IfcSpatialElement, } from "./ifc4_gen/index.js";
+import IfcStepParser from "./ifc_step_parser.js";
+/**
+ * Attribute positions in the serialised record, matching the generated
+ * accessors exactly (`IfcRoot.Name` is `extractString( 2, … )`, and so on).
+ * STEP writes the flattened inherited list, so these are absolute positions in
+ * any subtype's record.
+ */
+const ATTRIBUTE_GLOBAL_ID = 0;
+const ATTRIBUTE_NAME = 2;
+const ATTRIBUTE_LONG_NAME = 7;
+/**
+ * `LongName` sits at a different position on `IfcContext` (`IfcProject`'s
+ * supertype) than on `IfcSpatialElement`, because the two branches inherit
+ * different prefixes — 5 against 7. The generated getters disagree the same
+ * way (`IfcContext.extractString( 5, … )` vs
+ * `IfcSpatialElement.extractString( 7, … )`), and reading the wrong one
+ * silently yields a different attribute, not an error.
+ */
+const ATTRIBUTE_CONTEXT_LONG_NAME = 5;
+const ATTRIBUTE_AGGREGATES_RELATING = 4;
+const ATTRIBUTE_AGGREGATES_RELATED = 5;
+const ATTRIBUTE_CONTAINED_RELATED = 4;
+const ATTRIBUTE_CONTAINED_RELATING = 5;
+/** Initial capacity of the edge columns; both grow by doubling. */
+const INITIAL_EDGES = 1024;
+/**
+ * The spatial subtype closure as a set — the `LongName` test runs per named
+ * record, so it must not be a scan of the closure array.
+ */
+const SPATIAL_TYPES = new Set(IfcSpatialElement.query);
+/** The context closure — `IfcProject` and friends, whose `LongName` is at 5. */
+const CONTEXT_TYPES = new Set(IfcContext.query);
+/**
+ * The spatial **names skeleton** (M2, issue #393): project → site → building →
+ * storey → product, with names, built from the streaming parse's record events
+ * so the tree can be shown while the model is still loading.
+ *
+ * This is the one standard consumer that genuinely belongs on the event path,
+ * and the reason is the record's *bytes*. Everything else M2 wanted —
+ * membership, counts, ids — is in the columnar index and is cheaper (and, for
+ * complex records, only correct) when derived from a prefix snapshot; see
+ * {@link import('../step/parsing/prefix_type_index').PrefixTypeIndex}. Names
+ * and relationship edges are not in the columns, and after the parse they cost
+ * a second pass that pages every relationship and every named record back in
+ * through the windowed provider — which is exactly what Share's post-parse
+ * `'names'` sweep does today.
+ *
+ * What runs per record is deliberately small: tokenize the record's attribute
+ * list, copy out at most three short strings, and append two integers per
+ * edge. Nothing is resolved and no tree is built until {@link tree} is called —
+ * "resolvable" therefore means "present when you asked", and a file that
+ * forward-references its way through the spatial hierarchy simply resolves at
+ * end of stream, with no pending-reference table to maintain.
+ *
+ * Idempotence: the streaming builder's grow-and-restart re-fires records from
+ * localID 0. A non-ascending localID is taken as that restart and clears both
+ * the nodes and the edge columns, so a restarted parse rebuilds rather than
+ * doubling its edges.
+ */
+export class IfcSpatialSkeleton {
+    /**
+     * @param parser The IFC parser whose tokenizer reads the record bytes.
+     * Defaults to the singleton the streaming open uses.
+     */
+    constructor(parser = IfcStepParser.Instance) {
+        this.nodes_ = new Map();
+        this.edgeParents_ = new Uint32Array(INITIAL_EDGES);
+        this.edgeChildren_ = new Uint32Array(INITIAL_EDGES);
+        this.edgeCount_ = 0;
+        this.lastLocalID_ = -1;
+        /**
+         * Record a named object definition. Bound for direct use as a subscription.
+         *
+         * @param localID The record's dense local ID.
+         * @param expressID The record's express ID.
+         * @param typeID The record's concrete type.
+         * @param buffer The live parse window holding the record.
+         * @param byteOffset Offset of the record's attribute list in `buffer`.
+         * @param byteLength Length of the attribute list.
+         */
+        this.handleObject = (localID, expressID, typeID, buffer, byteOffset, byteLength) => {
+            this.noteRestart(localID);
+            if (typeID === void 0 || buffer === void 0 ||
+                byteOffset === void 0 || byteLength === void 0) {
+                return;
+            }
+            if (this.cursor_.open(buffer, byteOffset, byteLength) === 0) {
+                return;
+            }
+            const node = { expressID, type: typeID, children: [] };
+            const globalId = this.cursor_.string(ATTRIBUTE_GLOBAL_ID);
+            const name = this.cursor_.string(ATTRIBUTE_NAME);
+            if (globalId !== void 0) {
+                node.globalId = globalId;
+            }
+            if (name !== void 0) {
+                node.name = name;
+            }
+            // LongName is what a row actually displays when Name is a code. Only
+            // spatial elements and contexts carry it, at different positions.
+            const longNameAt = this.longNameAttribute(typeID);
+            if (longNameAt !== void 0) {
+                const longName = this.cursor_.string(longNameAt);
+                if (longName !== void 0) {
+                    node.longName = longName;
+                }
+            }
+            this.nodes_.set(expressID, node);
+        };
+        /**
+         * Record the containment edges of one relationship. Bound for direct use as
+         * a subscription.
+         *
+         * @param localID The record's dense local ID.
+         * @param expressID The record's express ID.
+         * @param typeID The record's concrete type.
+         * @param buffer The live parse window holding the record.
+         * @param byteOffset Offset of the record's attribute list in `buffer`.
+         * @param byteLength Length of the attribute list.
+         */
+        this.handleRelationship = (localID, expressID, typeID, buffer, byteOffset, byteLength) => {
+            this.noteRestart(localID);
+            if (typeID === void 0 || buffer === void 0 ||
+                byteOffset === void 0 || byteLength === void 0) {
+                return;
+            }
+            if (this.cursor_.open(buffer, byteOffset, byteLength) === 0) {
+                return;
+            }
+            // The two relationships put their parent on opposite sides.
+            const aggregates = typeID === EntityTypesIfc.IFCRELAGGREGATES;
+            const parentIndex = aggregates ? ATTRIBUTE_AGGREGATES_RELATING : ATTRIBUTE_CONTAINED_RELATING;
+            const childrenIndex = aggregates ? ATTRIBUTE_AGGREGATES_RELATED : ATTRIBUTE_CONTAINED_RELATED;
+            const parent = this.cursor_.reference(parentIndex);
+            if (parent === void 0) {
+                return;
+            }
+            this.cursor_.forEachReference(childrenIndex, (child) => {
+                this.pushEdge(parent, child);
+            });
+        };
+        this.cursor_ = new RecordFieldCursor(parser);
+    }
+    /**
+     * Subscribe this skeleton to a dispatcher — the object definitions it names
+     * and the two relationship types it draws edges from.
+     *
+     * @param dispatcher The dispatcher fed by the streaming parse.
+     */
+    subscribe(dispatcher) {
+        dispatcher.on([IfcObjectDefinition], this.handleObject);
+        dispatcher.on([IfcRelAggregates, IfcRelContainedInSpatialStructure], this.handleRelationship);
+    }
+    /**
+     * @return {number} Nodes seen so far (children not yet linked).
+     */
+    get nodeCount() {
+        return this.nodes_.size;
+    }
+    /**
+     * @return {number} Containment edges captured so far.
+     */
+    get edgeCount() {
+        return this.edgeCount_;
+    }
+    /**
+     * Where this type keeps `LongName`, if it has one.
+     *
+     * @param typeID The record's concrete type.
+     * @return {number | undefined} The attribute index, or undefined for types
+     * that carry no `LongName` at all.
+     */
+    longNameAttribute(typeID) {
+        if (SPATIAL_TYPES.has(typeID)) {
+            return ATTRIBUTE_LONG_NAME;
+        }
+        return CONTEXT_TYPES.has(typeID) ? ATTRIBUTE_CONTEXT_LONG_NAME : void 0;
+    }
+    /**
+     * Reset if the parse restarted. localIDs ascend strictly within a run, so a
+     * localID that does not exceed the last one seen means the streaming
+     * builder hit its grow-and-restart valve and is re-firing from 0. Testing
+     * for `localID === 0` would not do: this consumer only sees its subscribed
+     * types, and record 0 is rarely one of them.
+     *
+     * @param localID The record's dense local ID.
+     */
+    noteRestart(localID) {
+        if (localID <= this.lastLocalID_) {
+            this.edgeCount_ = 0;
+            this.nodes_.clear();
+        }
+        this.lastLocalID_ = localID;
+    }
+    /**
+     * Append one containment edge, growing the columns as needed.
+     *
+     * @param parent Express ID of the containing entity.
+     * @param child Express ID of the contained entity.
+     */
+    pushEdge(parent, child) {
+        if (this.edgeCount_ === this.edgeParents_.length) {
+            const parents = new Uint32Array(this.edgeParents_.length * 2);
+            const children = new Uint32Array(this.edgeChildren_.length * 2);
+            parents.set(this.edgeParents_);
+            children.set(this.edgeChildren_);
+            this.edgeParents_ = parents;
+            this.edgeChildren_ = children;
+        }
+        this.edgeParents_[this.edgeCount_] = parent;
+        this.edgeChildren_[this.edgeCount_] = child;
+        ++this.edgeCount_;
+    }
+    /**
+     * Look one node up without building the tree.
+     *
+     * @param expressID The express ID.
+     * @return {SkeletonNode | undefined} The node, if it has been parsed.
+     */
+    node(expressID) {
+        return this.nodes_.get(expressID);
+    }
+    /**
+     * Build the tree over everything parsed so far and return its roots — nodes
+     * that are nobody's child. That is the project once it has been seen, plus
+     * whatever a prefix has not reached the parent of yet, plus the object
+     * definitions that genuinely hang outside the spatial hierarchy (type
+     * objects, ungrouped actors); a caller that wants strictly the spatial tree
+     * should walk down from the project's express ID rather than treat every
+     * root as spatial.
+     *
+     * Each call relinks children from the edge columns, so a caller may call it
+     * repeatedly as the parse advances; the returned nodes are the live ones, so
+     * a previously returned tree is not a snapshot.
+     *
+     * @return {SkeletonNode[]} The roots, in parse order.
+     */
+    tree() {
+        const children = new Set();
+        for (const node of this.nodes_.values()) {
+            node.children.length = 0;
+        }
+        for (let edge = 0; edge < this.edgeCount_; ++edge) {
+            const parent = this.nodes_.get(this.edgeParents_[edge]);
+            const child = this.nodes_.get(this.edgeChildren_[edge]);
+            if (parent === void 0 || child === void 0) {
+                // Either end may be a forward reference the parse has not reached.
+                // Nothing is remembered as pending: the edge is re-read on the next
+                // call, so it links as soon as both ends exist.
+                continue;
+            }
+            parent.children.push(child);
+            children.add(child.expressID);
+        }
+        const roots = [];
+        for (const node of this.nodes_.values()) {
+            if (!children.has(node.expressID)) {
+                roots.push(node);
+            }
+        }
+        return roots;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,199 @@
+/* eslint-disable no-magic-numbers */
+// M2 (#393): the spatial names skeleton built from the streaming parse's
+// record events.
+//
+// The parity bar is the tree Share builds today from the finished model
+// (IfcProperties' spatial structure in 'names' mode): same containment edges,
+// same Name/LongName/GlobalId — but available while the parse runs, and
+// without paging every relationship back in afterwards.
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { BufferByteSource } from "../step/parsing/byte_source.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { buildIndexStreaming } from "../step/parsing/streaming_index_builder.js";
+import { StreamingRecordDispatcher } from "../step/parsing/streaming_record_dispatcher.js";
+import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
+import { IfcSpatialSkeleton } from "./ifc_spatial_skeleton.js";
+import IfcStepParser from "./ifc_step_parser.js";
+let bytes;
+let model;
+beforeAll(() => {
+    bytes = new Uint8Array(fs.readFileSync("data/index.ifc"));
+    const input = new ParsingBuffer(bytes);
+    IfcStepParser.Instance.parseHeader(input);
+    model = IfcStepParser.Instance.parseDataToModel(input)[1];
+});
+/**
+ * Stream the fixture through a skeleton.
+ *
+ * @param onRecord Optional per-record hook, for querying mid-parse.
+ * @return {IfcSpatialSkeleton} The populated skeleton.
+ */
+function streamed(onRecord) {
+    const skeleton = new IfcSpatialSkeleton();
+    const dispatcher = new StreamingRecordDispatcher();
+    skeleton.subscribe(dispatcher);
+    if (onRecord !== void 0) {
+        dispatcher.onAnyRecord((localID) => onRecord(localID));
+    }
+    const result = buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, dispatcher.onRecordIndexed);
+    expect(result.result).toBe(ParseResult.COMPLETE);
+    return skeleton;
+}
+/**
+ * Find a node anywhere in a forest.
+ *
+ * @param roots The forest.
+ * @param expressID The express ID to find.
+ * @return {SkeletonNode | undefined} The node, if present.
+ */
+function find(roots, expressID) {
+    for (const root of roots) {
+        if (root.expressID === expressID) {
+            return root;
+        }
+        const found = find(root.children, expressID);
+        if (found !== void 0) {
+            return found;
+        }
+    }
+    return void 0;
+}
+describe("IfcSpatialSkeleton", () => {
+    test("names come out matching the entities the model decodes", () => {
+        const skeleton = streamed();
+        for (const node of skeleton.tree()) {
+            expectNamesMatchModel(node);
+        }
+    });
+    /**
+     * Assert a node's strings against the model's own decode of that record,
+     * recursively.
+     *
+     * @param node The skeleton node.
+     */
+    function expectNamesMatchModel(node) {
+        const entity = model.getElementByExpressID(node.expressID);
+        expect(entity).toBeDefined();
+        expect(node.globalId).toBe(entity.GlobalId);
+        expect(node.name ?? null).toBe(entity.Name ?? null);
+        // Asserted from the MODEL's side: if the entity has a LongName, the
+        // skeleton must have it too. Testing `node.longName !== undefined` first
+        // would pass a skeleton that silently dropped every LongName it should
+        // have captured — which is exactly how reading the wrong attribute
+        // position for IfcContext went unnoticed.
+        if (typeof entity.LongName === "string") {
+            expect(node.longName).toBe(entity.LongName);
+        }
+        else {
+            expect(node.longName).toBeUndefined();
+        }
+        for (const child of node.children) {
+            expectNamesMatchModel(child);
+        }
+    }
+    test("containment edges match the relationships in the model", () => {
+        const skeleton = streamed();
+        const roots = skeleton.tree();
+        // The project is the spatial root, and its site/storey chain is what the
+        // NavTree draws.
+        const projectID = [...model.expressIDsOfTypes({ query: [EntityTypesIfc.IFCPROJECT] })][0];
+        const project = find(roots, projectID);
+        expect(project).toBeDefined();
+        expect(project.name).toBe("Bldrs");
+        const site = project.children.find((child) => child.type === EntityTypesIfc.IFCSITE);
+        expect(site).toBeDefined();
+        expect(site.name).toBe("Build");
+        const storey = find([site], 154);
+        expect(storey).toBeDefined();
+        expect(storey.type).toBe(EntityTypesIfc.IFCBUILDINGSTOREY);
+        expect(storey.name).toBe("Thing");
+    });
+    test("LongName is read from each branch's own attribute position", () => {
+        // IfcContext keeps LongName at 5 and IfcSpatialElement at 7, because the
+        // two branches inherit different prefixes. A single hard-coded position
+        // reads some other attribute — silently, since both are optional strings.
+        const source = [
+            "ISO-10303-21;",
+            "HEADER;",
+            "FILE_DESCRIPTION((''),'');",
+            "FILE_NAME('','',(''),(''),'','','');",
+            "FILE_SCHEMA(('IFC4'));",
+            "ENDSEC;",
+            "DATA;",
+            "#1= IFCPROJECT('p',$,'PRJ-001',$,$,'Riverside Tower',$,$,$);",
+            "#2= IFCSITE('s',$,'SITE-A',$,$,$,$,'North Parcel',$,$,$,$,$,$);",
+            "#3= IFCRELAGGREGATES('r',$,$,$,#1,(#2));",
+            "ENDSEC;",
+            "END-ISO-10303-21;",
+            "",
+        ].join("\n");
+        const skeleton = new IfcSpatialSkeleton();
+        const dispatcher = new StreamingRecordDispatcher();
+        skeleton.subscribe(dispatcher);
+        const result = buildIndexStreaming(new BufferByteSource(new TextEncoder().encode(source)), IfcStepParser.Instance, 4 * 1024, dispatcher.onRecordIndexed);
+        expect(result.result).toBe(ParseResult.COMPLETE);
+        const project = skeleton.node(1);
+        const site = skeleton.node(2);
+        expect(project?.name).toBe("PRJ-001");
+        expect(project?.longName).toBe("Riverside Tower");
+        expect(site?.name).toBe("SITE-A");
+        expect(site?.longName).toBe("North Parcel");
+    });
+    test("the tree is answerable mid-parse and only grows", () => {
+        const skeleton = new IfcSpatialSkeleton();
+        const dispatcher = new StreamingRecordDispatcher();
+        skeleton.subscribe(dispatcher);
+        const counts = [];
+        dispatcher.onAnyRecord((localID) => {
+            if (localID === 64 || localID === 128) {
+                counts.push(skeleton.nodeCount);
+            }
+        });
+        buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, dispatcher.onRecordIndexed);
+        expect(counts).toHaveLength(2);
+        expect(counts[0]).toBeLessThanOrEqual(counts[1]);
+        expect(counts[1]).toBeLessThanOrEqual(skeleton.nodeCount);
+        expect(skeleton.nodeCount).toBeGreaterThan(0);
+        expect(skeleton.edgeCount).toBeGreaterThan(0);
+    });
+    test("a forward-referenced parent links as soon as both ends exist", () => {
+        // Hostile ordering: the relationship names entities that appear later in
+        // the file. Nothing is remembered as pending — the edge simply links on
+        // the next tree() once both ends have been parsed.
+        const source = [
+            "ISO-10303-21;",
+            "HEADER;",
+            "FILE_DESCRIPTION((''),'');",
+            "FILE_NAME('','',(''),(''),'','','');",
+            "FILE_SCHEMA(('IFC4'));",
+            "ENDSEC;",
+            "DATA;",
+            "#1= IFCRELAGGREGATES('r',$,$,$,#2,(#3));",
+            "#2= IFCPROJECT('p',$,'Late Project',$,$,$,$,$,$);",
+            "#3= IFCSITE('s',$,'Late Site',$,$,$,$,'Long Site',$,$,$,$,$,$);",
+            "ENDSEC;",
+            "END-ISO-10303-21;",
+            "",
+        ].join("\n");
+        const skeleton = new IfcSpatialSkeleton();
+        const dispatcher = new StreamingRecordDispatcher();
+        skeleton.subscribe(dispatcher);
+        const midParse = [];
+        dispatcher.onAnyRecord(() => {
+            midParse.push(skeleton.tree().length);
+        });
+        const result = buildIndexStreaming(new BufferByteSource(new TextEncoder().encode(source)), IfcStepParser.Instance, 4 * 1024, dispatcher.onRecordIndexed);
+        expect(result.result).toBe(ParseResult.COMPLETE);
+        // After the relationship alone, there is nothing to link; by the end the
+        // project owns the site.
+        expect(midParse[0]).toBe(0);
+        const roots = skeleton.tree();
+        expect(roots).toHaveLength(1);
+        expect(roots[0].name).toBe("Late Project");
+        expect(roots[0].children).toHaveLength(1);
+        expect(roots[0].children[0].name).toBe("Late Site");
+        expect(roots[0].children[0].longName).toBe("Long Site");
+    });
+});

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

@@ -1,6 +1,7 @@
 import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
 import StepModelBase from "../step/step_model_base.js";
 import { StepIndexEntry } from "../step/parsing/step_parser.js";
+import { StepIndexColumns } from "../step/parsing/columnar_index.js";
 import { MultiIndexSet } from "../indexing/multi_index_set.js";
 import { IfcModelGeometry } from "./ifc_model_geometry.js";
 import { IfcModelProfile } from "./ifc_model_profile.js";
@@ -8,6 +9,7 @@ import IfcStepExternalMapping from "./ifc_step_external_mapping.js";
 import IfcModelCurves from "./ifc_model_curves.js";
 import { CsgMemoization } from "../core/csg_operations.js";
 import { IfcMaterialCache } from "./ifc_material_cache.js";
+import { StepBufferProvider } from "../step/step_buffer_provider.js";
 /**
  * Represents an IFC model deserialized from step.
  */
@@ -26,9 +28,11 @@ export default class IfcStepModel extends StepModelBase<EntityTypesIfc> {
      * Construct this model given a buffer containing the data and the parsed data index on that,
      * adding the typeIndex on top of that.
      *
-     * @param buffer The buffer to values from.
+     * @param buffer The buffer to values from, or `undefined` with `provider`
+     * set for a windowed (streaming) source.
      * @param elementIndex The parsed index to elements in the STEP.
+     * @param provider Optional pre-built buffer provider (windowed source).
      */
-    constructor(buffer: Uint8Array, elementIndex: StepIndexEntry<EntityTypesIfc>[]);
+    constructor(buffer: Uint8Array | undefined, elementIndex: StepIndexEntry<EntityTypesIfc>[] | StepIndexColumns<EntityTypesIfc>, provider?: StepBufferProvider);
 }
 //# sourceMappingURL=ifc_step_model.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ifc_step_model.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,cAAqC,MAAM,iCAAiC,CAAA;AACnF,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,sBAAsB,MAAM,6BAA6B,CAAA;AAChE,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAE,cAAc,CAAE;IAEvE,SAAgB,SAAS,EAAE,aAAa,CAAE,cAAc,CAAE,CAAA;IAC1D,SAAgB,mBAAmB,gCAAyB;IAC5D,SAAgB,QAAQ,mBAA+B;IACvD,SAAgB,YAAY,mBAAqC;IACjE,SAAgB,QAAQ,kBAA4B;IACpD,SAAgB,MAAM,iBAA2B;IACjD,SAAgB,aAAa,iBAAuB;IACpD,SAAgB,SAAS,mBAA+B;IACxD,SAAgB,aAAa,mBAAqC;IAClE,SAAgB,cAAc,wBAAiB;IAE/C;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,cAAc,CAAE,EAAE;CAKrD"}
+{"version":3,"file":"ifc_step_model.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,cAAqC,MAAM,iCAAiC,CAAA;AACnF,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAA;AAE/D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,sBAAsB,MAAM,6BAA6B,CAAA;AAChE,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAKjE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAE,cAAc,CAAE;IAEvE,SAAgB,SAAS,EAAE,aAAa,CAAE,cAAc,CAAE,CAAA;IAC1D,SAAgB,mBAAmB,gCAAyB;IAC5D,SAAgB,QAAQ,mBAA+B;IACvD,SAAgB,YAAY,mBAAqC;IACjE,SAAgB,QAAQ,kBAA4B;IACpD,SAAgB,MAAM,iBAA2B;IACjD,SAAgB,aAAa,iBAAuB;IACpD,SAAgB,SAAS,mBAA+B;IACxD,SAAgB,aAAa,mBAAqC;IAClE,SAAgB,cAAc,wBAAiB;IAE/C;;;;;;;;OAQG;gBAEC,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,YAAY,EAAE,cAAc,CAAE,cAAc,CAAE,EAAE,GAAG,gBAAgB,CAAE,cAAc,CAAE,EACrF,QAAQ,CAAC,EAAE,kBAAkB;CAKlC"}

package/compiled/src/ifc/ifc_step_model.js

@@ -17,11 +17,13 @@ export default class IfcStepModel extends StepModelBase {
      * Construct this model given a buffer containing the data and the parsed data index on that,
      * adding the typeIndex on top of that.
      *
-     * @param buffer The buffer to values from.
+     * @param buffer The buffer to values from, or `undefined` with `provider`
+     * set for a windowed (streaming) source.
      * @param elementIndex The parsed index to elements in the STEP.
+     * @param provider Optional pre-built buffer provider (windowed source).
      */
-    constructor(buffer, elementIndex) {
-        super(SchemaIfc, buffer, elementIndex);
+    constructor(buffer, elementIndex, provider) {
+        super(SchemaIfc, buffer, elementIndex, provider);
         this.externalMappingType = IfcStepExternalMapping;
         this.geometry = new IfcModelGeometry(this);
         this.voidGeometry = new IfcModelGeometry(this, true);
@@ -31,6 +33,6 @@ export default class IfcStepModel extends StepModelBase {
         this.materials = new IfcMaterialCache(this);
         this.voidMaterials = new IfcMaterialCache(this, true);
         this.elementTypeIDs = EntityTypesIfc;
-        this.typeIndex = indexerInstance.create(elementIndex);
+        this.typeIndex = indexerInstance.createFor(elementIndex);
     }
 }

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

@@ -2,6 +2,8 @@ import ParsingBuffer from "../parsing/parsing_buffer.js";
 import StepParser, { ParseProgressCallback, ParseResult } from "../step/parsing/step_parser.js";
 import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
 import IfcStepModel from "./ifc_step_model.js";
+import { ByteSource, ReadableByteSource } from "../step/parsing/byte_source.js";
+import { StepExternalByteStore } from "../step/step_buffer_provider.js";
 /**
  * Parser for taking IFC file serialized in step and turning them into a lazily parsed model.
  */
@@ -42,5 +44,61 @@ export default class IfcStepParser extends StepParser<EntityTypesIfc> {
         ParseResult,
         IfcStepModel | undefined
     ]>;
+    /**
+     * Build a model by streaming the source through a bounded moving window
+     * (see buildIndexStreaming / M0) rather than parsing one resident buffer,
+     * then backing the model with a windowed provider over `store` — so the
+     * source is never held fully resident in the JS heap.
+     *
+     * `source` serves the parse (synchronous windowed reads — on a worker this
+     * is an OPFS sync-access handle; in node/tests a file descriptor or buffer)
+     * and `store` serves the model's post-parse property access (asynchronous
+     * windowed reads paged in on demand — OPFS `File.slice()` in the browser).
+     * Both view the same file bytes, so the file-absolute addresses the index
+     * records resolve identically through either.
+     *
+     * NOTE (M1 scope): this delivers the bounded-memory *parse*. Synchronous
+     * geometry extraction still needs its record ranges resident — as after
+     * `spillSourceToExternalStore` — so a caller that extracts geometry must
+     * `ensureResident` first (demand-driven geometry is M3). Property / index
+     * access works directly via the async surfaces.
+     *
+     * @param source Synchronous byte source feeding the streaming parse.
+     * @param store Async external store backing the windowed model.
+     * @param opts Optional window sizing: `pool` (parse window),
+     * `chunkBytes` / `maxResidentChunks` (model window).
+     * @return {[ParseResult, IfcStepModel | undefined]} The parse result and
+     * the windowed model.
+     */
+    parseStreamToModel(source: ByteSource, store: StepExternalByteStore, opts?: {
+        pool?: number;
+        chunkBytes?: number;
+        maxResidentChunks?: number;
+    }): [
+        ParseResult,
+        IfcStepModel | undefined
+    ];
+    /**
+     * Cooperative twin of {@link parseStreamToModel}: the index build
+     * yields to the event loop and can fill windows from an async
+     * {@link ReadableByteSource} (an OPFS `File.slice()` store). The
+     * model is still windowed — geometry extract must
+     * `ensureResident` first.
+     *
+     * @param source Sync or async byte source feeding the parse.
+     * @param store Async external store backing the windowed model.
+     * @param opts Optional window sizing plus parse progress.
+     * @return {Promise<[ParseResult, IfcStepModel | undefined]>} The
+     * parse result and the windowed model.
+     */
+    parseStreamToModelAsync(source: ReadableByteSource, store: StepExternalByteStore, opts?: {
+        pool?: number;
+        chunkBytes?: number;
+        maxResidentChunks?: number;
+        onProgress?: (absoluteByteCursor: number) => void;
+    }): Promise<[
+        ParseResult,
+        IfcStepModel | undefined
+    ]>;
 }
 //# sourceMappingURL=ifc_step_parser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ifc_step_parser.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_parser.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,2BAA2B,CAAA;AACrD,OAAO,UAAU,EAAE,EAAC,qBAAqB,EAAE,WAAW,EAAC,MAAM,6BAA6B,CAAA;AAC1F,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAE5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAE3C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAE,cAAc,CAAE;IACrE;;OAEG;;IAKH;;;;;OAKG;IACH,gBAAuB,QAAQ,gBAAsB;IAErD;;;;;;;OAOG;IACI,gBAAgB,CACnB,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAAI,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IAMjF;;;;;;;;OAQG;IACU,qBAAqB,CAC9B,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC,CAAC;CAKrD"}
+{"version":3,"file":"ifc_step_parser.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_parser.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,2BAA2B,CAAA;AACrD,OAAO,UAAU,EAAE,EAAC,qBAAqB,EAAE,WAAW,EAAC,MAAM,6BAA6B,CAAA;AAC1F,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAE5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAK5E,OAAO,EACL,qBAAqB,EAEtB,MAAM,8BAA8B,CAAA;AAOrC;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAE,cAAc,CAAE;IACrE;;OAEG;;IAKH;;;;;OAKG;IACH,gBAAuB,QAAQ,gBAAsB;IAErD;;;;;;;OAOG;IACI,gBAAgB,CACnB,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAAI,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IAMjF;;;;;;;;OAQG;IACU,qBAAqB,CAC9B,KAAK,EAAE,aAAa,EACpB,UAAU,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC,CAAC;IAMpD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,kBAAkB,CACrB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,qBAAqB,EAC5B,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAE,GACzE;QAAC,WAAW;QAAE,YAAY,GAAG,SAAS;KAAC;IAmB3C;;;;;;;;;;;;OAYG;IACU,uBAAuB,CAChC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,qBAAqB,EAC5B,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,iBAAiB,CAAC,EAAE,MAAM,CAAA;QAC1B,UAAU,CAAC,EAAE,CAAE,kBAAkB,EAAE,MAAM,KAAM,IAAI,CAAA;KACpD,GACD,OAAO,CAAC,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC,CAAC;CAkBrD"}