@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -0,0 +1,153 @@
+/**
+ * A random-access, forward-readable byte source for the streaming parser.
+ *
+ * The streaming index builder (see streaming_index_builder.ts) reads the
+ * source sequentially into a small moving window, so a `ByteSource` only has
+ * to satisfy positioned reads — it never needs the whole file resident. The
+ * in-memory `BufferByteSource` here is for tests and the resident case; a
+ * file-descriptor source (node) or an HTTP-Range source (M4) implements the
+ * same shape without holding the file in the JS heap.
+ *
+ * M0 keeps reads synchronous to reuse the existing synchronous parse loop
+ * unchanged. The asynchronous variant (network pull-parser) is M4.
+ */
+export interface ByteSource {
+    /** Total length of the source in bytes. */
+    readonly byteLength: number;
+    /**
+     * Read up to `length` bytes starting at `offset` into `into` at
+     * `intoOffset`, returning the number of bytes actually copied (fewer than
+     * `length` only at end of source).
+     *
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): number;
+}
+/**
+ * A `ByteSource` backed by an in-memory `Uint8Array`. Reads are `subarray`
+ * copies into the destination window. Used by tests and the resident path;
+ * note it does hold the whole buffer (that residency is the source's, not the
+ * parser's — the parser still only touches a window).
+ */
+export declare class BufferByteSource implements ByteSource {
+    private readonly buffer;
+    /**
+     * @param buffer The backing bytes.
+     */
+    constructor(buffer: Uint8Array);
+    /**
+     * @return {number} The buffer length.
+     */
+    get byteLength(): number;
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): number;
+}
+/**
+ * A `ByteSource` whose `read` is asynchronous — a `StepExternalByteStore`
+ * (OPFS `File.slice()`), or any other store that cannot serve bytes
+ * synchronously on this thread. `buildIndexStreamingAsync` accepts either
+ * this or a sync {@link ByteSource}; the sync builder does not.
+ */
+export interface AsyncByteSource {
+    /** Total length of the source in bytes. */
+    readonly byteLength: number;
+    /**
+     * Read up to `length` bytes starting at `offset` into `into` at
+     * `intoOffset`. Same contract as {@link ByteSource.read}, but async.
+     *
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {Promise<number>} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): Promise<number>;
+}
+/**
+ * Either a sync or async positioned byte source. The cooperative index
+ * builder awaits each fill; a sync source just resolves immediately.
+ */
+export type ReadableByteSource = ByteSource | AsyncByteSource;
+/**
+ * Minimal sync-access handle (OPFS `FileSystemSyncAccessHandle` in a
+ * worker). Defined here so the source has no DOM lib dependency.
+ */
+export interface SyncAccessHandleLike {
+    /**
+     * Read into `buffer` starting at file offset `options.at`.
+     *
+     * @param buffer Destination view.
+     * @param options `{ at }` file offset (default 0).
+     * @return {number} Bytes copied.
+     */
+    read(buffer: Uint8Array, options?: {
+        at?: number;
+    }): number;
+    /**
+     * @return {number} File size in bytes.
+     */
+    getSize(): number;
+}
+/**
+ * A `ByteSource` over an OPFS (or similar) synchronous access handle —
+ * the worker-side parse feed for M1b write-through. Reads never
+ * materialise the file as one `ArrayBuffer`.
+ */
+export declare class SyncAccessHandleByteSource implements ByteSource {
+    private readonly handle_;
+    /**
+     * @param handle_ A sync-access handle already opened on the file.
+     */
+    constructor(handle_: SyncAccessHandleLike);
+    /**
+     * @return {number} The file length.
+     */
+    get byteLength(): number;
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): number;
+}
+/**
+ * An {@link AsyncByteSource} over a {@link StepExternalByteStore} — the
+ * main-thread parse feed for a file that is already in OPFS (or any
+ * store whose `read` is async). Peak parse scratch is one window, not
+ * the whole file.
+ */
+export declare class StoreByteSource implements AsyncByteSource {
+    private readonly store_;
+    /**
+     * @param store_ The external store (same bytes the model will page).
+     */
+    constructor(store_: {
+        readonly byteLength: number;
+        read(offset: number, length: number): Promise<Uint8Array>;
+    });
+    /**
+     * @return {number} The store length.
+     */
+    get byteLength(): number;
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {Promise<number>} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): Promise<number>;
+}
+//# sourceMappingURL=byte_source.d.ts.map

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,47 @@
+/* eslint-disable no-magic-numbers */
+import { describe, expect, test } from "@jest/globals";
+import { BufferByteSource, StoreByteSource, SyncAccessHandleByteSource, } from "./byte_source.js";
+import { InMemoryStepByteStore } from "../step_buffer_provider.js";
+import { FileDescriptorByteSource } from "./byte_source_node.js";
+describe("ByteSource implementations", () => {
+    const bytes = new Uint8Array([10, 20, 30, 40, 50]);
+    test("BufferByteSource copies a range", () => {
+        const source = new BufferByteSource(bytes);
+        const into = new Uint8Array(4);
+        expect(source.read(1, 3, into, 1)).toBe(3);
+        expect([...into]).toEqual([0, 20, 30, 40]);
+    });
+    test("StoreByteSource matches BufferByteSource over the same bytes", async () => {
+        const source = new StoreByteSource(new InMemoryStepByteStore(bytes));
+        const into = new Uint8Array(3);
+        expect(await source.read(2, 10, into, 0)).toBe(3);
+        expect([...into]).toEqual([30, 40, 50]);
+    });
+    test("SyncAccessHandleByteSource reads through the handle contract", () => {
+        const handle = {
+            getSize: () => bytes.length,
+            read(buffer, options) {
+                const at = options?.at ?? 0;
+                const want = Math.min(buffer.length, bytes.length - at);
+                buffer.set(bytes.subarray(at, at + want));
+                return want;
+            },
+        };
+        const source = new SyncAccessHandleByteSource(handle);
+        const into = new Uint8Array(2);
+        expect(source.read(3, 2, into, 0)).toBe(2);
+        expect([...into]).toEqual([40, 50]);
+    });
+    test("FileDescriptorByteSource reads index.ifc without holding it", () => {
+        const source = FileDescriptorByteSource.open("data/index.ifc");
+        try {
+            const head = new Uint8Array(15);
+            const got = source.read(0, 15, head, 0);
+            expect(got).toBe(15);
+            expect(new TextDecoder().decode(head).startsWith("ISO-10303-21;")).toBe(true);
+        }
+        finally {
+            source.close();
+        }
+    });
+});

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

