@bldrs-ai/conway 1.413.1255 → 1.416.1260

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

@@ -0,0 +1,68 @@
+import { ByteSource } from "../step/parsing/byte_source.js";
+import { StepIndexColumns } from "../step/parsing/columnar_index.js";
+import { StreamingIndexStats } from "../step/parsing/streaming_index_builder.js";
+import { ParseResult, StepHeader } from "../step/parsing/step_parser.js";
+import { StepExternalByteStore } from "../step/step_buffer_provider.js";
+import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
+import IfcStepModel from "./ifc_step_model.js";
+/**
+ * Options for a streamed IFC open. All optional; defaults suit a browser
+ * worker over an OPFS-backed store.
+ */
+export interface StreamedIfcOpenOptions {
+    /** Parse window size in bytes (default 1 MiB). */
+    pool?: number;
+    /** Windowed provider chunk size (default: provider's). */
+    chunkBytes?: number;
+    /** Windowed provider LRU cap in chunks (default: provider's). */
+    maxResidentChunks?: number;
+    /**
+     * Live per-record event `(localID, expressID, typeID)` — the M2 seam for
+     * incremental consumers (type index, roots, cross-refs) that run while
+     * the model is still parsing. Must be synchronous and cheap.
+     */
+    onRecordIndexed?: (localID: number, expressID: number, typeID: EntityTypesIfc | undefined) => void;
+}
+/**
+ * The result of a streamed IFC open: the windowed-source model plus the
+ * artifacts a consumer needs around it.
+ */
+export interface StreamedIfcOpen {
+    /** The model over the windowed source (undefined if the parse failed). */
+    model: IfcStepModel | undefined;
+    /** The parse result. */
+    result: ParseResult;
+    /** The STEP header (available even on some failed parses). */
+    header: StepHeader;
+    /**
+     * The columnar index the model was built from. Hand to
+     * `serializeIndexSidecarFromColumns` (with a source hash) to produce the
+     * revisit sidecar — the columns ARE the sidecar payload (M7 identity).
+     */
+    columns: StepIndexColumns<EntityTypesIfc>;
+    /** Window diagnostics from the streaming build. */
+    stats: StreamingIndexStats;
+}
+/**
+ * Open an IFC model from a streamed source with a **fixed-memory parse**
+ * (the release-facing Phase B API; composes M0/M1a/M7):
+ *
+ *  - the index builds through a moving window over `source` — the source is
+ *    never resident in the JS heap, and the index is columnar from birth
+ *    (no per-record object phase);
+ *  - the model reads source bytes on demand through a windowed LRU provider
+ *    over `store` (`ensureResidentByLocalID`/`ByExpressID` page ranges in
+ *    before synchronous reads — see `DemandResidencyPump` for the demand
+ *    orchestration).
+ *
+ * The typical browser wiring: a worker streams the network body **through**
+ * to OPFS while feeding the same bytes to `source`; `store` reads back from
+ * OPFS. `source.byteLength` and `store.byteLength` must agree.
+ *
+ * @param source The sequential parse source.
+ * @param store The random-access store the model reads from afterwards.
+ * @param options See {@link StreamedIfcOpenOptions}.
+ * @return {StreamedIfcOpen} The model + header, columns, and diagnostics.
+ */
+export declare function openStreamedIfcModel(source: ByteSource, store: StepExternalByteStore, options?: StreamedIfcOpenOptions): StreamedIfcOpen;
+//# sourceMappingURL=ifc_stream_open.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_stream_open.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_stream_open.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAEL,mBAAmB,EACpB,MAAM,yCAAyC,CAAA;AAChD,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EACL,qBAAqB,EAEtB,MAAM,8BAA8B,CAAA;AACrC,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAC5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAI3C;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IAErC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;;;OAIG;IACH,eAAe,CAAC,EACd,CAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,SAAS,KAAM,IAAI,CAAA;CACrF;AAGD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAE9B,0EAA0E;IAC1E,KAAK,EAAE,YAAY,GAAG,SAAS,CAAA;IAE/B,wBAAwB;IACxB,MAAM,EAAE,WAAW,CAAA;IAEnB,8DAA8D;IAC9D,MAAM,EAAE,UAAU,CAAA;IAElB;;;;OAIG;IACH,OAAO,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAA;IAEzC,mDAAmD;IACnD,KAAK,EAAE,mBAAmB,CAAA;CAC3B;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,qBAAqB,EAC5B,OAAO,CAAC,EAAE,sBAAsB,GAAI,eAAe,CA4BtD"}

