@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/ifc/ifc_tile_extractor.d.ts

@@ -0,0 +1,84 @@
+import { GeometryTilePoolBindings, TileAssetExtractor } from "../core/geometry_tile_bindings.js";
+import { GeometryAsset } from "../core/geometry_tile_pool.js";
+import { IfcGeometryExtraction } from "./ifc_geometry_extraction.js";
+/**
+ * The wasm module surface the extractor commits through: the tile pool
+ * bindings plus the Geometry-taking commit (embind `commitGeometryTile`,
+ * which serialises a reified Geometry's payload straight into pool chunks).
+ */
+export interface TileCommitBindings extends GeometryTilePoolBindings {
+    /**
+     * Commit a reified geometry's payload into the wasm tile pool.
+     *
+     * @param assetID The tile's asset id.
+     * @param geometry The wasm Geometry object (reified on access).
+     * @return {boolean} True on success.
+     */
+    commitGeometryTile(assetID: number, geometry: unknown): boolean;
+}
+/**
+ * The production {@link TileAssetExtractor} (Phase B3): drives the
+ * per-product demand extraction seam (Phase B2) and commits the resulting
+ * meshes into the wasm tile pool.
+ *
+ * Asset identity: one asset per produced **mesh**, keyed by the mesh's
+ * localID (the representation item). Mapped items reuse representation
+ * geometry across products, so shared representations become shared assets —
+ * the sharing the pools refcount.
+ *
+ * Contract notes:
+ * - `assetsOf` runs the (expensive) per-product extraction on first call and
+ *   caches the asset list; sizes are exact reified byte costs, so the TS
+ *   accounting layer admits with real numbers. This front-loads cost into
+ *   `assetsOf` by design — see `GeometryTilePool.extract`'s pricing pass.
+ * - `materialize` commits an already-extracted mesh into the pool;
+ *   `discard` releases the wasm tile. The CPU-side canonical mesh is left in
+ *   place in this phase (serving uploads from tiles — and dropping the fat
+ *   working geometry — is the Phase C flip).
+ */
+export declare class IfcTileAssetExtractor implements TileAssetExtractor {
+    private readonly extraction_;
+    private readonly bindings_;
+    /** Product localID → its assets, cached after first extraction. */
+    private readonly assetsByProduct_;
+    /**
+     * @param extraction_ The geometry extraction (its model provides meshes).
+     * @param bindings_ The wasm tile pool surface to commit through.
+     */
+    constructor(extraction_: IfcGeometryExtraction, bindings_: TileCommitBindings);
+    /**
+     * The assets (meshes) a product references, extracting it on first ask.
+     *
+     * Attribution walks the product's **representation-item closure**
+     * (recursing through mapped items into their shared source
+     * representations) and claims every item that has an extracted mesh —
+     * NOT a before/after diff of the mesh set. The distinction is the
+     * mapped-item case: a shared source's meshes already exist when the
+     * second product asks, so a diff would omit them and its tile would not
+     * hold references to geometry it renders. Closure attribution is
+     * extraction-order independent.
+     *
+     * @param productLocalID The product's local ID.
+     * @return {GeometryAsset<number>[]} One asset per referenced mesh, keyed
+     * by the mesh's representation-item localID (shared across products for
+     * mapped sources), sized at exact reified cost.
+     */
+    assetsOf(productLocalID: number): GeometryAsset<number>[];
+    /**
+     * The localIDs of every representation item in a product's Body /
+     * Facetation representations, recursing through mapped items into their
+     * (shared) source representations — the key space extraction stores
+     * meshes under.
+     *
+     * @param productLocalID The product's local ID.
+     * @return {Set<number>} The representation-item localIDs.
+     */
+    private representationItemIDs_;
+    /**
+     * Commit one extracted mesh into the wasm tile pool.
+     *
+     * @param assetID The mesh (representation item) localID.
+     */
+    extractIntoTile(assetID: number): void;
+}
+//# sourceMappingURL=ifc_tile_extractor.d.ts.map