@@ -0,0 +1,41 @@
+import { ByteSource } from "./byte_source.js";
+/**
+ * A `ByteSource` over a Node file descriptor — the node/test twin of
+ * `SyncAccessHandleByteSource`. The file is never held as one JS
+ * buffer; each `read` is `fs.readSync` into the caller's window.
+ *
+ * The caller owns the fd (open + close). This class does not close it.
+ */
+export declare class FileDescriptorByteSource implements ByteSource {
+    private readonly fd_;
+    private readonly byteLength_;
+    /**
+     * @param fd_ An fd open for reading.
+     * @param byteLength_ File size in bytes (`fstat.size`).
+     */
+    constructor(fd_: number, byteLength_: number);
+    /**
+     * Open `path` read-only and wrap it. Caller must {@link close}.
+     *
+     * @param path Filesystem path.
+     * @return {FileDescriptorByteSource} The source.
+     */
+    static open(path: string): FileDescriptorByteSource;
+    /**
+     * @return {number} The file length.
+     */
+    get byteLength(): number;
+    /**
+     * Close the underlying fd. Further reads throw.
+     */
+    close(): void;
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset: number, length: number, into: Uint8Array, intoOffset: number): number;
+}
+//# sourceMappingURL=byte_source_node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"byte_source_node.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/byte_source_node.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAG1C;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,UAAU;IAOrD,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW;IANhC;;;OAGG;gBAEkB,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM;IAExC;;;;;OAKG;WACW,IAAI,CAAE,IAAI,EAAE,MAAM,GAAI,wBAAwB;IAO5D;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;;OAMG;IACI,IAAI,CACP,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAI,MAAM;CAUnF"}

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

