@bldrs-ai/conway 1.389.1221 → 1.394.1504

package/compiled/src/compat/web-ifc/streamed_preview_channel.js

@@ -0,0 +1,580 @@
+import { CanonicalMeshType } from "../../index.js";
+import IfcStepModel from "../../ifc/ifc_step_model.js";
+import { IfcGeometryExtraction } from "../../ifc/ifc_geometry_extraction.js";
+import { IfcProduct } from "../../ifc/ifc4_gen/index.js";
+import AP214StepModel from "../../AP214E3_2010/ap214_step_model.js";
+import { AP214GeometryExtraction, } from "../../AP214E3_2010/ap214_geometry_extraction.js";
+import { cursorIterator } from "../../indexing/cursor_utilities.js";
+import * as glmatrix from "gl-matrix";
+import { composeTransformF64, deriveCoordinationF64, NORMALIZE_MAT_F64, } from "./coordination_f64.js";
+/* eslint-disable no-magic-numbers */
+/** Initial ms between preview pump ticks (interleaves with the parse's
+ * yields). The interval decays (TICK_INTERVAL_GROWTH per tick, capped at
+ * TICK_INTERVAL_MAX_MS): dense ticking in the first seconds delivers the
+ * immediate-feedback wow, then the channel backs off so a long parse
+ * isn't taxed all the way through. */
+const TICK_INTERVAL_MS = 150;
+const TICK_INTERVAL_MAX_MS = 600;
+const TICK_INTERVAL_GROWTH = 1.1;
+/** Extraction + capture time budget per tick, so the parse keeps most of
+ * the main thread (~25/150 ≈ 17% worst-case preview share). */
+const TICK_BUDGET_MS = 25;
+/** Don't build the first generation before this many top-level records —
+ * below it the prefix rarely contains a placeable product. */
+const FIRST_GENERATION_MIN_RECORDS = 1024;
+/** A new generation only when the index grew this much past the previous
+ * snapshot (bounds snapshot copies to O(GROWTH/(GROWTH-1)) of the file). */
+const GENERATION_GROWTH_FACTOR = 2;
+/** Default cap on units the preview channel ever extracts. Preview
+ * generations are throwaway extractions whose native geometry is not
+ * reclaimed until page teardown (the shim never frees classic scenes
+ * either — see closeModel), so the cap bounds that one-time cost. */
+const DEFAULT_MAX_PREVIEW_UNITS = 4096;
+/** Default cap on total payload bytes copied out to the consumer. */
+const DEFAULT_MAX_PREVIEW_BYTES = 48 * 1024 * 1024;
+const FLOATS_PER_VERTEX = 6;
+const BYTES_PER_FLOAT = 4;
+const DEFAULT_COLOR = [0.8, 0.8, 0.8, 1];
+/**
+ * IFC adapter: units are IfcProducts in localID order (stable across
+ * prefix growth), extracted through the per-product demand seam.
+ *
+ * @return {PreviewSchemaAdapter} The adapter.
+ */
+export function ifcPreviewAdapter() {
+    return {
+        buildGeneration(data, conwaywasm, columns) {
+            const model = new IfcStepModel(data, columns);
+            // Enumerate product localIDs straight off the type index — NO
+            // entity materialization (a per-generation sweep of 50k+ product
+            // entities was a dominant channel cost on PSB-class models).
+            const products = [];
+            for (const localID of cursorIterator(model.typeIndex.cursor(...IfcProduct.query))) {
+                products.push(localID);
+            }
+            if (products.length === 0) {
+                return void 0;
+            }
+            const extraction = new IfcGeometryExtraction(conwaywasm, model);
+            // Prefix extractions hit representation items whose style/select
+            // references aren't parsed yet — expected on a truncated tail;
+            // don't flood the report (DOWA: 1164 styled-item errors).
+            extraction.quietRecoverableLogging = true;
+            // A product whose placement records sit beyond this prefix must
+            // defer, not extract unplaced: Revit writes placements near the
+            // end of the file, so an early product can reference a placement
+            // the index does not hold yet. Lenient reads null the dangling
+            // reference and the product extracts at the origin — on a
+            // georeferenced model the emitted payloads then sit a site-offset
+            // away from the model (Share#1744: Snowdon's door #5014 put 88
+            // payloads ~425km out, and the camera follow framed them). The
+            // per-unit catch below already treats a throwing product as
+            // not-yet-extractable; this makes a dangling placement throw like
+            // any other unparsed forward reference. The classic-mode cursor
+            // does not re-run passed units, so a deferred product sits out
+            // the preview and the durable pump renders it — an empty slot,
+            // never geometry at the wrong placement.
+            extraction.deferDanglingPlacements = true;
+            // Preview-only preparation: skip the relationship sweeps whose
+            // entity materialization dominates per-generation cost.
+            extraction.prepareDemandExtraction(true);
+            return {
+                scene: extraction.scene,
+                unitCount: products.length,
+                get linearScalingFactor() {
+                    return extraction.getLinearScalingFactor();
+                },
+                runUnits: (from, count) => {
+                    const end = Math.min(from + count, products.length);
+                    let executed = 0;
+                    for (let where = from; where < end; ++where) {
+                        try {
+                            if (extraction.extractProductGeometryByLocalID(products[where])) {
+                                ++executed;
+                            }
+                        }
+                        catch {
+                            // Unparsed forward reference — the durable pump extracts
+                            // this product from the full model later.
+                        }
+                    }
+                    return executed;
+                },
+                geometryExpressID: (geometryLocalID) => model.getElementByLocalID(geometryLocalID)?.expressID,
+                recenter: true,
+                dispose: () => {
+                    releaseModelGeometry(model.geometry);
+                },
+            };
+        },
+    };
+}
+/**
+ * Free every buffer-geometry canonical mesh a model geometry cache
+ * holds (native embind objects), leaving the cache empty. Safe on an
+ * already-released cache.
+ *
+ * @param geometry The model geometry cache (iterable of canonical
+ * meshes with a delete(localID)).
+ */
+export function releaseModelGeometry(geometry) {
+    const localIDs = [];
+    for (const mesh of geometry) {
+        localIDs.push(mesh.localID);
+    }
+    for (const localID of localIDs) {
+        try {
+            geometry.delete(localID);
+        }
+        catch {
+            // Never let a free break a load — leaked is better than crashed.
+        }
+    }
+}
+/**
+ * AP214 adapter: units are assembly-tree units (see
+ * AP214GeometryExtraction.prepareDemandExtraction). Unit ordinals are
+ * only approximately stable across prefix growth (a root's child list
+ * can grow, shifting later ordinals) — for a preview that is
+ * acceptable: a shifted ordinal re-emits an instance at an identical
+ * placement (invisible overlap) or skips one (the durable pump renders
+ * it later).
+ *
+ * @return {PreviewSchemaAdapter} The adapter.
+ */
+export function ap214PreviewAdapter() {
+    return {
+        retryEmptyUnits: true,
+        buildGeneration(data, conwaywasm, columns) {
+            const model = new AP214StepModel(data, columns);
+            const extraction = new AP214GeometryExtraction(conwaywasm, model);
+            // Prefix extractions hit dangling records by construction —
+            // don't let their expected per-record errors flood the report
+            // (Arty: 5k+ styled-item warnings across generations).
+            extraction.quietRecoverableLogging = true;
+            extraction.prepareDemandExtraction();
+            if (extraction.demandUnitCount === 0) {
+                return void 0;
+            }
+            return {
+                scene: extraction.scene,
+                unitCount: extraction.demandUnitCount,
+                get linearScalingFactor() {
+                    return extraction.getLinearScalingFactor();
+                },
+                runUnits: (from, count) => {
+                    if (extraction.demandUnitCursor < from) {
+                        extraction.skipDemandUnits(from - extraction.demandUnitCursor);
+                    }
+                    return extraction.extractDemandUnitBatch(count);
+                },
+                geometryExpressID: (geometryLocalID) => model.getElementByLocalID(geometryLocalID)?.expressID,
+                recenter: false,
+                dispose: () => {
+                    releaseModelGeometry(model.geometry);
+                },
+            };
+        },
+    };
+}
+/**
+ * Parse-time preview channel (demand/tiled rendering slice A2): while a
+ * deferred streamed open is still parsing, periodically snapshot the
+ * growing columnar index into a PREFIX model, extract a bounded number of
+ * units through a throwaway extraction, and emit self-contained mesh
+ * payloads — first pixels within the first seconds of a large parse
+ * instead of after it. Schema knowledge lives in the
+ * {@link PreviewSchemaAdapter}; the channel owns scheduling, generations,
+ * watermarks, payload copies, caps and the coordination pin.
+ *
+ * Preview quality, by construction: relationship records (IFC voids,
+ * materials, styled items) spread to the very end of real files
+ * (measured ~92–97% depth), so a prefix extraction can miss
+ * openings and materials. That is why these extractions are throwaway:
+ * the durable batch pump after the parse re-extracts every unit with the
+ * full model and REPLACES the preview — final geometry parity is
+ * untouched by this channel.
+ *
+ * Scheduling: the cooperative parse yields to the event loop via
+ * macrotasks every ~50ms; each pump tick runs in one of those gaps under
+ * a hard time budget, so the parse keeps the bulk of the main thread.
+ */
+export class StreamedPreviewChannel {
+    /**
+     * @param data The (fully resident) source buffer the parse is indexing.
+     * @param conwaywasm The shared geometry wasm wrapper (sequential use only
+     * — ticks run between parse yields, never concurrently with the durable
+     * extraction, which is created after the parse completes).
+     * @param sink The live columnar sink the streamed parse is filling.
+     * @param adapter The schema adapter building prefix generations.
+     * @param coordinateToOrigin The open's COORDINATE_TO_ORIGIN setting.
+     * @param onMesh Consumer callback for each preview payload.
+     * @param maxUnits Cap on units ever preview-extracted.
+     * @param maxBytes Cap on total payload bytes copied out.
+     * @param firstGenerationMinRecords Records required before the first
+     * snapshot (tests lower it for tiny fixtures).
+     */
+    constructor(data, conwaywasm, sink, adapter, coordinateToOrigin, onMesh, maxUnits = DEFAULT_MAX_PREVIEW_UNITS, maxBytes = DEFAULT_MAX_PREVIEW_BYTES, firstGenerationMinRecords = FIRST_GENERATION_MIN_RECORDS) {
+        this.data = data;
+        this.conwaywasm = conwaywasm;
+        this.sink = sink;
+        this.adapter = adapter;
+        this.coordinateToOrigin = coordinateToOrigin;
+        this.onMesh = onMesh;
+        this.maxUnits = maxUnits;
+        this.maxBytes = maxBytes;
+        this.firstGenerationMinRecords = firstGenerationMinRecords;
+        this.stopped_ = false;
+        this.emittedUnits_ = 0;
+        this.emittedBytes_ = 0;
+        /** Ordinal cursor into the unit list (see the adapter's stability
+         * notes). */
+        this.unitOrdinal_ = 0;
+        /** Retry mode (adapter.retryEmptyUnits): ordinals that captured ≥ 1
+         * instance — done for good, skipped on later generations. */
+        this.completedUnits_ = new Set();
+        /** Retry mode: scan position within the CURRENT generation (resets to
+         * 0 on every new generation so empty units get re-run). */
+        this.retryScan_ = 0;
+        /** Geometry expressIDs whose payload has been emitted (cross-generation
+         * dedup for mapped/shared geometry). */
+        this.emittedGeometry_ = new Set();
+        this.lastSnapshotRecords_ = 0;
+        /** Records at the last snapshot whose generation build THREW (a
+         * structurally incomplete prefix) — gates retries to index growth so a
+         * throwing prefix build can't hot-loop every tick. */
+        this.lastFailedSnapshotRecords_ = 0;
+        this.lastInlineTick_ = 0;
+        this.tickIntervalMs_ = TICK_INTERVAL_MS;
+        // A field rather than reading TICK_BUDGET_MS directly, so a test can lift
+        // the wall-clock bound the way it already lifts tickIntervalMs_. Asserting
+        // "this tick ran all N units" against a real 25ms budget is a coin flip on
+        // a loaded runner: the retryEmptyUnits test expected [0,1,2] and got [0,1]
+        // in CI while passing locally. Production behaviour is unchanged.
+        this.tickBudgetMs_ = TICK_BUDGET_MS;
+    }
+    /** Begin ticking (call just before awaiting the parse). */
+    start() {
+        this.schedule_();
+    }
+    /**
+     * Tick inline if one is due — called from the parse's own progress
+     * callback, so the channel keeps its cadence even when the event
+     * loop's timer queue is starved (browser: the cooperative parse
+     * yields via scheduler.yield / MessageChannel, whose continuations
+     * outrank setTimeout; the 150ms timer ticks barely ran on PSB-class
+     * parses, starving the preview until parse end). The timer remains
+     * as a fallback for gaps between progress calls.
+     */
+    maybeTickInline() {
+        if (this.stopped_ || this.capped) {
+            return;
+        }
+        const now = Date.now();
+        if (now - this.lastInlineTick_ < this.tickIntervalMs_) {
+            return;
+        }
+        this.lastInlineTick_ = now;
+        this.tickIntervalMs_ =
+            Math.min(this.tickIntervalMs_ * TICK_INTERVAL_GROWTH, TICK_INTERVAL_MAX_MS);
+        try {
+            this.tick_();
+        }
+        catch {
+            // A preview failure must never break the open.
+            this.stopped_ = true;
+        }
+    }
+    /**
+     * Stop ticking (call once the parse settles, before finalize/fallback).
+     * Idempotent; no tick runs after this returns (ticks are synchronous and
+     * scheduled on the same event loop).
+     */
+    stop() {
+        this.stopped_ = true;
+        if (this.timer_ !== void 0) {
+            clearTimeout(this.timer_);
+            this.timer_ = void 0;
+        }
+        // Payloads are copies — a stopped channel's throwaway scenes hold
+        // nothing anyone can reference. Free them so repeated loads in one
+        // tab reuse the wasm pages instead of stacking preview scenes.
+        try {
+            this.generation_?.generation.dispose();
+        }
+        catch {
+            // Never let a free break the open.
+        }
+        this.generation_ = void 0;
+    }
+    /** True when a cap was hit and the channel retired itself early. */
+    get capped() {
+        return this.emittedUnits_ >= this.maxUnits ||
+            this.emittedBytes_ >= this.maxBytes;
+    }
+    // eslint-disable-next-line require-jsdoc
+    schedule_() {
+        if (this.stopped_ || this.capped) {
+            return;
+        }
+        this.timer_ = setTimeout(() => {
+            this.timer_ = void 0;
+            try {
+                this.tick_();
+            }
+            catch {
+                // A preview failure must never break the open — retire quietly;
+                // the durable pump renders everything after the parse.
+                this.stopped_ = true;
+            }
+            this.schedule_();
+        }, this.tickIntervalMs_);
+    }
+    /**
+     * One pump tick: ensure a generation with pending units exists, then
+     * extract + capture under the time budget.
+     */
+    tick_() {
+        const deadline = Date.now() + this.tickBudgetMs_;
+        if (!this.ensureGeneration_()) {
+            return;
+        }
+        const active = this.generation_;
+        const { generation } = active;
+        if (this.adapter.retryEmptyUnits === true) {
+            // Retry mode: scan the fixed unit list, skipping units that
+            // already captured instances on an earlier (or this) generation.
+            // Capture runs per unit so completion can be attributed — unit
+            // counts here are small by construction (assembly roots).
+            while (this.retryScan_ < generation.unitCount &&
+                this.emittedUnits_ < this.maxUnits &&
+                Date.now() < deadline) {
+                const ordinal = this.retryScan_++;
+                if (this.completedUnits_.has(ordinal)) {
+                    continue;
+                }
+                const executed = generation.runUnits(ordinal, 1);
+                if (executed > 0 && this.captureNewInstances_() > 0) {
+                    this.completedUnits_.add(ordinal);
+                    ++this.emittedUnits_;
+                }
+            }
+            return;
+        }
+        let extractedThisTick = 0;
+        while (this.unitOrdinal_ < generation.unitCount &&
+            this.emittedUnits_ + extractedThisTick < this.maxUnits &&
+            Date.now() < deadline) {
+            const executed = generation.runUnits(this.unitOrdinal_, 1);
+            ++this.unitOrdinal_;
+            extractedThisTick += executed;
+        }
+        if (extractedThisTick > 0) {
+            this.captureNewInstances_();
+            this.emittedUnits_ += extractedThisTick;
+        }
+    }
+    /**
+     * Ensure a generation with pending units: keep the current one while
+     * it has work; otherwise snapshot a fresh prefix model once the index
+     * has grown enough to be worth the copy.
+     *
+     * @return {boolean} True when a generation with pending units exists.
+     */
+    ensureGeneration_() {
+        const active = this.generation_;
+        if (active !== void 0 && this.hasPendingUnits_(active.generation)) {
+            return true;
+        }
+        const records = this.sink.topLevelCount;
+        if (records < this.firstGenerationMinRecords) {
+            return false;
+        }
+        if (active !== void 0 &&
+            records < this.lastSnapshotRecords_ * GENERATION_GROWTH_FACTOR) {
+            return false;
+        }
+        if (records < this.lastFailedSnapshotRecords_ * GENERATION_GROWTH_FACTOR) {
+            return false;
+        }
+        const columns = this.sink.snapshot();
+        let generation;
+        try {
+            generation =
+                this.adapter.buildGeneration(this.data, this.conwaywasm, columns);
+        }
+        catch {
+            // A mid-parse prefix can be structurally incomplete — dangling
+            // references throw schema-typed errors (AP214's assembly-tree
+            // prep especially; a bad prefix killed the whole STEP preview
+            // before this catch). That retires THIS attempt, not the
+            // channel: the growth gate above retries once the index has
+            // grown enough for a materially different prefix.
+            this.lastFailedSnapshotRecords_ = records;
+            return false;
+        }
+        this.lastFailedSnapshotRecords_ = 0;
+        this.lastSnapshotRecords_ = records;
+        if (generation === void 0) {
+            // Prefix grew but cannot build yet — wait for more records.
+            return false;
+        }
+        const newGenerationPending = this.adapter.retryEmptyUnits === true ?
+            generation.unitCount > 0 &&
+                this.completedUnits_.size < generation.unitCount :
+            generation.unitCount > this.unitOrdinal_;
+        if (!newGenerationPending) {
+            // Nothing this prefix can add — free it and wait for more records.
+            // (The active generation, if any, keeps its scan state untouched.)
+            try {
+                generation.dispose();
+            }
+            catch {
+                // Never let a free break the open.
+            }
+            return false;
+        }
+        // Retry mode: a fresh generation re-runs every not-yet-captured unit.
+        this.retryScan_ = 0;
+        // The outgoing generation's instances are all captured (a
+        // generation is only replaced once exhausted + captured) — free its
+        // native scenes before adopting the new one.
+        try {
+            active?.generation.dispose();
+        }
+        catch {
+            // Never let a free break the open.
+        }
+        this.generation_ = {
+            generation,
+            capturedCounts: new Map(),
+        };
+        return true;
+    }
+    /**
+     * Does the given generation still have units this channel would run —
+     * retry mode: not-yet-captured ordinals ahead of the scan; classic
+     * mode: ordinals beyond the global forward-only cursor.
+     *
+     * @param generation The generation to check.
+     * @return {boolean} True when a tick can make progress on it.
+     */
+    hasPendingUnits_(generation) {
+        if (this.adapter.retryEmptyUnits === true) {
+            return this.retryScan_ < generation.unitCount &&
+                this.completedUnits_.size < generation.unitCount;
+        }
+        return this.unitOrdinal_ < generation.unitCount;
+    }
+    /**
+     * Walk the current generation's scene and emit every not-yet-captured
+     * placed instance as a payload — the preview twin of the durable delta
+     * captures, with the same placed-geometry math per schema (recentering
+     * for IFC, bare composition for AP214) so preview and durable
+     * placements coincide, but copying geometry OUT of the wasm heap
+     * instead of retaining native references.
+     *
+     * @return {number} Instances emitted by this pass (retry mode uses
+     * this to attribute unit completion).
+     */
+    captureNewInstances_() {
+        const active = this.generation_;
+        const { generation, capturedCounts } = active;
+        const { scene, recenter } = generation;
+        const linearScalingFactor = generation.linearScalingFactor;
+        const seenThisPass = new Map();
+        let emitted = 0;
+        for (const walked of scene.walk()) {
+            const [, nativeTransform, geometry, material, entity] = walked;
+            if (entity?.localID === void 0 || entity.expressID === void 0) {
+                continue;
+            }
+            const walkIndex = seenThisPass.get(entity.localID) ?? 0;
+            seenThisPass.set(entity.localID, walkIndex + 1);
+            if (walkIndex < (capturedCounts.get(entity.localID) ?? 0)) {
+                continue;
+            }
+            capturedCounts.set(entity.localID, walkIndex + 1);
+            if (geometry.type !== CanonicalMeshType.BUFFER_GEOMETRY || geometry.temporary) {
+                continue;
+            }
+            const material_ = material ?? {
+                name: "",
+                baseColor: DEFAULT_COLOR,
+                legacyColor: DEFAULT_COLOR,
+                doubleSided: true,
+                blend: 0,
+            };
+            let nativePt;
+            if (this.coordinationMatrix === void 0 && this.coordinateToOrigin) {
+                nativePt = geometry.geometry.getPoint(0);
+            }
+            // normalize() recenters the geometry buffer (side effect) and returns
+            // the local centre; only the per-leaf recenter path (IFC) applies it —
+            // AP214 shares one buffer and composes bare (issue #308).
+            const center = recenter ? geometry.geometry.normalize() : undefined;
+            const geometryExpressID = generation.geometryExpressID(geometry.localID);
+            // Full-precision float64 placement straight from the wasm boundary
+            // (glm::dmat4) — never truncated through a gl-matrix Float32Array;
+            // the recentre math runs in double precision (see coordination_f64).
+            const geometryTransform = nativeTransform?.getValues();
+            if (this.coordinationMatrix === void 0 && this.coordinateToOrigin) {
+                this.coordinationMatrix = deriveCoordinationF64(geometryTransform, nativePt, NORMALIZE_MAT_F64, linearScalingFactor);
+            }
+            const coordination = this.coordinationMatrix ?? glmatrix.mat4.create();
+            const newTransform = composeTransformF64(coordination, geometryTransform, center);
+            const payload = {
+                expressID: entity.expressID,
+                geometryExpressID,
+                color: {
+                    x: material_.legacyColor[0],
+                    y: material_.legacyColor[1],
+                    z: material_.legacyColor[2],
+                    w: material_.legacyColor[3],
+                },
+                flatTransformation: Array.from(newTransform),
+            };
+            if (!this.emittedGeometry_.has(geometryExpressID)) {
+                const nativeGeometry = geometry.geometry;
+                const vertexData = this.conwaywasm.floatHeapSlice(nativeGeometry.GetVertexData(), nativeGeometry.GetVertexDataSize()).slice();
+                const indexData = this.conwaywasm.uint32HeapSlice(nativeGeometry.GetIndexData(), nativeGeometry.GetIndexDataSize()).slice();
+                if (vertexData.length < FLOATS_PER_VERTEX || indexData.length === 0) {
+                    continue;
+                }
+                payload.vertexData = vertexData;
+                payload.indexData = indexData;
+                this.emittedGeometry_.add(geometryExpressID);
+                this.emittedBytes_ +=
+                    (vertexData.length + indexData.length) * BYTES_PER_FLOAT;
+            }
+            this.onMesh(payload);
+            ++emitted;
+            if (this.emittedBytes_ >= this.maxBytes) {
+                return emitted;
+            }
+        }
+        return emitted;
+    }
+    /**
+     * Test seam: run generation building + extraction + capture synchronously
+     * until either every unit currently in the sink is attempted or a cap
+     * is hit — what the timer-driven ticks do, without the timers.
+     */
+    drainForTest() {
+        for (;;) {
+            if (this.capped || !this.ensureGeneration_()) {
+                return;
+            }
+            const active = this.generation_;
+            if (this.unitOrdinal_ >= active.generation.unitCount) {
+                return;
+            }
+            const executed = active.generation.runUnits(this.unitOrdinal_, 1);
+            ++this.unitOrdinal_;
+            if (executed > 0) {
+                this.captureNewInstances_();
+                ++this.emittedUnits_;
+            }
+        }
+    }
+}

