@bldrs-ai/conway 1.509.1435 → 1.511.1441

package/compiled/src/ifc/ifc_geometry_extraction.js

@@ -4430,8 +4430,13 @@ export class IfcGeometryExtraction {
         const styledItems = this.model.types(IfcStyledItem);
         for (const styledItem of styledItems) {
             try {
-                if (styledItem.Item !== null) {
-                    this.materials.styledItemMap.set(styledItem.Item.localID, styledItem.localID);
+                // IfcStyledItem.Item — same vtable slot as the generated
+                // getter's extractElement(0, 0, 1, true, ...). Hydrating Item
+                // would acquire the faceset record (often the packed geometry
+                // itself) for every styled item at once.
+                const itemLocalID = styledItem.extractReferenceLocalID(0, 0, 1, true);
+                if (itemLocalID !== null) {
+                    this.materials.styledItemMap.set(itemLocalID, styledItem.localID);
                 }
             }
             catch (ex) {
@@ -4736,6 +4741,141 @@ export class IfcGeometryExtraction {
         this.extractProductGeometry(element);
         return true;
     }
+    /**
+     * Page in every record {@link prepareDemandExtraction} will read, so
+     * the relationship sweeps succeed on a windowed source. Call before
+     * the first prepare on a model whose source is external.
+     *
+     * Pins the prep-type records themselves (and a 1-hop of product /
+     * material records the relationship getters hydrate). Does **not**
+     * BFS-pin styled-item Item closures — those are facesets, and
+     * walking them here pulled most of the file into the windowed LRU
+     * before the first product extract.
+     *
+     * @return {Promise<Set<number>>} Pinned local IDs — caller must
+     * {@link StepModelBase.unpinLocalIDs} after prepare/extract.
+     */
+    async ensureResidentForDemandPrep() {
+        const pinned = new Set();
+        if (!this.model.isSourceExternal) {
+            return pinned;
+        }
+        // Small trees: project units, material-definition style stacks.
+        for (const type of [IfcProject, IfcMaterialDefinitionRepresentation]) {
+            for (const expressID of this.model.expressIDsOfTypes(type)) {
+                await this.model.ensureResidentClosureByExpressID(expressID, void 0, pinned);
+            }
+        }
+        const recordOnlyTypes = [
+            IfcRelAssociatesMaterial,
+            IfcRelVoidsElement,
+            IfcStyledItem,
+            IfcRelAggregates,
+        ];
+        for (const type of recordOnlyTypes) {
+            for (const expressID of this.model.expressIDsOfTypes(type)) {
+                const localID = this.model.resolveExpressID(expressID);
+                if (localID === void 0 || pinned.has(localID)) {
+                    continue;
+                }
+                await this.model.ensureResidentByLocalID(localID);
+                this.model.pinByLocalID(localID);
+                pinned.add(localID);
+            }
+        }
+        // Relationship getters hydrate the related product / material
+        // records (not their geometry). Pin that 1-hop so populate can
+        // read `.localID` without a full closure walk.
+        const oneHopTypes = [
+            IfcRelAssociatesMaterial,
+            IfcRelVoidsElement,
+            IfcRelAggregates,
+        ];
+        for (const type of oneHopTypes) {
+            for (const expressID of this.model.expressIDsOfTypes(type)) {
+                const localID = this.model.resolveExpressID(expressID);
+                if (localID === void 0) {
+                    continue;
+                }
+                for (const refExpressID of this.model.referencedExpressIDs(localID)) {
+                    const refLocalID = this.model.resolveExpressID(refExpressID);
+                    if (refLocalID === void 0 || pinned.has(refLocalID)) {
+                        continue;
+                    }
+                    await this.model.ensureResidentByLocalID(refLocalID);
+                    this.model.pinByLocalID(refLocalID);
+                    pinned.add(refLocalID);
+                }
+            }
+        }
+        return pinned;
+    }
+    /**
+     * Page in the `#ref` closure a per-product extract will acquire,
+     * including this product's voids, bound materials and styled items
+     * (those are inverse — not written in the product record).
+     *
+     * @param localID The product's local ID.
+     * @return {Promise<Set<number>>} Pinned local IDs — caller must unpin
+     * after extract.
+     */
+    async ensureResidentForProductExtract(localID, seen) {
+        if (!this.model.isSourceExternal) {
+            return seen ?? new Set();
+        }
+        const extra = [];
+        const voids = this.productToVoidGeometryMap.get(localID);
+        if (voids !== void 0) {
+            extra.push(...voids);
+        }
+        const material = this.materials.relMaterialsMap.get(localID);
+        if (material !== void 0) {
+            extra.push(material);
+        }
+        const visited = await this.model.ensureResidentClosureByLocalID(localID, extra, seen);
+        const styleExtra = [];
+        for (const visitedID of visited) {
+            const styled = this.materials.styledItemMap.get(visitedID);
+            if (styled !== void 0) {
+                styleExtra.push(styled);
+            }
+            const definition = this.materials.materialDefinitionsMap.get(visitedID);
+            if (definition !== void 0) {
+                styleExtra.push(definition);
+            }
+        }
+        if (styleExtra.length > 0) {
+            await this.model.ensureResidentClosureByLocalID(localID, styleExtra, visited);
+        }
+        return visited;
+    }
+    /**
+     * Page in the records {@link extractRelAggregateGeometry} will
+     * acquire: the relationship, the relating product (and its voids)
+     * and every related product.
+     *
+     * @param relAggregate The relationship to prefetch.
+     * @return {Promise<Set<number>>} Pinned local IDs — caller must unpin
+     * after extract.
+     */
+    async ensureResidentForAggregateExtract(relAggregate) {
+        if (!this.model.isSourceExternal) {
+            return new Set();
+        }
+        const pinned = await this.model.ensureResidentClosureByLocalID(relAggregate.localID);
+        const relating = relAggregate.RelatingObject;
+        if (relating !== null && relating !== void 0) {
+            await this.ensureResidentForProductExtract(relating.localID, pinned);
+        }
+        const related = relAggregate.RelatedObjects;
+        if (related === null || related === void 0) {
+            return pinned;
+        }
+        for (const product of related) {
+            await this.ensureResidentForProductExtract(product.localID, pinned);
+        }
+        return pinned;
+    }
     /**
      * The whole-model walk's SECOND product pass, shared with the demand
      * pump: for every IfcRelAggregates, re-extract the related products

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

@@ -2,7 +2,7 @@ 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 } from "../step/parsing/byte_source.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.
@@ -78,5 +78,27 @@ export default class IfcStepParser extends StepParser<EntityTypesIfc> {
         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;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAExD,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;CAkB5C"}
+{"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"}

package/compiled/src/ifc/ifc_step_parser.js

@@ -1,7 +1,7 @@
 import StepParser from "../step/parsing/step_parser.js";
 import EntitTypesIfcSearch from "./ifc4_gen/entity_types_search.gen.js";
 import IfcStepModel from "./ifc_step_model.js";
-import { buildColumnarIndexStreaming } from "../step/parsing/streaming_index_builder.js";
+import { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } from "../step/parsing/streaming_index_builder.js";
 import { WindowedStepBufferProvider, } from "../step/step_buffer_provider.js";
 /** Default moving-window size for the streaming index build (1 MiB). */
 // eslint-disable-next-line no-magic-numbers
@@ -78,6 +78,28 @@ class IfcStepParser extends StepParser {
         const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
         return [result, new IfcStepModel(void 0, columns, provider)];
     }
+    /**
+     * 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.
+     */
+    async parseStreamToModelAsync(source, store, opts) {
+        if (store.byteLength !== source.byteLength) {
+            throw new Error(`Streaming store byteLength ${store.byteLength} does not match ` +
+                `source byteLength ${source.byteLength}`);
+        }
+        const { columns, result } = await buildColumnarIndexStreamingAsync(source, this, opts?.pool ?? DEFAULT_STREAM_POOL_BYTES, void 0, opts?.onProgress);
+        const provider = new WindowedStepBufferProvider(store, opts?.chunkBytes, opts?.maxResidentChunks);
+        return [result, new IfcStepModel(void 0, columns, provider)];
+    }
 }
 /**
  * An easily accessible and re-usable instance of the parser.

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

@@ -1,4 +1,4 @@
-import { ByteSource } from "../step/parsing/byte_source.js";
+import { ByteSource, ReadableByteSource } 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";
@@ -65,4 +65,31 @@ export interface StreamedIfcOpen {
  * @return {StreamedIfcOpen} The model + header, columns, and diagnostics.
  */
 export declare function openStreamedIfcModel(source: ByteSource, store: StepExternalByteStore, options?: StreamedIfcOpenOptions): StreamedIfcOpen;
+/**
+ * Cooperative twin of {@link openStreamedIfcModel}: the index build
+ * yields to the event loop and can fill windows from an async
+ * {@link ReadableByteSource}. Pass a {@link StoreByteSource} wrapping
+ * `store` to parse a file that is already in OPFS without ever
+ * holding it as one `ArrayBuffer`.
+ *
+ * @param source Sync or async parse source.
+ * @param store The random-access store the model reads from afterwards.
+ * @param options See {@link StreamedIfcOpenOptions} plus `onProgress`.
+ * @return {Promise<StreamedIfcOpen>} The model + header, columns, diagnostics.
+ */
+export declare function openStreamedIfcModelAsync(source: ReadableByteSource, store: StepExternalByteStore, options?: StreamedIfcOpenOptions & {
+    onProgress?: (absoluteByteCursor: number) => void;
+}): Promise<StreamedIfcOpen>;
+/**
+ * Open a windowed IFC model from a store alone — parse windows and
+ * post-parse reads share `store`. This is the M1b embedder entry for
+ * a file already sitting in OPFS.
+ *
+ * @param store The source of truth for the file bytes.
+ * @param options See {@link openStreamedIfcModelAsync}.
+ * @return {Promise<StreamedIfcOpen>} The model + header, columns, diagnostics.
+ */
+export declare function openStreamedIfcModelFromStore(store: StepExternalByteStore, options?: StreamedIfcOpenOptions & {
+    onProgress?: (absoluteByteCursor: number) => void;
+}): Promise<StreamedIfcOpen>;
 //# sourceMappingURL=ifc_stream_open.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"ifc_stream_open.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_stream_open.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAmB,MAAM,6BAA6B,CAAA;AAC7F,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAGL,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;AAGD;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAC3C,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,qBAAqB,EAC5B,OAAO,CAAC,EAAE,sBAAsB,GAAG;IACjC,UAAU,CAAC,EAAE,CAAE,kBAAkB,EAAE,MAAM,KAAM,IAAI,CAAA;CACpD,GAAI,OAAO,CAAC,eAAe,CAAC,CA6BhC;AAGD;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CACzC,KAAK,EAAE,qBAAqB,EAC5B,OAAO,CAAC,EAAE,sBAAsB,GAAG;IACjC,UAAU,CAAC,EAAE,CAAE,kBAAkB,EAAE,MAAM,KAAM,IAAI,CAAA;CACpD,GAAI,OAAO,CAAC,eAAe,CAAC,CAGhC"}

package/compiled/src/ifc/ifc_stream_open.js

@@ -1,4 +1,5 @@
-import { buildColumnarIndexStreaming, } from "../step/parsing/streaming_index_builder.js";
+import { StoreByteSource } from "../step/parsing/byte_source.js";
+import { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } 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";
@@ -44,3 +45,45 @@ export function openStreamedIfcModel(source, store, options) {
         stats,
     };
 }
+/**
+ * Cooperative twin of {@link openStreamedIfcModel}: the index build
+ * yields to the event loop and can fill windows from an async
+ * {@link ReadableByteSource}. Pass a {@link StoreByteSource} wrapping
+ * `store` to parse a file that is already in OPFS without ever
+ * holding it as one `ArrayBuffer`.
+ *
+ * @param source Sync or async parse source.
+ * @param store The random-access store the model reads from afterwards.
+ * @param options See {@link StreamedIfcOpenOptions} plus `onProgress`.
+ * @return {Promise<StreamedIfcOpen>} The model + header, columns, diagnostics.
+ */
+export async function openStreamedIfcModelAsync(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 } = await buildColumnarIndexStreamingAsync(source, IfcStepParser.Instance, options?.pool ?? DEFAULT_STREAM_POOL_BYTES, options?.onRecordIndexed, options?.onProgress);
+    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,
+    };
+}
+/**
+ * Open a windowed IFC model from a store alone — parse windows and
+ * post-parse reads share `store`. This is the M1b embedder entry for
+ * a file already sitting in OPFS.
+ *
+ * @param store The source of truth for the file bytes.
+ * @param options See {@link openStreamedIfcModelAsync}.
+ * @return {Promise<StreamedIfcOpen>} The model + header, columns, diagnostics.
+ */
+export function openStreamedIfcModelFromStore(store, options) {
+    return openStreamedIfcModelAsync(new StoreByteSource(store), store, options);
+}

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

