@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -307,9 +307,88 @@ export default class StepParser extends StepHeaderParser {
             if (next.done === true) {
                 return next.value;
             }
+            if (typeof next.value === "number") {
+                onProgress?.(next.value);
+            }
+        }
+    }
+    /**
+     * Streaming driver over parseDataBlockIncremental: identical parse (same
+     * generator body) but invokes `onRecordBoundary` at every top-level record
+     * boundary so a caller feeding the parser from a moving window can slide
+     * that window forward while the rewind stack is empty. See
+     * streaming_index_builder.ts for the coordinator that owns the window.
+     *
+     * @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. Must be
+     * synchronous on this driver — a returned Promise is a caller bug.
+     * @param onRecordIndexed Called as each top-level record is indexed, with
+     * its localID, expressID, typeID (0 for external-mapping records) and the
+     * record's bytes as an un-materialised `(buffer, byteOffset, byteLength)`
+     * window view — the seam for incremental semantic consumers (type index,
+     * roots registry, names skeleton). See {@link RecordEventHandler} for the
+     * window-lifetime rule. 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, onRecordIndexed, onProgress, sink) {
+        const parser = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink);
+        while (true) {
+            const next = parser.next();
+            if (next.done === true) {
+                return next.value;
+            }
+            if (typeof next.value !== "number") {
+                throw new Error("parseDataBlockStreamed: async window slide requires parseDataBlockStreamedAsync");
+            }
             onProgress?.(next.value);
         }
     }
+    /**
+     * Cooperative variant of parseDataBlockStreamed: identical parse and
+     * window-slide behaviour (same generator body, same boundary callback),
+     * but periodically awaits a macrotask so the event loop can run —
+     * browsers repaint progress UI during a large streamed parse instead of
+     * flagging the tab as stalled. Issue #301 §2 for the streamed path.
+     *
+     * @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. May return
+     * a Promise when the slide itself is I/O (an async ByteSource); this
+     * driver awaits it before the next record is lexed.
+     * @param onRecordIndexed Called as each top-level record is indexed — see
+     * parseDataBlockStreamed.
+     * @param onProgress Optional byte-cursor progress callback.
+     * @param sink Optional index sink (columnar builds).
+     * @param yieldIntervalMs Minimum ms between event-loop yields.
+     * @return {Promise<BlockParseResult>} The parsing result, including the
+     * index and result enum.
+     */
+    async parseDataBlockStreamedAsync(input, onRecordBoundary, onRecordIndexed, onProgress, sink, yieldIntervalMs = DEFAULT_PARSE_YIELD_INTERVAL_MS) {
+        const parser = this.parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink);
+        let lastYield = Date.now();
+        while (true) {
+            const next = parser.next();
+            if (next.done === true) {
+                return next.value;
+            }
+            if (typeof next.value !== "number") {
+                await next.value;
+                continue;
+            }
+            const progressed = onProgress?.(next.value);
+            if (progressed !== void 0 &&
+                typeof progressed.then === "function") {
+                await progressed;
+            }
+            if (Date.now() - lastYield >= yieldIntervalMs) {
+                await yieldToEventLoop();
+                lastYield = Date.now();
+            }
+        }
+    }
     /**
      * Cooperative variant of parseDataBlock: identical parse (same generator
      * body), but periodically awaits a macrotask so the event loop can run —
@@ -330,7 +409,9 @@ export default class StepParser extends StepHeaderParser {
             if (next.done === true) {
                 return next.value;
             }
-            onProgress?.(next.value);
+            if (typeof next.value === "number") {
+                onProgress?.(next.value);
+            }
             if (Date.now() - lastYield >= yieldIntervalMs) {
                 await yieldToEventLoop();
                 lastYield = Date.now();
@@ -347,8 +428,18 @@ 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) {
+    *parseDataBlockIncremental(input, onRecordBoundary, onRecordIndexed, sink) {
         const indexResult = { elements: [] };
+        // With a sink, completed top-level entries are diverted instead of
+        // accumulated — the object index never materialises (columnar path).
+        let topLevelCount = 0;
+        const pushEntry = sink !== void 0 ?
+            (entry) => {
+                sink.pushTopLevel(entry);
+            } :
+            (entry) => {
+                indexResult.elements.push(entry);
+            };
         const match = input.match;
         const comment = () => match(commentParser);
         const whitespace = () => {
@@ -394,7 +485,10 @@ export default class StepParser extends StepHeaderParser {
                 return syntaxError();
             }
             whitespace();
-            const startElement = input.cursor;
+            // File-absolute (== input.cursor when initialOffset is 0, i.e. every
+            // resident parse; file-absolute under a streaming moving window so the
+            // recorded address/length stay stable as the window slides).
+            const startElement = input.address;
             let stackDepth = 1;
             const savedInlineElements = inlineElements;
             inlineElements = void 0;
@@ -492,6 +586,16 @@ export default class StepParser extends StepHeaderParser {
             if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
                 yield input.cursor;
             }
+            // Top-level record boundary: the rewind stack is empty and the cursor
+            // sits at the next record's leading whitespace/`#`. A streaming driver
+            // uses this to slide its moving window forward (see
+            // streaming_index_builder.ts). No-op on the resident path. An async
+            // slide (OPFS File.slice / HTTP range) is yielded so the async
+            // driver can await it before the next record is lexed.
+            const slide = onRecordBoundary?.(input);
+            if (slide !== void 0 && typeof slide.then === "function") {
+                yield slide;
+            }
             if (!charws(HASH)) {
                 if (tokenws(END_SECTION)) {
                     return parseResult(ParseResult.COMPLETE);
@@ -516,7 +620,10 @@ export default class StepParser extends StepHeaderParser {
                 }
                 whitespace();
                 inlineElements = void 0;
-                const startElement = input.cursor;
+                // File-absolute (== input.cursor when initialOffset is 0, i.e. every
+                // resident parse; file-absolute under a streaming moving window so the
+                // recorded address/length stay stable as the window slides).
+                const startElement = input.address;
                 // todo, loop and read inline then add them to a special "External Mapping" node.
                 while (!charws(CLOSE_PAREN)) {
                     input.begin();
@@ -530,7 +637,7 @@ export default class StepParser extends StepHeaderParser {
                 if (!charws(SEMICOLON)) {
                     return syntaxError();
                 }
-                indexResult.elements.push({
+                pushEntry({
                     address: startElement,
                     length: input.address - startElement,
                     typeID: 0, // external mapping special case.
@@ -538,6 +645,15 @@ export default class StepParser extends StepHeaderParser {
                     inlineEntities: inlineElements,
                     multiMapping: multiElements
                 });
+                // AFTER the entry is indexed, so a consumer that queries the index
+                // from this event sees the record the event is about — the columns
+                // are the source of truth a prefix-derived consumer reads. Still
+                // before the window can slide, so the record bytes stay valid.
+                {
+                    const recordLen = input.address - startElement;
+                    onRecordIndexed?.(topLevelCount, expressID, 0, input.buffer, input.cursor - recordLen, recordLen);
+                }
+                ++topLevelCount;
                 multiElements = void 0;
                 continue;
             }
@@ -547,7 +663,10 @@ export default class StepParser extends StepHeaderParser {
                 return syntaxError();
             }
             whitespace();
-            const startElement = input.cursor;
+            // File-absolute (== input.cursor when initialOffset is 0, i.e. every
+            // resident parse; file-absolute under a streaming moving window so the
+            // recorded address/length stay stable as the window slides).
+            const startElement = input.address;
             let stackDepth = 1;
             inlineElements = void 0;
             while (stackDepth > 0) {
@@ -574,9 +693,38 @@ export default class StepParser extends StepHeaderParser {
                         input.begin();
                         const elementResult = parseInlineElement();
                         if (elementResult !== (void 0)) {
-                            for (const element of elementResult[0].elements) {
-                                element.expressID = expressID;
-                            }
+                            // No stamping here. This used to run
+                            //
+                            //   for ( const element of elementResult[0].elements ) {
+                            //     element.expressID = expressID
+                            //   }
+                            //
+                            // and elementResult[0] is `indexResult` - syntaxError() returns
+                            // it wholesale - so that wrote THIS record's express ID over
+                            // every top-level entry indexed so far in the block.
+                            //
+                            // It cannot have been doing anything useful. Both pushEntry
+                            // sites already set `expressID` at construction, so every entry
+                            // arrives correct and the loop could only overwrite correct
+                            // values with one wrong one. The same recovery inside the nested
+                            // parseInlineElement - begin, parse, rollback, tokenws(INF) - has
+                            // never had the loop and works.
+                            //
+                            // Note it ran BEFORE the rollback and the INF check, so it was
+                            // never specific to INF: any top-level inline-instance parse
+                            // failure poisoned the index the same way. And the index is not
+                            // discarded on a syntax error - parseDataToModel builds the
+                            // model from itemIndex.elements whatever the ParseResult, and
+                            // the loaders only log and continue - so a poisoned index does
+                            // reach consumers.
+                            //
+                            // What kept it hidden is narrower than that: no public corpus
+                            // model reaches this recovery at all. A private one does, via an
+                            // exporter writing `IFCQUANTITYLENGTH(...,INF,$)` for an
+                            // unbounded quantity - not valid ISO 10303-21, but what the tool
+                            // emits - where it cost 3,116 entities and produced 630
+                            // relationship failures all naming the same record.
+                            // See #412, #481, #482.
                             input.rollback();
                             if (tokenws(INF)) {
                                 break;
@@ -620,13 +768,19 @@ export default class StepParser extends StepHeaderParser {
             if (!charws(SEMICOLON)) {
                 return syntaxError();
             }
-            indexResult.elements.push({
+            pushEntry({
                 address: startElement,
                 length: input.address - startElement,
                 typeID: foundItem,
                 expressID: expressID,
                 inlineEntities: inlineElements,
             });
+            // See the external-mapping site above: indexed first, then announced.
+            {
+                const recordLen = input.address - startElement;
+                onRecordIndexed?.(topLevelCount, expressID, foundItem, input.buffer, input.cursor - recordLen, recordLen);
+            }
+            ++topLevelCount;
         }
         // Got here without finding an end of the section.
         return parseResult(ParseResult.INCOMPLETE);

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

@@ -1,6 +1,6 @@
 import ParsingConstants from "../../parsing/parsing_constants.js";
 import ParsingDfa16Table from "../../parsing/parsing_dfa_16table.js";
-import { decodeUtf8, installResizableTextDecoderShim } from "./decode_utf8.js";
+import { decodeStepString, installResizableTextDecoderShim } from "./decode_utf8.js";
 // Emscripten 6's browser wasm heap is a resizable ArrayBuffer, on which strict
 // browsers' TextDecoder.decode() throws — including the glue's own UTF8ToString
 // during geometry extraction. Install the global copy-first shim as the STEP
@@ -76,7 +76,7 @@ class StepStringParser extends ParsingDfa16Table {
                             if (nextCursor < endCursor && input[nextCursor] === QUOTE) {
                                 result ??= "";
                                 if (cursor > reificationIndex) {
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor - 1));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor - 1));
                                 }
                                 result += "'";
                                 cursor = nextCursor + 1;
@@ -84,7 +84,7 @@ class StepStringParser extends ParsingDfa16Table {
                             }
                             else {
                                 result ??= "";
-                                result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                result += decodeStepString(input.subarray(reificationIndex, cursor));
                                 return result;
                             }
                         }
@@ -111,7 +111,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     const nextChar2 = input[nextCursor2];
                                     if (nextChar2 !== BSLASH) {
                                         result ??= "";
-                                        result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                        result += decodeStepString(input.subarray(reificationIndex, cursor));
                                         cursor = nextCursor2 + 1;
                                         break;
                                     }
@@ -124,7 +124,7 @@ class StepStringParser extends ParsingDfa16Table {
                                         return result;
                                     }
                                     result ??= "";
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor));
                                     codePage = nextChar3 - A;
                                     cursor = nextCursor3 + 1;
                                     reificationIndex = cursor;
@@ -138,7 +138,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     const nextChar2 = input[nextCursor2];
                                     if (nextChar2 !== BSLASH) {
                                         result ??= "";
-                                        result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                        result += decodeStepString(input.subarray(reificationIndex, cursor));
                                         cursor = nextCursor2 + 1;
                                         break;
                                     }
@@ -148,7 +148,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     }
                                     const nextChar3 = input[nextCursor3];
                                     result ??= "";
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor));
                                     /* eslint-disable no-magic-numbers */
                                     if (nextChar3 < 127) {
                                         result += String.fromCharCode(nextChar3);
@@ -171,7 +171,7 @@ class StepStringParser extends ParsingDfa16Table {
                                     }
                                     const nextChar2 = input[nextCursor2];
                                     result ??= "";
-                                    result += decodeUtf8(input.subarray(reificationIndex, cursor));
+                                    result += decodeStepString(input.subarray(reificationIndex, cursor));
                                     const hexParserTil0 = (count) => {
                                         if (nextCursor2 + 1 >= endCursor || input[nextCursor2 + 1] !== BSLASH) {
                                             return false;

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

@@ -0,0 +1,141 @@
+import { ByteSource, ReadableByteSource } from "./byte_source.js";
+import { ColumnarIndexSink, StepIndexColumns } from "./columnar_index.js";
+import { RecordEventHandler } from "./record_event.js";
+import StepParser, { ParseResult, StepHeader, StepIndexEntry, StepIndexSink } from "./step_parser.js";
+/**
+ * Diagnostics from a streaming index build — how hard the moving window had
+ * to work, so a pool-size sweep can compare cost against a resident parse.
+ */
+export interface StreamingIndexStats {
+    /** Target window size in bytes (the pool). */
+    pool: number;
+    /** Physical window buffer size actually used (grows past `pool` only if a
+     * single record exceeds the pool). */
+    windowBytes: number;
+    /** Number of times the window slid forward. */
+    slides: number;
+    /** Largest single top-level record observed, in bytes. */
+    maxRecordLen: number;
+    /** Total bytes read from the source (≈ file size + re-reads on growth). */
+    bytesRead: number;
+}
+/**
+ * The output of a streaming index build: the same element index a resident
+ * `parseDataBlock` produces, plus the header and window diagnostics.
+ */
+export interface StreamingIndexResult<TypeIDType> {
+    header: StepHeader;
+    elements: StepIndexEntry<TypeIDType>[];
+    result: ParseResult;
+    stats: StreamingIndexStats;
+}
+/**
+ * Build the entity index by streaming a `ByteSource` through a fixed-size
+ * moving window, instead of parsing one resident buffer. The parse loop is
+ * byte-for-byte the resident one (`StepParser.parseDataBlockStreamed` drives
+ * the same generator); this coordinator only owns the window: it fills it,
+ * parses the header from the first fill, then slides the window forward at
+ * top-level record boundaries as the parser advances.
+ *
+ * Because the parser records file-absolute addresses and its rewind stack is
+ * empty at every top-level boundary, sliding there is transparent: the
+ * unconsumed tail is copied to the front, fresh bytes are appended, and the
+ * buffer is rebased so `address` keeps its file-absolute value. Peak JS heap
+ * for the index build is therefore `window + index columns`, independent of
+ * file size.
+ *
+ * The window slides only once the cursor passes `pool / 2`, bounding the
+ * memmove frequency; a record up to `pool / 2` bytes always fits after a
+ * slide. If a single record exceeds that (never on the current corpus, whose
+ * largest STEP record is ~25 KB), the whole parse restarts from the
+ * beginning with the window doubled, and repeats until every record fits —
+ * correctness over the pathological case, at the cost of a re-scan. (M1's
+ * production path will instead grow in place / restart from the last
+ * boundary; from-scratch keeps the spike simple.)
+ *
+ * @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, onRecordIndexed?: RecordEventHandler<TypeIDType>, sink?: StepIndexSink<TypeIDType>): StreamingIndexResult<TypeIDType>;
+/**
+ * Cooperative twin of {@link buildIndexStreaming}: identical parse, window
+ * and grow-and-restart behaviour (mirrored the same way the parser mirrors
+ * parseDataBlock/parseDataBlockAsync), but the parse periodically yields to
+ * the event loop so browsers repaint progress UI mid-parse instead of
+ * flagging the tab as stalled (issue #301 §2 for the streamed path).
+ *
+ * @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 (see buildIndexStreaming).
+ * @param sink Optional index sink (columnar builds).
+ * @param onProgress Optional progress callback with the ABSOLUTE source byte
+ * cursor (unlike the parser's window-relative cursor), so callers can report
+ * `cursor / source.byteLength` directly.
+ * @param yieldIntervalMs Minimum ms between event-loop yields.
+ * @return {Promise<StreamingIndexResult>} The index, header, result and
+ * diagnostics.
+ */
+export declare function buildIndexStreamingAsync<TypeIDType>(source: ReadableByteSource, parser: StepParser<TypeIDType>, pool: number, onRecordIndexed?: RecordEventHandler<TypeIDType>, sink?: StepIndexSink<TypeIDType>, onProgress?: (absoluteByteCursor: number) => unknown, yieldIntervalMs?: number): Promise<StreamingIndexResult<TypeIDType>>;
+/**
+ * The output of a columnar streaming index build: the index in its SoA
+ * column form (no object phase — see columnar_index.ts), plus the header and
+ * window diagnostics.
+ */
+export interface StreamingColumnarIndexResult<TypeIDType> {
+    header: StepHeader;
+    columns: StepIndexColumns<TypeIDType>;
+    result: ParseResult;
+    stats: StreamingIndexStats;
+}
+/**
+ * Build the entity index by streaming, **directly into typed-array columns**
+ * (M7): identical parse and window behaviour to {@link buildIndexStreaming},
+ * but completed records are encoded straight into a {@link ColumnarIndexSink}
+ * so the per-record object index never materialises. Peak JS heap for the
+ * index build becomes `window + columns` — the object phase (the dominant
+ * heap cost on large models) is gone.
+ *
+ * @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 (see buildIndexStreaming).
+ * @param sink Optional caller-owned sink. Pass one to hold the *live* columns
+ * while the parse runs — that is what a prefix-derived consumer
+ * ({@link import('./prefix_type_index').PrefixTypeIndex}) reads. Omit it and
+ * the columns only exist once this returns.
+ * @return {StreamingColumnarIndexResult} Columns, header, result, stats.
+ */
+export declare function buildColumnarIndexStreaming<TypeIDType extends number>(source: ByteSource, parser: StepParser<TypeIDType>, pool: number, onRecordIndexed?: RecordEventHandler<TypeIDType>, sink?: ColumnarIndexSink<TypeIDType>): StreamingColumnarIndexResult<TypeIDType>;
+/**
+ * Cooperative twin of {@link buildColumnarIndexStreaming}: identical
+ * columnar build, but the parse periodically yields to the event loop (see
+ * {@link buildIndexStreamingAsync}) and reports absolute byte-cursor
+ * progress — the browser-facing variant for large models.
+ *
+ * @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 (see buildIndexStreaming).
+ * @param onProgress Optional absolute byte-cursor progress callback.
+ * @param yieldIntervalMs Minimum ms between event-loop yields.
+ * @param sink Optional caller-owned sink (see
+ * {@link buildColumnarIndexStreaming}) — the seam for reading the columns
+ * while the parse is still running.
+ * @return {Promise<StreamingColumnarIndexResult>} Columns, header, result,
+ * stats.
+ */
+export declare function buildColumnarIndexStreamingAsync<TypeIDType extends number>(source: ReadableByteSource, parser: StepParser<TypeIDType>, pool: number, onRecordIndexed?: RecordEventHandler<TypeIDType>, onProgress?: (absoluteByteCursor: number) => unknown, yieldIntervalMs?: number, sink?: ColumnarIndexSink<TypeIDType>): Promise<StreamingColumnarIndexResult<TypeIDType>>;
+//# sourceMappingURL=streaming_index_builder.d.ts.map

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

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