@bldrs-ai/conway 1.427.1287 → 1.429.1291

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

@@ -2,6 +2,8 @@ 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 * as glmatrix from "gl-matrix";
 /* eslint-disable no-magic-numbers */
 /** Ms between preview pump ticks (interleaves with the parse's yields). */
@@ -15,43 +17,151 @@ 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 = 1.5;
-/** Default cap on products the preview channel ever extracts. Preview
+/** 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_PRODUCTS = 4096;
+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];
-// Matches the shim proxy's NormalizeMat (Z-up -> Y-up).
+// Matches the shim proxies' NormalizeMat (Z-up -> Y-up).
 const NORMALIZE_MAT = glmatrix.mat4.fromValues(1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1);
 /**
- * Parse-time preview channel (demand/tiled rendering slice A2): while the
- * deferred streamed open is still parsing, periodically snapshot the growing
- * columnar index into a PREFIX model, extract a bounded number of products
- * through a throwaway extraction, and emit self-contained mesh payloads —
- * first pixels within the first seconds of a large parse instead of after
- * it.
+ * IFC adapter: units are IfcProducts in localID order (stable across
+ * prefix growth), extracted through the per-product demand seam.
  *
- * Preview quality, by construction: IFC relationship records
- * (IfcRelVoidsElement, IfcRelAssociatesMaterial, 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
- * product with the full model and REPLACES the preview — final geometry
- * parity is untouched by this channel.
+ * @return {PreviewSchemaAdapter} The adapter.
+ */
+export function ifcPreviewAdapter() {
+    return {
+        buildGeneration(data, conwaywasm, columns) {
+            const model = new IfcStepModel(data, columns);
+            const products = [];
+            for (const product of model.types(IfcProduct)) {
+                products.push(product.localID);
+            }
+            if (products.length === 0) {
+                return void 0;
+            }
+            const extraction = new IfcGeometryExtraction(conwaywasm, model);
+            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)).
+ */
+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 {
+        buildGeneration(data, conwaywasm, columns) {
+            const model = new AP214StepModel(data, columns);
+            const extraction = new AP214GeometryExtraction(conwaywasm, model);
+            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.
  *
- * 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.
+ * 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.
  *
- * Product cursor: top-level localIDs are stable across snapshots (dense
- * parse order) and `types(IfcProduct)` iterates in localID order, so a
- * single ordinal cursor advances across generations without re-extracting.
- * Products whose extraction throws mid-parse (unparsed forward references)
- * are skipped — the durable pump extracts them correctly later.
+ * 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 {
     /**
@@ -60,27 +170,30 @@ export class StreamedPreviewChannel {
      * — 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 maxProducts Cap on products ever preview-extracted.
+     * @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, coordinateToOrigin, onMesh, maxProducts = DEFAULT_MAX_PREVIEW_PRODUCTS, maxBytes = DEFAULT_MAX_PREVIEW_BYTES, firstGenerationMinRecords = FIRST_GENERATION_MIN_RECORDS) {
+    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.maxProducts = maxProducts;
+        this.maxUnits = maxUnits;
         this.maxBytes = maxBytes;
         this.firstGenerationMinRecords = firstGenerationMinRecords;
         this.stopped_ = false;
-        this.emittedProducts_ = 0;
+        this.emittedUnits_ = 0;
         this.emittedBytes_ = 0;
-        /** Ordinal cursor into the (append-stable) product list. */
-        this.productOrdinal_ = 0;
+        /** Ordinal cursor into the unit list (see the adapter's stability
+         * notes). */
+        this.unitOrdinal_ = 0;
         /** Geometry expressIDs whose payload has been emitted (cross-generation
          * dedup for mapped/shared geometry). */
         this.emittedGeometry_ = new Set();
@@ -101,10 +214,20 @@ export class StreamedPreviewChannel {
             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.emittedProducts_ >= this.maxProducts ||
+        return this.emittedUnits_ >= this.maxUnits ||
             this.emittedBytes_ >= this.maxBytes;
     }
     // eslint-disable-next-line require-jsdoc
@@ -126,7 +249,7 @@ export class StreamedPreviewChannel {
         }, TICK_INTERVAL_MS);
     }
     /**
-     * One pump tick: ensure a generation with pending products exists, then
+     * One pump tick: ensure a generation with pending units exists, then
      * extract + capture under the time budget.
      */
     tick_() {
@@ -134,87 +257,81 @@ export class StreamedPreviewChannel {
         if (!this.ensureGeneration_()) {
             return;
         }
-        const generation = this.generation_;
-        const { extraction, products } = generation;
+        const active = this.generation_;
+        const { generation } = active;
         let extractedThisTick = 0;
-        while (generation.nextIndex < products.length &&
-            this.emittedProducts_ + extractedThisTick < this.maxProducts &&
+        while (this.unitOrdinal_ < generation.unitCount &&
+            this.emittedUnits_ + extractedThisTick < this.maxUnits &&
             Date.now() < deadline) {
-            const localID = products[generation.nextIndex++];
-            ++this.productOrdinal_;
-            try {
-                if (extraction.extractProductGeometryByLocalID(localID)) {
-                    ++extractedThisTick;
-                }
-            }
-            catch {
-                // Unparsed forward reference (or any other mid-parse gap): skip.
-                // The durable pump extracts this product from the full model.
-            }
+            const executed = generation.runUnits(this.unitOrdinal_, 1);
+            ++this.unitOrdinal_;
+            extractedThisTick += executed;
         }
         if (extractedThisTick > 0) {
             this.captureNewInstances_();
-            this.emittedProducts_ += extractedThisTick;
+            this.emittedUnits_ += extractedThisTick;
         }
     }
     /**
-     * Ensure a generation with pending products: 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.
+     * 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 products exists.
+     * @return {boolean} True when a generation with pending units exists.
      */
     ensureGeneration_() {
-        const generation = this.generation_;
-        if (generation !== void 0 && generation.nextIndex < generation.products.length) {
+        const active = this.generation_;
+        if (active !== void 0 && this.unitOrdinal_ < active.generation.unitCount) {
             return true;
         }
         const records = this.sink.topLevelCount;
         if (records < this.firstGenerationMinRecords) {
             return false;
         }
-        if (generation !== void 0 &&
+        if (active !== void 0 &&
             records < this.lastSnapshotRecords_ * GENERATION_GROWTH_FACTOR) {
             return false;
         }
         const columns = this.sink.snapshot();
-        const model = new IfcStepModel(this.data, columns);
-        const products = [];
-        for (const product of model.types(IfcProduct)) {
-            products.push(product.localID);
+        const generation = this.adapter.buildGeneration(this.data, this.conwaywasm, columns);
+        this.lastSnapshotRecords_ = records;
+        // 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.
+        if (generation !== void 0 && generation.unitCount > this.unitOrdinal_) {
+            try {
+                active?.generation.dispose();
+            }
+            catch {
+                // Never let a free break the open.
+            }
         }
-        if (products.length <= this.productOrdinal_) {
-            // Prefix grew but produced no new products — wait for more records.
-            this.lastSnapshotRecords_ = records;
+        if (generation === void 0 || generation.unitCount <= this.unitOrdinal_) {
+            // Prefix grew but produced no new units — wait for more records.
             return false;
         }
-        const extraction = new IfcGeometryExtraction(this.conwaywasm, model);
         this.generation_ = {
-            model,
-            extraction,
-            products,
-            nextIndex: this.productOrdinal_,
+            generation,
             capturedCounts: new Map(),
-            snapshotRecords: records,
         };
-        this.lastSnapshotRecords_ = records;
         return true;
     }
     /**
      * Walk the current generation's scene and emit every not-yet-captured
-     * placed instance as a payload — the preview twin of the shim's durable
-     * delta capture, with the same placed-geometry math (normalize, scaling,
-     * coordination) so preview and durable placements coincide, but copying
-     * geometry OUT of the wasm heap instead of retaining native references.
+     * 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.
      */
     captureNewInstances_() {
-        const generation = this.generation_;
-        const { model, extraction, capturedCounts } = generation;
-        const scene = extraction.scene;
-        const linearScalingFactor = extraction.getLinearScalingFactor();
+        const active = this.generation_;
+        const { generation, capturedCounts } = active;
+        const { scene, recenter } = generation;
+        const linearScalingFactor = generation.linearScalingFactor;
         const seenThisPass = new Map();
-        // eslint-disable-next-line no-unused-vars
-        for (const [_, nativeTransform, geometry, material, entity] of scene.walk()) {
+        for (const walked of scene.walk()) {
+            const [, nativeTransform, geometry, material, entity] = walked;
             if (entity?.localID === void 0 || entity.expressID === void 0) {
                 continue;
             }
@@ -238,14 +355,16 @@ export class StreamedPreviewChannel {
             if (this.coordinationMatrix === void 0 && this.coordinateToOrigin) {
                 nativePt = geometry.geometry.getPoint(0);
             }
-            const geomCenter = glmatrix.vec3.create();
-            const center = geometry.geometry.normalize();
-            geomCenter[0] = center.x;
-            geomCenter[1] = center.y;
-            geomCenter[2] = center.z;
             const translationMatrixGeomMin = glmatrix.mat4.create();
-            glmatrix.mat4.fromTranslation(translationMatrixGeomMin, geomCenter);
-            const geometryExpressID = model.getElementByLocalID(geometry.localID)?.expressID;
+            if (recenter) {
+                const geomCenter = glmatrix.vec3.create();
+                const center = geometry.geometry.normalize();
+                geomCenter[0] = center.x;
+                geomCenter[1] = center.y;
+                geomCenter[2] = center.z;
+                glmatrix.mat4.fromTranslation(translationMatrixGeomMin, geomCenter);
+            }
+            const geometryExpressID = generation.geometryExpressID(geometry.localID);
             const geometryTransform = nativeTransform?.getValues();
             let newMatrix;
             if (geometryTransform !== void 0) {
@@ -268,11 +387,18 @@ export class StreamedPreviewChannel {
             }
             const coordination = this.coordinationMatrix ?? glmatrix.mat4.create();
             const newTransform = glmatrix.mat4.create();
-            const scaleMatrix = glmatrix.mat4.create();
-            const scaleVec = glmatrix.vec3.fromValues(linearScalingFactor, linearScalingFactor, linearScalingFactor);
-            glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
-            glmatrix.mat4.multiply(newTransform, coordination, newMatrix);
-            glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
+            if (recenter) {
+                const scaleMatrix = glmatrix.mat4.create();
+                const scaleVec = glmatrix.vec3.fromValues(linearScalingFactor, linearScalingFactor, linearScalingFactor);
+                glmatrix.mat4.scale(scaleMatrix, scaleMatrix, scaleVec);
+                glmatrix.mat4.multiply(newTransform, coordination, newMatrix);
+                glmatrix.mat4.multiply(newTransform, newTransform, translationMatrixGeomMin);
+            }
+            else {
+                // Bare composition — no per-leaf recenter (AP214 instances share
+                // one geometry buffer, issue #308), matching its durable capture.
+                glmatrix.mat4.multiply(newTransform, coordination, newMatrix);
+            }
             const payload = {
                 expressID: entity.expressID,
                 geometryExpressID,
@@ -305,7 +431,7 @@ export class StreamedPreviewChannel {
     }
     /**
      * Test seam: run generation building + extraction + capture synchronously
-     * until either every product currently in the sink is attempted or a cap
+     * 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() {
@@ -313,22 +439,15 @@ export class StreamedPreviewChannel {
             if (this.capped || !this.ensureGeneration_()) {
                 return;
             }
-            const generation = this.generation_;
-            if (generation.nextIndex >= generation.products.length) {
+            const active = this.generation_;
+            if (this.unitOrdinal_ >= active.generation.unitCount) {
                 return;
             }
-            const localID = generation.products[generation.nextIndex++];
-            ++this.productOrdinal_;
-            let extracted = false;
-            try {
-                extracted = generation.extraction.extractProductGeometryByLocalID(localID);
-            }
-            catch {
-                // Skip — mirrors tick_.
-            }
-            if (extracted) {
+            const executed = active.generation.runUnits(this.unitOrdinal_, 1);
+            ++this.unitOrdinal_;
+            if (executed > 0) {
                 this.captureNewInstances_();
-                ++this.emittedProducts_;
+                ++this.emittedUnits_;
             }
         }
     }

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.427.1287';
+const versionString = 'Conway v1.429.1291';
 export { versionString };