@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/step/step_model_base.js

@@ -1,22 +1,30 @@
 import { releaseScratchParsingBuffer } from "./parsing/step_deserialization_functions.js";
+import { scanExpressRefs } from "./parsing/express_ref_scan.js";
 import { ResidentStepBufferProvider, WindowedStepBufferProvider, } from "./step_buffer_provider.js";
 import StepVtableBuilder from "./parsing/step_vtable_builder.js";
+import { extractIntegerArrayAt } from "./parsing/uint32_sink.js";
 import { extractOneHotLow } from "../indexing/bit_operations.js";
 import { TriangleElementMap } from "../core/triangle_element_map.js";
 import InterpolationSearchTable32 from "../indexing/interpolation_search_table_32.js";
 /**
  * The base for models parsed from STEP.
  */
-export default class StepModelBase {
+class StepModelBase {
     /**
      * Construct this step model with its matching schema, a buffer to read from and an element index.
      *
      * @param schema The Step schema this is based on.
-     * @param buffer_ The buffer to read this from.
+     * @param buffer_ The buffer to read this from. Pass `undefined` together
+     * with `provider` to build a model whose source is windowed from
+     * construction (e.g. a streaming open — see buildModelStreaming); the
+     * synchronous read paths (geometry extraction) then require the relevant
+     * ranges to be resident, exactly as after `spillSourceToExternalStore`.
      * @param elementIndex The element index for this, parsed or deserialized - note this takes
      * ownership of this array in the sense it will modify values/unfold inline elements etc.
+     * @param provider Optional pre-built buffer provider. When omitted, a
+     * resident provider over `buffer_` is used (the classic path).
      */
-    constructor(schema, buffer_, elementIndex) {
+    constructor(schema, buffer_, elementIndex, provider) {
         this.schema = schema;
         this.buffer_ = buffer_;
         this.vtableBuilder_ = new StepVtableBuilder();
@@ -39,7 +47,38 @@ export default class StepModelBase {
          * error, and the field is optional, return null instead of throwing an exception.
          */
         this.nullOnErrors = true;
-        this.bufferProvider_ = new ResidentStepBufferProvider(buffer_);
+        this.bufferProvider_ = provider ?? new ResidentStepBufferProvider(buffer_);
+        if (!Array.isArray(elementIndex)) {
+            // Columns path (M7): the parse produced the SoA columns directly (see
+            // columnar_index.ts) — adopt them, build the lookup tables straight off
+            // the columns, and skip the object walk entirely. Inline entities are
+            // already unfolded into [firstInlineElement, count) in the same order
+            // the object path would have produced.
+            const columns = elementIndex;
+            const firstInline = columns.firstInlineElement;
+            const inlineCount = columns.count - firstInline;
+            const inlineElementTable = new Uint32Array(inlineCount << 1);
+            for (let where = 0; where < inlineCount; ++where) {
+                inlineElementTable[where << 1] = firstInline + where;
+                inlineElementTable[(where << 1) + 1] = columns.address[firstInline + where];
+            }
+            this.inlineAddressMap_ = new InterpolationSearchTable32(inlineElementTable, true);
+            const expressIdTable = new Uint32Array(firstInline << 1);
+            for (let where = 0; where < firstInline; ++where) {
+                expressIdTable[where << 1] = where;
+                expressIdTable[(where << 1) + 1] = columns.expressID[where];
+            }
+            this.expressIDMap_ =
+                new InterpolationSearchTable32(expressIdTable, columns.expressIdsSorted);
+            this.address_ = columns.address;
+            this.length_ = columns.length;
+            this.typeID_ = columns.typeID;
+            this.expressID_ = columns.expressID;
+            this.count_ = columns.count;
+            this.firstInlineElement_ = firstInline;
+            this.complexEntries_ = columns.complexEntries;
+            return;
+        }
         const localElementIndex = elementIndex;
         let where = 0;
         const firstInlineElement = localElementIndex.length;
@@ -204,11 +243,101 @@ export default class StepModelBase {
         }
     }
     /**
-     * Populate a raw vtable entry for a particular element, extra
+     * Resolve an express ID to a local ID, using `hintLocalID + 1` when
+     * the next record is the one we want. Tessellated Faces lists are
+     * sequential (PSB: every faceset), so this turns 9.1M interpolation
+     * searches into one per faceset.
      *
-     * @param element The raw elment to populate the vtable entry for.
-     * @return {boolean} Did the vtable entry populate correctly?
+     * @param expressID The referenced record.
+     * @param hintLocalID Local ID of the previous resolve, if any.
+     * @return {number | undefined} The local ID, or undefined if unknown.
+     */
+    resolveExpressID(expressID, hintLocalID) {
+        if (hintLocalID !== void 0) {
+            const next = hintLocalID + 1;
+            if (next < this.firstInlineElement_ &&
+                this.expressID_[next] === expressID) {
+                return next;
+            }
+        }
+        return this.expressIDMap_.get(expressID);
+    }
+    /**
+     * Append a local record's unsigned-integer list field into `sink`
+     * without an express-ID lookup. The reference-level twin of
+     * `StepEntityBase.extractIntegerArrayInto`, for hot loops that walk
+     * millions of small records (tessellated facesets) where constructing
+     * an entity per record dominates. It deliberately handles only the
+     * simple case and reports failure otherwise, so callers keep a
+     * correct fallback rather than this growing subtle special cases:
+     * the record must be single-class (no multi-mapping) and exactly
+     * `expectedTypeID`.
+     *
+     * Field 0 is the data-block start the parser stored in `address_`
+     * (after `TYPE(`). Reading it from the columns skips the descriptor
+     * and vtable `entry()` would retain — on a 9 M-face model those are
+     * the objects the faceset path is trying not to build. Non-zero
+     * offsets still go through a vtable, because only field 0 has that
+     * address identity.
+     *
+     * @param localID The record's local ID.
+     * @param offset The field's vtable offset.
+     * @param expectedTypeID The type the record must be.
+     * @param sink Receives the appended values.
+     * @return {number | undefined} Count appended, or undefined when the
+     * fast path does not apply.
+     */
+    extractIntegerArrayByLocalIDInto(localID, offset, expectedTypeID, sink) {
+        if (localID >= this.count_) {
+            return void 0;
+        }
+        // Multi-mapped records need per-depth base offsets; leave them to
+        // the generated getters. typeID_ is -1 when unset.
+        if (this.complexEntries_?.has(localID) ||
+            this.typeID_[localID] !== expectedTypeID) {
+            return void 0;
+        }
+        if (offset === 0) {
+            const address = this.address_[localID];
+            const acquisition = this.bufferProvider_.acquire(address, this.length_[localID]);
+            const viewAddress = address - acquisition.offset;
+            return extractIntegerArrayAt(acquisition.buffer, viewAddress, acquisition.buffer.length, sink);
+        }
+        const element = this.entry(localID);
+        if (element.vtableIndex === void 0 && !this.populateVtableEntryRaw(element)) {
+            return void 0;
+        }
+        if (element.buffer === void 0) {
+            this.populateBufferEntry(localID);
+        }
+        const vtable = element.vtable;
+        const buffer = element.buffer;
+        if (vtable === void 0 || buffer === void 0 ||
+            offset >= (element.vtableCount ?? 0)) {
+            return void 0;
+        }
+        // Same window the vtable cursors were recorded against, and the
+        // same end bound the generated array getters use.
+        return extractIntegerArrayAt(buffer, vtable[element.vtableIndex + offset], buffer.length, sink);
+    }
+    /**
+     * Append a referenced record's unsigned-integer list field into `sink`
+     * without materialising the referenced entity.
+     *
+     * @param expressID The referenced record's express ID.
+     * @param offset The field's vtable offset within the record.
+     * @param expectedTypeID The type the record must be.
+     * @param sink Receives the appended values.
+     * @return {number | undefined} Count appended, or undefined when the
+     * fast path does not apply.
      */
+    extractIntegerArrayByExpressIDInto(expressID, offset, expectedTypeID, sink) {
+        const localID = this.expressIDMap_.get(expressID);
+        if (localID === void 0) {
+            return void 0;
+        }
+        return this.extractIntegerArrayByLocalIDInto(localID, offset, expectedTypeID, sink);
+    }
     populateVtableEntryRaw(element) {
         if (element.vtableIndex !== void 0 || element.typeID === 0) {
             return true;
@@ -257,6 +386,12 @@ export default class StepModelBase {
         const element = this.entry(localID);
         element.buffer =
             this.bufferProvider_.acquire(element.address, element.length).buffer;
+        if (element.multiMapping !== void 0) {
+            for (const mapped of element.multiMapping) {
+                mapped.buffer =
+                    this.bufferProvider_.acquire(mapped.address, mapped.length).buffer;
+            }
+        }
     }
     /**
      * Get the size in bytes of the backing buffer for this.
@@ -284,6 +419,74 @@ export default class StepModelBase {
     get residentSourceBytes() {
         return this.bufferProvider_.residentBytes;
     }
+    /**
+     * Column type of a record, or `undefined` if the id is unknown / untyped.
+     *
+     * @param localID The record.
+     * @return {number | undefined} The schema type id.
+     */
+    typeIDOf(localID) {
+        if (localID >= this.count_) {
+            return;
+        }
+        const typeID = this.typeID_[localID];
+        return typeID < 0 ? void 0 : typeID;
+    }
+    /**
+     * Absolute source address of a record.
+     *
+     * @param localID The record.
+     * @return {number | undefined} The address.
+     */
+    recordAddress(localID) {
+        return localID < this.count_ ? this.address_[localID] : void 0;
+    }
+    /**
+     * Source length of a record.
+     *
+     * @param localID The record.
+     * @return {number | undefined} The length.
+     */
+    recordLength(localID) {
+        return localID < this.count_ ? this.length_[localID] : void 0;
+    }
+    /**
+     * Pin an arbitrary source span (e.g. a faceset's packed Faces[] run).
+     *
+     * @param address Absolute start.
+     * @param length Length in bytes.
+     */
+    pinAddressRange(address, length) {
+        if (!this.isSourceExternal) {
+            return;
+        }
+        this.bufferProvider_.pinRange?.(address, length);
+    }
+    /**
+     * Drop one {@link pinAddressRange} hold.
+     *
+     * @param address Absolute start.
+     * @param length Length in bytes.
+     */
+    unpinAddressRange(address, length) {
+        if (!this.isSourceExternal) {
+            return;
+        }
+        this.bufferProvider_.unpinRange?.(address, length);
+    }
+    /**
+     * Page an arbitrary source span.
+     *
+     * @param address Absolute start.
+     * @param length Length in bytes.
+     * @return {Promise<void>} Resolves when resident.
+     */
+    async ensureResidentRange(address, length) {
+        if (!this.isSourceExternal) {
+            return;
+        }
+        await this.bufferProvider_.ensureResident(address, length);
+    }
     /**
      * Release the resident source buffer and serve subsequent record
      * reads from fixed-size windows paged in from an external store.
@@ -359,6 +562,332 @@ export default class StepModelBase {
         }
         await this.ensureResidentByLocalID(localID);
     }
+    /**
+     * Page in the byte ranges a record *and every `#ref` reachable from
+     * its text* will need, so a following synchronous extract of that
+     * subgraph succeeds on a windowed source. Inverse relationships
+     * (not written in the record) are not discovered — callers that
+     * need them (rel-voids, styled items) pass their local IDs as
+     * `extraLocalIDs`.
+     *
+     * No-op while the source is fully resident.
+     *
+     * @param localID Seed record.
+     * @param extraLocalIDs Additional seeds (voids, styles, materials).
+     * @param seen Optional set to extend (also skips already-pinned IDs).
+     * @param descend If set, records for which this returns false are
+     * still visited (pinned, in `seen`) but their `#refs` are not
+     * followed — e.g. an `IfcPolygonalFaceSet` whose Faces[] payload
+     * is paged as one span afterwards.
+     * @param leafSpans Optional out-array of coalesced pin ranges for
+     * {@link spanLeaf} children — caller must {@link unpinAddressRange}
+     * each.
+     * @param spanLeaf If set, matching children are *not* visited
+     * (absent from `seen`); their bytes are one pin span. Packed
+     * extract reads `IfcIndexedPolygonalFace.CoordIndex` as integers —
+     * following those faces pinned ~78k records per PSB product. If
+     * omitted, `!descend` children use this span path (test helper).
+     * @param claimed Optional out-set of the IDs *this call* claimed and
+     * awaited residency for — a strict subset of `seen`. When `seen` is
+     * shared across concurrent walks (a batch of products sharing mapped
+     * geometry), an ID another walk claimed is skipped here and is NOT
+     * resident yet from this call's point of view: that walk's pin holds
+     * the chunk once it lands, but its read is still in flight. Anything
+     * that must synchronously read a record's bytes after this returns
+     * has to iterate `claimed`, never `seen` (conway#526).
+     * @return {Promise<Set<number>>} The local IDs that were visited.
+     */
+    async ensureResidentClosureByLocalID(localID, extraLocalIDs, seen = new Set(), descend, leafSpans, spanLeaf, claimed) {
+        if (!this.isSourceExternal) {
+            return seen;
+        }
+        // BFS by hop: page a whole frontier in parallel so a product whose
+        // #refs sit in different OPFS chunks is one round-trip, not one
+        // await per record. Claim `seen` before the await so overlapping
+        // walks (a batch of products sharing mapped geometry) pin once.
+        const frontier = [];
+        const enqueue = (id) => {
+            if (id < this.count_ && !seen.has(id)) {
+                frontier.push(id);
+            }
+        };
+        enqueue(localID);
+        if (extraLocalIDs !== void 0) {
+            for (const extra of extraLocalIDs) {
+                enqueue(extra);
+            }
+        }
+        while (frontier.length > 0) {
+            const wave = [];
+            for (const id of frontier) {
+                if (seen.has(id) || id >= this.count_) {
+                    continue;
+                }
+                // Claim + pin before the await so a sibling ensure cannot
+                // evict this range once its own ensurePins_ drop.
+                seen.add(id);
+                this.pinByLocalID(id);
+                wave.push(id);
+                claimed?.add(id);
+            }
+            frontier.length = 0;
+            if (wave.length === 0) {
+                break;
+            }
+            await Promise.all(wave.map((id) => this.ensureResidentByLocalID(id)));
+            const waveSpans = [];
+            for (const id of wave) {
+                if (descend !== void 0 && !descend(id)) {
+                    continue;
+                }
+                const skipped = [];
+                for (const expressID of this.scanRecordRefs_(id)) {
+                    const referenced = this.expressIDMap_.get(expressID);
+                    if (referenced === void 0 || seen.has(referenced)) {
+                        continue;
+                    }
+                    // Packed leaves (Faces[]) are spanned, not visited. Stop
+                    // nodes (facesets) fail `descend` so we do not scan their
+                    // refs, but they still go on the frontier so they land in
+                    // `seen` for the payload pass.
+                    const leaf = spanLeaf !== void 0 ?
+                        spanLeaf(referenced) :
+                        (descend !== void 0 && !descend(referenced));
+                    if (leaf) {
+                        skipped.push(referenced);
+                        continue;
+                    }
+                    frontier.push(referenced);
+                }
+                if (skipped.length > 0) {
+                    for (const span of this.spansOf_(skipped)) {
+                        this.pinAddressRange(span.address, span.length);
+                        waveSpans.push(span);
+                        leafSpans?.push(span);
+                    }
+                }
+            }
+            if (waveSpans.length > 0) {
+                await Promise.all(waveSpans.map((span) => this.ensureResidentRange(span.address, span.length)));
+            }
+        }
+        return seen;
+    }
+    /**
+     * Hold a record's source range against windowed LRU eviction until
+     * {@link unpinByLocalID}. No-op while the source is fully resident.
+     *
+     * @param localID The record to pin.
+     */
+    pinByLocalID(localID) {
+        if (!this.isSourceExternal || localID >= this.count_) {
+            return;
+        }
+        this.bufferProvider_.pinRange?.(this.address_[localID], this.length_[localID]);
+    }
+    /**
+     * Drop one {@link pinByLocalID} hold.
+     *
+     * @param localID The record to unpin.
+     */
+    unpinByLocalID(localID) {
+        if (!this.isSourceExternal || localID >= this.count_) {
+            return;
+        }
+        this.bufferProvider_.unpinRange?.(this.address_[localID], this.length_[localID]);
+    }
+    /**
+     * Drop captured source-window views on `localIDs` so the LRU can
+     * evict those chunks. Vtables stay — `acquire` of the same
+     * `(address, length)` is at a stable base. The next
+     * `ensureResident` + field read rematerialises the view.
+     *
+     * @param localIDs Records whose `buffer` views to drop.
+     */
+    releaseSourceViews(localIDs) {
+        if (!this.isSourceExternal) {
+            return;
+        }
+        for (const localID of localIDs) {
+            if (localID >= this.count_) {
+                continue;
+            }
+            const item = this.complexEntries_?.get(localID) ?? this.descriptorCache_[localID];
+            if (item === void 0) {
+                continue;
+            }
+            item.buffer = void 0;
+            if (item.multiMapping !== void 0) {
+                for (const mapped of item.multiMapping) {
+                    mapped.buffer = void 0;
+                }
+            }
+        }
+        releaseScratchParsingBuffer();
+    }
+    /**
+     * Unpin every local ID in `localIDs` (best-effort; missing IDs are
+     * ignored). Use after {@link ensureResidentClosureByLocalID}, which
+     * pins as it walks.
+     *
+     * @param localIDs The records to unpin.
+     */
+    unpinLocalIDs(localIDs) {
+        for (const localID of localIDs) {
+            this.unpinByLocalID(localID);
+        }
+    }
+    /**
+     * Express-ID twin of {@link ensureResidentClosureByLocalID}. Unknown
+     * IDs resolve to an empty visit set.
+     *
+     * @param expressID Seed record.
+     * @param extraLocalIDs Additional seeds (local IDs).
+     * @return {Promise<Set<number>>} The local IDs that were visited.
+     */
+    async ensureResidentClosureByExpressID(expressID, extraLocalIDs, seen) {
+        if (!this.isSourceExternal) {
+            return seen ?? new Set();
+        }
+        const localID = this.expressIDMap_.get(expressID);
+        if (localID === void 0) {
+            return seen ?? new Set();
+        }
+        return this.ensureResidentClosureByLocalID(localID, extraLocalIDs, seen);
+    }
+    /**
+     * Source spans covering the records referenced by `expressIDs` from
+     * `fromIndex` onward. A packed Faces[] run is consecutive in parse
+     * order — two express-ID lookups then cover the whole range. Sparse
+     * sets are coalesced into tight runs so intervening file is not
+     * pinned.
+     *
+     * @param expressIDs Referenced express IDs (e.g. a faceset's #refs).
+     * @param fromIndex First index to include (skip Coordinates at [0]).
+     * @return {{address: number, length: number}[]} The spans.
+     */
+    spansOfExpressIDs(expressIDs, fromIndex = 0) {
+        let minExpressID = Infinity;
+        let maxExpressID = 0;
+        let count = 0;
+        for (let i = fromIndex; i < expressIDs.length; ++i) {
+            const expressID = expressIDs[i];
+            if (expressID < minExpressID) {
+                minExpressID = expressID;
+            }
+            if (expressID > maxExpressID) {
+                maxExpressID = expressID;
+            }
+            ++count;
+        }
+        if (count === 0 || !Number.isFinite(minExpressID)) {
+            return [];
+        }
+        const minLocal = this.expressIDMap_.get(minExpressID);
+        const maxLocal = this.expressIDMap_.get(maxExpressID);
+        if (minLocal === void 0 || maxLocal === void 0) {
+            return [];
+        }
+        const lo = Math.min(minLocal, maxLocal);
+        const hi = Math.max(minLocal, maxLocal);
+        if (hi - lo + 1 === count) {
+            const address = this.address_[lo];
+            const end = this.address_[hi] + this.length_[hi];
+            if (end <= address) {
+                return [];
+            }
+            return [{ address, length: end - address }];
+        }
+        const locals = [];
+        for (let i = fromIndex; i < expressIDs.length; ++i) {
+            const localID = this.expressIDMap_.get(expressIDs[i]);
+            if (localID !== void 0) {
+                locals.push(localID);
+            }
+        }
+        return this.spansOf_(locals);
+    }
+    /**
+     * Coalesce `localIDs` into tight source runs. Records more than
+     * {@link LEAF_SPAN_COALESCE_GAP_} apart stay separate so a sparse
+     * Faces[] list does not pin the file between them.
+     *
+     * @param localIDs The records.
+     * @return {{address: number, length: number}[]} The spans.
+     */
+    spansOf_(localIDs) {
+        const items = [];
+        for (const id of localIDs) {
+            if (id >= this.count_) {
+                continue;
+            }
+            items.push({
+                address: this.address_[id],
+                length: this.length_[id],
+            });
+        }
+        items.sort((a, b) => a.address - b.address);
+        const spans = [];
+        let run;
+        for (const item of items) {
+            if (run === void 0) {
+                run = { address: item.address, length: item.length };
+                continue;
+            }
+            const runEnd = run.address + run.length;
+            if (item.address <= runEnd + StepModelBase.LEAF_SPAN_COALESCE_GAP_) {
+                const end = Math.max(runEnd, item.address + item.length);
+                run.length = end - run.address;
+                continue;
+            }
+            spans.push(run);
+            run = { address: item.address, length: item.length };
+        }
+        if (run !== void 0) {
+            spans.push(run);
+        }
+        return spans;
+    }
+    /**
+     * Express IDs referenced by a resident record (`#<id>` tokens in its
+     * text, including multi-mapped class records). The record itself
+     * must already be resident.
+     *
+     * @param localID The record to scan.
+     * @return {number[]} Distinct referenced express IDs.
+     */
+    referencedExpressIDs(localID) {
+        return this.scanRecordRefs_(localID);
+    }
+    /**
+     * Scan a resident record's bytes for `#<expressID>` references.
+     *
+     * @param localID The record to scan.
+     * @return {number[]} Distinct referenced express IDs.
+     */
+    scanRecordRefs_(localID) {
+        const address = this.address_[localID];
+        const length = this.length_[localID];
+        const acquisition = this.bufferProvider_.acquire(address, length);
+        const viewStart = address - acquisition.offset;
+        const refs = scanExpressRefs(acquisition.buffer, viewStart, length);
+        const complex = this.complexEntries_?.get(localID);
+        if (complex?.multiMapping === void 0) {
+            return refs;
+        }
+        const seen = new Set(refs);
+        for (const mapped of complex.multiMapping) {
+            const mappedAcquisition = this.bufferProvider_.acquire(mapped.address, mapped.length);
+            const mappedStart = mapped.address - mappedAcquisition.offset;
+            for (const expressID of scanExpressRefs(mappedAcquisition.buffer, mappedStart, mapped.length)) {
+                if (!seen.has(expressID)) {
+                    seen.add(expressID);
+                    refs.push(expressID);
+                }
+            }
+        }
+        return refs;
+    }
     /**
      * Get the number of elements/entities in this model.
      *
@@ -769,3 +1298,9 @@ export default class StepModelBase {
         return this.geometry?.getByLocalID(node.localID);
     }
 }
+// Merge neighbouring leaf records only when the hole between them is
+// a few small STEP rows. A Faces[] dump is packed; a sparse list
+// must not pin the file in between.
+// eslint-disable-next-line no-magic-numbers
+StepModelBase.LEAF_SPAN_COALESCE_GAP_ = 1024;
+export default StepModelBase;

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

@@ -0,0 +1,34 @@
+/**
+ * `@bldrs-ai/conway/stream` — the streaming parse/index plane (epic #390;
+ * design/new/streaming-federated-loader.md).
+ *
+ * Fixed-memory opens: a model parses through a bounded moving window over
+ * a {@link ByteSource} into a columnar record index ({@link StepIndexColumns}
+ * — no per-record object phase), reads its source bytes on demand through a
+ * windowed provider over a {@link StepExternalByteStore} (e.g. OPFS), and
+ * serializes its index to a revisit sidecar whose payload IS the columns.
+ * Consumers work against the parse as it runs two ways: membership-shaped
+ * ones ({@link PrefixTypeIndex}) derive from a prefix snapshot of the columns
+ * at a cadence they choose, and byte-shaped ones subscribe to per-record
+ * events via {@link StreamingRecordDispatcher} (issue #393 for why the split
+ * is where it is).
+ *
+ * This is the conway-native namespace for new-era consumers. The web-ifc
+ * compat shim (`@bldrs-ai/conway/web-ifc`) adapts parts of this surface to
+ * web-ifc's API (e.g. `OpenModelStreamed`) and is headed for retirement;
+ * new integrations should build against this module directly.
+ */
+export { openStreamedIfcModel, openStreamedIfcModelAsync, openStreamedIfcModelFromStore, ifcPrefixTypeIndex, StreamedIfcOpen, StreamedIfcOpenOptions, } from "../ifc/ifc_stream_open.js";
+export { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, StreamingColumnarIndexResult, StreamingIndexStats, } from "../step/parsing/streaming_index_builder.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, ColumnarIndexSink } from "../step/parsing/columnar_index.js";
+export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "../step/parsing/index_sidecar.js";
+export { StreamingRecordDispatcher, RecordHandler, } from "../step/parsing/streaming_record_dispatcher.js";
+export { PrefixTypeIndex } from "../step/parsing/prefix_type_index.js";
+export { StepTypeIndexer } from "../step/indexing/step_type_indexer.js";
+export { RecordEventHandler } from "../step/parsing/record_event.js";
+export { RecordFieldCursor } from "../step/parsing/record_field_cursor.js";
+export { IfcSpatialSkeleton, SkeletonNode } from "../ifc/ifc_spatial_skeleton.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/stream/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,6BAA6B,EAC7B,kBAAkB,EAClB,eAAe,EACf,sBAAsB,GACvB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,EAChC,4BAA4B,EAC5B,mBAAmB,GACpB,MAAM,yCAAyC,CAAA;AAChD,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,0BAA0B,EAC1B,oBAAoB,GACrB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAA;AAClE,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AACpF,OAAO,EACL,gCAAgC,EAChC,gCAAgC,EAChC,oBAAoB,EACpB,UAAU,GACX,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,yBAAyB,EACzB,aAAa,GACd,MAAM,6CAA6C,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA"}

package/compiled/src/stream/index.js

@@ -0,0 +1,32 @@
+/**
+ * `@bldrs-ai/conway/stream` — the streaming parse/index plane (epic #390;
+ * design/new/streaming-federated-loader.md).
+ *
+ * Fixed-memory opens: a model parses through a bounded moving window over
+ * a {@link ByteSource} into a columnar record index ({@link StepIndexColumns}
+ * — no per-record object phase), reads its source bytes on demand through a
+ * windowed provider over a {@link StepExternalByteStore} (e.g. OPFS), and
+ * serializes its index to a revisit sidecar whose payload IS the columns.
+ * Consumers work against the parse as it runs two ways: membership-shaped
+ * ones ({@link PrefixTypeIndex}) derive from a prefix snapshot of the columns
+ * at a cadence they choose, and byte-shaped ones subscribe to per-record
+ * events via {@link StreamingRecordDispatcher} (issue #393 for why the split
+ * is where it is).
+ *
+ * This is the conway-native namespace for new-era consumers. The web-ifc
+ * compat shim (`@bldrs-ai/conway/web-ifc`) adapts parts of this surface to
+ * web-ifc's API (e.g. `OpenModelStreamed`) and is headed for retirement;
+ * new integrations should build against this module directly.
+ */
+export { openStreamedIfcModel, openStreamedIfcModelAsync, openStreamedIfcModelFromStore, ifcPrefixTypeIndex, } from "../ifc/ifc_stream_open.js";
+export { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } from "../step/parsing/streaming_index_builder.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 { ColumnarIndexSink } from "../step/parsing/columnar_index.js";
+export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "../step/parsing/index_sidecar.js";
+export { StreamingRecordDispatcher, } from "../step/parsing/streaming_record_dispatcher.js";
+export { PrefixTypeIndex } from "../step/parsing/prefix_type_index.js";
+export { StepTypeIndexer } from "../step/indexing/step_type_indexer.js";
+export { RecordFieldCursor } from "../step/parsing/record_field_cursor.js";
+export { IfcSpatialSkeleton } from "../ifc/ifc_spatial_skeleton.js";