@@ -7,7 +7,7 @@ import * as fs from "fs";
 import { beforeAll, describe, expect, test } from "@jest/globals";
 import ParsingBuffer from "../parsing/parsing_buffer.js";
 import IfcStepParser from "./ifc_step_parser.js";
-import { openStreamedIfcModel } from "./ifc_stream_open.js";
+import { openStreamedIfcModel, openStreamedIfcModelFromStore } from "./ifc_stream_open.js";
 import { BufferByteSource } from "../step/parsing/byte_source.js";
 import { InMemoryStepByteStore } from "../step/step_buffer_provider.js";
 import { ParseResult } from "../step/parsing/step_parser.js";
@@ -60,4 +60,13 @@ describe("openStreamedIfcModel (Phase B3)", () => {
         expect(() => openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes.subarray(0, 100))))
             .toThrow(/does not match/);
     });
+    test("openStreamedIfcModelFromStore matches the sync open", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const fromStore = await openStreamedIfcModelFromStore(store, { pool: 4 * 1024 });
+        const streamed = openStreamedIfcModel(new BufferByteSource(bytes), store, { pool: 4 * 1024 });
+        expect(fromStore.result).toBe(ParseResult.COMPLETE);
+        expect(fromStore.model.isSourceExternal).toBe(true);
+        expect([...fromStore.model.expressIDsOfTypes(IfcRoot)])
+            .toEqual([...streamed.model.expressIDsOfTypes(IfcRoot)]);
+    });
 });