package/compiled/src/compat/web-ifc/web_wasm_directory.test.d.ts

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

package/compiled/src/compat/web-ifc/web_wasm_directory.test.d.ts.map

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

package/compiled/src/compat/web-ifc/web_wasm_directory.test.js

@@ -0,0 +1,22 @@
+// The wasm-directory normalization behind the isolated-context module
+// prefix (Share #1610): embedder SetWasmPath values are site-root-
+// relative by convention and must come out as absolute directories,
+// since they become runtime dynamic-import prefixes whose resolution
+// must not depend on the page or bundle URL (the pthread worker script
+// URL derives from the imported module's import.meta.url).
+import { describe, expect, test } from "@jest/globals";
+import { webWasmDirectory } from "./ifc_api.js";
+describe("webWasmDirectory", () => {
+    test("site-root-relative convention absolutizes", () => {
+        expect(webWasmDirectory("./static/js/")).toBe("/static/js/");
+        expect(webWasmDirectory("static/js/")).toBe("/static/js/");
+    });
+    test("absolute paths pass through with a trailing slash ensured", () => {
+        expect(webWasmDirectory("/static/js/")).toBe("/static/js/");
+        expect(webWasmDirectory("/wasm")).toBe("/wasm/");
+    });
+    test("missing input falls back to the conventional serve directory", () => {
+        expect(webWasmDirectory(undefined)).toBe("/static/js/");
+        expect(webWasmDirectory("")).toBe("/static/js/");
+    });
+});