package/compiled/src/ifc/ifc_tile_extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_tile_extractor.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_tile_extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AAGjE;;;;GAIG;AACH,MAAM,WAAW,kBAAmB,SAAQ,wBAAwB;IAElE;;;;;;OAMG;IACH,kBAAkB,CAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAI,OAAO,CAAA;CAClE;AAUD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,qBAAsB,YAAW,kBAAkB;IAU5D,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAT5B,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6C;IAE9E;;;OAGG;gBAEgB,WAAW,EAAE,qBAAqB,EAClC,SAAS,EAAE,kBAAkB;IAKhD;;;;;;;;;;;;;;;;OAgBG;IACI,QAAQ,CAAE,cAAc,EAAE,MAAM,GAAI,aAAa,CAAC,MAAM,CAAC,EAAE;IAqClE;;;;;;;;OAQG;IACH,OAAO,CAAC,sBAAsB;IA0C9B;;;;OAIG;IACI,eAAe,CAAE,OAAO,EAAE,MAAM,GAAI,IAAI;CAiBhD"}

package/compiled/src/ifc/ifc_tile_extractor.js

@@ -0,0 +1,134 @@
+// Reified payload framing: 8-byte header + float vertex data + u32 indices
+// (tile_pool_api.h layout).
+const TILE_HEADER_BYTES = 8;
+const FLOAT_BYTES = 4;
+const INDEX_BYTES = 4;
+/**
+ * The production {@link TileAssetExtractor} (Phase B3): drives the
+ * per-product demand extraction seam (Phase B2) and commits the resulting
+ * meshes into the wasm tile pool.
+ *
+ * Asset identity: one asset per produced **mesh**, keyed by the mesh's
+ * localID (the representation item). Mapped items reuse representation
+ * geometry across products, so shared representations become shared assets —
+ * the sharing the pools refcount.
+ *
+ * Contract notes:
+ * - `assetsOf` runs the (expensive) per-product extraction on first call and
+ *   caches the asset list; sizes are exact reified byte costs, so the TS
+ *   accounting layer admits with real numbers. This front-loads cost into
+ *   `assetsOf` by design — see `GeometryTilePool.extract`'s pricing pass.
+ * - `materialize` commits an already-extracted mesh into the pool;
+ *   `discard` releases the wasm tile. The CPU-side canonical mesh is left in
+ *   place in this phase (serving uploads from tiles — and dropping the fat
+ *   working geometry — is the Phase C flip).
+ */
+export class IfcTileAssetExtractor {
+    /**
+     * @param extraction_ The geometry extraction (its model provides meshes).
+     * @param bindings_ The wasm tile pool surface to commit through.
+     */
+    constructor(extraction_, bindings_) {
+        this.extraction_ = extraction_;
+        this.bindings_ = bindings_;
+        /** Product localID → its assets, cached after first extraction. */
+        this.assetsByProduct_ = new Map();
+        this.extraction_.prepareDemandExtraction();
+    }
+    /**
+     * The assets (meshes) a product references, extracting it on first ask.
+     *
+     * Attribution walks the product's **representation-item closure**
+     * (recursing through mapped items into their shared source
+     * representations) and claims every item that has an extracted mesh —
+     * NOT a before/after diff of the mesh set. The distinction is the
+     * mapped-item case: a shared source's meshes already exist when the
+     * second product asks, so a diff would omit them and its tile would not
+     * hold references to geometry it renders. Closure attribution is
+     * extraction-order independent.
+     *
+     * @param productLocalID The product's local ID.
+     * @return {GeometryAsset<number>[]} One asset per referenced mesh, keyed
+     * by the mesh's representation-item localID (shared across products for
+     * mapped sources), sized at exact reified cost.
+     */
+    assetsOf(productLocalID) {
+        const cached = this.assetsByProduct_.get(productLocalID);
+        if (cached !== void 0) {
+            return cached;
+        }
+        this.extraction_.extractProductGeometryByLocalID(productLocalID);
+        const geometry = this.extraction_.model.geometry;
+        const assets = [];
+        for (const itemLocalID of this.representationItemIDs_(productLocalID)) {
+            const mesh = geometry.getByLocalID(itemLocalID);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const wasmGeometry = mesh?.geometry;
+            if (wasmGeometry === void 0 ||
+                typeof wasmGeometry.GetVertexDataSize !== 'function') {
+                continue;
+            }
+            const byteSize = TILE_HEADER_BYTES +
+                wasmGeometry.GetVertexDataSize() * FLOAT_BYTES +
+                wasmGeometry.GetIndexDataSize() * INDEX_BYTES;
+            assets.push({ assetID: itemLocalID, byteSize });
+        }
+        this.assetsByProduct_.set(productLocalID, assets);
+        return assets;
+    }
+    /**
+     * The localIDs of every representation item in a product's Body /
+     * Facetation representations, recursing through mapped items into their
+     * (shared) source representations — the key space extraction stores
+     * meshes under.
+     *
+     * @param productLocalID The product's local ID.
+     * @return {Set<number>} The representation-item localIDs.
+     */
+    representationItemIDs_(productLocalID) {
+        const ids = new Set();
+        const element = this.extraction_.model.getElementByLocalID(productLocalID);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const representations = element?.Representation?.Representations;
+        if (representations === void 0 || representations === null) {
+            return ids;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const addItems = (items) => {
+            for (const item of items) {
+                ids.add(item.localID);
+                // Mapped item: recurse into the shared source representation.
+                const source = item.MappingSource?.MappedRepresentation?.Items;
+                if (source !== void 0 && source !== null) {
+                    addItems(source);
+                }
+            }
+        };
+        for (const representation of representations) {
+            const identifier = representation.RepresentationIdentifier;
+            if (identifier !== null && identifier !== 'Body' &&
+                identifier !== 'Facetation') {
+                continue;
+            }
+            addItems(representation.Items);
+        }
+        return ids;
+    }
+    /**
+     * Commit one extracted mesh into the wasm tile pool.
+     *
+     * @param assetID The mesh (representation item) localID.
+     */
+    extractIntoTile(assetID) {
+        const mesh = this.extraction_.model.geometry.getByLocalID(assetID);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const wasmGeometry = mesh?.geometry;
+        if (wasmGeometry === void 0) {
+            throw new Error(`No extracted mesh for asset ${assetID}`);
+        }
+        if (!this.bindings_.commitGeometryTile(assetID, wasmGeometry)) {
+            throw new Error(`Wasm tile commit failed for asset ${assetID} — ` +
+                'the scheduler budget must not exceed the pool budget');
+        }
+    }
+}

package/compiled/src/ifc/ifc_tile_extractor.test.d.ts

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

package/compiled/src/ifc/ifc_tile_extractor.test.d.ts.map

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

package/compiled/src/ifc/ifc_tile_extractor.test.js

@@ -0,0 +1,118 @@
+/* eslint-disable no-magic-numbers, @typescript-eslint/no-explicit-any */
+// Phase B3: the production TileAssetExtractor drives the per-product demand
+// seam (B2) and commits reified meshes through the wasm tile surface —
+// verified with real extraction and recording commit bindings, composed all
+// the way up through the queue + pump.
+import fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { IfcGeometryExtraction } from "./ifc_geometry_extraction.js";
+import { IfcTileAssetExtractor } from "./ifc_tile_extractor.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import IfcStepParser from "./ifc_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import { createWasmTileBackend } from "../core/geometry_tile_bindings.js";
+import { DemandGeometryQueue } from "../core/demand_geometry_queue.js";
+import { DemandResidencyPump } from "../core/demand_residency_pump.js";
+import { IfcProduct } from "./ifc4_gen/index.js";
+let conwayGeometry;
+/**
+ * @return {IfcStepModel} A fresh parsed model of index.ifc.
+ */
+function freshModel() {
+    const bytes = fs.readFileSync("data/index.ifc");
+    const input = new ParsingBuffer(bytes);
+    expect(IfcStepParser.Instance.parseHeader(input)[1]).toBe(ParseResult.COMPLETE);
+    const [, model] = IfcStepParser.Instance.parseDataToModel(input);
+    return model;
+}
+/**
+ * Recording fake of the commit surface: accepts every init/commit/release,
+ * records ids, verifies commit receives a live reified geometry.
+ *
+ * @return {object} `{ bindings, committed, released }`.
+ */
+function recordingBindings() {
+    const committed = [];
+    const released = [];
+    const bindings = {
+        initGeometryTilePool: () => true,
+        geometryTilePoolInitialized: () => true,
+        commitGeometryTile: (assetID, geometry) => {
+            // A real reified geometry must be handed over.
+            expect(typeof geometry.GetVertexDataSize).toBe("function");
+            expect(geometry.GetVertexDataSize()).toBeGreaterThan(0);
+            committed.push(assetID);
+            return true;
+        },
+        commitGeometryTileBytes: () => true,
+        retainGeometryTile: () => true,
+        releaseGeometryTile: (assetID) => {
+            released.push(assetID);
+            return true;
+        },
+        geometryTileResident: (assetID) => committed.includes(assetID) && !released.includes(assetID),
+        geometryTileRefCount: () => 1,
+        geometryTileByteSize: () => 0,
+        geometryTileSegmentCount: () => 0,
+        geometryTileSegmentAddress: () => 0,
+        geometryTileSegmentByteLength: () => 0,
+        geometryTileVertexByteLength: () => 0,
+        geometryTileIndexByteLength: () => 0,
+        geometryTilePoolBytesInUse: () => 0,
+        geometryTilePoolTotalBytes: () => 0,
+        geometryTilePoolFreeChunks: () => 0,
+        geometryTilePoolFailedCommits: () => 0,
+    };
+    return { bindings, committed, released };
+}
+beforeAll(async () => {
+    conwayGeometry = new ConwayGeometry();
+    expect(await conwayGeometry.initialize()).toBe(true);
+});
+describe("IfcTileAssetExtractor (Phase B3)", () => {
+    test("assetsOf extracts on first ask, caches, and sizes at reified cost", () => {
+        const model = freshModel();
+        const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+        const { bindings } = recordingBindings();
+        const extractor = new IfcTileAssetExtractor(extraction, bindings);
+        // Find a product with geometry.
+        let assets = [];
+        let productID = -1;
+        for (const product of model.types(IfcProduct)) {
+            assets = extractor.assetsOf(product.localID);
+            if (assets.length > 0) {
+                productID = product.localID;
+                break;
+            }
+        }
+        expect(assets.length).toBeGreaterThan(0);
+        for (const asset of assets) {
+            expect(asset.byteSize).toBeGreaterThan(8); // header + payload
+        }
+        // Cached: second ask returns the same array without re-extraction.
+        expect(extractor.assetsOf(productID)).toBe(assets);
+    });
+    test("full composition: pump \u2192 queue \u2192 tiles \u2192 extractor \u2192 wasm commit", async () => {
+        const model = freshModel();
+        const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+        const { bindings, committed, released } = recordingBindings();
+        const extractor = new IfcTileAssetExtractor(extraction, bindings);
+        const backend = createWasmTileBackend(bindings, extractor, 64 * 1024 * 1024, 4096);
+        const queue = new DemandGeometryQueue(backend.tiles, 64 * 1024 * 1024);
+        const pump = new DemandResidencyPump(queue, model);
+        for (const product of model.types(IfcProduct)) {
+            pump.request(product.localID, 1);
+        }
+        // Drain admission in batches.
+        while (pump.pendingCount > 0) {
+            const result = await pump.pump();
+            expect(result.prefetchFailures).toBe(0);
+        }
+        expect(committed.length).toBeGreaterThan(0);
+        expect(queue.stats.residentCount).toBeGreaterThan(0);
+        // Evicting everything releases every committed wasm tile.
+        queue.evictAll();
+        expect(new Set(released)).toEqual(new Set(committed));
+    });
+});

package/compiled/src/ifc/ifc_typed_select_enum.test.d.ts

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

package/compiled/src/ifc/ifc_typed_select_enum.test.d.ts.map

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

package/compiled/src/ifc/ifc_typed_select_enum.test.js

@@ -0,0 +1,60 @@
+// A select member whose type is an enum may be written bare or in its typed
+// form - `.NULL.` or `NULL_STYLE(.NULL.)`. Inside a SELECT the typed form is
+// how a reader tells which member the value is, so exporters use it, and the
+// NIST AP242 set uses it throughout.
+//
+// Reading the typed form used to throw 'Value in select must be populated',
+// because the generated getter's enum fallback is a bare parse starting at
+// the cursor and the wrapper made it fail. Entity-valued members were never
+// affected - the parser indexes an inline TYPENAME(...) entity and
+// extractBufferReference resolves it by address - so this was specific to
+// enum members, and `null_style` / `IfcNullStyle` is the only enum inside a
+// select in either schema. It accounted for 274 of the public regression
+// baseline's error rows, every one of them a lost styled item. See
+// bldrs-ai/conway#489.
+//
+// Both schemas are covered: the fix is emitted by the generator at two sites,
+// one per schema, and a regeneration that reverted either would otherwise
+// ship green. scripts/code-gen.cjs clones the generator unpinned, so that is
+// not a hypothetical.
+//
+// Parser-only, so no geometry wasm is initialized here - importing it would
+// make this fail at import in a checkout without the Dist built, for a
+// dependency it never uses.
+import { describe, expect, test } from "@jest/globals";
+import IfcStepParser from "./ifc_step_parser.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { IfcNullStyle, IfcPresentationStyleAssignment } from "./ifc4_gen/index.js";
+const parser = IfcStepParser.Instance;
+const TYPED_STYLE = `#10028 = IFCPRESENTATIONSTYLEASSIGNMENT((IFCNULLSTYLE(.NULL.)));`;
+// The same value written bare, which always worked. Kept alongside so a
+// change that fixes one by breaking the other cannot pass.
+const BARE_STYLE = `#10028 = IFCPRESENTATIONSTYLEASSIGNMENT((.NULL.));`;
+const STYLE_EXPRESS_ID = 10028;
+/**
+ * Parse one IFCPRESENTATIONSTYLEASSIGNMENT and read back its styles.
+ *
+ * @param source The STEP text to parse.
+ * @return {Array<unknown>} The resolved styles array.
+ */
+function stylesOf(source) {
+    const [result, model] = parser.parseDataToModel(new ParsingBuffer(new TextEncoder().encode(source)));
+    if (model === void 0 ||
+        (result !== ParseResult.COMPLETE && result !== ParseResult.INCOMPLETE)) {
+        throw new Error(`parse failed with result ${result}`);
+    }
+    const assignment = model.getElementByExpressID(STYLE_EXPRESS_ID);
+    if (!(assignment instanceof IfcPresentationStyleAssignment)) {
+        throw new Error("expected an IfcPresentationStyleAssignment");
+    }
+    return assignment.Styles;
+}
+describe("a typed enum in an IFC select", () => {
+    test("IFCNULLSTYLE(.NULL.) resolves instead of throwing", () => {
+        expect(stylesOf(TYPED_STYLE)).toEqual([IfcNullStyle.NULL]);
+    });
+    test("the bare form still resolves", () => {
+        expect(stylesOf(BARE_STYLE)).toEqual([IfcNullStyle.NULL]);
+    });
+});

package/compiled/src/index.d.ts

@@ -1,7 +1,7 @@
 export { ParseResult } from "./step/parsing/step_parser.js";
 export { IfcGeometryExtraction } from "./ifc/ifc_geometry_extraction.js";
 export { IfcPropertyExtraction } from "./ifc/ifc_property_extraction.js";
-export { ConwayGeometry, GeometryObject, FileHandlerFunction } from "../dependencies/conway-geom/index.js";
+export { ConwayGeometry, GeometryObject, FileHandlerFunction, setModulePrefix, } from "../dependencies/conway-geom/index.js";
 export { versionString } from "./version/version.js";
 export { default as Logger, LogLevel, LogEntry, LoggingProxy, LogSink } from "./logging/logger.js";
 export { product, shape_definition_representation } from "./AP214E3_2010/AP214E3_2010_gen/index.js";
@@ -11,4 +11,24 @@ export { ExtractResult } from "./core/shared_constants.js";
 export { ProgressEvent, ProgressCallback, ProgressPhase, ProgressUnit, ProgressTracker, CountProgressCallback, yieldToEventLoop, } from "./core/progress.js";
 export { ModelLoadOptions } from "./loaders/conway_model_loader.js";
 export { LoadLogAccumulator, ModelInfo, ProgressEventLike, formatBar, formatMb, formatModelLine, formatSeconds, stageLabel, } from "./core/progress_log.js";
+export { openStreamedIfcModel, openStreamedIfcModelAsync, openStreamedIfcModelFromStore, ifcPrefixTypeIndex, StreamedIfcOpen, StreamedIfcOpenOptions, } from "./ifc/ifc_stream_open.js";
+export { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } from "./step/parsing/streaming_index_builder.js";
+export { ByteSource, BufferByteSource, AsyncByteSource, ReadableByteSource, StoreByteSource, SyncAccessHandleByteSource, SyncAccessHandleLike, } from "./step/parsing/byte_source.js";
+export { scanExpressRefs } from "./step/parsing/express_ref_scan.js";
+export { StepExternalByteStore, InMemoryStepByteStore, StepBufferProvider, WindowedStepBufferProvider, } from "./step/step_buffer_provider.js";
+export { StepIndexColumns, ColumnarIndexSink } from "./step/parsing/columnar_index.js";
+export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "./step/parsing/index_sidecar.js";
+export { StreamingRecordDispatcher, RecordHandler } from "./step/parsing/streaming_record_dispatcher.js";
+export { PrefixTypeIndex } from "./step/parsing/prefix_type_index.js";
+export { StepTypeIndexer } from "./step/indexing/step_type_indexer.js";
+export { RecordEventHandler } from "./step/parsing/record_event.js";
+export { RecordFieldCursor } from "./step/parsing/record_field_cursor.js";
+export { IfcSpatialSkeleton, SkeletonNode } from "./ifc/ifc_spatial_skeleton.js";
+export { DemandGeometryQueue, GeometryTiles, DemandQueueStats } from "./core/demand_geometry_queue.js";
+export { DemandResidencyPump, ResidencyPrefetcher, PumpResult } from "./core/demand_residency_pump.js";
+export { GeometryTilePoolBindings, TileAssetExtractor, WasmTileBackend, createWasmTileBackend, readGeometryTilePayload, GeometryTilePayload, } from "./core/geometry_tile_bindings.js";
+export { IfcTileAssetExtractor, TileCommitBindings } from "./ifc/ifc_tile_extractor.js";
+export { ChunkedPool, ChunkSpan } from "./core/mem/chunked_pool.js";
+export { SharedAssetPool } from "./core/mem/shared_asset_pool.js";
+export { GeometryTilePool, InstanceAssetSource, GeometryAsset } from "./core/geometry_tile_pool.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,mBAAmB,EAAC,MAAM,6BAA6B,CAAA;AAChG,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEjD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/F,OAAO,EAAE,OAAO,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAA;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EACL,kBAAkB,EAClB,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,QAAQ,EACR,eAAe,EACf,aAAa,EACb,UAAU,GACX,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/compiled/src/index.js

@@ -1,7 +1,7 @@
 export { ParseResult } from "./step/parsing/step_parser.js";
 export { IfcGeometryExtraction } from "./ifc/ifc_geometry_extraction.js";
 export { IfcPropertyExtraction } from "./ifc/ifc_property_extraction.js";
-export { ConwayGeometry } from "../dependencies/conway-geom/index.js";
+export { ConwayGeometry, setModulePrefix, } from "../dependencies/conway-geom/index.js";
 export { versionString } from "./version/version.js";
 // Replace your current Logger export with this
 export { default as Logger, LogLevel } from "./logging/logger.js";
@@ -10,3 +10,30 @@ export { CanonicalMeshType } from "./core/canonical_mesh.js";
 export { ExtractResult } from "./core/shared_constants.js";
 export { ProgressTracker, yieldToEventLoop, } from "./core/progress.js";
 export { LoadLogAccumulator, formatBar, formatMb, formatModelLine, formatSeconds, stageLabel, } from "./core/progress_log.js";
+// --- Streaming / demand-geometry surface (epic #390; design doc
+// design/new/streaming-federated-loader.md). The release-facing API for
+// fixed-memory opens and demand-driven residency.
+//
+// Canonical homes are the plane subpath modules — `@bldrs-ai/conway/stream`,
+// `/demand`, and `/mem` — which is where new conway-native APIs land (the
+// web-ifc compat shim stays an adapter and is headed for retirement). The
+// flat re-exports below are kept for root-import compatibility.
+export { openStreamedIfcModel, openStreamedIfcModelAsync, openStreamedIfcModelFromStore, ifcPrefixTypeIndex, } from "./ifc/ifc_stream_open.js";
+export { buildColumnarIndexStreaming, buildColumnarIndexStreamingAsync, } from "./step/parsing/streaming_index_builder.js";
+export { BufferByteSource, StoreByteSource, SyncAccessHandleByteSource, } from "./step/parsing/byte_source.js";
+export { scanExpressRefs } from "./step/parsing/express_ref_scan.js";
+export { InMemoryStepByteStore, WindowedStepBufferProvider, } from "./step/step_buffer_provider.js";
+export { ColumnarIndexSink } from "./step/parsing/columnar_index.js";
+export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "./step/parsing/index_sidecar.js";
+export { StreamingRecordDispatcher } from "./step/parsing/streaming_record_dispatcher.js";
+export { PrefixTypeIndex } from "./step/parsing/prefix_type_index.js";
+export { StepTypeIndexer } from "./step/indexing/step_type_indexer.js";
+export { RecordFieldCursor } from "./step/parsing/record_field_cursor.js";
+export { IfcSpatialSkeleton } from "./ifc/ifc_spatial_skeleton.js";
+export { DemandGeometryQueue } from "./core/demand_geometry_queue.js";
+export { DemandResidencyPump } from "./core/demand_residency_pump.js";
+export { createWasmTileBackend, readGeometryTilePayload, } from "./core/geometry_tile_bindings.js";
+export { IfcTileAssetExtractor } from "./ifc/ifc_tile_extractor.js";
+export { ChunkedPool } from "./core/mem/chunked_pool.js";
+export { SharedAssetPool } from "./core/mem/shared_asset_pool.js";
+export { GeometryTilePool } from "./core/geometry_tile_pool.js";

package/compiled/src/logging/logger.d.ts

@@ -38,6 +38,16 @@ export type LogSink = (level: LogLevelName, message: string) => void;
  * first occurrence of each distinct entry at or above the current threshold
  * is echoed to the console sink immediately, so warnings/errors are visible
  * live without waiting for a displayLogs() dump.
+ *
+ * Deduplication keys on the exact message string, so anything interpolated
+ * into the message splits one problem into N entries with count 1 each and
+ * `count` stops meaning "how big is this". That is not hypothetical: one
+ * record ID in a message turned a single AP242 failure into 272 rows of the
+ * regression run's errors.csv, and normalising the whole public corpus that
+ * way takes it from 325 rows to 22. Pass the record as the `expressID`
+ * argument instead of writing it into the message - it lands in `expressIDs`,
+ * which is unioned across repeats, and the family stays one row that `count`
+ * can size.
  */
 export default class Logger {
     private static logs;
@@ -86,6 +96,8 @@ export default class Logger {
      *
      * @param level - log level
      * @param message - log message
+     * @param expressID - record this entry is about, kept out of the message
+     *   text so repeats dedupe into one entry (see the class doc)
      */
     private static log;
     /**
@@ -142,13 +154,15 @@ export default class Logger {
     /**
      *
      * @param message - log message
+     * @param expressID - record this entry is about
      */
-    static warning(message: string): void;
+    static warning(message: string, expressID?: number | string): void;
     /**
      *
      * @param message - log message
+     * @param expressID - record this entry is about
      */
-    static error(message: string): void;
+    static error(message: string, expressID?: number | string): void;
     /**
      *
      * @return {LogEntry[]} - list of logs

package/compiled/src/logging/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/logging/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAIrD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAA;AAEjE;;;;;;GAMG;AACH,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,OAAO,IAAI;IACX,KAAK,IAAI;IACT,GAAG,IAAI;CACR;AASD,MAAM,WAAW,QAAQ;IACrB,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAC,GAAG,CAAC,MAAM,CAAC,CAAA;CACzB;AAGD,MAAM,WAAW,YAAY;IACzB,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;CAC7B;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,CAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,KAAM,IAAI,CAAA;AAetE;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAiB;IACpC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAqB;IAC3C,OAAO,CAAC,MAAM,CAAC,UAAU,CAAyD;IAClF,OAAO,CAAC,MAAM,CAAC,SAAS,CAA0B;IAClD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAuB;IAG1C;;OAEG;WACW,uBAAuB;IAiBrC;;;;;OAKG;WACW,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAIhD;;;OAGG;WACW,WAAW,IAAI,QAAQ;IAIrC;;;;;OAKG;WACW,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAItD;;;;;OAKG;WACW,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAI3B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,GAAG;IAoClB;;OAEG;WACW,YAAY,IAAI,IAAI;IAuBlC;;;OAGG;WACW,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAIjD;;;;OAIG;WACW,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAQpD;;;OAGG;WACW,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI1C;;;OAGG;WACW,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIzC;;;;OAIG;WACW,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIpE;;;;;;OAMG;WACW,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQ3D;;;OAGG;WACW,eAAe,CAAC,OAAO,EAAE,MAAM;IAgB7C;;;;;OAKG;WACW,SAAS,IAAI,QAAQ,EAAE;IAOrC;;;OAGG;WACW,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI5C;;;OAGG;WACW,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI1C;;;OAGG;WACW,OAAO,IAAI,QAAQ,EAAE;IAInC;;;;;;;OAOG;WACW,WAAW,CAAC,KAAK,GAAE,OAAe,GAAG,IAAI;IASvD;;OAEG;WACW,SAAS,IAAI,IAAI;CAGhC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/logging/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAIrD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAA;AAEjE;;;;;;GAMG;AACH,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,OAAO,IAAI;IACX,KAAK,IAAI;IACT,GAAG,IAAI;CACR;AASD,MAAM,WAAW,QAAQ;IACrB,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAC,GAAG,CAAC,MAAM,CAAC,CAAA;CACzB;AAGD,MAAM,WAAW,YAAY;IACzB,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAA;CAC7B;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,CAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,KAAM,IAAI,CAAA;AAetE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAiB;IACpC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAqB;IAC3C,OAAO,CAAC,MAAM,CAAC,UAAU,CAAyD;IAClF,OAAO,CAAC,MAAM,CAAC,SAAS,CAA0B;IAClD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAuB;IAG1C;;OAEG;WACW,uBAAuB;IAiBrC;;;;;OAKG;WACW,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAIhD;;;OAGG;WACW,WAAW,IAAI,QAAQ;IAIrC;;;;;OAKG;WACW,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAItD;;;;;OAKG;WACW,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAI3B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,GAAG;IAoDlB;;OAEG;WACW,YAAY,IAAI,IAAI;IAuBlC;;;OAGG;WACW,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAIjD;;;;OAIG;WACW,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAQpD;;;OAGG;WACW,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI1C;;;OAGG;WACW,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIzC;;;;OAIG;WACW,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIpE;;;;;;OAMG;WACW,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAQ3D;;;OAGG;WACW,eAAe,CAAC,OAAO,EAAE,MAAM;IAgB7C;;;;;OAKG;WACW,SAAS,IAAI,QAAQ,EAAE;IAOrC;;;;OAIG;WACW,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIzE;;;;OAIG;WACW,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIvE;;;OAGG;WACW,OAAO,IAAI,QAAQ,EAAE;IAInC;;;;;;;OAOG;WACW,WAAW,CAAC,KAAK,GAAE,OAAe,GAAG,IAAI;IASvD;;OAEG;WACW,SAAS,IAAI,IAAI;CAGhC"}

package/compiled/src/logging/logger.js

@@ -42,6 +42,16 @@ const defaultSink = (level, message) => {
  * first occurrence of each distinct entry at or above the current threshold
  * is echoed to the console sink immediately, so warnings/errors are visible
  * live without waiting for a displayLogs() dump.
+ *
+ * Deduplication keys on the exact message string, so anything interpolated
+ * into the message splits one problem into N entries with count 1 each and
+ * `count` stops meaning "how big is this". That is not hypothetical: one
+ * record ID in a message turned a single AP242 failure into 272 rows of the
+ * regression run's errors.csv, and normalising the whole public corpus that
+ * way takes it from 325 rows to 22. Pass the record as the `expressID`
+ * argument instead of writing it into the message - it lands in `expressIDs`,
+ * which is unioned across repeats, and the family stays one row that `count`
+ * can size.
  */
 class Logger {
     /**
@@ -110,10 +120,20 @@ class Logger {
      *
      * @param level - log level
      * @param message - log message
+     * @param expressID - record this entry is about, kept out of the message
+     *   text so repeats dedupe into one entry (see the class doc)
      */
-    static log(level, message) {
+    static log(level, message, expressID) {
+        // Two ways to attach a record to an entry. The parameter is the one to
+        // use; the ' expressID: ' suffix is the older in-message form, kept
+        // because TS call sites still use it. Nothing on the wasm side does - the
+        // C++ logger spells its own IDs differently and never matches this split -
+        // so the suffix has no external dependency and can go once the remaining
+        // call sites are converted.
         const baseMessage = message.split(" expressID: ")[0]; // Extract the base message
-        const data = message.split(" expressID: ")[1]; // Extract the expressID
+        const data = expressID !== void 0 ?
+            String(expressID) :
+            message.split(" expressID: ")[1]; // Extract the expressID
         const index = Logger.findLogIndex(baseMessage, level);
         let logEntry;
         let firstOccurrence = false;
@@ -137,8 +157,13 @@ class Logger {
         }
         // Echo only the first occurrence of each distinct entry — repeats keep
         // deduplicating silently into the buffer (visible via displayLogs()).
+        //
+        // The record goes back on for the echo. Only the BUFFER needs the ID out
+        // of the message, so that repeats collapse to one entry; a console line is
+        // read once by a person, and dropping the ID there would trade a one-off
+        // browser error's only pointer to the offending record for nothing.
         if (firstOccurrence && Logger.isLevelEnabled(LOG_LEVEL_BY_NAME[level])) {
-            Logger.sink(level, baseMessage);
+            Logger.sink(level, data !== void 0 ? `${baseMessage} expressID: ${data}` : baseMessage);
         }
         Logger.proxies.forEach((proxy) => proxy.log(logEntry));
     }
@@ -247,16 +272,18 @@ class Logger {
     /**
      *
      * @param message - log message
+     * @param expressID - record this entry is about
      */
-    static warning(message) {
-        Logger.log("warning", message);
+    static warning(message, expressID) {
+        Logger.log("warning", message, expressID);
     }
     /**
      *
      * @param message - log message
+     * @param expressID - record this entry is about
      */
-    static error(message) {
-        Logger.log("error", message);
+    static error(message, expressID) {
+        Logger.log("error", message, expressID);
     }
     /**
      *