@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/logging/logger.test.js

@@ -39,6 +39,36 @@ describe("Logger levels + sink", () => {
         expect(entry?.count).toBe(3);
         expect(entry?.expressIDs.size).toBe(3);
     });
+    // The whole point of the parameter: an ID written into the message text
+    // makes every occurrence its own entry, and `count` then reports 1 for a
+    // problem that hit hundreds of records. One AP242 model in the regression
+    // corpus produced 272 such rows before this.
+    test("the expressID argument dedupes where interpolating the ID does not", () => {
+        // Deliberately mixed: the parameter takes an express ID as a number and a
+        // local ID as an already-formatted string, and both must key the same way.
+        const numericRecord = 11;
+        const records = [numericRecord, "22", "33"];
+        for (const record of records) {
+            Logger.error("boom", record);
+        }
+        const entries = Logger.getErrors();
+        expect(entries.length).toBe(1);
+        expect(entries[0].count).toBe(records.length);
+        expect(entries[0].expressIDs).toEqual(new Set(records.map((record) => `${record}`)));
+        // ...and the ID never reaches the buffered message, so the CSV cell is the
+        // family rather than one instance of it.
+        expect(entries[0].message).toBe("boom");
+        // The console echo still carries it, though. Only the buffer needs the ID
+        // out of the way, and a console line read once by a person should not lose
+        // its only pointer to the record.
+        expect(echoed).toEqual([["error", `boom expressID: ${numericRecord}`]]);
+    });
+    test("the argument wins over an in-message expressID suffix", () => {
+        Logger.error("clash expressID: 1", 2);
+        const entries = Logger.getErrors();
+        expect(entries[0].message).toBe("clash");
+        expect(entries[0].expressIDs).toEqual(new Set(["2"]));
+    });
     test("isLevelEnabled matches the threshold ordering", () => {
         Logger.setLogLevel(LogLevel.WARNING);
         expect(Logger.isLevelEnabled(LogLevel.DEBUG)).toBe(false);

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

@@ -0,0 +1,17 @@
+/**
+ * `@bldrs-ai/conway/mem` — the general memory system (src/core/mem;
+ * design/new/streaming-federated-loader.md, resident-memory design).
+ *
+ * Domain-neutral primitives for explicitly budgeted residency:
+ * {@link ChunkedPool} (accounting-only fixed-chunk freelist),
+ * {@link SharedAssetPool} (refcounted instance⇄asset sharing), and
+ * {@link SharedByteBudget} (a byte budget shareable across consumers).
+ * The geometry narrowing over these lives in `@bldrs-ai/conway/demand`
+ * ({@link import('../core/geometry_tile_pool').GeometryTilePool}); other
+ * asset domains (textures, property blocks) are expected to narrow the
+ * same way.
+ */
+export { ChunkedPool, ChunkSpan } from "../core/mem/chunked_pool.js";
+export { SharedAssetPool } from "../core/mem/shared_asset_pool.js";
+export { SharedByteBudget } from "../core/shared_byte_budget.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA"}

package/compiled/src/mem/index.js

@@ -0,0 +1,16 @@
+/**
+ * `@bldrs-ai/conway/mem` — the general memory system (src/core/mem;
+ * design/new/streaming-federated-loader.md, resident-memory design).
+ *
+ * Domain-neutral primitives for explicitly budgeted residency:
+ * {@link ChunkedPool} (accounting-only fixed-chunk freelist),
+ * {@link SharedAssetPool} (refcounted instance⇄asset sharing), and
+ * {@link SharedByteBudget} (a byte budget shareable across consumers).
+ * The geometry narrowing over these lives in `@bldrs-ai/conway/demand`
+ * ({@link import('../core/geometry_tile_pool').GeometryTilePool}); other
+ * asset domains (textures, property blocks) are expected to narrow the
+ * same way.
+ */
+export { ChunkedPool } from "../core/mem/chunked_pool.js";
+export { SharedAssetPool } from "../core/mem/shared_asset_pool.js";
+export { SharedByteBudget } from "../core/shared_byte_budget.js";

package/compiled/src/namespace_surface.test.d.ts

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

package/compiled/src/namespace_surface.test.d.ts.map

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

package/compiled/src/namespace_surface.test.js

@@ -0,0 +1,43 @@
+// Pins the conway-native plane namespaces (`@bldrs-ai/conway/stream`,
+// `/demand`, `/mem`): each module must expose its plane's key runtime
+// symbols. Guards the packaging contract — a refactor that moves or
+// renames an export breaks embedders through these subpaths first.
+import { describe, expect, test } from "@jest/globals";
+import * as demand from "./demand/index.js";
+import * as mem from "./mem/index.js";
+import * as stream from "./stream/index.js";
+describe("plane namespace surface", () => {
+    test("stream exposes the fixed-memory open plane", () => {
+        expect(typeof stream.openStreamedIfcModel).toBe("function");
+        expect(typeof stream.openStreamedIfcModelFromStore).toBe("function");
+        expect(typeof stream.BufferByteSource).toBe("function");
+        expect(typeof stream.StoreByteSource).toBe("function");
+        expect(typeof stream.SyncAccessHandleByteSource).toBe("function");
+        expect(typeof stream.InMemoryStepByteStore).toBe("function");
+        expect(typeof stream.WindowedStepBufferProvider).toBe("function");
+        expect(typeof stream.serializeIndexSidecarFromColumns).toBe("function");
+        expect(typeof stream.deserializeIndexSidecarToColumns).toBe("function");
+        expect(typeof stream.sidecarMatchesSource).toBe("function");
+        expect(typeof stream.hashSource).toBe("function");
+        expect(typeof stream.StreamingRecordDispatcher).toBe("function");
+        expect(typeof stream.PrefixTypeIndex).toBe("function");
+        expect(typeof stream.ColumnarIndexSink).toBe("function");
+        expect(typeof stream.StepTypeIndexer).toBe("function");
+        expect(typeof stream.ifcPrefixTypeIndex).toBe("function");
+        expect(typeof stream.RecordFieldCursor).toBe("function");
+        expect(typeof stream.IfcSpatialSkeleton).toBe("function");
+    });
+    test("demand exposes the residency/extraction plane", () => {
+        expect(typeof demand.DemandGeometryQueue).toBe("function");
+        expect(typeof demand.DemandResidencyPump).toBe("function");
+        expect(typeof demand.GeometryTilePool).toBe("function");
+        expect(typeof demand.createWasmTileBackend).toBe("function");
+        expect(typeof demand.readGeometryTilePayload).toBe("function");
+        expect(typeof demand.IfcTileAssetExtractor).toBe("function");
+    });
+    test("mem exposes the general pool primitives", () => {
+        expect(typeof mem.ChunkedPool).toBe("function");
+        expect(typeof mem.SharedAssetPool).toBe("function");
+        expect(typeof mem.SharedByteBudget).toBe("function");
+    });
+});

package/compiled/src/parsing/parsing_buffer.d.ts

@@ -61,6 +61,29 @@ export default class ParsingBuffer {
      * of the buffer.
      */
     reinit(buffer: Uint8Array, initialOffset: number, endOffset: number): void;
+    /**
+     * Streaming support: repoint this buffer at a fresh window over the same
+     * logical stream while keeping `address` file-absolute.
+     *
+     * A moving-window parse holds only a slice of the source in memory at a
+     * time. Between top-level records (where the rewind stack is empty) the
+     * driver slides the window forward: it copies the unconsumed tail to the
+     * front of a reused buffer, appends freshly-read bytes, and calls this to
+     * repoint the parser. `addressBase` is the file offset that window index 0
+     * now corresponds to; we store it as a negative initial offset so
+     * `address` ( = cursor − initialOffset ) stays the file-absolute value the
+     * non-streaming parse would have produced.
+     *
+     * Must only be called with the rewind stack empty (i.e. at a record
+     * boundary) — the stack holds window-relative cursors that a slide would
+     * invalidate. Throws otherwise.
+     *
+     * @param buffer The new window buffer.
+     * @param cursorInWindow The cursor position within the new window.
+     * @param endInWindow The count of valid bytes in the new window.
+     * @param addressBase The file offset that window index 0 maps to.
+     */
+    rebaseWindow(buffer: Uint8Array, cursorInWindow: number, endInWindow: number, addressBase: number): void;
     /**
      * Construct this with a buffer, initial offset into the buffer and an end offset.
      *

package/compiled/src/parsing/parsing_buffer.d.ts.map

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

package/compiled/src/parsing/parsing_buffer.js

@@ -86,6 +86,37 @@ export default class ParsingBuffer {
         this.buffer = buffer;
         this.end = endOffset;
     }
+    /**
+     * Streaming support: repoint this buffer at a fresh window over the same
+     * logical stream while keeping `address` file-absolute.
+     *
+     * A moving-window parse holds only a slice of the source in memory at a
+     * time. Between top-level records (where the rewind stack is empty) the
+     * driver slides the window forward: it copies the unconsumed tail to the
+     * front of a reused buffer, appends freshly-read bytes, and calls this to
+     * repoint the parser. `addressBase` is the file offset that window index 0
+     * now corresponds to; we store it as a negative initial offset so
+     * `address` ( = cursor − initialOffset ) stays the file-absolute value the
+     * non-streaming parse would have produced.
+     *
+     * Must only be called with the rewind stack empty (i.e. at a record
+     * boundary) — the stack holds window-relative cursors that a slide would
+     * invalidate. Throws otherwise.
+     *
+     * @param buffer The new window buffer.
+     * @param cursorInWindow The cursor position within the new window.
+     * @param endInWindow The count of valid bytes in the new window.
+     * @param addressBase The file offset that window index 0 maps to.
+     */
+    rebaseWindow(buffer, cursorInWindow, endInWindow, addressBase) {
+        if (this.rewindStack_.length !== 0) {
+            throw Error("rebaseWindow called mid-transaction (rewind stack non-empty)");
+        }
+        this.buffer = buffer;
+        this.cursor_ = cursorInWindow;
+        this.initialOffset_ = -addressBase;
+        this.end = endInWindow;
+    }
     /**
      * Construct this with a buffer, initial offset into the buffer and an end offset.
      *

package/compiled/src/scripts/model_report_displacement.test.d.ts

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

package/compiled/src/scripts/model_report_displacement.test.d.ts.map

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

package/compiled/src/scripts/model_report_displacement.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, test } from '@jest/globals';
+// @ts-expect-error -- an untyped .mjs helper beside the CLI it serves.
+import { localCentre, placeCentre, robustCentre } from '../../../scripts/debug/displacement.mjs';
+/* eslint-disable no-magic-numbers -- these are synthetic coordinates and
+   distances chosen to mirror the real model in conway#456. Naming each one
+   would obscure the shape the cases exist to express: a tight cluster near
+   the site origin plus one part flung far away. */
+/**
+ * The scoring behind model_report.mjs's `displacement` stage (conway#456).
+ *
+ * The stage answers "which parts are flung away from where they belong",
+ * which the `mesh` stage cannot: `mesh` measures extent in MESH-LOCAL
+ * coordinates, so on an export that writes geometry directly in site
+ * coordinates every honest part looks displaced by its distance from the
+ * file origin.
+ *
+ * These cases use synthetic centres rather than a model, because the
+ * motivating file is 256 MB and private. What is worth pinning is the
+ * scoring, and the scoring is pure — which is why it lives in
+ * displacement.mjs rather than in the CLI script, whose module body runs
+ * the whole tool on import.
+ */
+/**
+ * Column-major 4x4 translation, matching the walk tuple's layout.
+ *
+ * @param x Translation along x.
+ * @param y Translation along y.
+ * @param z Translation along z.
+ * @return The 16-element matrix.
+ */
+function translation(x, y, z) {
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1];
+}
+/**
+ * A stub geometry over a fixed point list.
+ *
+ * @param points One [x, y, z] per vertex.
+ * @return Something with the getPoint() shape worldCentre reads.
+ */
+function geometryOf(points) {
+    return {
+        getPoint: (i) => ({ x: points[i][0], y: points[i][1], z: points[i][2] }),
+    };
+}
+describe('displacement scoring', () => {
+    test('the robust centre ignores outliers rather than chasing them', () => {
+        // Nine parts clustered near the site origin, one flung far away — the
+        // shape of the motivating model, scaled down.
+        const centres = [
+            ...Array.from({ length: 9 }, (_, i) => [578 + i, 763, 3]),
+            [-751, 1075, 1377],
+        ];
+        const centre = robustCentre(centres);
+        // A MEAN would sit ~130 units off in x and ~137 in z, dragged by the
+        // single outlier; every honest part would then score as displaced and
+        // the outlier's own score would shrink. That inversion is the reason
+        // this is a median.
+        expect(centre[0]).toBeGreaterThan(577);
+        expect(centre[0]).toBeLessThan(587);
+        expect(centre[2]).toBeCloseTo(3, 6);
+        const distances = centres.map((each) => Math.hypot(each[0] - centre[0], each[1] - centre[1], each[2] - centre[2]));
+        const cluster = distances.slice(0, 9);
+        const outlier = distances[9];
+        // The signal the stage's `factor x median` threshold consumes: the
+        // outlier has to clear 8x the median by a wide margin, or it would be
+        // reported as ordinary.
+        const median = [...cluster].sort((a, b) => a - b)[Math.floor(cluster.length / 2)];
+        expect(outlier).toBeGreaterThan(median * 8);
+    });
+    test('a mesh centre is placed by its transform, not left local', () => {
+        // The defect this stage exists to fix in one assertion: identical local
+        // geometry at two different placements must score differently. Reading
+        // local coordinates would make these indistinguishable.
+        const unitBox = [[-1, -1, -1], [1, 1, 1]];
+        const local = localCentre(geometryOf(unitBox), 2);
+        const atOrigin = placeCentre(local, translation(0, 0, 0));
+        const farAway = placeCentre(local, translation(1000, 0, 0));
+        expect(atOrigin).toEqual([0, 0, 0]);
+        expect(farAway).toEqual([1000, 0, 0]);
+    });
+    test('an undefined transform means identity, not a skipped mesh', () => {
+        expect(placeCentre(localCentre(geometryOf([[2, 4, 6], [4, 8, 12]]), 2), undefined))
+            .toEqual([3, 6, 9]);
+    });
+    test('a wrong walk-tuple index throws rather than scoring NaN', () => {
+        // conway#456 names the transform as walked[1]; it is walked[0].
+        // Following the issue verbatim handed this an object, every
+        // multiplication produced NaN, Stage.record silently discarded every
+        // non-finite value, and the stage reported "N calls, 0 measured" — a
+        // clean-looking result manufactured by a bug. That is hazard 1 from the
+        // script's own header, so it has to be loud.
+        const notATransform = { someObject: true };
+        expect(() => placeCentre([0, 0, 0], notATransform)).toThrow(/walk tuple index/);
+    });
+    test('non-finite vertex data yields no centre rather than a NaN score', () => {
+        expect(localCentre(geometryOf([[0, 0, 0], [NaN, 0, 0]]), 2)).toBeUndefined();
+    });
+    test('a right-shaped transform holding NaN drops the mesh, and does not throw', () => {
+        // Data, not a programming error: one unusable placement must not take
+        // down the whole run and discard the other stages' reports.
+        const nanTransform = translation(NaN, 0, 0);
+        expect(placeCentre([1, 1, 1], nanTransform)).toBeUndefined();
+    });
+});

package/compiled/src/scripts/render_glb_paths.test.d.ts

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

package/compiled/src/scripts/render_glb_paths.test.d.ts.map

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

package/compiled/src/scripts/render_glb_paths.test.js

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { describe, expect, test, beforeAll, afterAll } from '@jest/globals';
+import { createRequire } from 'module';
+/* eslint-disable @typescript-eslint/no-explicit-any -- render_glb.cjs is an
+   untyped CommonJS CLI script, loaded here through createRequire. */
+/**
+ * Path resolution in scripts/render_glb.cjs (conway#457).
+ *
+ * The script accepts a comma-joined chunk list, and used to split on comma
+ * unconditionally — which tore a real path containing a comma into fragments
+ * and reported the first fragment as missing. Several models we ship are
+ * named that way, and `-g` keeps the source basename, so following
+ * scripts/debug/README.md on one of them failed.
+ */
+const require_ = createRequire(import.meta.url);
+// Resolved from the repo root rather than relative to this file: the test
+// runs from compiled/src/scripts, where a relative hop would land in
+// compiled/scripts, which does not exist (scripts/ is not part of the tsc
+// build). Jest's rootDir is the repo root.
+const { resolveGlbPaths } = require_(path.resolve(process.cwd(), 'scripts/render_glb.cjs'));
+let workDir;
+/** A name in the shape that broke: a comma inside a single real filename. */
+const COMMA_NAME = 'Wiesenplatz 7, 4057 Basel_test0.glb';
+beforeAll(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'render-glb-paths-'));
+    fs.writeFileSync(path.join(workDir, COMMA_NAME), 'not-a-real-glb');
+    fs.writeFileSync(path.join(workDir, 'chunk0.glb'), 'not-a-real-glb');
+    fs.writeFileSync(path.join(workDir, 'chunk1.glb'), 'not-a-real-glb');
+});
+afterAll(() => {
+    fs.rmSync(workDir, { recursive: true, force: true });
+});
+describe('render_glb path resolution', () => {
+    test('a real path containing a comma resolves to itself (issue #457)', () => {
+        const target = path.join(workDir, COMMA_NAME);
+        // The regression: this used to come back as ['<dir>/Wiesenplatz 7',
+        // ' 4057 Basel_test0.glb'] and fail on the first, which reads as a
+        // missing file rather than as a parsing decision.
+        expect(resolveGlbPaths(target)).toEqual([target]);
+    });
+    test('a genuine chunk list still splits', () => {
+        const chunks = [
+            path.join(workDir, 'chunk0.glb'),
+            path.join(workDir, 'chunk1.glb'),
+        ];
+        expect(resolveGlbPaths(chunks.join(','))).toEqual(chunks);
+    });
+    test('a JSON array resolves chunks whose names contain commas', () => {
+        // The case the literal-path rule alone cannot reach: a comma-named model
+        // large enough that the CLI splits it, so no single file bears the name.
+        // visual_diff_report.cjs passes this form.
+        const chunks = [
+            path.join(workDir, COMMA_NAME),
+            path.join(workDir, 'chunk0.glb'),
+        ];
+        expect(resolveGlbPaths(JSON.stringify(chunks))).toEqual(chunks);
+    });
+    test('a JSON array with a missing member fails rather than rendering part', () => {
+        const chunks = [path.join(workDir, 'chunk0.glb'), path.join(workDir, 'gone.glb')];
+        expect(() => resolveGlbPaths(JSON.stringify(chunks))).toThrow(/gone\.glb/);
+    });
+    test('a trailing comma from a shell-built list still resolves', () => {
+        const target = path.join(workDir, 'chunk0.glb');
+        expect(resolveGlbPaths(`${target},`)).toEqual([target]);
+    });
+    test('a missing path names both readings rather than one fragment', () => {
+        const missing = path.join(workDir, 'Nowhere 1, 2345 Somewhere.glb');
+        // What the error says is the whole point of the issue: the old failure
+        // surfaced as ENOENT on "Nowhere 1", a string the caller never typed.
+        expect(() => resolveGlbPaths(missing)).toThrow(/No such GLB/);
+        expect(() => resolveGlbPaths(missing)).toThrow(/2-chunk list/);
+    });
+    test('a CLI failure surfaces its own message to visual_diff_report', () => {
+        // This contract spans two files and has no other guard. render_glb.cjs
+        // prints "Error: <message>"; visual_diff_report.cjs's
+        // childFailureDiagnostic picks the FIRST stderr line matching its regex
+        // and puts it in the PR comment's table cell. Letting Node throw
+        // uncaught instead degrades every render-failure cell to a source code
+        // frame, with the whole suite otherwise green.
+        //
+        // Scope, honestly: this pins the END-TO-END result, not each mechanism.
+        // Removing the "Error:" prefix alone keeps it passing, because the stack
+        // printed after the message opens with an "Error:" line that matches the
+        // same regex. Both are kept because a non-Error throw has no stack.
+        const script = path.resolve(process.cwd(), 'scripts/render_glb.cjs');
+        const missing = path.join(workDir, 'Nowhere 1, 2345 Somewhere.glb');
+        let stderr = '';
+        try {
+            execFileSync(process.execPath, [script, missing, path.join(workDir, 'out.png')], { stdio: 'pipe' });
+        }
+        catch (err) {
+            stderr = (err.stderr ?? '').toString();
+        }
+        // The regex is copied from visual_diff_report.cjs:138 deliberately — the
+        // point is to fail here if either side drifts.
+        const picked = stderr.split('\n').filter(Boolean).find((line) => /error|cannot|not found|bad option|unexpected/i.test(line));
+        expect(picked).toMatch(/No such GLB/);
+        expect(picked).toContain('Nowhere 1, 2345 Somewhere.glb');
+        // And the stack still reaches the job log, which is a separate consumer.
+        expect(stderr).toMatch(/at resolveGlbPaths/);
+    });
+    test('a chunk list with one missing member does not silently render the rest', () => {
+        const spec = [
+            path.join(workDir, 'chunk0.glb'),
+            path.join(workDir, 'absent.glb'),
+        ].join(',');
+        // Rendering the surviving chunk would drop part of the model and look
+        // like a geometry regression in the visual diff, which is worse than
+        // failing.
+        expect(() => resolveGlbPaths(spec)).toThrow(/absent\.glb/);
+    });
+});

