@bldrs-ai/conway 1.426.1283 → 1.428.1289

package/compiled/src/compat/web-ifc/streamed_preview_channel.d.ts

@@ -1,5 +1,4 @@
 import { ConwayGeometry } from "../../index.js";
-import EntityTypesIfc from "../../ifc/ifc4_gen/entity_types_ifc.gen.js";
 import { ColumnarIndexSink } from "../../step/parsing/columnar_index.js";
 import * as glmatrix from "gl-matrix";
 /**
@@ -25,38 +24,109 @@ export interface PreviewMeshPayload {
     indexData?: Uint32Array;
 }
 /**
- * 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.
+ * A throwaway prefix extraction built by a {@link PreviewSchemaAdapter} —
+ * one preview "generation" over a snapshot of the growing columnar index.
+ */
+export interface PreviewPrefixGeneration {
+    /** Scene the capture walks (canonical placed-instance tuples — the
+     * exact tuple shape is schema-specific; the capture narrows it). */
+    scene: {
+        walk(): IterableIterator<unknown>;
+    };
+    /** Total pumpable units in this prefix. */
+    unitCount: number;
+    /** Scaling factor for the capture math. */
+    linearScalingFactor: number;
+    /**
+     * Execute units [from, from+count) — cheap per unit, exceptions per
+     * unit swallowed by the adapter (mid-parse forward references).
+     *
+     * @param from First unit ordinal to execute.
+     * @param count Max units.
+     * @return {number} Units actually executed.
+     */
+    runUnits(from: number, count: number): number;
+    /**
+     * ExpressID identifying a walked geometry (payload identity / dedup).
+     *
+     * @param geometryLocalID The canonical mesh's localID.
+     * @return {number | undefined} The geometry's expressID.
+     */
+    geometryExpressID(geometryLocalID: number): number | undefined;
+    /**
+     * Whether the capture math recenters geometry (IFC's classic
+     * normalize + center re-add) or uses bare coordination x placement
+     * composition (AP214 — instances share one geometry buffer, issue
+     * #308).
+     */
+    recenter: boolean;
+}
+/**
+ * Builds throwaway prefix generations for one schema — the only piece of
+ * the preview channel that knows what a "model" or a "unit" is.
+ */
+export interface PreviewSchemaAdapter {
+    /**
+     * Build a generation over the given prefix columns.
+     *
+     * @param data The (fully resident) source buffer.
+     * @param conwaywasm The shared geometry wasm wrapper.
+     * @param columns A prefix snapshot of the columnar index.
+     * @return {PreviewPrefixGeneration | undefined} The generation, or
+     * undefined when the prefix cannot build one yet (throw is also
+     * tolerated — the channel retries on a later, larger prefix).
+     */
+    buildGeneration(data: Uint8Array, conwaywasm: ConwayGeometry, columns: unknown): PreviewPrefixGeneration | undefined;
+}
+/**
+ * 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 declare function ifcPreviewAdapter(): PreviewSchemaAdapter;
+/**
+ * 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 declare function ap214PreviewAdapter(): PreviewSchemaAdapter;
+/**
+ * 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 declare class StreamedPreviewChannel {
     private readonly data;
     private readonly conwaywasm;
     private readonly sink;
+    private readonly adapter;
     private readonly coordinateToOrigin;
     private readonly onMesh;
-    private readonly maxProducts;
+    private readonly maxUnits;
     private readonly maxBytes;
     private readonly firstGenerationMinRecords;
     /** Coordination matrix pinned from the first captured instance, exactly
@@ -65,10 +135,11 @@ export declare class StreamedPreviewChannel {
     coordinationMatrix?: glmatrix.mat4;
     private stopped_;
     private timer_?;
-    private emittedProducts_;
+    private emittedUnits_;
     private emittedBytes_;
-    /** Ordinal cursor into the (append-stable) product list. */
-    private productOrdinal_;
+    /** Ordinal cursor into the unit list (see the adapter's stability
+     * notes). */
+    private unitOrdinal_;
     /** Geometry expressIDs whose payload has been emitted (cross-generation
      * dedup for mapped/shared geometry). */
     private readonly emittedGeometry_;