package/compiled/src/core/composed_model_skeleton.d.ts

@@ -0,0 +1,63 @@
+import { StepEntityConstructorAbstract } from "../step/step_entity_constructor.js";
+import { EntityAddress } from "./model_uri.js";
+import { ModelRegistry } from "./model_registry.js";
+/**
+ * A model that can answer a type query — the minimum a federated model must
+ * expose to take part in cross-file composition. Both the resident model's
+ * type index and the streaming {@link IncrementalTypeIndex} satisfy this, so a
+ * composed view works whether its members are fully parsed or still streaming.
+ */
+export interface TypeQueryableModel<TypeIDType extends number> {
+    /**
+     * Express IDs of all records of the given types (including subtypes).
+     *
+     * @param types The entity constructors to query.
+     * @return {IterableIterator<number>} The matching express IDs.
+     */
+    expressIDsOfTypes(...types: StepEntityConstructorAbstract<TypeIDType>[]): IterableIterator<number>;
+}
+/**
+ * A composed view over every model in a {@link ModelRegistry} (M5 / design S3).
+ *
+ * Federation's read side: a site plan that references per-building files, or a
+ * project split across disciplines, is browsed as **one** model whose entities
+ * carry universal {@link EntityAddress}es (`modelURI#expressID`). A type query
+ * here fans out across all registered members and yields addresses, not bare
+ * express IDs — so "every `IfcWall` in the project" spans files, and each
+ * result round-trips back through {@link ModelRegistry.resolve} to the right
+ * model.
+ *
+ * This is the composition scaffold: it unions the members' type skeletons
+ * under the shared address space. The spatial-containment merge (a site's
+ * `IfcRelAggregates` linking to building files) layers on top by resolving the
+ * cross-file references the {@link CrossReferenceRegistry} discovers — the next
+ * increment, gated on the loader registering streamed models here.
+ */
+export declare class ComposedModelSkeleton<TypeIDType extends number, H extends TypeQueryableModel<TypeIDType>> {
+    private readonly registry_;
+    /**
+     * @param registry_ The registry whose models this composes over.
+     */
+    constructor(registry_: ModelRegistry<H>);
+    /**
+     * @return {ModelRegistry<H>} The registry backing this composed view.
+     */
+    get registry(): ModelRegistry<H>;
+    /**
+     * Yield the universal address of every entity of the given types across all
+     * registered models.
+     *
+     * @param types The entity constructors to query (subtype closures unioned).
+     * @return {IterableIterator<EntityAddress>} Addresses of matching entities.
+     * @yields {EntityAddress} Each matching entity's universal address.
+     */
+    entitiesOfType(...types: StepEntityConstructorAbstract<TypeIDType>[]): IterableIterator<EntityAddress>;
+    /**
+     * Count entities of the given types across all registered models.
+     *
+     * @param types The entity constructors to count.
+     * @return {number} The total across the federation.
+     */
+    countOfType(...types: StepEntityConstructorAbstract<TypeIDType>[]): number;
+}
+//# sourceMappingURL=composed_model_skeleton.d.ts.map

package/compiled/src/core/composed_model_skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composed_model_skeleton.d.ts","sourceRoot":"","sources":["../../../src/core/composed_model_skeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAA;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAGhD;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB,CAAC,UAAU,SAAS,MAAM;IAE3D;;;;;OAKG;IACH,iBAAiB,CACf,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GAAI,gBAAgB,CAAC,MAAM,CAAC,CAAA;CACpF;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAqB,CAChC,UAAU,SAAS,MAAM,EACzB,CAAC,SAAS,kBAAkB,CAAC,UAAU,CAAC;IAK3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAHvC;;OAEG;gBAC2B,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC;IAEzD;;OAEG;IACH,IAAW,QAAQ,IAAI,aAAa,CAAC,CAAC,CAAC,CAEtC;IAED;;;;;;;OAOG;IACK,cAAc,CAClB,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GACrD,gBAAgB,CAAC,aAAa,CAAC;IAgBnC;;;;;OAKG;IACI,WAAW,CACd,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GAAI,MAAM;CAapE"}