package/compiled/src/index.d.ts

@@ -11,9 +11,10 @@ export { ExtractResult } from "./core/shared_constants.js";
 export { ProgressEvent, ProgressCallback, ProgressPhase, ProgressUnit, ProgressTracker, CountProgressCallback, yieldToEventLoop, } from "./core/progress.js";
 export { ModelLoadOptions } from "./loaders/conway_model_loader.js";
 export { LoadLogAccumulator, ModelInfo, ProgressEventLike, formatBar, formatMb, formatModelLine, formatSeconds, stageLabel, } from "./core/progress_log.js";
-export { openStreamedIfcModel, StreamedIfcOpen, StreamedIfcOpenOptions } from "./ifc/ifc_stream_open.js";
+export { openStreamedIfcModel, openStreamedIfcModelAsync, openStreamedIfcModelFromStore, StreamedIfcOpen, StreamedIfcOpenOptions, } from "./ifc/ifc_stream_open.js";
 export { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } from "./step/parsing/streaming_index_builder.js";
-export { ByteSource, BufferByteSource } from "./step/parsing/byte_source.js";
+export { ByteSource, BufferByteSource, AsyncByteSource, ReadableByteSource, StoreByteSource, SyncAccessHandleByteSource, SyncAccessHandleLike, } from "./step/parsing/byte_source.js";
+export { scanExpressRefs } from "./step/parsing/express_ref_scan.js";
 export { StepExternalByteStore, InMemoryStepByteStore, StepBufferProvider, WindowedStepBufferProvider, } from "./step/step_buffer_provider.js";
 export { StepIndexColumns } from "./step/parsing/columnar_index.js";
 export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "./step/parsing/index_sidecar.js";