@@ -80,14 +151,15 @@ export declare 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: Uint8Array, conwaywasm: ConwayGeometry, sink: ColumnarIndexSink<EntityTypesIfc>, coordinateToOrigin: boolean, onMesh: (mesh: PreviewMeshPayload) => void, maxProducts?: number, maxBytes?: number, firstGenerationMinRecords?: number);
+    constructor(data: Uint8Array, conwaywasm: ConwayGeometry, sink: ColumnarIndexSink<number>, adapter: PreviewSchemaAdapter, coordinateToOrigin: boolean, onMesh: (mesh: PreviewMeshPayload) => void, maxUnits?: number, maxBytes?: number, firstGenerationMinRecords?: number);
     /** Begin ticking (call just before awaiting the parse). */
     start(): void;
     /**
@@ -100,29 +172,30 @@ export declare class StreamedPreviewChannel {
     get capped(): boolean;
     private schedule_;
     /**
-     * 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.
      */
     private tick_;
     /**
-     * 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.
      */
     private ensureGeneration_;
     /**
      * 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.
      */
     private captureNewInstances_;
     /**
      * 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(): void;

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

@@ -1 +1 @@
-{"version":3,"file":"streamed_preview_channel.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/streamed_preview_channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAM5C,OAAO,cAAc,MAAM,yCAAyC,CAAA;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAErE,OAAO,KAAK,QAAQ,MAAM,WAAW,CAAA;AAwCrC;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,EAAE,MAAM,CAAA;IACzB,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACrD,kBAAkB,EAAE,MAAM,EAAE,CAAA;IAC5B,UAAU,CAAC,EAAE,YAAY,CAAA;IACzB,SAAS,CAAC,EAAE,WAAW,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,sBAAsB;IA6C7B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAlD9C;;4DAEwD;IACjD,kBAAkB,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAA;IAEzC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,MAAM,CAAC,CAA+B;IAE9C,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,aAAa,CAAI;IAEzB,4DAA4D;IAC5D,OAAO,CAAC,eAAe,CAAI;IAE3B;4CACwC;IACxC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoB;IAErD,OAAO,CAAC,WAAW,CAAC,CAOnB;IAED,OAAO,CAAC,oBAAoB,CAAI;IAEhC;;;;;;;;;;;;OAYG;gBAEkB,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,cAAc,EAC1B,IAAI,EAAE,iBAAiB,CAAC,cAAc,CAAC,EACvC,kBAAkB,EAAE,OAAO,EAC3B,MAAM,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,EAC1C,WAAW,GAAE,MAAqC,EAClD,QAAQ,GAAE,MAAkC,EAC5C,yBAAyB,GAAE,MAChB;IAGhC,2DAA2D;IACpD,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACI,IAAI,IAAI,IAAI;IASnB,oEAAoE;IACpE,IAAW,MAAM,IAAI,OAAO,CAG3B;IAGD,OAAO,CAAC,SAAS;IAqBjB;;;OAGG;IACH,OAAO,CAAC,KAAK;IAoCb;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAgJ5B;;;;OAIG;IACI,YAAY,IAAI,IAAI;CA+B5B"}
+{"version":3,"file":"streamed_preview_channel.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/streamed_preview_channel.ts"],"names":[],"mappings":"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"}

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,123 @@ 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,
+            };
+        },
+    };
+}
+/**
+ * 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,
+            };
+        },
+    };
+}
+/**
+ * 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 +142,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();
@@ -104,7 +189,7 @@ export class StreamedPreviewChannel {
     }
     /** 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 +211,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 +219,70 @@ 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);
-        }
-        if (products.length <= this.productOrdinal_) {
-            // Prefix grew but produced no new products — wait for more records.
-            this.lastSnapshotRecords_ = records;
+        const generation = this.adapter.buildGeneration(this.data, this.conwaywasm, columns);
+        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 +306,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 +338,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 +382,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 +390,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.426.1283';
+const versionString = 'Conway v1.428.1289';
 export { versionString };