@bldrs-ai/conway 1.536.1507 → 1.543.1513

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

@@ -6,9 +6,10 @@
 // same geometry ids, same placed transforms — since the durable pump the
 // preview hands over to is already pinned to classic parity.
 import * as fs from "fs";
-import { beforeAll, describe, expect, test } from "@jest/globals";
+import { beforeAll, describe, expect, jest, test } from "@jest/globals";
 import { ConwayGeometry } from "../../../dependencies/conway-geom/index.js";
 import IfcStepParser from "../../ifc/ifc_step_parser.js";
+import Logger from "../../logging/logger.js";
 import { BufferByteSource } from "../../step/parsing/byte_source.js";
 import { ColumnarIndexSink, } from "../../step/parsing/columnar_index.js";
 import { ParseResult } from "../../step/parsing/step_parser.js";
@@ -380,4 +381,266 @@ describe("StreamedPreviewChannel", () => {
             }
         }
     }, 240000);
+    test("a tail-placement file recovers its deferred products", () => {
+        // The resident twin of the store channel's test for conway#542.
+        // data/index_tail_placements.ifc is index_georeferenced_multicell.ifc
+        // with every leaf point/direction record moved to the end of DATA —
+        // same ids, same text, hostile order. It is the Archicad shape at
+        // fixture scale: its products reference a placement chain that bottoms
+        // out after them, so an index stopping short of the tail cannot place
+        // any of them. The multicell fixture rather than index.ifc because it
+        // carries enough products that one attempt cannot exhaust the
+        // generation — which is what leaves the preemption path, not the
+        // exhaustion path, as the only way to rebuild.
+        const tailText = fs.readFileSync("data/index_tail_placements.ifc", "utf8");
+        const lines = tailText.split("\n");
+        const firstLeaf = lines.findIndex((line) => /=\s*IFC(CARTESIANPOINT|DIRECTION)/.test(line));
+        expect(firstLeaf).toBeGreaterThan(0);
+        // A genuine prefix, closed off so it parses: every record up to the
+        // leaf block, and nothing after it. The full file is stage two.
+        const prefixText = `${lines.slice(0, firstLeaf).join("\n")}\nENDSEC;\nEND-ISO-10303-21;\n`;
+        const prefixBytes = new Uint8Array(Buffer.from(prefixText, "latin1"));
+        const tailBytes = new Uint8Array(Buffer.from(tailText, "latin1"));
+        const sink = new ColumnarIndexSink();
+        const payloads = [];
+        // The source buffer is the WHOLE file throughout, as it is on a
+        // resident open — only the index grows.
+        const channel = new StreamedPreviewChannel(tailBytes, conwayGeometry, sink, ifcPreviewAdapter(), true, (mesh) => payloads.push(mesh), void 0, void 0, 1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const internals = channel;
+        // One unit per tick, so stage one leaves units UNATTEMPTED. That is
+        // what forces the preemption path: with units still pending, a channel
+        // that only rebuilds on exhaustion keeps its starved generation and
+        // never looks at the deferrals again.
+        internals.tickBudgetMs_ = Number.MAX_SAFE_INTEGER;
+        internals.tickMaxAttempts_ = 1;
+        // Stage one: index only the prefix, then let the channel work it.
+        expect(buildIndexStreaming(new BufferByteSource(prefixBytes), IfcStepParser.Instance, POOL, void 0, sink).result).toBe(ParseResult.COMPLETE);
+        internals.lastInlineTick_ = 0;
+        channel.maybeTickInline();
+        const afterPrefix = channel.previewYield;
+        // The fixture has to actually exercise the path, or the rest proves
+        // nothing about it — and units must be left over, or the rebuild would
+        // happen by exhaustion and prove nothing about preemption.
+        expect(afterPrefix.deferredOnPlacement).toBeGreaterThan(0);
+        expect(afterPrefix.emitted).toBe(0);
+        expect(afterPrefix.firstMeshMs).toBeUndefined();
+        expect(internals.unitOrdinal_)
+            .toBeLessThan(internals.generation_.generation.unitCount);
+        // Stage two: the same reset-and-replay the streaming builder performs
+        // when it grows its window, so top-level localIDs stay in dense parse
+        // order and the deferred ORDINALS the channel is holding still mean
+        // what they meant (see ColumnarIndexSink.reset).
+        sink.reset();
+        expect(buildIndexStreaming(new BufferByteSource(tailBytes), IfcStepParser.Instance, POOL, void 0, sink).result).toBe(ParseResult.COMPLETE);
+        // Exactly one attempt in this tick. That is what makes this an
+        // assertion about PREEMPTION: with units still pending, a channel that
+        // rebuilds only on exhaustion spends the attempt on the next fresh unit
+        // against the old starved generation, and the retry never happens.
+        internals.lastInlineTick_ = 0;
+        channel.maybeTickInline();
+        const afterFull = channel.previewYield;
+        // Both halves of the fix, and `retried` is what separates them from a
+        // channel that merely got lucky on a later unit. Without the retry
+        // queue a deferred unit is attempted once, at the most index-starved
+        // generation it appears in, and abandoned. Without preemptive rebuilds
+        // the generation is kept while units remain, so the deferrals are never
+        // revisited against the longer index. Either one missing holds this at
+        // zero.
+        expect(afterFull.retried).toBeGreaterThan(0);
+        expect(afterFull.emitted).toBeGreaterThan(0);
+        // And the recovered products become pixels: one attempt per tick is
+        // what makes the assertions above about preemption, but a single unit
+        // need not be one that carries geometry (a site or a storey extracts
+        // and walks no buffer geometry), so let the channel run out the
+        // recovered queue before reading time-to-first-pixel.
+        internals.tickMaxAttempts_ = Number.MAX_SAFE_INTEGER;
+        internals.lastInlineTick_ = 0;
+        channel.maybeTickInline();
+        expect(payloads.length).toBeGreaterThan(0);
+        expect(channel.previewYield.firstMeshMs).toBeGreaterThanOrEqual(0);
+        channel.stop();
+    }, 240000);
+    test("a generation is preempted only when it is deferring", () => {
+        // The counterweight. Rebuilding on index growth alone regressed the
+        // case that already worked: PSB, which defers nothing, went from a
+        // first mesh at 269ms to 495ms on the store path because it kept paying
+        // for rebuilds it had no use for. index.ifc is that shape at fixture
+        // scale, so the same two-stage growth must leave its generation alone.
+        const sink = new ColumnarIndexSink();
+        const channel = new StreamedPreviewChannel(data, conwayGeometry, sink, ifcPreviewAdapter(), true, () => { }, void 0, void 0, 1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const internals = channel;
+        // One unit per tick, so the generation is nowhere near exhausted when
+        // the index grows — otherwise the exhaustion path would rebuild and
+        // this would assert nothing about preemption.
+        internals.tickBudgetMs_ = Number.MAX_SAFE_INTEGER;
+        internals.tickMaxAttempts_ = 1;
+        expect(buildIndexStreaming(new BufferByteSource(data), IfcStepParser.Instance, POOL, void 0, sink).result).toBe(ParseResult.COMPLETE);
+        internals.lastInlineTick_ = 0;
+        channel.maybeTickInline();
+        const snapshotRecords = internals.lastSnapshotRecords_;
+        expect(snapshotRecords).toBeGreaterThan(0);
+        expect(channel.previewYield.deferredOnPlacement).toBe(0);
+        // Index growth well past GENERATION_GROWTH_FACTOR, with units still
+        // pending and nothing deferring: the generation must be kept.
+        sink.reset();
+        for (let repeat = 0; repeat < 3; ++repeat) {
+            expect(buildIndexStreaming(new BufferByteSource(data), IfcStepParser.Instance, POOL, void 0, sink).result).toBe(ParseResult.COMPLETE);
+        }
+        expect(sink.topLevelCount).toBeGreaterThan(snapshotRecords * 2);
+        internals.lastInlineTick_ = 0;
+        channel.maybeTickInline();
+        expect(internals.lastSnapshotRecords_).toBe(snapshotRecords);
+        expect(channel.previewYield.retried).toBe(0);
+        channel.stop();
+    }, 240000);
+    test("retry mode preempts a generation whose units captured nothing", () => {
+        // AP214's half of conway#542. `retryEmptyUnits` already re-runs empty
+        // units, so that schema never abandoned a deferral — but it kept a
+        // stale generation for the same reason the IFC path did: the growth
+        // gate sat behind "this generation still has units", and a scan that
+        // never finishes never reaches it. An empty unit is this schema's
+        // deferral signal (the adapter cannot classify a failure — an assembly
+        // unit simply produces no instances until the solids it references are
+        // indexed), so index growth must preempt mid-scan.
+        const UNIT_COUNT = 3;
+        const runsPerGeneration = [];
+        let reportedRecords = 2048;
+        const fakeSink = {
+            get topLevelCount() {
+                return reportedRecords;
+            },
+            snapshot: () => ({}),
+        };
+        const makeGeneration = () => {
+            const runs = [];
+            runsPerGeneration.push(runs);
+            return {
+                // Empty scene: units "execute" but never capture, so no unit ever
+                // completes and every generation re-runs all of them.
+                scene: { *walk() { } },
+                unitCount: UNIT_COUNT,
+                linearScalingFactor: 1,
+                runUnits: (from) => {
+                    runs.push(from);
+                    return 1;
+                },
+                geometryExpressID: () => void 0,
+                recenter: false,
+                dispose: () => { },
+            };
+        };
+        const adapter = {
+            retryEmptyUnits: true,
+            buildGeneration: () => makeGeneration(),
+        };
+        const channel = new StreamedPreviewChannel(data, conwayGeometry, fakeSink, adapter, false, () => { }, void 0, void 0, 1);
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        const internals = channel;
+        // One unit per tick, so the scan is deliberately left unfinished.
+        internals.tickBudgetMs_ = Number.MAX_SAFE_INTEGER;
+        internals.tickMaxAttempts_ = 1;
+        /* eslint-enable @typescript-eslint/no-explicit-any */
+        const forceTick = () => {
+            internals.lastInlineTick_ = 0;
+            internals.tickIntervalMs_ = 0;
+            channel.maybeTickInline();
+        };
+        // Generation 1 runs one unit, which captures nothing.
+        forceTick();
+        expect(runsPerGeneration.length).toBe(1);
+        expect(runsPerGeneration[0]).toEqual([0]);
+        // The index grows past the gate with the scan still mid-list. Without
+        // preemption the channel keeps generation 1 and runs its unit 1; with
+        // it, a fresh generation restarts the scan against the longer index.
+        reportedRecords *= 4;
+        forceTick();
+        expect(runsPerGeneration.length).toBe(2);
+        expect(runsPerGeneration[1]).toEqual([0]);
+        channel.stop();
+    }, 240000);
+    test("preemption preserves the unconsumed suffix of the retry queue", () => {
+        // Codex round 1 on #543: preemption replaced retryQueue_ outright with
+        // this generation's fresh deferredForRetry_, discarding whatever the
+        // OLD queue's tail had not yet been popped. A retry queue can easily
+        // span more than one tick's attempt budget (bounded per tick, unbounded
+        // in total), so index growth can preempt a generation mid-drain of it
+        // — and every un-popped entry is a unit whose unitOrdinal_ has already
+        // passed, so replacing rather than concatenating strands it exactly
+        // the way abandoned deferrals were stranded before this queue existed
+        // (conway#542).
+        //
+        // The bug is purely mechanical (which array wins the assignment), so
+        // this seeds the private queue state directly and forces the growth
+        // gate via lastSnapshotRecords_ rather than engineering a real
+        // multi-tick deferral sequence.
+        const fakeGeneration = () => ({
+            scene: { *walk() { } },
+            unitCount: 1,
+            linearScalingFactor: 1,
+            runUnits: () => 0,
+            geometryExpressID: () => void 0,
+            recenter: false,
+            dispose: () => { },
+        });
+        const fakeSink = {
+            get topLevelCount() {
+                return 2048;
+            },
+            snapshot: () => ({}),
+        };
+        const adapter = { buildGeneration: () => fakeGeneration() };
+        const channel = new StreamedPreviewChannel(data, conwayGeometry, fakeSink, adapter, false, () => { }, void 0, void 0, 1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const internals = channel;
+        // Generation 1: a real, successful build (active must be defined for
+        // the preemption branch to even be reachable).
+        expect(internals.ensureGeneration_()).toBe(true);
+        // A retry queue spanning more than one tick's budget: 6 queued
+        // retries, only the first 3 consumed (retryCursor_ short of
+        // retryQueue_.length is exactly "mid-drain") before the index grew
+        // again. deferredForRetry_ is this generation's OWN fresh deferral —
+        // the only thing the buggy version kept.
+        internals.retryQueue_ = [10, 11, 12, 13, 14, 15];
+        internals.retryCursor_ = 3;
+        internals.deferredForRetry_ = [99];
+        // Force the growth gate trivially open on the next check, without
+        // needing the sink to actually grow: the gate is a ratio against
+        // lastSnapshotRecords_, not an absolute count.
+        internals.lastSnapshotRecords_ = 1;
+        // Preemption fires: active is defined, growthReady (2048 >= 1 * factor),
+        // and hasDeferred_() is true (deferredForRetry_.length > 0).
+        expect(internals.ensureGeneration_()).toBe(true);
+        // The unconsumed suffix of the old queue (indices 3..5) must survive,
+        // carried ahead of this generation's own fresh deferral — not replaced
+        // by it.
+        expect(internals.retryQueue_).toEqual([13, 14, 15, 99]);
+        expect(internals.retryCursor_).toBe(0);
+        channel.stop();
+    }, 240000);
+    test("reports a preview line even when nothing was ever attempted", () => {
+        // Codex round 1 on #543: stop() suppressed the Preview line unless
+        // emittedUnits_ or deferredUnits_ was nonzero. A channel that never
+        // reached firstGenerationMinRecords -- or whose every generation build
+        // threw -- leaves both at zero, and that is exactly the worst-case
+        // blank-first-load conway#542 exists to make diagnosable: an enabled
+        // preview that produced nothing must not read the same as a preview
+        // that never ran. formatPreviewLine already renders the zero case as
+        // "no mesh, 0 meshes from 0 units, 0 deferred".
+        const fakeSink = {
+            get topLevelCount() {
+                return 0;
+            },
+            snapshot: () => ({}),
+        };
+        const infoSpy = jest.spyOn(Logger, "info").mockImplementation(() => { });
+        // Default firstGenerationMinRecords (1024): with topLevelCount pinned
+        // at 0, ensureGeneration_ never builds a generation, so the channel
+        // reaches stop() having attempted nothing at all.
+        const channel = new StreamedPreviewChannel(data, conwayGeometry, fakeSink, { buildGeneration: () => { throw new Error("must not be called"); } }, false, () => { });
+        channel.stop();
+        expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining("Preview: no mesh, 0 meshes from 0 units, 0 deferred"));
+        infoSpy.mockRestore();
+    });
 });

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