package/compiled/src/ifc/ifc_stream_open.js

@@ -0,0 +1,46 @@
+import { buildColumnarIndexStreaming, } from "../step/parsing/streaming_index_builder.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { WindowedStepBufferProvider, } from "../step/step_buffer_provider.js";
+import IfcStepModel from "./ifc_step_model.js";
+import IfcStepParser from "./ifc_step_parser.js";
+// eslint-disable-next-line no-magic-numbers
+const DEFAULT_STREAM_POOL_BYTES = 1024 * 1024;
+/**
+ * Open an IFC model from a streamed source with a **fixed-memory parse**
+ * (the release-facing Phase B API; composes M0/M1a/M7):
+ *
+ *  - the index builds through a moving window over `source` — the source is
+ *    never resident in the JS heap, and the index is columnar from birth
+ *    (no per-record object phase);
+ *  - the model reads source bytes on demand through a windowed LRU provider
+ *    over `store` (`ensureResidentByLocalID`/`ByExpressID` page ranges in
+ *    before synchronous reads — see `DemandResidencyPump` for the demand
+ *    orchestration).
+ *
+ * The typical browser wiring: a worker streams the network body **through**
+ * to OPFS while feeding the same bytes to `source`; `store` reads back from
+ * OPFS. `source.byteLength` and `store.byteLength` must agree.
+ *
+ * @param source The sequential parse source.
+ * @param store The random-access store the model reads from afterwards.
+ * @param options See {@link StreamedIfcOpenOptions}.
+ * @return {StreamedIfcOpen} The model + header, columns, and diagnostics.
+ */
+export function openStreamedIfcModel(source, store, options) {
+    if (store.byteLength !== source.byteLength) {
+        throw new Error(`Streaming store byteLength ${store.byteLength} does not match ` +
+            `source byteLength ${source.byteLength}`);
+    }
+    const { header, columns, result, stats } = buildColumnarIndexStreaming(source, IfcStepParser.Instance, options?.pool ?? DEFAULT_STREAM_POOL_BYTES, options?.onRecordIndexed);
+    if (result !== ParseResult.COMPLETE) {
+        return { model: void 0, result, header, columns, stats };
+    }
+    const provider = new WindowedStepBufferProvider(store, options?.chunkBytes, options?.maxResidentChunks);
+    return {
+        model: new IfcStepModel(void 0, columns, provider),
+        result,
+        header,
+        columns,
+        stats,
+    };
+}

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

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

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

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

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