package/compiled/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,eAAe,GAChB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEjD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/F,OAAO,EAAE,OAAO,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAA;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EACL,kBAAkB,EAClB,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,QAAQ,EACR,eAAe,EACf,aAAa,EACb,UAAU,GACX,MAAM,qBAAqB,CAAA;AAU5B,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AACrG,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,GACjC,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AACzE,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EACL,gCAAgC,EAChC,gCAAgC,EAChC,oBAAoB,EACpB,UAAU,GACX,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAA;AACrG,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAC5E,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACnG,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AACnG,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AACpF,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,eAAe,GAChB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEjD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/F,OAAO,EAAE,OAAO,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAA;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EACL,kBAAkB,EAClB,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,QAAQ,EACR,eAAe,EACf,aAAa,EACb,UAAU,GACX,MAAM,qBAAqB,CAAA;AAU5B,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,6BAA6B,EAC7B,eAAe,EACf,sBAAsB,GACvB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,GACjC,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,0BAA0B,EAC1B,oBAAoB,GACrB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EACL,gCAAgC,EAChC,gCAAgC,EAChC,oBAAoB,EACpB,UAAU,GACX,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAA;AACrG,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAC5E,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACnG,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AACnG,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AACpF,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA"}

package/compiled/src/index.js

@@ -18,9 +18,10 @@ export { LoadLogAccumulator, formatBar, formatMb, formatModelLine, formatSeconds
 // `/demand`, and `/mem` — which is where new conway-native APIs land (the
 // web-ifc compat shim stays an adapter and is headed for retirement). The
 // flat re-exports below are kept for root-import compatibility.
-export { openStreamedIfcModel } from "./ifc/ifc_stream_open.js";
+export { openStreamedIfcModel, openStreamedIfcModelAsync, openStreamedIfcModelFromStore, } from "./ifc/ifc_stream_open.js";
 export { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } from "./step/parsing/streaming_index_builder.js";
-export { BufferByteSource } from "./step/parsing/byte_source.js";
+export { BufferByteSource, StoreByteSource, SyncAccessHandleByteSource, } from "./step/parsing/byte_source.js";
+export { scanExpressRefs } from "./step/parsing/express_ref_scan.js";
 export { InMemoryStepByteStore, WindowedStepBufferProvider, } from "./step/step_buffer_provider.js";
 export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "./step/parsing/index_sidecar.js";
 export { StreamingRecordDispatcher } from "./step/parsing/streaming_record_dispatcher.js";

package/compiled/src/namespace_surface.test.js

@@ -9,7 +9,10 @@ import * as stream from "./stream/index.js";
 describe("plane namespace surface", () => {
     test("stream exposes the fixed-memory open plane", () => {
         expect(typeof stream.openStreamedIfcModel).toBe("function");
+        expect(typeof stream.openStreamedIfcModelFromStore).toBe("function");
         expect(typeof stream.BufferByteSource).toBe("function");
+        expect(typeof stream.StoreByteSource).toBe("function");
+        expect(typeof stream.SyncAccessHandleByteSource).toBe("function");
         expect(typeof stream.InMemoryStepByteStore).toBe("function");
         expect(typeof stream.WindowedStepBufferProvider).toBe("function");
         expect(typeof stream.serializeIndexSidecarFromColumns).toBe("function");

package/compiled/src/step/parsing/byte_source.d.ts

@@ -52,4 +52,102 @@ export declare class BufferByteSource implements ByteSource {
      */
     read(offset: number, length: number, into: Uint8Array, intoOffset: number): number;
 }
+/**
+ * A `ByteSource` whose `read` is asynchronous — a `StepExternalByteStore`
+ * (OPFS `File.slice()`), or any other store that cannot serve bytes
+ * synchronously on this thread. `buildIndexStreamingAsync` accepts either
+ * this or a sync {@link ByteSource}; the sync builder does not.
+ */
+export interface AsyncByteSource {
+    /** Total length of the source in bytes. */
+    readonly byteLength: number;
+    /**
+     * Read up to `length` bytes starting at `offset` into `into` at
+     * `intoOffset`. Same contract as {@link ByteSource.read}, but async.
+     *
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {Promise<number>} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): Promise<number>;
+}
+/**
+ * Either a sync or async positioned byte source. The cooperative index
+ * builder awaits each fill; a sync source just resolves immediately.
+ */
+export type ReadableByteSource = ByteSource | AsyncByteSource;
+/**
+ * Minimal sync-access handle (OPFS `FileSystemSyncAccessHandle` in a
+ * worker). Defined here so the source has no DOM lib dependency.
+ */
+export interface SyncAccessHandleLike {
+    /**
+     * Read into `buffer` starting at file offset `options.at`.
+     *
+     * @param buffer Destination view.
+     * @param options `{ at }` file offset (default 0).
+     * @return {number} Bytes copied.
+     */
+    read(buffer: Uint8Array, options?: {
+        at?: number;
+    }): number;
+    /**
+     * @return {number} File size in bytes.
+     */
+    getSize(): number;
+}
+/**
+ * A `ByteSource` over an OPFS (or similar) synchronous access handle —
+ * the worker-side parse feed for M1b write-through. Reads never
+ * materialise the file as one `ArrayBuffer`.
+ */
+export declare class SyncAccessHandleByteSource implements ByteSource {
+    private readonly handle_;
+    /**
+     * @param handle_ A sync-access handle already opened on the file.
+     */
+    constructor(handle_: SyncAccessHandleLike);
+    /**
+     * @return {number} The file length.
+     */
+    get byteLength(): number;
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): number;
+}
+/**
+ * An {@link AsyncByteSource} over a {@link StepExternalByteStore} — the
+ * main-thread parse feed for a file that is already in OPFS (or any
+ * store whose `read` is async). Peak parse scratch is one window, not
+ * the whole file.
+ */
+export declare class StoreByteSource implements AsyncByteSource {
+    private readonly store_;
+    /**
+     * @param store_ The external store (same bytes the model will page).
+     */
+    constructor(store_: {
+        readonly byteLength: number;
+        read(offset: number, length: number): Promise<Uint8Array>;
+    });
+    /**
+     * @return {number} The store length.
+     */
+    get byteLength(): number;
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {Promise<number>} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): Promise<number>;
+}
 //# sourceMappingURL=byte_source.d.ts.map

package/compiled/src/step/parsing/byte_source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"byte_source.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/byte_source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IAEzB,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAE3B;;;;;;;;;;OAUG;IACH,IAAI,CAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,MAAM,CAAA;CACrF;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,UAAU;IAKpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHpC;;OAEG;gBAC2B,MAAM,EAAE,UAAU;IAEhD;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;;OAMG;IACI,IAAI,CACP,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,MAAM;CAYnF"}
+{"version":3,"file":"byte_source.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/byte_source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IAEzB,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAE3B;;;;;;;;;;OAUG;IACH,IAAI,CAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,MAAM,CAAA;CACrF;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,UAAU;IAKpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHpC;;OAEG;gBAC2B,MAAM,EAAE,UAAU;IAEhD;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;;OAMG;IACI,IAAI,CACP,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,MAAM;CAYnF;AAGD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAE9B,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAE3B;;;;;;;;;OASG;IACH,IAAI,CACA,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5F;AAGD;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,eAAe,CAAA;AAG7D;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IAEnC;;;;;;OAMG;IACH,IAAI,CAAE,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,GAAI,MAAM,CAAA;IAE7D;;OAEG;IACH,OAAO,IAAI,MAAM,CAAA;CAClB;AAGD;;;;GAIG;AACH,qBAAa,0BAA2B,YAAW,UAAU;IAK9C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHrC;;OAEG;gBAC2B,OAAO,EAAE,oBAAoB;IAE3D;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;;OAMG;IACI,IAAI,CACP,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,MAAM;CAYnF;AAGD;;;;;GAKG;AACH,qBAAa,eAAgB,YAAW,eAAe;IAKxC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHpC;;OAEG;gBAC2B,MAAM,EAAE;QACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;QAC3B,IAAI,CAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAI,OAAO,CAAC,UAAU,CAAC,CAAA;KAC5D;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;;OAMG;IACU,IAAI,CACb,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,OAAO,CAAC,MAAM,CAAC;CAe5F"}

package/compiled/src/step/parsing/byte_source.js

@@ -33,3 +33,74 @@ export class BufferByteSource {
         return end - offset;
     }
 }
+/**
+ * A `ByteSource` over an OPFS (or similar) synchronous access handle —
+ * the worker-side parse feed for M1b write-through. Reads never
+ * materialise the file as one `ArrayBuffer`.
+ */
+export class SyncAccessHandleByteSource {
+    /**
+     * @param handle_ A sync-access handle already opened on the file.
+     */
+    constructor(handle_) {
+        this.handle_ = handle_;
+    }
+    /**
+     * @return {number} The file length.
+     */
+    get byteLength() {
+        return this.handle_.getSize();
+    }
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset, length, into, intoOffset) {
+        const end = Math.min(offset + length, this.byteLength);
+        if (end <= offset) {
+            return 0;
+        }
+        const want = end - offset;
+        return this.handle_.read(into.subarray(intoOffset, intoOffset + want), { at: offset });
+    }
+}
+/**
+ * An {@link AsyncByteSource} over a {@link StepExternalByteStore} — the
+ * main-thread parse feed for a file that is already in OPFS (or any
+ * store whose `read` is async). Peak parse scratch is one window, not
+ * the whole file.
+ */
+export class StoreByteSource {
+    /**
+     * @param store_ The external store (same bytes the model will page).
+     */
+    constructor(store_) {
+        this.store_ = store_;
+    }
+    /**
+     * @return {number} The store length.
+     */
+    get byteLength() {
+        return this.store_.byteLength;
+    }
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {Promise<number>} The number of bytes copied.
+     */
+    async read(offset, length, into, intoOffset) {
+        const end = Math.min(offset + length, this.store_.byteLength);
+        if (end <= offset) {
+            return 0;
+        }
+        const want = end - offset;
+        const bytes = await this.store_.read(offset, want);
+        into.set(bytes.subarray(0, want), intoOffset);
+        return Math.min(bytes.byteLength, want);
+    }
+}

package/compiled/src/step/parsing/byte_source.test.d.ts

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

package/compiled/src/step/parsing/byte_source.test.d.ts.map

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