@@ -155,6 +155,18 @@ export declare class IfcApiProxyIfc implements IfcApiModelPassthrough {
      * large-coordinate budget.
      */
     private demandCoordinationFromPreview_;
+    /**
+     * 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.
+     */
+    private coordinationSupplied_;
     _isCoordinated: boolean;
     linearScalingFactor: number;
     identity: number[];
@@ -577,6 +589,98 @@ export declare class IfcApiProxyIfc implements IfcApiModelPassthrough {
      * rel-aggregates). Shared by the sync and async pumps.
      */
     private ensureDemandWorklists_;
+    /**
+     * 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.
+     */
+    private ensureDemandWorklistsAsync_;
+    /**
+     * 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.
+     */
+    private collectDemandCandidates_;
+    /**
+     * 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.
+     */
+    private adoptDemandWorklists_;
+    /**
+     * 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`.
+     */
+    private adoptShardedWorklists_;
+    /**
+     * 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?: number[]): void;
     /**
      * Extract only one shard of this model's geometry — the across-product
      * parallelism seam.
@@ -635,12 +739,19 @@ export declare class IfcApiProxyIfc implements IfcApiModelPassthrough {
      * 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.
+     *
+     * 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 and apply a recentre frame.
+     * @return {boolean} Whether to derive a recentre frame from this
+     * instance's first geometry.
      */
     private recentreEnabled_;
     private checkShardPreconditions_;

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

@@ -1 +1 @@
-{"version":3,"file":"ifc_api_proxy_ifc.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_proxy_ifc.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ifc_api_proxy_ifc.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_proxy_ifc.ts"],"names":[],"mappings":"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"}