@@ -0,0 +1,54 @@
+import fs from 'fs';
+/**
+ * A `ByteSource` over a Node file descriptor — the node/test twin of
+ * `SyncAccessHandleByteSource`. The file is never held as one JS
+ * buffer; each `read` is `fs.readSync` into the caller's window.
+ *
+ * The caller owns the fd (open + close). This class does not close it.
+ */
+export class FileDescriptorByteSource {
+    /**
+     * @param fd_ An fd open for reading.
+     * @param byteLength_ File size in bytes (`fstat.size`).
+     */
+    constructor(fd_, byteLength_) {
+        this.fd_ = fd_;
+        this.byteLength_ = byteLength_;
+    }
+    /**
+     * Open `path` read-only and wrap it. Caller must {@link close}.
+     *
+     * @param path Filesystem path.
+     * @return {FileDescriptorByteSource} The source.
+     */
+    static open(path) {
+        const fd = fs.openSync(path, 'r');
+        return new FileDescriptorByteSource(fd, fs.fstatSync(fd).size);
+    }
+    /**
+     * @return {number} The file length.
+     */
+    get byteLength() {
+        return this.byteLength_;
+    }
+    /**
+     * Close the underlying fd. Further reads throw.
+     */
+    close() {
+        fs.closeSync(this.fd_);
+    }
+    /**
+     * @param offset Absolute source offset to read from.
+     * @param length Maximum number of bytes to read.
+     * @param into Destination buffer.
+     * @param intoOffset Offset within `into` to write at.
+     * @return {number} The number of bytes copied.
+     */
+    read(offset, length, into, intoOffset) {
+        const end = Math.min(offset + length, this.byteLength_);
+        if (end <= offset) {
+            return 0;
+        }
+        return fs.readSync(this.fd_, into, intoOffset, end - offset, offset);
+    }
+}

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