@@ -0,0 +1,63 @@
+/* eslint-disable no-magic-numbers */
+// Phase B3: the release-facing streamed open — fixed-memory columnar parse
+// over a ByteSource, model over a windowed store, columns exposed for the
+// revisit sidecar — behaves like a resident open for reads once ranges are
+// resident.
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import IfcStepParser from "./ifc_step_parser.js";
+import { openStreamedIfcModel } from "./ifc_stream_open.js";
+import { BufferByteSource } from "../step/parsing/byte_source.js";
+import { InMemoryStepByteStore } from "../step/step_buffer_provider.js";
+import { ParseResult } from "../step/parsing/step_parser.js";
+import { hashSource, serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, } from "../step/parsing/index_sidecar.js";
+import { IfcRoot } from "./ifc4_gen/index.js";
+let bytes;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let residentModel;
+beforeAll(() => {
+    bytes = new Uint8Array(fs.readFileSync("data/index.ifc"));
+    const input = new ParsingBuffer(bytes);
+    IfcStepParser.Instance.parseHeader(input);
+    residentModel = IfcStepParser.Instance.parseDataToModel(input)[1];
+});
+describe("openStreamedIfcModel (Phase B3)", () => {
+    test("opens a model matching the resident parse, with header and columns", () => {
+        const open = openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes), { pool: 4 * 1024 });
+        expect(open.result).toBe(ParseResult.COMPLETE);
+        expect(open.model).toBeDefined();
+        expect(open.header.headers.size).toBeGreaterThan(0);
+        expect(open.columns.firstInlineElement).toBeGreaterThan(0);
+        const streamedRoots = new Set(open.model.expressIDsOfTypes(IfcRoot));
+        const residentRoots = new Set(residentModel.expressIDsOfTypes(IfcRoot));
+        expect(streamedRoots).toEqual(residentRoots);
+    });
+    test("reads work after ensureResident (the windowed contract)", async () => {
+        const open = openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes));
+        const model = open.model;
+        const expressID = [...model.expressIDsOfTypes(IfcRoot)][0];
+        await model.ensureResidentByExpressID(expressID);
+        const element = model.getElementByExpressID(expressID);
+        expect(element?.expressID).toBe(expressID);
+    });
+    test("record events fire live during the open", () => {
+        let events = 0;
+        openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes), { onRecordIndexed: () => void ++events });
+        expect(events).toBe(openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes)).columns.firstInlineElement);
+    });
+    test("the returned columns serialize to a trustable revisit sidecar", () => {
+        const open = openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes));
+        const hash = hashSource(bytes);
+        const sidecar = serializeIndexSidecarFromColumns(open.columns, bytes.byteLength, hash);
+        const restored = deserializeIndexSidecarToColumns(sidecar);
+        expect(sidecarMatchesSource(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        restored, bytes.byteLength, hash)).toBe(true);
+        expect(restored.columns.count).toBe(open.columns.firstInlineElement);
+    });
+    test("rejects a store whose length disagrees with the source", () => {
+        expect(() => openStreamedIfcModel(new BufferByteSource(bytes), new InMemoryStepByteStore(bytes.subarray(0, 100))))
+            .toThrow(/does not match/);
+    });
+});

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/index.d.ts

@@ -11,4 +11,18 @@ 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, StreamedIfcOpen, StreamedIfcOpenOptions } from "./ifc/ifc_stream_open.js";
+export { ByteSource, BufferByteSource } from "./step/parsing/byte_source.js";
+export { StepExternalByteStore, InMemoryStepByteStore, StepBufferProvider, WindowedStepBufferProvider, } from "./step/step_buffer_provider.js";
+export { StepIndexColumns } 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 { IncrementalTypeIndex } from "./step/parsing/incremental_type_index.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":"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;AAK5B,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AACrG,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AACzE,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EACL,gCAAgC,EAChC,gCAAgC,EAChC,oBAAoB,EACpB,UAAU,GACX,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,yBAAyB,EAAE,aAAa,EAAE,MAAM,4CAA4C,CAAA;AACrG,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAC5E,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACnG,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AACnG,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AACpF,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA"}

package/compiled/src/index.js

@@ -10,3 +10,19 @@ 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.
+export { openStreamedIfcModel } from "./ifc/ifc_stream_open.js";
+export { BufferByteSource } from "./step/parsing/byte_source.js";
+export { InMemoryStepByteStore, WindowedStepBufferProvider, } from "./step/step_buffer_provider.js";
+export { serializeIndexSidecarFromColumns, deserializeIndexSidecarToColumns, sidecarMatchesSource, hashSource, } from "./step/parsing/index_sidecar.js";
+export { StreamingRecordDispatcher } from "./step/parsing/streaming_record_dispatcher.js";
+export { IncrementalTypeIndex } from "./step/parsing/incremental_type_index.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/version/version.js

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