package/compiled/src/step/indexing/step_type_indexer.d.ts

@@ -1,4 +1,5 @@
 import { MultiIndexSet } from "../../indexing/multi_index_set.js";
+import { StepIndexColumns } from "../parsing/columnar_index.js";
 import { StepIndexEntry } from "../parsing/step_parser.js";
 /**
  * Indexes STEP by type so that it can be searched by type.
@@ -11,6 +12,25 @@ export declare class StepTypeIndexer<TypeIDType extends number> {
      * @param typeCount The number of types that will be indexed.
      */
     constructor(typeCount: number);
+    /**
+     * Create a type index from either index form — the parsed object array or
+     * the columnar index (M7).
+     *
+     * @param index The element index, object or columnar.
+     * @return {MultiIndexSet} The created multi-set index.
+     */
+    createFor(index: StepIndexEntry<TypeIDType>[] | StepIndexColumns<TypeIDType>): MultiIndexSet<TypeIDType>;
+    /**
+     * Create a type index straight from the columnar index — the same
+     * membership `create` produces from the unfolded object array: every row's
+     * concrete type (top-level + inline; −1 rows skipped) plus the
+     * multi-mapping subtypes of retained complex entries at their parent's
+     * dense index.
+     *
+     * @param columns The columnar index.
+     * @return {MultiIndexSet} The created multi-set index.
+     */
+    createFromColumns(columns: StepIndexColumns<TypeIDType>): MultiIndexSet<TypeIDType>;
     /**
      * Create a type index from a set of parsed STEP elements.
      *

package/compiled/src/step/indexing/step_type_indexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step_type_indexer.d.ts","sourceRoot":"","sources":["../../../../src/step/indexing/step_type_indexer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAEvD;;GAEG;AACH,qBAAa,eAAe,CAAE,UAAU,SAAS,MAAM;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAY;IAE5C;;;;OAIG;gBACiB,SAAS,EAAE,MAAM;IAIrC;;;;;OAKG;IACI,MAAM,CAAE,QAAQ,EAAE,cAAc,CAAE,UAAU,CAAE,EAAE,GAAI,aAAa,CAAE,UAAU,CAAE;CA8FvF"}
+{"version":3,"file":"step_type_indexer.d.ts","sourceRoot":"","sources":["../../../../src/step/indexing/step_type_indexer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAEvD;;GAEG;AACH,qBAAa,eAAe,CAAE,UAAU,SAAS,MAAM;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAY;IAE5C;;;;OAIG;gBACiB,SAAS,EAAE,MAAM;IAIrC;;;;;;OAMG;IACI,SAAS,CACZ,KAAK,EAAE,cAAc,CAAE,UAAU,CAAE,EAAE,GAAG,gBAAgB,CAAE,UAAU,CAAE,GACtE,aAAa,CAAE,UAAU,CAAE;IAK/B;;;;;;;;;OASG;IACI,iBAAiB,CACpB,OAAO,EAAE,gBAAgB,CAAE,UAAU,CAAE,GAAI,aAAa,CAAE,UAAU,CAAE;IAwE1E;;;;;OAKG;IACI,MAAM,CAAE,QAAQ,EAAE,cAAc,CAAE,UAAU,CAAE,EAAE,GAAI,aAAa,CAAE,UAAU,CAAE;CA8FvF"}

package/compiled/src/step/indexing/step_type_indexer.js

@@ -12,6 +12,73 @@ export class StepTypeIndexer {
     constructor(typeCount) {
         this.elementCounter_ = new Int32Array(typeCount << 1);
     }
+    /**
+     * Create a type index from either index form — the parsed object array or
+     * the columnar index (M7).
+     *
+     * @param index The element index, object or columnar.
+     * @return {MultiIndexSet} The created multi-set index.
+     */
+    createFor(index) {
+        return Array.isArray(index) ? this.create(index) : this.createFromColumns(index);
+    }
+    /**
+     * Create a type index straight from the columnar index — the same
+     * membership `create` produces from the unfolded object array: every row's
+     * concrete type (top-level + inline; −1 rows skipped) plus the
+     * multi-mapping subtypes of retained complex entries at their parent's
+     * dense index.
+     *
+     * @param columns The columnar index.
+     * @return {MultiIndexSet} The created multi-set index.
+     */
+    createFromColumns(columns) {
+        for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+            initCountCompactedElements32State(this.elementCounter_, where);
+        }
+        const elementCounter = this.elementCounter_;
+        const prefixSum = new Uint32Array((this.elementCounter_.length >>> 1) + 1);
+        const typeIDs = columns.typeID;
+        const count = columns.count;
+        // Walk retained complex entries alongside the rows (their keys ascend in
+        // localID order) so multi-mapping subtypes interleave at their parent's
+        // dense index — the object path's exact output order.
+        const walkRows = (addOne) => {
+            const complexIterator = columns.complexEntries?.entries();
+            let nextComplex = complexIterator?.next();
+            for (let denseIndex = 0; denseIndex < count; ++denseIndex) {
+                const typeID = typeIDs[denseIndex];
+                if (typeID >= 0) {
+                    addOne(denseIndex, typeID);
+                }
+                if (nextComplex !== void 0 && !nextComplex.done &&
+                    nextComplex.value[0] === denseIndex) {
+                    for (const subElement of nextComplex.value[1].multiMapping ?? []) {
+                        const subTypeID = subElement.typeID;
+                        if (subTypeID !== void 0) {
+                            addOne(denseIndex, subTypeID);
+                        }
+                    }
+                    nextComplex = complexIterator.next();
+                }
+            }
+        };
+        walkRows((denseIndex, typeID) => {
+            prefixSum[typeID + 1] =
+                addCompactedElementCount32State(denseIndex, elementCounter, typeID << 1);
+        });
+        for (let prefixSumIndex = 2, prefixSumEnd = prefixSum.length; prefixSumIndex < prefixSumEnd; ++prefixSumIndex) {
+            prefixSum[prefixSumIndex] += prefixSum[prefixSumIndex - 1];
+        }
+        for (let where = 0, end = this.elementCounter_.length; where < end; where += 2) {
+            initCountCompactedElements32State(this.elementCounter_, where);
+        }
+        const indexOutput = new Uint32Array(prefixSum[prefixSum.length - 1] << 1);
+        walkRows((denseIndex, typeID) => {
+            addCompactedElement32State(denseIndex, elementCounter, indexOutput, typeID << 1, prefixSum[typeID] << 1);
+        });
+        return new MultiIndexSet(prefixSum, indexOutput);
+    }
     /**
      * Create a type index from a set of parsed STEP elements.
      *