@bldrs-ai/conway 1.538.1511 → 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/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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"}