@@ -0,0 +1,103 @@
+import { StepIndexEntry, StepIndexSink } from "./step_parser.js";
+/**
+ * The entity index in its **columnar (SoA) form** — the same packed typed-array
+ * columns `StepModelBase` compacts the object index into at construction, but
+ * produced *directly by the parse* so the per-record object phase never exists
+ * (M7; "Structural memory" in the design doc).
+ *
+ * Layout mirrors the model's internal columns exactly:
+ *
+ *   [0, firstInlineElement)   top-level records, in parse order (localID)
+ *   [firstInlineElement, count)  inline entities, in the model's unfold order
+ *
+ * `expressID` covers only the top-level range (inline entities have none).
+ * `typeID` uses −1 for "no concrete type" (matching the sidecar sentinel);
+ * 0 is a valid type (external mapping). The rare records with children —
+ * inline entities or a multi-mapping — are additionally retained as objects
+ * in `complexEntries` / consumed during the unfold, exactly the set the model
+ * keeps today; everything else is scalars only.
+ */
+export interface StepIndexColumns<TypeIDType> {
+    address: Uint32Array;
+    length: Uint32Array;
+    typeID: Int32Array;
+    expressID: Uint32Array;
+    /** Total rows (top-level + inline). */
+    count: number;
+    /** Top-level record count == start of the inline range. */
+    firstInlineElement: number;
+    /** Records with a multiMapping, keyed by localID (rare; retained). */
+    complexEntries?: Map<number, StepIndexEntry<TypeIDType>>;
+    /** True if top-level express IDs arrived in non-decreasing order. */
+    expressIdsSorted: boolean;
+}
+/** Type sentinel for "no concrete type" in the typeID column. */
+export declare const COLUMN_UNDEFINED_TYPE = -1;
+/**
+ * A {@link StepIndexSink} that encodes top-level records straight into
+ * chunked-segment typed-array columns, so the parse holds **no per-record
+ * objects** for the (overwhelmingly common) simple records. Records with
+ * children keep their object form — inline entities are unfolded into the
+ * inline column range at {@link finalize}, and multi-mapping holders are
+ * retained for the model's `complexEntries`, matching the object path's
+ * behaviour entry-for-entry.
+ *
+ * `reset` supports the streaming builder's rare grow-and-restart: columns
+ * rewind to empty without reallocating the first segment.
+ */
+export declare class ColumnarIndexSink<TypeIDType extends number> implements StepIndexSink<TypeIDType> {
+    private segments_;
+    private count_;
+    /** Entries with inlineEntities and/or multiMapping, keyed by localID. */
+    private retained_;
+    private expressIdsSorted_;
+    private previousExpressID_;
+    /**
+     * @return {number} Top-level records pushed so far.
+     */
+    get topLevelCount(): number;
+    /**
+     * Encode one completed top-level record into the columns. The entry object
+     * is not kept unless it carries children (inline entities / multi-mapping).
+     *
+     * @param entry The completed top-level index entry.
+     */
+    pushTopLevel(entry: StepIndexEntry<TypeIDType>): void;
+    /**
+     * Rewind to empty (the streaming builder's grow-and-restart). The first
+     * segment is kept for reuse.
+     */
+    reset(): void;
+    /**
+     * Snapshot the columns pushed SO FAR into a self-contained prefix index,
+     * without disturbing the sink — the parse can keep pushing afterwards and
+     * a later snapshot/finalize sees the full data. Safe to call between the
+     * cooperative parse's yields (the parser only suspends at top-level
+     * record boundaries, where the sink is consistent). Top-level localIDs
+     * are stable across snapshots (dense parse order), so consumers can carry
+     * per-localID cursors from one snapshot to the next; inline-range
+     * localIDs are NOT stable (the inline tail re-packs after the growing
+     * top-level range) and must not be carried across snapshots.
+     *
+     * @return {StepIndexColumns} A prefix columnar index over the records
+     * pushed so far.
+     */
+    snapshot(): StepIndexColumns<TypeIDType>;
+    /**
+     * Assemble the final columns: concatenate the top-level segments (one
+     * column at a time, bounding transient overhead to a single column's
+     * segments) and unfold retained inline entities into the inline range in
+     * the model's exact unfold order.
+     *
+     * @return {StepIndexColumns} The finished columnar index.
+     */
+    finalize(): StepIndexColumns<TypeIDType>;
+    /**
+     * Shared assembly behind {@link snapshot} and {@link finalize} — pure
+     * over the sink's current state.
+     *
+     * @return {StepIndexColumns} The assembled columnar index.
+     */
+    private assemble_;
+}
+//# sourceMappingURL=columnar_index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columnar_index.d.ts","sourceRoot":"","sources":["../../../../src/step/parsing/columnar_index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAEd,aAAa,EACd,MAAM,eAAe,CAAA;AAGtB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,gBAAgB,CAAC,UAAU;IAE1C,OAAO,EAAE,WAAW,CAAA;IACpB,MAAM,EAAE,WAAW,CAAA;IACnB,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,WAAW,CAAA;IAEtB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAA;IAEb,2DAA2D;IAC3D,kBAAkB,EAAE,MAAM,CAAA;IAE1B,sEAAsE;IACtE,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC,CAAA;IAExD,qEAAqE;IACrE,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAGD,iEAAiE;AACjE,eAAO,MAAM,qBAAqB,KAAK,CAAA;AAmBvC;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB,CAAC,UAAU,SAAS,MAAM,CACxD,YAAW,aAAa,CAAC,UAAU,CAAC;IAElC,OAAO,CAAC,SAAS,CAAsB;IAEvC,OAAO,CAAC,MAAM,CAAI;IAElB,yEAAyE;IACzE,OAAO,CAAC,SAAS,CAAgD;IAEjE,OAAO,CAAC,iBAAiB,CAAO;IAEhC,OAAO,CAAC,kBAAkB,CAAI;IAE9B;;OAEG;IACH,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED;;;;;OAKG;IACI,YAAY,CAAE,KAAK,EAAE,cAAc,CAAC,UAAU,CAAC,GAAI,IAAI;IAkC9D;;;OAGG;IACI,KAAK,IAAI,IAAI;IAQpB;;;;;;;;;;;;;OAaG;IACI,QAAQ,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAI/C;;;;;;;OAOG;IACI,QAAQ,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAI/C;;;;;OAKG;IACH,OAAO,CAAC,SAAS;CAyElB"}