@bldrs-ai/conway 1.400.1226 → 1.401.1237

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.400.1226";
+var versionString = "Conway v1.401.1237";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -3493,11 +3493,16 @@ var StepParser = class extends StepHeaderParser {
    * @param input The input parsing buffer, positioned at the data section.
    * @param onRecordBoundary Called at each top-level record boundary with the
    * buffer; the callback may rebase the buffer's window in place.
+   * @param onRecordIndexed Called as each top-level record is indexed, with
+   * its localID, expressID and typeID (0 for external-mapping records) — the
+   * seam for incremental semantic consumers (type index, roots registry,
+   * names skeleton). Must be synchronous and cheap; expensive work belongs on
+   * a demand queue, not the parse path.
    * @param onProgress Optional byte-cursor progress callback.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  parseDataBlockStreamed(input, onRecordBoundary, onProgress) {
-    const parser211 = this.parseDataBlockIncremental(input, onRecordBoundary);
+  parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress) {
+    const parser211 = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed);
     while (true) {
       const next = parser211.next();
       if (next.done === true) {
@@ -3543,7 +3548,7 @@ var StepParser = class extends StepHeaderParser {
    * @yields {number} The current byte cursor within the input buffer.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  *parseDataBlockIncremental(input, onRecordBoundary) {
+  *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed) {
     const indexResult = { elements: [] };
     const match = input.match;
     const comment = () => match(commentParser2);
@@ -3720,6 +3725,7 @@ var StepParser = class extends StepHeaderParser {
         if (!charws(SEMICOLON)) {
           return syntaxError();
         }
+        onRecordIndexed?.(indexResult.elements.length, expressID, 0);
         indexResult.elements.push({
           address: startElement2,
           length: input.address - startElement2,
@@ -3811,6 +3817,7 @@ var StepParser = class extends StepHeaderParser {
       if (!charws(SEMICOLON)) {
         return syntaxError();
       }
+      onRecordIndexed?.(indexResult.elements.length, expressID, foundItem);
       indexResult.elements.push({
         address: startElement,
         length: input.address - startElement,
@@ -70774,7 +70781,7 @@ var IfcStepModel = class extends StepModelBase {
 };
 
 // compiled/src/step/parsing/streaming_index_builder.js
-function buildIndexStreaming(source, parser211, pool3) {
+function buildIndexStreaming(source, parser211, pool3, onRecordIndexed) {
   const fileSize = source.byteLength;
   let windowBytes = Math.max(pool3, MIN_WINDOW);
   for (; ; ) {
@@ -70820,7 +70827,7 @@ function buildIndexStreaming(source, parser211, pool3) {
       buffer.rebaseWindow(window2, 0, windowLen, windowStartFile);
       ++slides;
     };
-    const [index, result] = parser211.parseDataBlockStreamed(input, onRecordBoundary);
+    const [index, result] = parser211.parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed);
     const stoppedShort = result !== ParseResult.COMPLETE;
     const notAtEof = windowStartFile + windowLen < fileSize;
     if (stoppedShort && notAtEof) {

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

@@ -0,0 +1,64 @@
+import { StepEntityConstructorAbstract } from "../step_entity_constructor.js";
+import { RecordHandler } from "./streaming_record_dispatcher.js";
+/**
+ * A type index built **incrementally** from the streaming parse's per-record
+ * events (M2), rather than from the finished element array. Feed its
+ * {@link handler} to a {@link StreamingRecordDispatcher} (or directly to
+ * `buildIndexStreaming`'s `onRecordIndexed`) and it accumulates, per concrete
+ * type, the set of express IDs seen — so the moment parsing reaches a record
+ * it is queryable, without waiting for end-of-parse.
+ *
+ * Queries take entity constructors and expand to their subtype closure via
+ * the generated `query` (conway #383), so `expressIDsOfTypes(IfcProduct)`
+ * unions every product subtype exactly as the resident model's type index
+ * does.
+ *
+ * Express IDs are held in per-type `Set`s, so the consumer is idempotent
+ * under the streaming builder's rare grow-and-restart (records re-fire from
+ * localID 0): re-adding an express ID is a no-op. Memory is O(records) — the
+ * same order as the element index it mirrors.
+ *
+ * Scope: membership is keyed on the raw parse `typeID`. External-mapping /
+ * complex records (typeID 0) are therefore not attributed to their mapped
+ * classes here — resolving those needs the record's `multiMapping`, which the
+ * event stream doesn't carry; that's the model's construction-time index. For
+ * the overwhelming majority of records (simple, one type each) this index is
+ * exact, which the parity test pins.
+ */
+export declare class IncrementalTypeIndex<TypeIDType extends number> {
+    /** Concrete typeID → express IDs of records of exactly that type. */
+    private readonly byType_;
+    /**
+     * Record one indexed entity. Bound as {@link handler} for direct use as a
+     * dispatcher subscription / `onRecordIndexed` callback.
+     *
+     * @param localID Unused (kept for the RecordHandler shape).
+     * @param expressID The record's express ID.
+     * @param typeID The record's concrete type ID (undefined / 0 records are
+     * ignored — they carry no concrete queryable type here).
+     */
+    readonly handler: RecordHandler<TypeIDType>;
+    /**
+     * The distinct concrete type IDs seen so far.
+     *
+     * @return {IterableIterator<TypeIDType>} The concrete types.
+     */
+    concreteTypes(): IterableIterator<TypeIDType>;
+    /**
+     * Lazily iterate the express IDs of all records of the given types
+     * (including subtypes).
+     *
+     * @param types The entity constructors to query (subtype closures unioned).
+     * @return {IterableIterator<number>} Express IDs of matching records.
+     * @yields {number} Each matching express ID.
+     */
+    expressIDsOfTypes(...types: StepEntityConstructorAbstract<TypeIDType>[]): IterableIterator<number>;
+    /**
+     * Count records of the given types (including subtypes) seen so far.
+     *
+     * @param types The entity constructors to count.
+     * @return {number} The number of matching records.
+     */
+    count(...types: StepEntityConstructorAbstract<TypeIDType>[]): number;
+}
+//# sourceMappingURL=incremental_type_index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"incremental_type_index.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/incremental_type_index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,oBAAoB,CAAC,UAAU,SAAS,MAAM;IAEzD,qEAAqE;IACrE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAE7D;;;;;;;;OAQG;IACH,SAAgB,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,CAe/C;IAEH;;;;OAIG;IACI,aAAa,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAIpD;;;;;;;OAOG;IACK,iBAAiB,CACrB,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GACrD,gBAAgB,CAAC,MAAM,CAAC;IAc5B;;;;;OAKG;IACI,KAAK,CAAE,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GAAI,MAAM;CAa9E"}

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

@@ -0,0 +1,92 @@
+/**
+ * A type index built **incrementally** from the streaming parse's per-record
+ * events (M2), rather than from the finished element array. Feed its
+ * {@link handler} to a {@link StreamingRecordDispatcher} (or directly to
+ * `buildIndexStreaming`'s `onRecordIndexed`) and it accumulates, per concrete
+ * type, the set of express IDs seen — so the moment parsing reaches a record
+ * it is queryable, without waiting for end-of-parse.
+ *
+ * Queries take entity constructors and expand to their subtype closure via
+ * the generated `query` (conway #383), so `expressIDsOfTypes(IfcProduct)`
+ * unions every product subtype exactly as the resident model's type index
+ * does.
+ *
+ * Express IDs are held in per-type `Set`s, so the consumer is idempotent
+ * under the streaming builder's rare grow-and-restart (records re-fire from
+ * localID 0): re-adding an express ID is a no-op. Memory is O(records) — the
+ * same order as the element index it mirrors.
+ *
+ * Scope: membership is keyed on the raw parse `typeID`. External-mapping /
+ * complex records (typeID 0) are therefore not attributed to their mapped
+ * classes here — resolving those needs the record's `multiMapping`, which the
+ * event stream doesn't carry; that's the model's construction-time index. For
+ * the overwhelming majority of records (simple, one type each) this index is
+ * exact, which the parity test pins.
+ */
+export class IncrementalTypeIndex {
+    constructor() {
+        /** Concrete typeID → express IDs of records of exactly that type. */
+        this.byType_ = new Map();
+        /**
+         * Record one indexed entity. Bound as {@link handler} for direct use as a
+         * dispatcher subscription / `onRecordIndexed` callback.
+         *
+         * @param localID Unused (kept for the RecordHandler shape).
+         * @param expressID The record's express ID.
+         * @param typeID The record's concrete type ID (undefined / 0 records are
+         * ignored — they carry no concrete queryable type here).
+         */
+        this.handler = (localID, expressID, typeID) => {
+            if (typeID === void 0) {
+                return;
+            }
+            let ids = this.byType_.get(typeID);
+            if (ids === void 0) {
+                ids = new Set();
+                this.byType_.set(typeID, ids);
+            }
+            ids.add(expressID);
+        };
+    }
+    /**
+     * The distinct concrete type IDs seen so far.
+     *
+     * @return {IterableIterator<TypeIDType>} The concrete types.
+     */
+    concreteTypes() {
+        return this.byType_.keys();
+    }
+    /**
+     * Lazily iterate the express IDs of all records of the given types
+     * (including subtypes).
+     *
+     * @param types The entity constructors to query (subtype closures unioned).
+     * @return {IterableIterator<number>} Express IDs of matching records.
+     * @yields {number} Each matching express ID.
+     */
+    *expressIDsOfTypes(...types) {
+        const typeSet = types.length === 1 ? types[0].query :
+            new Set(types.flatMap((type) => type.query));
+        for (const typeID of typeSet) {
+            const ids = this.byType_.get(typeID);
+            if (ids !== void 0) {
+                yield* ids;
+            }
+        }
+    }
+    /**
+     * Count records of the given types (including subtypes) seen so far.
+     *
+     * @param types The entity constructors to count.
+     * @return {number} The number of matching records.
+     */
+    count(...types) {
+        const typeSet = types.length === 1 ? types[0].query :
+            new Set(types.flatMap((type) => type.query));
+        let total = 0;
+        for (const typeID of typeSet) {
+            total += this.byType_.get(typeID)?.size ?? 0;
+        }
+        return total;
+    }
+}

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

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

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

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

package/compiled/src/step/parsing/incremental_type_index.test.js

@@ -0,0 +1,55 @@
+/* eslint-disable no-magic-numbers */
+// M2b: a type index built incrementally from the streaming parse's record
+// events must, once parsing finishes, hold the same membership as the
+// resident model's type index — for every queried type (and its subtypes).
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import ParsingBuffer from "../../parsing/parsing_buffer.js";
+import IfcStepParser from "../../ifc/ifc_step_parser.js";
+import { BufferByteSource } from "./byte_source.js";
+import { buildIndexStreaming } from "./streaming_index_builder.js";
+import { IncrementalTypeIndex } from "./incremental_type_index.js";
+import { StreamingRecordDispatcher } from "./streaming_record_dispatcher.js";
+import { ParseResult } from "./step_parser.js";
+import { IfcRoot, IfcProduct, IfcWall, IfcPropertySet } from "../../ifc/ifc4_gen/index.js";
+let bytes;
+let model;
+beforeAll(() => {
+    bytes = new Uint8Array(fs.readFileSync("data/index.ifc"));
+    const input = new ParsingBuffer(bytes);
+    IfcStepParser.Instance.parseHeader(input);
+    model = IfcStepParser.Instance.parseDataToModel(input)[1];
+});
+describe("IncrementalTypeIndex", () => {
+    /**
+     * Stream index.ifc, feeding an IncrementalTypeIndex, and return it.
+     *
+     * @return {IncrementalTypeIndex} The populated index.
+     */
+    function streamed() {
+        const index = new IncrementalTypeIndex();
+        const dispatcher = new StreamingRecordDispatcher();
+        dispatcher.onAnyRecord(index.handler);
+        const r = buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, dispatcher.onRecordIndexed);
+        expect(r.result).toBe(ParseResult.COMPLETE);
+        return index;
+    }
+    test.each([
+        ["IfcRoot", IfcRoot],
+        ["IfcProduct", IfcProduct],
+        ["IfcWall", IfcWall],
+        ["IfcPropertySet", IfcPropertySet],
+    ])("membership matches the resident type index for %s", (_name, ctor) => {
+        const index = streamed();
+        const incremental = new Set(index.expressIDsOfTypes(ctor));
+        const resident = new Set(model.expressIDsOfTypes(ctor));
+        expect(incremental).toEqual(resident);
+        expect(index.count(ctor)).toBe(resident.size);
+    });
+    test("a multi-type query unions the subtype closures", () => {
+        const index = streamed();
+        const incremental = new Set(index.expressIDsOfTypes(IfcWall, IfcPropertySet));
+        const resident = new Set(model.expressIDsOfTypes(IfcWall, IfcPropertySet));
+        expect(incremental).toEqual(resident);
+    });
+});

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

@@ -126,10 +126,15 @@ export default class StepParser<TypeIDType> extends StepHeaderParser {
      * @param input The input parsing buffer, positioned at the data section.
      * @param onRecordBoundary Called at each top-level record boundary with the
      * buffer; the callback may rebase the buffer's window in place.
+     * @param onRecordIndexed Called as each top-level record is indexed, with
+     * its localID, expressID and typeID (0 for external-mapping records) — the
+     * seam for incremental semantic consumers (type index, roots registry,
+     * names skeleton). Must be synchronous and cheap; expensive work belongs on
+     * a demand queue, not the parse path.
      * @param onProgress Optional byte-cursor progress callback.
      * @return {BlockParseResult} The parsing result, including the index and result enum.
      */
-    parseDataBlockStreamed(input: ParsingBuffer, onRecordBoundary: (input: ParsingBuffer) => void, onProgress?: ParseProgressCallback): BlockParseResult<TypeIDType>;
+    parseDataBlockStreamed(input: ParsingBuffer, onRecordBoundary: (input: ParsingBuffer) => void, onRecordIndexed?: (localID: number, expressID: number, typeID: TypeIDType | undefined) => void, onProgress?: ParseProgressCallback): BlockParseResult<TypeIDType>;
     /**
      * Cooperative variant of parseDataBlock: identical parse (same generator
      * body), but periodically awaits a macrotask so the event loop can run —

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

@@ -1 +1 @@
-{"version":3,"file":"step_parser.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/step_parser.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step_parser.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/step_parser.ts"],"names":[],"mappings":"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"}

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

@@ -320,11 +320,16 @@ export default class StepParser extends StepHeaderParser {
      * @param input The input parsing buffer, positioned at the data section.
      * @param onRecordBoundary Called at each top-level record boundary with the
      * buffer; the callback may rebase the buffer's window in place.
+     * @param onRecordIndexed Called as each top-level record is indexed, with
+     * its localID, expressID and typeID (0 for external-mapping records) — the
+     * seam for incremental semantic consumers (type index, roots registry,
+     * names skeleton). Must be synchronous and cheap; expensive work belongs on
+     * a demand queue, not the parse path.
      * @param onProgress Optional byte-cursor progress callback.
      * @return {BlockParseResult} The parsing result, including the index and result enum.
      */
-    parseDataBlockStreamed(input, onRecordBoundary, onProgress) {
-        const parser = this.parseDataBlockIncremental(input, onRecordBoundary);
+    parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed, onProgress) {
+        const parser = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed);
         while (true) {
             const next = parser.next();
             if (next.done === true) {
@@ -370,7 +375,7 @@ export default class StepParser extends StepHeaderParser {
      * @yields {number} The current byte cursor within the input buffer.
      * @return {BlockParseResult} The parsing result, including the index and result enum.
      */
-    *parseDataBlockIncremental(input, onRecordBoundary) {
+    *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed) {
         const indexResult = { elements: [] };
         const match = input.match;
         const comment = () => match(commentParser);
@@ -564,6 +569,7 @@ export default class StepParser extends StepHeaderParser {
                 if (!charws(SEMICOLON)) {
                     return syntaxError();
                 }
+                onRecordIndexed?.(indexResult.elements.length, expressID, 0);
                 indexResult.elements.push({
                     address: startElement,
                     length: input.address - startElement,
@@ -657,6 +663,7 @@ export default class StepParser extends StepHeaderParser {
             if (!charws(SEMICOLON)) {
                 return syntaxError();
             }
+            onRecordIndexed?.(indexResult.elements.length, expressID, foundItem);
             indexResult.elements.push({
                 address: startElement,
                 length: input.address - startElement,

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

@@ -54,7 +54,17 @@ export interface StreamingIndexResult<TypeIDType> {
  * @param source The byte source.
  * @param parser The STEP parser (typed to the schema).
  * @param pool Target window size in bytes.
+ * @param onRecordIndexed Optional per-record event, invoked live as each
+ * top-level record is indexed with its (localID, expressID, typeID) — the
+ * seam for incremental semantic consumers (M2). localIDs are dense and
+ * assigned in parse order from 0. On the rare grow-and-restart (a single
+ * record larger than the window — never on real files, whose largest STEP
+ * record is ~25 KB), the parse re-runs from the start and records re-fire
+ * from localID 0; consumers must therefore be idempotent by localID /
+ * expressID (the standard consumers — type index keyed by localID, roots
+ * registry keyed by expressID — are). Must be synchronous and cheap;
+ * expensive work belongs on a demand queue, not the parse path.
  * @return {StreamingIndexResult} The index, header, result and diagnostics.
  */
-export declare function buildIndexStreaming<TypeIDType>(source: ByteSource, parser: StepParser<TypeIDType>, pool: number): StreamingIndexResult<TypeIDType>;
+export declare function buildIndexStreaming<TypeIDType>(source: ByteSource, parser: StepParser<TypeIDType>, pool: number, onRecordIndexed?: (localID: number, expressID: number, typeID: TypeIDType | undefined) => void): StreamingIndexResult<TypeIDType>;
 //# sourceMappingURL=streaming_index_builder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"streaming_index_builder.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/streaming_index_builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,UAAU,EAAE,EACjB,WAAW,EACX,UAAU,EACV,cAAc,EACf,MAAM,eAAe,CAAA;AAGtB;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAElC,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAA;IAEZ;0CACsC;IACtC,WAAW,EAAE,MAAM,CAAA;IAEnB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;IAEd,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAA;IAEpB,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAA;CAClB;AAGD;;;GAGG;AACH,MAAM,WAAW,oBAAoB,CAAC,UAAU;IAC9C,MAAM,EAAE,UAAU,CAAA;IAClB,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,EAAE,CAAA;IACtC,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,mBAAmB,CAAA;CAC3B;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAC1C,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,EAC9B,IAAI,EAAE,MAAM,GAAI,oBAAoB,CAAC,UAAU,CAAC,CA2GnD"}
+{"version":3,"file":"streaming_index_builder.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/streaming_index_builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,UAAU,EAAE,EACjB,WAAW,EACX,UAAU,EACV,cAAc,EACf,MAAM,eAAe,CAAA;AAGtB;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAElC,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAA;IAEZ;0CACsC;IACtC,WAAW,EAAE,MAAM,CAAA;IAEnB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;IAEd,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAA;IAEpB,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAA;CAClB;AAGD;;;GAGG;AACH,MAAM,WAAW,oBAAoB,CAAC,UAAU;IAC9C,MAAM,EAAE,UAAU,CAAA;IAClB,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,EAAE,CAAA;IACtC,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,mBAAmB,CAAA;CAC3B;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAC1C,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,EAC9B,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EACd,CAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,KAAM,IAAI,GAChF,oBAAoB,CAAC,UAAU,CAAC,CA4GnC"}

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

@@ -27,9 +27,19 @@ import { ParseResult, } from "./step_parser.js";
  * @param source The byte source.
  * @param parser The STEP parser (typed to the schema).
  * @param pool Target window size in bytes.
+ * @param onRecordIndexed Optional per-record event, invoked live as each
+ * top-level record is indexed with its (localID, expressID, typeID) — the
+ * seam for incremental semantic consumers (M2). localIDs are dense and
+ * assigned in parse order from 0. On the rare grow-and-restart (a single
+ * record larger than the window — never on real files, whose largest STEP
+ * record is ~25 KB), the parse re-runs from the start and records re-fire
+ * from localID 0; consumers must therefore be idempotent by localID /
+ * expressID (the standard consumers — type index keyed by localID, roots
+ * registry keyed by expressID — are). Must be synchronous and cheap;
+ * expensive work belongs on a demand queue, not the parse path.
  * @return {StreamingIndexResult} The index, header, result and diagnostics.
  */
-export function buildIndexStreaming(source, parser, pool) {
+export function buildIndexStreaming(source, parser, pool, onRecordIndexed) {
     const fileSize = source.byteLength;
     // Grow-and-restart loop: the body runs a full streamed parse at the current
     // window size. It only re-runs if a single record couldn't fit the window
@@ -86,7 +96,7 @@ export function buildIndexStreaming(source, parser, pool) {
             buffer.rebaseWindow(window, 0, windowLen, windowStartFile);
             ++slides;
         };
-        const [index, result] = parser.parseDataBlockStreamed(input, onRecordBoundary);
+        const [index, result] = parser.parseDataBlockStreamed(input, onRecordBoundary, onRecordIndexed);
         // A parse that stopped short of true EOF, with the window not spanning to
         // EOF, means a single record overflowed the window: grow and retry.
         const stoppedShort = result !== ParseResult.COMPLETE;

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

@@ -0,0 +1,55 @@
+import { StepEntityConstructorAbstract } from "../step_entity_constructor.js";
+/**
+ * A per-record event handler. Receives a record's dense `localID` (assigned
+ * in parse order from 0), its `expressID`, and its `typeID` (0 for
+ * external-mapping records).
+ */
+export type RecordHandler<TypeIDType> = (localID: number, expressID: number, typeID: TypeIDType | undefined) => void;
+/**
+ * Routes the streaming parse's per-record events (M2) to consumers that
+ * subscribe by **type set**. A subscription's type set is the subtype closure
+ * of the entity constructors it names — the same `query` closure the type
+ * index and `expressIDsOfTypes` use (conway #383) — so `on([IfcRoot], …)`
+ * matches every product, relationship, property set and quantity, and any
+ * future IfcRoot subtype, with no whitelist to maintain.
+ *
+ * Feed `dispatcher.onRecordIndexed` to `buildIndexStreaming` /
+ * `parseDataBlockStreamed`. Handlers run synchronously in the parse path, so
+ * they must be cheap (copy ids into a compact structure); anything expensive
+ * belongs on a demand queue, not here.
+ *
+ * Because subscriptions match on the raw parse `typeID`, external-mapping /
+ * complex records (typeID 0) are only delivered via `onAnyRecord` — resolving
+ * their concrete type is the incremental-type-index consumer's job (it reads
+ * `multiMapping`), a follow-on. For the overwhelming majority of records
+ * (simple, one type each) type-set delivery is exact.
+ */
+export declare class StreamingRecordDispatcher<TypeIDType extends number> {
+    private readonly typed;
+    private readonly any;
+    /**
+     * Subscribe to records of the given entity types (including their
+     * subtypes).
+     *
+     * @param types The entity constructors whose subtype closures to match.
+     * @param handler Called for each matching record.
+     */
+    on(types: StepEntityConstructorAbstract<TypeIDType>[], handler: RecordHandler<TypeIDType>): void;
+    /**
+     * Subscribe to every record regardless of type (the firehose — including
+     * external-mapping records).
+     *
+     * @param handler Called for every record.
+     */
+    onAnyRecord(handler: RecordHandler<TypeIDType>): void;
+    /**
+     * The per-record callback to hand to the streaming parse. Dispatches each
+     * record to the matching subscribers. Bound so it can be passed directly.
+     *
+     * @param localID The record's dense local ID.
+     * @param expressID The record's express ID.
+     * @param typeID The record's type ID (0 for external-mapping records).
+     */
+    readonly onRecordIndexed: RecordHandler<TypeIDType>;
+}
+//# sourceMappingURL=streaming_record_dispatcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streaming_record_dispatcher.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/streaming_record_dispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAA;AAG1E;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,UAAU,IAClC,CAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,SAAS,KAAM,IAAI,CAAA;AAGhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,yBAAyB,CAAC,UAAU,SAAS,MAAM;IAE9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAGf;IAEP,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkC;IAEtD;;;;;;OAMG;IACI,EAAE,CACL,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,EAClD,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,GAAI,IAAI;IAQ9C;;;;;OAKG;IACI,WAAW,CAAE,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,GAAI,IAAI;IAI9D;;;;;;;OAOG;IACH,SAAgB,eAAe,EAAE,aAAa,CAAC,UAAU,CAAC,CAcvD;CACJ"}

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

@@ -0,0 +1,67 @@
+/**
+ * Routes the streaming parse's per-record events (M2) to consumers that
+ * subscribe by **type set**. A subscription's type set is the subtype closure
+ * of the entity constructors it names — the same `query` closure the type
+ * index and `expressIDsOfTypes` use (conway #383) — so `on([IfcRoot], …)`
+ * matches every product, relationship, property set and quantity, and any
+ * future IfcRoot subtype, with no whitelist to maintain.
+ *
+ * Feed `dispatcher.onRecordIndexed` to `buildIndexStreaming` /
+ * `parseDataBlockStreamed`. Handlers run synchronously in the parse path, so
+ * they must be cheap (copy ids into a compact structure); anything expensive
+ * belongs on a demand queue, not here.
+ *
+ * Because subscriptions match on the raw parse `typeID`, external-mapping /
+ * complex records (typeID 0) are only delivered via `onAnyRecord` — resolving
+ * their concrete type is the incremental-type-index consumer's job (it reads
+ * `multiMapping`), a follow-on. For the overwhelming majority of records
+ * (simple, one type each) type-set delivery is exact.
+ */
+export class StreamingRecordDispatcher {
+    constructor() {
+        this.typed = [];
+        this.any = [];
+        /**
+         * The per-record callback to hand to the streaming parse. Dispatches each
+         * record to the matching subscribers. Bound so it can be passed directly.
+         *
+         * @param localID The record's dense local ID.
+         * @param expressID The record's express ID.
+         * @param typeID The record's type ID (0 for external-mapping records).
+         */
+        this.onRecordIndexed = (localID, expressID, typeID) => {
+            for (const handler of this.any) {
+                handler(localID, expressID, typeID);
+            }
+            if (typeID !== void 0) {
+                for (const { set, handler } of this.typed) {
+                    if (set.has(typeID)) {
+                        handler(localID, expressID, typeID);
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Subscribe to records of the given entity types (including their
+     * subtypes).
+     *
+     * @param types The entity constructors whose subtype closures to match.
+     * @param handler Called for each matching record.
+     */
+    on(types, handler) {
+        this.typed.push({
+            set: new Set(types.flatMap((type) => type.query)),
+            handler,
+        });
+    }
+    /**
+     * Subscribe to every record regardless of type (the firehose — including
+     * external-mapping records).
+     *
+     * @param handler Called for every record.
+     */
+    onAnyRecord(handler) {
+        this.any.push(handler);
+    }
+}

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

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

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

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

package/compiled/src/step/parsing/streaming_record_dispatcher.test.js

@@ -0,0 +1,66 @@
+/* eslint-disable no-magic-numbers */
+// M2 core: record events emitted live from the streaming parse, routed by a
+// type-set subscription, let a consumer build a semantic structure
+// incrementally — and it must match what the finished model's type index
+// yields. Here: a roots registry collected from the event stream equals
+// `expressIDsOfTypes(IfcRoot)` on the resident model.
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import ParsingBuffer from "../../parsing/parsing_buffer.js";
+import IfcStepParser from "../../ifc/ifc_step_parser.js";
+import { BufferByteSource } from "./byte_source.js";
+import { buildIndexStreaming } from "./streaming_index_builder.js";
+import { StreamingRecordDispatcher } from "./streaming_record_dispatcher.js";
+import { ParseResult } from "./step_parser.js";
+import { IfcRoot, IfcProduct } from "../../ifc/ifc4_gen/index.js";
+let bytes;
+let residentRoots;
+let residentProducts;
+beforeAll(() => {
+    bytes = new Uint8Array(fs.readFileSync("data/index.ifc"));
+    const input = new ParsingBuffer(bytes);
+    IfcStepParser.Instance.parseHeader(input);
+    const [, model] = IfcStepParser.Instance.parseDataToModel(input);
+    residentRoots = new Set(model.expressIDsOfTypes(IfcRoot));
+    residentProducts = new Set(model.expressIDsOfTypes(IfcProduct));
+});
+describe("StreamingRecordDispatcher", () => {
+    test("a roots registry built live from the event stream matches the type index", () => {
+        const roots = [];
+        const products = new Set();
+        const dispatcher = new StreamingRecordDispatcher();
+        dispatcher.on([IfcRoot], (_localID, expressID) => roots.push(expressID));
+        dispatcher.on([IfcProduct], (_localID, expressID) => products.add(expressID));
+        const result = buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, // tiny pool → the parse slides; events still fire per record
+        dispatcher.onRecordIndexed);
+        expect(result.result).toBe(ParseResult.COMPLETE);
+        // index.ifc has no external-mapping records, so raw-typeID delivery is
+        // exact vs. the type index.
+        expect(new Set(roots)).toEqual(residentRoots);
+        expect(products).toEqual(residentProducts);
+        // Products are a strict subset of roots (IfcProduct ⊂ IfcRoot).
+        expect(residentProducts.size).toBeLessThan(residentRoots.size);
+        for (const p of products) {
+            expect(residentRoots.has(p)).toBe(true);
+        }
+    });
+    test("localIDs arrive dense and in ascending parse order", () => {
+        const localIDs = [];
+        const dispatcher = new StreamingRecordDispatcher();
+        dispatcher.onAnyRecord((localID) => localIDs.push(localID));
+        buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 128 * 1024, dispatcher.onRecordIndexed);
+        expect(localIDs.length).toBeGreaterThan(10);
+        // 0,1,2,…,n-1 in order.
+        expect(localIDs).toEqual(localIDs.map((_v, i) => i));
+    });
+    test("onAnyRecord sees every record; a type filter sees a subset", () => {
+        let all = 0;
+        let rootsCount = 0;
+        const dispatcher = new StreamingRecordDispatcher();
+        dispatcher.onAnyRecord(() => ++all);
+        dispatcher.on([IfcRoot], () => ++rootsCount);
+        buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 128 * 1024, dispatcher.onRecordIndexed);
+        expect(all).toBeGreaterThan(rootsCount);
+        expect(rootsCount).toBe(residentRoots.size);
+    });
+});

package/compiled/src/version/version.js

@@ -5,5 +5,5 @@
 // only the first segment (major) is meaningful and is the one CI carries forward.
 // Must stay in `vN.N.N` shape: the CI stamp regex, scripts/updateVersion.mjs, and
 // statistics.ts all match `v\d+\.\d+\.\d+`.
-const versionString = 'Conway v1.400.1226';
+const versionString = 'Conway v1.401.1237';
 export { versionString };