@bldrs-ai/conway 1.536.1507 → 1.543.1513

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

@@ -1,5 +1,5 @@
 import { ConwayGeometry, } from "../../index.js";
-import { geometryDispatchKey, shardOfDispatchKey } from "../../ifc/geometry_dispatch.js";
+import { computeDispatchKeys, computeRelatingLocalIDs, geometryDispatchKey, relatingLocalIDOf, shardOfDispatchKey, } from "../../ifc/geometry_dispatch.js";
 import IfcStepModel from "../../ifc/ifc_step_model.js";
 import { WindowedStepBufferProvider } from "../../step/step_buffer_provider.js";
 import * as glmatrix from "gl-matrix";
@@ -186,6 +186,18 @@ export class IfcApiProxyIfc {
          * large-coordinate budget.
          */
         this.demandCoordinationFromPreview_ = false;
+        /**
+         * True when the coordination frame was HANDED to this instance rather than
+         * derived from its own first geometry (see setCoordinationFrame).
+         *
+         * The distinction is what makes a recentred model shardable. A derived
+         * frame is anchored on whichever product this instance happened to extract
+         * first, so N workers derive N frames and their outputs merge shifted by
+         * whole recentre cells; a supplied one is the same for every worker by
+         * construction, which is the only property the refusals in
+         * checkShardPreconditions_ were ever protecting.
+         */
+        this.coordinationSupplied_ = false;
         this._isCoordinated = false;
         this.linearScalingFactor = 1;
         this.identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
@@ -1483,7 +1495,7 @@ export class IfcApiProxyIfc {
             return { extracted: 0, remaining: 0 };
         }
         this.checkShardPreconditions_();
-        this.ensureDemandWorklists_();
+        await this.ensureDemandWorklistsAsync_();
         if (!this.model[0].isSourceExternal) {
             return this.pumpGeometryBatch_(batchSize, meshCallback);
         }
@@ -1607,6 +1619,97 @@ export class IfcApiProxyIfc {
         if (this.demandProducts_ !== void 0) {
             return;
         }
+        const { products, aggregates } = this.collectDemandCandidates_();
+        if (this.shard_ === void 0) {
+            this.adoptDemandWorklists_(products, aggregates);
+            return;
+        }
+        // Reachable only on a resident source: the sync pump refuses a windowed
+        // one outright, and the async pump routes a sharded model through
+        // ensureDemandWorklistsAsync_. Asserted rather than assumed, because the
+        // failure it guards against is a silently wrong partition — a walk that
+        // hit a non-resident record here would throw out of the load instead
+        // (see geometryDispatchKey), but the diagnostic would name a record
+        // rather than the missing await.
+        if (this.model[0].isSourceExternal) {
+            throw new Error("a sharded windowed model needs the async worklist build, which " +
+                "pages each product's dispatch closure \u2014 reached the synchronous " +
+                "one instead");
+        }
+        const productKeys = new Uint32Array(products.length);
+        for (let where = 0; where < products.length; ++where) {
+            productKeys[where] = geometryDispatchKey(this.model[0], products[where]);
+        }
+        const aggregateKeys = new Uint32Array(aggregates.length);
+        for (let where = 0; where < aggregates.length; ++where) {
+            aggregateKeys[where] = geometryDispatchKey(this.model[0], relatingLocalIDOf(this.model[0], aggregates[where].localID));
+        }
+        this.adoptShardedWorklists_(products, aggregates, productKeys, aggregateKeys);
+    }
+    /**
+     * Worklist build for a windowed source — the same partition, with the
+     * dispatch walk's records paged before they are read.
+     *
+     * Sharding a windowed model rests on every worker computing the SAME key
+     * for a product, and an inline walk cannot promise that: whether a record
+     * read resolves depends on which chunks THIS worker holds, so workers
+     * disagree and both moduli select a product (extracted twice) or neither
+     * (dropped). computeDispatchKeys pages each hop of the walk first, which
+     * is what makes the keys a function of the file rather than of paging —
+     * and is why the pool can finally serve a store-backed open, the only kind
+     * Share performs.
+     *
+     * Resident sources take the same route with the paging short-circuited, so
+     * there is one partition rather than a windowed one and a resident one.
+     */
+    async ensureDemandWorklistsAsync_() {
+        if (this.demandProducts_ !== void 0) {
+            return;
+        }
+        // BEFORE collecting: the aggregate-target set is read from the
+        // IfcRelAggregates records themselves, and on a windowed source those
+        // pages are long gone by the first pump. The sync walk swallows the
+        // non-resident read and caches the incomplete set for the model's life,
+        // so a child it missed is extracted BOTH by the per-product worklist
+        // (with the uncut content that deferral exists to suppress) and again by
+        // the aggregates pass. Measured at 0 targets against a resident open's 1
+        // on aggregate_master_voids.ifc behind 512-byte windows.
+        //
+        // Not a sharding bug — it costs an unsharded windowed load the same
+        // duplicate — but this is the pump entry every windowed model reaches,
+        // so it is the place that can page first.
+        await this.conwayGeometry_.ensureAggregateTargetLocalIDs();
+        const { products, aggregates } = this.collectDemandCandidates_();
+        if (this.shard_ === void 0) {
+            this.adoptDemandWorklists_(products, aggregates);
+            return;
+        }
+        const productKeys = await computeDispatchKeys(this.model[0], products);
+        const aggregateKeys = await computeDispatchKeys(this.model[0], await computeRelatingLocalIDs(this.model[0], aggregates.map((aggregate) => aggregate.localID)));
+        // Re-checked after the awaits: a concurrent pump could have built the
+        // worklists while this one was paging, and adopting a second set would
+        // reset the cursors under it, re-extracting everything already pumped.
+        if (this.demandProducts_ !== void 0) {
+            return;
+        }
+        this.adoptShardedWorklists_(products, aggregates, productKeys, aggregateKeys);
+    }
+    /**
+     * Everything the pump could extract, before any shard narrows it.
+     *
+     * Unchanged from what the pump enumerated before sharding existed, and
+     * deliberately shared by both key computations so they start from the same
+     * lists in the same order — that order is what makes the keys align to the
+     * worklists.
+     *
+     * The product walk itself reads no record bytes (the type index and the
+     * local-ID column answer it). `aggregateTargetLocalIDs` does scan the
+     * IfcRelAggregates records, so a windowed caller must have paged them —
+     * `ensureDemandWorklistsAsync_` does, and carries the reasoning.
+     *
+     * @return {object} The unsharded product and rel-aggregates worklists.
+     */
+    collectDemandCandidates_() {
         // Aggregate-target products are extracted ONLY by the
         // rel-aggregates pass below (with the relating object's master
         // rel-voids), never by the per-product pass: extracting them here
@@ -1627,28 +1730,51 @@ export class IfcApiProxyIfc {
         for (const relAggregate of this.model[0].types(IfcRelAggregates)) {
             aggregates.push(relAggregate);
         }
+        return { products, aggregates };
+    }
+    /**
+     * Install the whole model's worklists — the unsharded case.
+     *
+     * @param products Every extractable product, in index order.
+     * @param aggregates Every rel-aggregates entry, in index order.
+     */
+    adoptDemandWorklists_(products, aggregates) {
+        this.demandProducts_ = products;
+        this.demandAggregates_ = aggregates;
+        this.demandCursor_ = 0;
+        this.demandAggregatesCursor_ = 0;
+    }
+    /**
+     * Install the worklists narrowed to this instance's shard.
+     *
+     * Keys are passed in rather than computed here because where they come
+     * from is the whole difference between a resident and a windowed source —
+     * one walks the attributes directly, the other pages the walk's closure
+     * first — while the narrowing itself is identical. Separate from
+     * {@link adoptDemandWorklists_} so the keys are required by the signature
+     * rather than by a comment.
+     *
+     * @param products Every extractable product, in index order.
+     * @param aggregates Every rel-aggregates entry, in index order.
+     * @param productKeys Placement keys aligned to `products`.
+     * @param aggregateKeys Placement keys aligned to `aggregates`.
+     */
+    adoptShardedWorklists_(products, aggregates, productKeys, aggregateKeys) {
+        const shard = this.shard_;
         let placed = 0;
         let positional = 0;
-        this.demandProducts_ = this.shard_ === void 0 ?
-            products : products.filter((localID) => {
-            const key = geometryDispatchKey(this.model[0], localID);
+        this.demandProducts_ = products.filter((localID, where) => {
+            const key = productKeys[where];
             // A key equal to the product's own local ID means the walk found
             // nothing to place by — a product with no representation. That
             // costs affinity, not correctness: the key is still a pure
             // function of the product, so every worker computes the same one
             // and the partition holds; it just stops avoiding duplication.
-            //
-            // Correctness would only break if the SAME product keyed
-            // differently in different workers, which is why windowed sources
-            // are refused outright (checkShardPreconditions_) rather than
-            // merely warned about — an earlier version of this comment had
-            // that wrong.
             key === localID ? ++positional : ++placed;
-            return shardOfDispatchKey(key, this.shard_.count) ===
-                this.shard_.index;
+            return shardOfDispatchKey(key, shard.count) === shard.index;
         });
-        if (this.shard_ !== void 0 && positional > placed) {
-            Logger.warning(`[shard ${this.shard_.index}/${this.shard_.count}] ` +
+        if (positional > placed) {
+            Logger.warning(`[shard ${shard.index}/${shard.count}] ` +
                 `${positional} of ${positional + placed} products have no ` +
                 "placement key, so sharding is mostly positional and shared " +
                 "geometry will be rebuilt per shard.");
@@ -1664,25 +1790,94 @@ export class IfcApiProxyIfc {
         // geometry, so getting it wrong leaves placement with almost nothing
         // to control (measured on D3D, where that mistake made every strategy
         // look identical).
-        this.demandAggregates_ = this.shard_ === void 0 ?
-            aggregates : aggregates.filter((relAggregate) => {
-            // Guarded even though sharding now refuses windowed sources:
-            // this getter reads a record synchronously, and geometryDispatchKey's
-            // own try/catch is INSIDE the call, so a throw here would abort
-            // worklist construction for the whole model rather than place one
-            // aggregate by fallback. Depth-in-depth for a total function.
-            let relating;
-            try {
-                relating = relAggregate.RelatingObject?.localID;
-            }
-            catch {
-                relating = void 0;
-            }
-            return shardOfDispatchKey(geometryDispatchKey(this.model[0], relating ?? relAggregate.localID), this.shard_.count) === this.shard_.index;
-        });
+        this.demandAggregates_ = aggregates.filter((relAggregate, where) => shardOfDispatchKey(aggregateKeys[where], shard.count) === shard.index);
         this.demandCursor_ = 0;
         this.demandAggregatesCursor_ = 0;
     }
+    /**
+     * Hand this model the recentre frame to apply, instead of letting it
+     * derive one — the other half of what a worker pool needs.
+     *
+     * `COORDINATE_TO_ORIGIN` normally recentres a model onto an anchor taken
+     * from the FIRST geometry the instance captures. That is fine for one
+     * instance and fatal for N: each worker starts on a different product, so
+     * each derives a different frame, and a model spanning more than one
+     * recentre cell reassembles with its shards offset by whole cells. Nothing
+     * downstream can detect it — the placements are individually plausible.
+     *
+     * So the frame becomes an input. A coordinator derives it once (Share's
+     * parse-time preview channel already does, and
+     * {@link getAppliedCoordination} reports what any instance applied), hands
+     * the same matrix to every worker, and the shards agree by construction
+     * rather than by luck. This is what lifts the COORDINATE_TO_ORIGIN refusal
+     * in {@link setGeometryShard}.
+     *
+     * A supplied frame is FINAL. The adopted-preview path re-derives when the
+     * first durable placement lands outside the large-coordinate budget
+     * (Share#1634); that check is disabled here, because a worker that
+     * re-derived would silently leave the frame its siblings are still using.
+     * A coordinator that wants that validation runs it on its own instance,
+     * before it hands the frame out.
+     *
+     * Deferred models only, like sharding itself: a classic open has already
+     * placed everything by the time this could be called.
+     *
+     * Supply it BEFORE claiming a shard: {@link setGeometryShard} refuses a
+     * COORDINATE_TO_ORIGIN model that has no frame yet, so the reverse order
+     * fails at the claim rather than at the pump.
+     *
+     * @param matrix Column-major mat4 of 16 finite numbers, or undefined to
+     * drop a previously supplied frame and go back to deriving.
+     */
+    setCoordinationFrame(matrix) {
+        // Same "before the first pump" rule as setGeometryShard, and for a
+        // sharper reason: placements already emitted carry the old frame, and
+        // nothing re-places them, so a late call would leave one model in two
+        // coordinate systems.
+        if (this.demandProducts_ !== void 0) {
+            throw new Error("SetCoordinationFrame must be called before the first " +
+                "ExtractGeometryBatch: placements already emitted carry the frame " +
+                "that was in force when they were captured, and are not re-placed.");
+        }
+        if (!this.deferredMode_) {
+            throw new Error("SetCoordinationFrame requires DEFER_GEOMETRY: a classic open has " +
+                "already placed every product, so a frame supplied now would be " +
+                "accepted and then ignored.");
+        }
+        if (matrix === void 0) {
+            if (this.coordinationSupplied_) {
+                this.demandCoordination_ = void 0;
+                this.coordinationSupplied_ = false;
+                this._isCoordinated = false;
+            }
+            return;
+        }
+        if (matrix.length !== IDENTITY_MAT4.length ||
+            !matrix.every((element) => Number.isFinite(element))) {
+            throw new Error(`invalid coordination frame: expected ${IDENTITY_MAT4.length} ` +
+                `finite numbers (column-major mat4), got ${matrix.length}`);
+        }
+        // A frame this instance DERIVED (or adopted from its own preview) is not
+        // one a coordinator can reconcile with — geometry has already been placed
+        // in it. Overwriting would leave that geometry in the old frame and
+        // everything after it in the new one.
+        if (this.demandCoordination_ !== void 0 && !this.coordinationSupplied_) {
+            throw new Error("this model has already adopted a coordination frame of its own " +
+                "(a preview channel, or a first durable capture), so it cannot be " +
+                "given another: geometry placed in the old frame is not re-placed.");
+        }
+        // Copied, not retained: a coordinator handing one array to N instances
+        // and mutating it between calls would otherwise leave every instance
+        // pointing at the last frame written. Same aliasing class as the shard
+        // descriptor below.
+        this.demandCoordination_ = [...matrix];
+        this.coordinationSupplied_ = true;
+        // Stops the capture path from deriving over the top of it (see
+        // streamNewMeshes_), and stops the adopted-preview revalidation from
+        // replacing it.
+        this._isCoordinated = true;
+        this.demandCoordinationFromPreview_ = false;
+    }
     /**
      * Extract only one shard of this model's geometry — the across-product
      * parallelism seam.
@@ -1782,29 +1977,22 @@ export class IfcApiProxyIfc {
                 "preview payloads.");
         }
         // Already-adopted frame, not just the current flag — see
-        // checkShardPreconditions_, which carries the reasoning.
-        if (this.demandCoordination_ !== void 0) {
+        // checkShardPreconditions_, which carries the reasoning. A SUPPLIED
+        // frame is the exception both refusals exist to allow: it is the same
+        // matrix in every worker, so there is nothing left to disagree about.
+        if (this.demandCoordination_ !== void 0 && !this.coordinationSupplied_) {
             throw new Error("SetGeometryShard cannot be used on a model that has already " +
                 "adopted a recentre frame (for example via ON_PREVIEW_MESH): the " +
                 "frame is derived from whichever geometry this instance saw " +
                 "first, so workers would not share it.");
         }
-        if (this.settings?.COORDINATE_TO_ORIGIN === true) {
-            throw new Error("SetGeometryShard cannot be combined with COORDINATE_TO_ORIGIN: " +
-                "each shard would derive its own recentre anchor from whichever " +
-                "product it happens to extract first, so merged output can be " +
-                "shifted between shards. Open without COORDINATE_TO_ORIGIN, or " +
-                "wait for a shared coordination frame.");
-        }
-        // Refused at claim time as well as at every pump (see
-        // checkShardPreconditions_, which carries the reasoning): whether the
-        // dispatch key resolves depends on which pages are resident in this
-        // worker, so workers disagree and the partition stops being a partition.
-        if (this.model[0].isSourceExternal) {
-            throw new Error("SetGeometryShard cannot be used with a windowed external " +
-                "source: the dispatch key walks attribute records, whose " +
-                "residency differs per worker, so workers would disagree about " +
-                "which products they own.");
+        if (this.settings?.COORDINATE_TO_ORIGIN === true && !this.coordinationSupplied_) {
+            throw new Error("SetGeometryShard cannot be combined with COORDINATE_TO_ORIGIN " +
+                "unless a coordination frame was supplied: each shard would " +
+                "otherwise derive its own recentre anchor from whichever product " +
+                "it happens to extract first, so merged output can be shifted " +
+                "between shards. Call SetCoordinationFrame with one frame for the " +
+                "whole pool, or open without COORDINATE_TO_ORIGIN.");
         }
         // Snapshotted, not retained. A coordinator configuring several engine
         // instances from one descriptor object — mutating `index` between calls
@@ -1851,12 +2039,19 @@ export class IfcApiProxyIfc {
      * it is the third such window found in this review; patching each one as
      * it turns up is losing strategy.
      *
-     * So a sharded model never recentres, whatever the flag says at the
-     * instant the frame would be derived. The refusals still fire first in
-     * every observable case, which is what a caller should see; this is what
-     * makes a missed one merely refused-late rather than silently wrong.
+     * So a sharded model never DERIVES a frame, whatever the flag says at the
+     * instant one would be derived. The refusals still fire first in every
+     * observable case, which is what a caller should see; this is what makes a
+     * missed one merely refused-late rather than silently wrong.
      *
-     * @return {boolean} Whether to derive and apply a recentre frame.
+     * Deriving is all this governs. A frame handed in by
+     * {@link setCoordinationFrame} is applied by the capture path
+     * unconditionally — that is the point of supplying one — and this staying
+     * false for a sharded model is exactly what keeps a worker from deriving
+     * over the top of it.
+     *
+     * @return {boolean} Whether to derive a recentre frame from this
+     * instance's first geometry.
      */
     recentreEnabled_() {
         return this.shard_ === void 0 && this.settings?.COORDINATE_TO_ORIGIN === true;
@@ -1881,42 +2076,18 @@ export class IfcApiProxyIfc {
                 "be sharded: the preview runs during open, before a shard " +
                 "exists, so its payloads are not partitioned.");
         }
-        if (this.demandCoordination_ !== void 0) {
+        if (this.demandCoordination_ !== void 0 && !this.coordinationSupplied_) {
             throw new Error("a recentre frame has already been adopted on this model, so it " +
                 "cannot be sharded: the frame came from whichever geometry this " +
                 "instance saw first, and other workers will have adopted their " +
                 "own.");
         }
-        if (this.settings?.COORDINATE_TO_ORIGIN === true) {
-            throw new Error("COORDINATE_TO_ORIGIN was enabled on a sharded model: each shard " +
-                "would derive its own recentre anchor from whichever product it " +
-                "extracts first, so merged output can be shifted between shards.");
-        }
-        // A windowed source breaks the property the whole partition rests on:
-        // that every worker computes the SAME key for a product. geometryDispatchKey
-        // walks attribute records, and on a windowed source whether that walk
-        // succeeds depends on which pages happen to be resident in THIS worker —
-        // so one worker returns the mapped-source key while another catches the
-        // non-resident read and falls back to the product's local ID.
-        //
-        // That is not weaker affinity, it is a wrong partition. Two workers
-        // disagreeing about a product's key can have both modulo results select
-        // it (extracted twice) or neither (dropped silently). The union check in
-        // m3_worker_pool.mjs cannot see it either, because it runs on resident
-        // buffers where the walk always succeeds.
-        //
-        // Making this work needs a key that does not depend on residency —
-        // derived from the reference columns, or from a closure paged
-        // deterministically before the split. Until then it is refused: workers
-        // on a windowed store were already out of scope for this change (they
-        // need the OPFS-backed source, not a resident buffer per worker), so
-        // this closes a path that has no caller rather than removing a feature.
-        if (this.model[0].isSourceExternal) {
-            throw new Error("a geometry shard cannot be claimed on a windowed external " +
-                "source: the dispatch key walks attribute records, so whether it " +
-                "resolves depends on which pages are resident in each worker, and " +
-                "workers that disagree about a product would extract it twice or " +
-                "not at all.");
+        if (this.settings?.COORDINATE_TO_ORIGIN === true && !this.coordinationSupplied_) {
+            throw new Error("COORDINATE_TO_ORIGIN was enabled on a sharded model with no " +
+                "supplied coordination frame: each shard would derive its own " +
+                "recentre anchor from whichever product it extracts first, so " +
+                "merged output can be shifted between shards. Supply one frame " +
+                "for the pool with SetCoordinationFrame.");
         }
     }
     pumpGeometryBatch_(batchSize, meshCallback) {

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

@@ -28,6 +28,40 @@ export declare class StorePreviewChannel {
     coordinationMatrix?: number[];
     private stopped_;
     private emittedUnits_;
+    /**
+     * Preview meshes handed to `onMesh_`. Tracked apart from
+     * {@link emittedUnits_} because the two genuinely diverge: a product can
+     * place several meshes, and a product with no Representation extracts
+     * cleanly while placing none — `extractProductGeometry` returns early on
+     * a null Representation and `extractProductGeometryByLocalID` still
+     * answers true. Reporting only units let the load log say "no mesh, 20
+     * emitted" about one load (codex round 2 on #543).
+     */
+    private meshesEmitted_;
+    private deferredUnits_;
+    private deferredOnPlacement_;
+    /**
+     * Products that deferred under the CURRENT generation, promoted to
+     * {@link retryQueue_} when the next one is built. Held separately so a
+     * retry always runs against a longer index than the attempt that failed —
+     * re-running one inside its own generation would fail identically and
+     * spin.
+     */
+    private deferredForRetry_;
+    private retryQueue_;
+    private retryCursor_;
+    private retriedUnits_;
+    /**
+     * Ms from channel construction to the first PLACED PRODUCT payload —
+     * time-to-first-pixel, the number conway#542 exists to move. The spatial
+     * plates are deliberately not counted: they are the building's wireframe
+     * skeleton, they go out on a different schedule (see
+     * {@link maybeEmitEarlySpatialPlates_}), and counting them would report
+     * first pixels for a load whose products are all still deferring.
+     * {@link earlyPlateCount} is where those are visible.
+     */
+    private firstMeshMs_?;
+    private readonly startedMs_;
     private emittedBytes_;
     private unitOrdinal_;
     private lastInlineTick_;
@@ -61,6 +95,35 @@ export declare class StorePreviewChannel {
     constructor(store_: StepExternalByteStore, sink_: ColumnarIndexSink<number>, conwaywasm_: ConwayGeometry, coordinateToOrigin_: boolean, onMesh_: (mesh: PreviewMeshPayload) => void, maxUnits?: number, maxBytes?: number, firstGenerationMinRecords?: number);
     get capped(): boolean;
     get emittedUnits(): number;
+    /**
+     * What the preview delivered, and how fast.
+     *
+     * `firstMeshMs` is time-to-first-pixel measured from channel
+     * construction, undefined when no placed product was ever emitted.
+     * `meshes` counts what actually reached the consumer, `emitted` counts
+     * the products extraction accepted — they are not the same number in
+     * either direction, so the line reports both.
+     * `deferred` counts products a tick attempted and could not extract;
+     * `deferredOnPlacement` is the subset still waiting on a placement chain
+     * the prefix does not hold; `retried` counts attempts that were second
+     * looks at an earlier deferral rather than first attempts, so a channel
+     * whose retry path has silently stopped firing is visible rather than
+     * merely slower. A first load that shows nothing is a very
+     * different problem depending on that ratio — near 1.0 is the file-layout
+     * case a sharded parse attacks, anything else is not — and inferring it
+     * from a code comment is what conway#542 exists to stop.
+     *
+     * @return {object} `{firstMeshMs, meshes, emitted, deferred,
+     * deferredOnPlacement, retried}`
+     */
+    get previewYield(): {
+        firstMeshMs?: number;
+        meshes: number;
+        emitted: number;
+        deferred: number;
+        deferredOnPlacement: number;
+        retried: number;
+    };
     /** Products the current generation would run (test seam). */
     get productCount(): number;
     /**
@@ -120,6 +183,20 @@ export declare class StorePreviewChannel {
      * @return {Promise<boolean>} True when a product was attempted.
      */
     private tickOnce_;
+    /**
+     * Whether either queue still has a product to attempt.
+     *
+     * Static and fully parameterised so the two callers — the tick and the
+     * generation gate — cannot drift apart on what "pending" means, which is
+     * the bug that would silently strand the retry queue.
+     *
+     * @param retryCursor How far into the retry queue this generation is.
+     * @param retryLength The retry queue's length.
+     * @param ordinal The forward cursor into the generation's products.
+     * @param productCount That generation's product count.
+     * @return {boolean} True when something is left to attempt.
+     */
+    private static hasPending_;
     /**
      * @return {Promise<boolean>} True when a generation with pending units exists.
      */
@@ -181,6 +258,8 @@ export declare class StorePreviewChannel {
     /**
      * Copy newly extracted instances out of wasm — same placement math
      * as {@link StreamedPreviewChannel}.
+     *
+     * @return {number} Meshes emitted by this pass.
      */
     private captureNewInstances_;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"store_preview_channel.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/store_preview_channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAY5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAGrE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAA;AAU5E,OAAO,EACL,kBAAkB,EAEnB,MAAM,4BAA4B,CAAA;AAuCnC;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAmB;IAoD1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAzDvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAEpC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,oBAAoB,CAAI;IAChC,OAAO,CAAC,0BAA0B,CAAI;IACtC,cAAc,CAAC,EAAE,MAAM,CAAA;IAMvB,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,gBAAgB,CAAoB;IAE5C,qEAAqE;IACrE,OAAO,CAAC,mBAAmB,CAAI;IAE/B;;;;;OAKG;IACH,OAAO,CAAC,6BAA6B,CAAQ;IAE7C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IAEvD,OAAO,CAAC,WAAW,CAAC,CAKnB;IAED;;;;;;;;;OASG;gBAEkB,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,iBAAiB,CAAE,MAAM,CAAE,EAClC,WAAW,EAAE,cAAc,EAC3B,mBAAmB,EAAE,OAAO,EAC5B,OAAO,EAAE,CAAE,IAAI,EAAE,kBAAkB,KAAM,IAAI,EAC7C,QAAQ,GAAE,MAAkC,EAC5C,QAAQ,GAAE,MAAkC,EAC5C,yBAAyB,GAAE,MAChB;IAGhC,IAAW,MAAM,IAAI,OAAO,CAG3B;IAED,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED,6DAA6D;IAC7D,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;;OAGG;IACH,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,cAAc,IAAI,OAAO,CAAE,IAAI,CAAE;IAyB9C;;;;;OAKG;YACW,aAAa;IAmB3B;;;;;;OAMG;IACU,UAAU,IAAI,OAAO,CAAE,IAAI,CAAE;IAuB1C,wDAAwD;IACjD,IAAI,IAAI,IAAI;IAMnB;;;;OAIG;IACU,YAAY,IAAI,OAAO,CAAE,IAAI,CAAE;IAmB5C;;OAEG;YACW,SAAS;IAyCvB;;OAEG;YACW,iBAAiB;IAgF/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;YACW,4BAA4B;IAsE1C,OAAO,CAAC,kBAAkB;IAiB1B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;CA+H7B"}
+{"version":3,"file":"store_preview_channel.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/store_preview_channel.ts"],"names":[],"mappings":"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"}