@bldrs-ai/conway 1.413.1255 → 1.417.1262

package/compiled/src/ifc/ifc_geometry_extraction.js

@@ -139,6 +139,9 @@ export class IfcGeometryExtraction {
         this.geometryTypeCounts = new Map();
         this.csgDepth = 0;
         this.freeVectorPolygonalFaces_ = [];
+        // Guards prepareExtractionMaps_ so the demand path and the whole-model
+        // walk can both trigger it without duplicating work.
+        this.extractionMapsPrepared_ = false;
         this.csgMemoization = !this.lowMemoryMode;
         this.materials = model.materials;
         this.scene = new IfcSceneBuilder(model, conwayModel, this.materials);
@@ -4364,6 +4367,223 @@ export class IfcGeometryExtraction {
            fs.writeFileSync(outputFilePath, objContent, 'utf8')
         } */
     }
+    /**
+     * One-time extraction setup shared by the whole-model walk and the
+     * per-product demand path (Phase B2): linear scaling factor and the
+     * cross-product maps (materials, material definitions, rel-voids, styled
+     * items). Idempotent.
+     */
+    prepareExtractionMaps_() {
+        if (this.extractionMapsPrepared_) {
+            return;
+        }
+        this.extractionMapsPrepared_ = true;
+        this.extractLinearScalingFactor();
+        // populate relMaterialsMap
+        const relAssociatesMaterials = this.model.types(IfcRelAssociatesMaterial);
+        for (const relAssociateMaterial of relAssociatesMaterials) {
+            const relatingMaterial = relAssociateMaterial.RelatingMaterial;
+            try {
+                const relatedObjects = relAssociateMaterial.RelatedObjects;
+                for (const relatedObject of relatedObjects) {
+                    const product = relatedObject;
+                    if (product instanceof IfcProduct) {
+                        if (product instanceof IfcOpeningElement ||
+                            product instanceof IfcSpace ||
+                            product instanceof IfcOpeningStandardCase) {
+                            continue;
+                        }
+                        // save mapping of IfcProduct --> IfcMaterial
+                        this.materials.relMaterialsMap.set(product.localID, relatingMaterial.localID);
+                    }
+                    else {
+                        //     Logger.warning(`type other than IfcProduct: ${EntityTypesIfc[product.type]}`)
+                    }
+                }
+            }
+            catch (ex) {
+                if (ex instanceof Error) {
+                    if (MATERIAL_RELATED_OBJECTS_PERMISSIVE) {
+                        Logger.error("Error processing relatingMaterial expressID: " +
+                            `${relatingMaterial.expressID}, error: ${ex.message}`);
+                    }
+                    else {
+                        throw ex;
+                    }
+                }
+                else {
+                    Logger.error("Unknown exception processing IfcRelAssociateMaterials.");
+                }
+            }
+        }
+        // populate MaterialDefinitionsMap
+        this.populateMaterialDefinitionsMap();
+        // populate relvoids map
+        this.populateRelVoidsMap();
+        // populate styled items map
+        this.populateStyledItemsMap();
+    }
+    /**
+     * Prepare for per-product demand extraction (Phase B2) without running the
+     * whole-model walk: populates the shared extraction maps so
+     * {@link extractProductGeometryByLocalID} can extract any single product.
+     * Idempotent; the whole-model walk shares the same preparation.
+     */
+    prepareDemandExtraction() {
+        this.prepareExtractionMaps_();
+    }
+    /**
+     * Extract one product's geometry into the scene by local ID — the demand
+     * path's entry (Phase B2). Requires {@link prepareDemandExtraction} (or a
+     * prior whole-model walk) so the shared maps exist.
+     *
+     * Note: products that are targets of IfcRelAggregates whose relating
+     * object carries rel-voids get those master voids only on the whole-model
+     * walk; the demand path extracts the product's own voids. The parity gate
+     * for this seam is the whole-model digest CI.
+     *
+     * @param localID The product's local ID.
+     * @return {boolean} True if the local ID was an IfcProduct and was
+     * extracted; false if it wasn't a product.
+     */
+    extractProductGeometryByLocalID(localID) {
+        this.prepareExtractionMaps_();
+        const element = this.model.getElementByLocalID(localID);
+        if (!(element instanceof IfcProduct)) {
+            return false;
+        }
+        this.extractProductGeometry(element);
+        return true;
+    }
+    /**
+     * Extract one product's geometry into the scene: placement, material /
+     * style extraction, representation items (including mapped items) and
+     * rel-void application. The deduplicated body of the whole-model walk's
+     * two product loops (plain products + rel-aggregates), shared with the
+     * per-product demand path.
+     *
+     * @param product The product to extract.
+     * @param precomputedRelVoids Optional caller-owned rel-voids (the
+     * rel-aggregates "master" case): when supplied the caller retains
+     * ownership and this method does not delete the mesh vector; when
+     * omitted, voids are extracted per product and freed here.
+     */
+    extractProductGeometry(product, precomputedRelVoids) {
+        this.scene.clearParentStack();
+        const isSpace = product instanceof IfcOpeningElement ||
+            product instanceof IfcSpace ||
+            product instanceof IfcOpeningStandardCase;
+        const objectPlacement = product.ObjectPlacement;
+        if (objectPlacement !== null) {
+            this.extractPlacement(objectPlacement);
+        }
+        const representations = product.Representation;
+        if (representations === null) {
+            return;
+        }
+        // extract styledItem material
+        const styledItemID = this.extractMaterialStyle(product);
+        let hasRelVoid = false;
+        const extractRelVoidsResult = precomputedRelVoids ?? this.extractRelVoids(product);
+        let relVoidsMeshVector;
+        let relVoidLocalIDs;
+        if (extractRelVoidsResult !== void 0) {
+            [relVoidsMeshVector, relVoidLocalIDs] = extractRelVoidsResult;
+        }
+        if (relVoidsMeshVector !== void 0) {
+            hasRelVoid = true;
+        }
+        if (styledItemID !== void 0) {
+            // optimization: extract the first representation item and cache
+            // the styleID to apply to the rest of the product geometry
+            const styledItem = this.model.getElementByLocalID(styledItemID);
+            let reusableStyleID;
+            for (const representation of representations.Representations) {
+                if (representation instanceof IfcShapeRepresentation) {
+                    // this check is essential -
+                    // if RepresentationIdentifier !== Body or Facetation we must skip it
+                    if (representation.RepresentationIdentifier !== "Body" &&
+                        representation.RepresentationIdentifier !== "Facetation") {
+                        continue;
+                    }
+                }
+                for (const item of representation.Items) {
+                    if (item instanceof IfcMappedItem) {
+                        this.extractMappedItem(item, product, hasRelVoid, isSpace);
+                    }
+                    else {
+                        try {
+                            this.extractRepresentationItem(item, product.localID, hasRelVoid, isSpace);
+                            if (hasRelVoid) {
+                                this.applyRelVoidToRepresentation(item, relVoidsMeshVector, product.localID, relVoidLocalIDs, void 0, isSpace);
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof Error) {
+                                Logger.error(`Error extracting representation item\n\t${error.message}\n\tExpress ID: #${item.expressID}`);
+                            }
+                            else {
+                                Logger.error(`Error extracting representation item\n\tExpress ID: #${item.expressID}`);
+                            }
+                        }
+                    }
+                    const styledItemLocalID_ = this.materials.styledItemMap.get(item.localID);
+                    if (styledItemLocalID_ !== undefined) {
+                        const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
+                        this.extractStyledItem(styledItem_);
+                    }
+                    else if (reusableStyleID !== void 0) {
+                        this.materials.addGeometryMapping(item.localID, reusableStyleID);
+                    }
+                    else if (styledItem instanceof IfcStyledItem) {
+                        // here we have the styled item, apply it to all geometry in this IfcProduct
+                        reusableStyleID = this.extractStyledItem(styledItem, item);
+                    }
+                }
+            }
+        }
+        else {
+            for (const representation of representations.Representations) {
+                if (representation instanceof IfcShapeRepresentation) {
+                    // this check is essential -
+                    // if RepresentationIdentifier !== Body or Facetation we must skip it
+                    if (representation.RepresentationIdentifier !== "Body" &&
+                        representation.RepresentationIdentifier !== "Facetation") {
+                        continue;
+                    }
+                }
+                for (const item of representation.Items) {
+                    if (item instanceof IfcMappedItem) {
+                        this.extractMappedItem(item, product, hasRelVoid, isSpace);
+                    }
+                    else {
+                        try {
+                            this.extractRepresentationItem(item, product.localID, hasRelVoid, isSpace);
+                            if (hasRelVoid) {
+                                this.applyRelVoidToRepresentation(item, relVoidsMeshVector, product.localID, relVoidLocalIDs, void 0, isSpace);
+                            }
+                            const styledItemLocalID_ = this.materials.styledItemMap.get(item.localID);
+                            if (styledItemLocalID_ !== void 0) {
+                                const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
+                                this.extractStyledItem(styledItem_);
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof Error) {
+                                Logger.error(`Error extracting representation item\n\t${error.message}\n\t${error.stack}\n\tExpress ID: #${item.localID}`);
+                            }
+                            else {
+                                Logger.error(`Unknown error extracting representation item Express ID: #${item.localID}`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (precomputedRelVoids === void 0) {
+            relVoidsMeshVector?.delete();
+        }
+    }
     /**
      * Extract the geometry data from the IFC
      *
@@ -4444,10 +4664,7 @@ export class IfcGeometryExtraction {
      */
     *extractIFCGeometryDataIncremental() {
         let result = ExtractResult.INCOMPLETE;
-        this.extractLinearScalingFactor();
         const previousMemoizationState = this.model.elementMemoization;
-        // populate relMaterialsMap
-        const relAssociatesMaterials = this.model.types(IfcRelAssociatesMaterial);
         try {
             // 256 meg limit for memoization - smaller models get a big
             // win from memoization, but much larger models it uses far too much heap.
@@ -4456,47 +4673,7 @@ export class IfcGeometryExtraction {
             if (this.lowMemoryMode || this.model.bufferBytesize > MEMOIZATION_THRESHOLD) {
                 this.model.elementMemoization = false;
             }
-            for (const relAssociateMaterial of relAssociatesMaterials) {
-                const relatingMaterial = relAssociateMaterial.RelatingMaterial;
-                try {
-                    const relatedObjects = relAssociateMaterial.RelatedObjects;
-                    for (const relatedObject of relatedObjects) {
-                        const product = relatedObject;
-                        if (product instanceof IfcProduct) {
-                            if (product instanceof IfcOpeningElement ||
-                                product instanceof IfcSpace ||
-                                product instanceof IfcOpeningStandardCase) {
-                                continue;
-                            }
-                            // save mapping of IfcProduct --> IfcMaterial
-                            this.materials.relMaterialsMap.set(product.localID, relatingMaterial.localID);
-                        }
-                        else {
-                            //     Logger.warning(`type other than IfcProduct: ${EntityTypesIfc[product.type]}`)
-                        }
-                    }
-                }
-                catch (ex) {
-                    if (ex instanceof Error) {
-                        if (MATERIAL_RELATED_OBJECTS_PERMISSIVE) {
-                            Logger.error("Error processing relatingMaterial expressID: " +
-                                `${relatingMaterial.expressID}, error: ${ex.message}`);
-                        }
-                        else {
-                            throw ex;
-                        }
-                    }
-                    else {
-                        Logger.error("Unknown exception processing IfcRelAssociateMaterials.");
-                    }
-                }
-            }
-            // populate MaterialDefinitionsMap
-            this.populateMaterialDefinitionsMap();
-            // populate relvoids map
-            this.populateRelVoidsMap();
-            // populate styled items map
-            this.populateStyledItemsMap();
+            this.prepareExtractionMaps_();
             const products = this.model.types(IfcProduct);
             // Prefix-sum counts (no iteration/materialization) — see typeCount.
             // Slight over-count from multi-mapped elements just leaves the bar
@@ -4505,117 +4682,7 @@ export class IfcGeometryExtraction {
             let completedItems = 0;
             for (const product of products) {
                 yield [++completedItems, totalItems];
-                this.scene.clearParentStack();
-                const isSpace = product instanceof IfcOpeningElement ||
-                    product instanceof IfcSpace ||
-                    product instanceof IfcOpeningStandardCase;
-                const objectPlacement = product.ObjectPlacement;
-                if (objectPlacement !== null) {
-                    this.extractPlacement(objectPlacement);
-                }
-                const representations = product.Representation;
-                if (representations !== null) {
-                    // extract styledItem material
-                    const styledItemID = this.extractMaterialStyle(product);
-                    let hasRelVoid = false;
-                    const extractRelVoidsResult = this.extractRelVoids(product);
-                    let relVoidsMeshVector;
-                    let relVoidLocalIDs;
-                    if (extractRelVoidsResult !== void 0) {
-                        [relVoidsMeshVector, relVoidLocalIDs] = extractRelVoidsResult;
-                    }
-                    if (relVoidsMeshVector !== void 0) {
-                        hasRelVoid = true;
-                    }
-                    if (styledItemID !== void 0) {
-                        // optimization: extract the first representation item and cache
-                        // the styleID to apply to the rest of the product geometry
-                        const styledItem = this.model.getElementByLocalID(styledItemID);
-                        let reusableStyleID;
-                        for (const representation of representations.Representations) {
-                            if (representation instanceof IfcShapeRepresentation) {
-                                // this check is essential -
-                                // if RepresentationIdentifier !== Body or Facetation we must skip it
-                                if (representation.RepresentationIdentifier !== "Body" &&
-                                    representation.RepresentationIdentifier !== "Facetation") {
-                                    continue;
-                                }
-                            }
-                            for (const item of representation.Items) {
-                                if (item instanceof IfcMappedItem) {
-                                    this.extractMappedItem(item, product, hasRelVoid, isSpace);
-                                }
-                                else {
-                                    try {
-                                        this.extractRepresentationItem(item, product.localID, hasRelVoid, isSpace);
-                                        if (hasRelVoid) {
-                                            this.applyRelVoidToRepresentation(item, relVoidsMeshVector, product.localID, relVoidLocalIDs, void 0, isSpace);
-                                        }
-                                    }
-                                    catch (error) {
-                                        if (error instanceof Error) {
-                                            Logger.error(`Error extracting representation item\n\t${error.message}\n\tExpress ID: #${item.expressID}`);
-                                        }
-                                        else {
-                                            Logger.error(`Error extracting representation item\n\tExpress ID: #${item.expressID}`);
-                                        }
-                                    }
-                                }
-                                const styledItemLocalID_ = this.materials.styledItemMap.get(item.localID);
-                                if (styledItemLocalID_ !== undefined) {
-                                    const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
-                                    this.extractStyledItem(styledItem_);
-                                }
-                                else if (reusableStyleID !== void 0) {
-                                    this.materials.addGeometryMapping(item.localID, reusableStyleID);
-                                }
-                                else if (styledItem instanceof IfcStyledItem) {
-                                    // here we have the styled item, apply it to all geometry in this IfcProduct
-                                    reusableStyleID = this.extractStyledItem(styledItem, item);
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        for (const representation of representations.Representations) {
-                            if (representation instanceof IfcShapeRepresentation) {
-                                // this check is essential -
-                                // if RepresentationIdentifier !== Body or Facetation we must skip it
-                                if (representation.RepresentationIdentifier !== "Body" &&
-                                    representation.RepresentationIdentifier !== "Facetation") {
-                                    continue;
-                                }
-                            }
-                            for (const item of representation.Items) {
-                                if (item instanceof IfcMappedItem) {
-                                    this.extractMappedItem(item, product, hasRelVoid, isSpace);
-                                }
-                                else {
-                                    try {
-                                        this.extractRepresentationItem(item, product.localID, hasRelVoid, isSpace);
-                                        if (hasRelVoid) {
-                                            this.applyRelVoidToRepresentation(item, relVoidsMeshVector, product.localID, relVoidLocalIDs, void 0, isSpace);
-                                        }
-                                        const styledItemLocalID_ = this.materials.styledItemMap.get(item.localID);
-                                        if (styledItemLocalID_ !== void 0) {
-                                            const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
-                                            this.extractStyledItem(styledItem_);
-                                        }
-                                    }
-                                    catch (error) {
-                                        if (error instanceof Error) {
-                                            Logger.error(`Error extracting representation item\n\t${error.message}\n\t${error.stack}\n\tExpress ID: #${item.localID}`);
-                                        }
-                                        else {
-                                            Logger.error(`Unknown error extracting representation item Express ID: #${item.localID}`);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    relVoidsMeshVector?.delete();
-                }
+                this.extractProductGeometry(product);
             }
             const relAggregates = this.model.types(IfcRelAggregates);
             for (const relAggregate of relAggregates) {
@@ -4632,120 +4699,7 @@ export class IfcGeometryExtraction {
                     const relatedObjects = relAggregate.RelatedObjects;
                     for (const productRepresentation of relatedObjects) {
                         if (productRepresentation instanceof IfcProduct) {
-                            const isSpace = productRepresentation instanceof IfcOpeningElement ||
-                                productRepresentation instanceof IfcSpace ||
-                                productRepresentation instanceof IfcOpeningStandardCase;
-                            const product = productRepresentation;
-                            this.scene.clearParentStack();
-                            const objectPlacement = product.ObjectPlacement;
-                            if (objectPlacement !== null) {
-                                this.extractPlacement(objectPlacement);
-                            }
-                            const representations = product.Representation;
-                            if (representations !== null) {
-                                // extract styledItem material
-                                const styledItemID = this.extractMaterialStyle(product);
-                                const extractRelVoidsResult = masterRelVoids ?? this.extractRelVoids(product);
-                                let hasRelVoid = false;
-                                let relVoidsMeshVector;
-                                let relVoidLocalIDs;
-                                if (extractRelVoidsResult !== void 0) {
-                                    [relVoidsMeshVector, relVoidLocalIDs] = extractRelVoidsResult;
-                                }
-                                if (relVoidsMeshVector !== void 0) {
-                                    hasRelVoid = true;
-                                }
-                                if (styledItemID !== void 0) {
-                                    // optimization: extract the first representation item and cache
-                                    // the styleID to apply to the rest of the product geometry
-                                    const styledItem = this.model.getElementByLocalID(styledItemID);
-                                    let reusableStyleID;
-                                    for (const representation of representations.Representations) {
-                                        if (representation instanceof IfcShapeRepresentation) {
-                                            // this check is essential -
-                                            // if RepresentationIdentifier !== Body or Facetation we must skip it
-                                            if (representation.RepresentationIdentifier !== "Body" &&
-                                                representation.RepresentationIdentifier !== "Facetation") {
-                                                continue;
-                                            }
-                                        }
-                                        for (const item of representation.Items) {
-                                            if (item instanceof IfcMappedItem) {
-                                                this.extractMappedItem(item, product, hasRelVoid, isSpace);
-                                            }
-                                            else {
-                                                try {
-                                                    this.extractRepresentationItem(item, product.localID, hasRelVoid, isSpace);
-                                                    if (hasRelVoid) {
-                                                        this.applyRelVoidToRepresentation(item, relVoidsMeshVector, product.localID, relVoidLocalIDs, void 0, isSpace);
-                                                    }
-                                                }
-                                                catch (error) {
-                                                    if (error instanceof Error) {
-                                                        Logger.error(`Error extracting rel aggregate representation item\n\t${error.message}\n\t${error.stack}\n\t Express ID: #${item.expressID}`);
-                                                    }
-                                                    else {
-                                                        Logger.error(`Unknown error extracting rel aggregate representation item Express ID: #${item.expressID}`);
-                                                    }
-                                                }
-                                            }
-                                            const styledItemLocalID_ = this.materials.styledItemMap.get(item.localID);
-                                            if (styledItemLocalID_ !== undefined) {
-                                                const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
-                                                this.extractStyledItem(styledItem_);
-                                            }
-                                            else if (reusableStyleID !== void 0) {
-                                                this.materials.addGeometryMapping(item.localID, reusableStyleID);
-                                            }
-                                            else if (styledItem instanceof IfcStyledItem) {
-                                                // here we have the styled item, apply it to all geometry in this IfcProduct
-                                                reusableStyleID = this.extractStyledItem(styledItem, item);
-                                            }
-                                        }
-                                    }
-                                }
-                                else {
-                                    for (const representation of representations.Representations) {
-                                        if (representation instanceof IfcShapeRepresentation) {
-                                            // this check is essential -
-                                            // if RepresentationIdentifier !== Body or Facetation we must skip it
-                                            if (representation.RepresentationIdentifier !== "Body" &&
-                                                representation.RepresentationIdentifier !== "Facetation") {
-                                                continue;
-                                            }
-                                        }
-                                        for (const item of representation.Items) {
-                                            if (item instanceof IfcMappedItem) {
-                                                this.extractMappedItem(item, product, hasRelVoid, isSpace);
-                                            }
-                                            else {
-                                                try {
-                                                    this.extractRepresentationItem(item, product.localID, hasRelVoid, isSpace);
-                                                    if (hasRelVoid) {
-                                                        this.applyRelVoidToRepresentation(item, relVoidsMeshVector, product.localID, relVoidLocalIDs, void 0, isSpace);
-                                                    }
-                                                    const styledItemLocalID_ = this.materials.styledItemMap.get(item.localID);
-                                                    if (styledItemLocalID_ !== void 0) {
-                                                        const styledItem_ = this.model.getElementByLocalID(styledItemLocalID_);
-                                                        this.extractStyledItem(styledItem_);
-                                                    }
-                                                }
-                                                catch (error) {
-                                                    if (error instanceof Error) {
-                                                        Logger.error(`Error extracting rel aggregate representation item\n\t${error.message}\n\t${error.stack}\n\t Express ID: #${item.expressID}`);
-                                                    }
-                                                    else {
-                                                        Logger.error(`Unknown error extracting rel aggregate representation item Express ID: #${item.expressID}`);
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                                if (masterRelVoids === void 0) {
-                                    relVoidsMeshVector?.delete();
-                                }
-                            }
+                            this.extractProductGeometry(productRepresentation, masterRelVoids);
                         }
                     }
                     if (masterRelVoids !== void 0) {

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

@@ -0,0 +1,68 @@
+import { ByteSource } from "../step/parsing/byte_source.js";
+import { StepIndexColumns } from "../step/parsing/columnar_index.js";
+import { StreamingIndexStats } from "../step/parsing/streaming_index_builder.js";
+import { ParseResult, StepHeader } from "../step/parsing/step_parser.js";
+import { StepExternalByteStore } from "../step/step_buffer_provider.js";
+import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
+import IfcStepModel from "./ifc_step_model.js";
+/**
+ * Options for a streamed IFC open. All optional; defaults suit a browser
+ * worker over an OPFS-backed store.
+ */
+export interface StreamedIfcOpenOptions {
+    /** Parse window size in bytes (default 1 MiB). */
+    pool?: number;
+    /** Windowed provider chunk size (default: provider's). */
+    chunkBytes?: number;
+    /** Windowed provider LRU cap in chunks (default: provider's). */
+    maxResidentChunks?: number;
+    /**
+     * Live per-record event `(localID, expressID, typeID)` — the M2 seam for
+     * incremental consumers (type index, roots, cross-refs) that run while
+     * the model is still parsing. Must be synchronous and cheap.
+     */
+    onRecordIndexed?: (localID: number, expressID: number, typeID: EntityTypesIfc | undefined) => void;
+}
+/**
+ * The result of a streamed IFC open: the windowed-source model plus the
+ * artifacts a consumer needs around it.
+ */
+export interface StreamedIfcOpen {
+    /** The model over the windowed source (undefined if the parse failed). */
+    model: IfcStepModel | undefined;
+    /** The parse result. */
+    result: ParseResult;
+    /** The STEP header (available even on some failed parses). */
+    header: StepHeader;
+    /**
+     * The columnar index the model was built from. Hand to
+     * `serializeIndexSidecarFromColumns` (with a source hash) to produce the
+     * revisit sidecar — the columns ARE the sidecar payload (M7 identity).
+     */
+    columns: StepIndexColumns<EntityTypesIfc>;
+    /** Window diagnostics from the streaming build. */
+    stats: StreamingIndexStats;
+}
+/**
+ * Open an IFC model from a streamed source with a **fixed-memory parse**
+ * (the release-facing Phase B API; composes M0/M1a/M7):
+ *
+ *  - the index builds through a moving window over `source` — the source is
+ *    never resident in the JS heap, and the index is columnar from birth
+ *    (no per-record object phase);
+ *  - the model reads source bytes on demand through a windowed LRU provider
+ *    over `store` (`ensureResidentByLocalID`/`ByExpressID` page ranges in
+ *    before synchronous reads — see `DemandResidencyPump` for the demand
+ *    orchestration).
+ *
+ * The typical browser wiring: a worker streams the network body **through**
+ * to OPFS while feeding the same bytes to `source`; `store` reads back from
+ * OPFS. `source.byteLength` and `store.byteLength` must agree.
+ *
+ * @param source The sequential parse source.
+ * @param store The random-access store the model reads from afterwards.
+ * @param options See {@link StreamedIfcOpenOptions}.
+ * @return {StreamedIfcOpen} The model + header, columns, and diagnostics.
+ */
+export declare function openStreamedIfcModel(source: ByteSource, store: StepExternalByteStore, options?: StreamedIfcOpenOptions): StreamedIfcOpen;
+//# sourceMappingURL=ifc_stream_open.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_stream_open.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_stream_open.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAEL,mBAAmB,EACpB,MAAM,yCAAyC,CAAA;AAChD,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EACL,qBAAqB,EAEtB,MAAM,8BAA8B,CAAA;AACrC,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAC5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAI3C;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IAErC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;;;OAIG;IACH,eAAe,CAAC,EACd,CAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,SAAS,KAAM,IAAI,CAAA;CACrF;AAGD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAE9B,0EAA0E;IAC1E,KAAK,EAAE,YAAY,GAAG,SAAS,CAAA;IAE/B,wBAAwB;IACxB,MAAM,EAAE,WAAW,CAAA;IAEnB,8DAA8D;IAC9D,MAAM,EAAE,UAAU,CAAA;IAElB;;;;OAIG;IACH,OAAO,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAA;IAEzC,mDAAmD;IACnD,KAAK,EAAE,mBAAmB,CAAA;CAC3B;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,qBAAqB,EAC5B,OAAO,CAAC,EAAE,sBAAsB,GAAI,eAAe,CA4BtD"}

package/compiled/src/ifc/ifc_stream_open.js

@@ -0,0 +1,46 @@
+import { buildColumnarIndexStreaming, } from "../step/parsing/streaming_index_builder.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { WindowedStepBufferProvider, } from "../step/step_buffer_provider.js";
+import IfcStepModel from "./ifc_step_model.js";
+import IfcStepParser from "./ifc_step_parser.js";
+// eslint-disable-next-line no-magic-numbers
+const DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
+/**
+ * Open an IFC model from a streamed source with a **fixed-memory parse**
+ * (the release-facing Phase B API; composes M0/M1a/M7):
+ *
+ *  - the index builds through a moving window over `source` — the source is
+ *    never resident in the JS heap, and the index is columnar from birth
+ *    (no per-record object phase);
+ *  - the model reads source bytes on demand through a windowed LRU provider
+ *    over `store` (`ensureResidentByLocalID`/`ByExpressID` page ranges in
+ *    before synchronous reads — see `DemandResidencyPump` for the demand
+ *    orchestration).
+ *
+ * The typical browser wiring: a worker streams the network body **through**
+ * to OPFS while feeding the same bytes to `source`; `store` reads back from
+ * OPFS. `source.byteLength` and `store.byteLength` must agree.
+ *
+ * @param source The sequential parse source.
+ * @param store The random-access store the model reads from afterwards.
+ * @param options See {@link StreamedIfcOpenOptions}.
+ * @return {StreamedIfcOpen} The model + header, columns, and diagnostics.
+ */
+export function openStreamedIfcModel(source, store, options) {
+    if (store.byteLength !== source.byteLength) {
+        throw new Error(`Streaming store byteLength ${store.byteLength} does not match ` +
+            `source byteLength ${source.byteLength}`);
+    }
+    const { header, columns, result, stats } = buildColumnarIndexStreaming(source, IfcStepParser.Instance, options?.pool ?? DEFAULT_STREAM_POOL_BYTES, options?.onRecordIndexed);
+    if (result !== ParseResult.COMPLETE) {
+        return { model: void 0, result, header, columns, stats };
+    }
+    const provider = new WindowedStepBufferProvider(store, options?.chunkBytes, options?.maxResidentChunks);
+    return {
+        model: new IfcStepModel(void 0, columns, provider),
+        result,
+        header,
+        columns,
+        stats,
+    };
+}

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

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

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

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