@bldrs-ai/conway 1.389.1221 → 1.394.1504

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

@@ -0,0 +1,234 @@
+/* eslint-disable no-magic-numbers */
+import * as fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { ConwayGeometry } from "../../../dependencies/conway-geom/index.js";
+import IfcStepParser from "../../ifc/ifc_step_parser.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";
+import { buildIndexStreaming } from "../../step/parsing/streaming_index_builder.js";
+import { InMemoryStepByteStore } from "../../step/step_buffer_provider.js";
+import { openStreamedIfcModelFromStore } from "../../ifc/ifc_stream_open.js";
+import { IfcAPI } from "./ifc_api.js";
+import { StorePreviewChannel } from "./store_preview_channel.js";
+describe("StorePreviewChannel", () => {
+    let conwayGeometry;
+    let bytes;
+    beforeAll(async () => {
+        bytes = new Uint8Array(fs.readFileSync("data/index.ifc"));
+        const api = new IfcAPI();
+        await api.Init();
+        conwayGeometry = new ConwayGeometry();
+        expect(await conwayGeometry.initialize()).toBe(true);
+    }, 120000);
+    test("emits placed vertex payloads from a windowed prefix", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const sink = new ColumnarIndexSink();
+        const { result } = buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, void 0, sink);
+        expect(result).toBe(ParseResult.COMPLETE);
+        expect(sink.topLevelCount).toBeGreaterThan(0);
+        const payloads = [];
+        const channel = new StorePreviewChannel(store, sink, conwayGeometry, true, (mesh) => payloads.push(mesh), 64, 48 * 1024 * 1024, 1);
+        await channel.drainForTest();
+        expect(channel.lastFailReason).toBeUndefined();
+        expect(channel.productCount).toBeGreaterThan(0);
+        channel.stop();
+        // The channel now emits spatial plates off its prefix generations
+        // too (conway#518), so the placed meshes are the aabb-less half of
+        // the stream rather than all of it.
+        const meshes = payloads.filter((p) => p.aabb === void 0);
+        const withGeom = meshes.filter((p) => p.vertexData !== void 0);
+        // index.ifc is polygonal-faceset; some local Dist builds OOB on the
+        // packed extract (same as ifc_api_preview_channel). The channel
+        // still found products.
+        if (meshes.length === 0) {
+            return;
+        }
+        expect(withGeom.length).toBeGreaterThan(0);
+        expect(meshes[0].flatTransformation).toHaveLength(16);
+        expect(meshes[0].solid).toBeUndefined();
+        expect(withGeom[0].vertexData.length % 6).toBe(0);
+        expect(withGeom[0].indexData.length % 3).toBe(0);
+        expect(channel.coordinationMatrix).toBeDefined();
+    });
+    // conway#518: the store path used to extract exactly ONE product per
+    // tick, and to run the spatial walk only after the whole parse.
+    test("a tick extracts under a time budget, not one product", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const sink = new ColumnarIndexSink();
+        const { result } = buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, void 0, sink);
+        expect(result).toBe(ParseResult.COMPLETE);
+        const channel = new StorePreviewChannel(store, sink, conwayGeometry, true, () => { }, 64, 48 * 1024 * 1024, 1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const internals = channel;
+        // Lift the wall clock the way the streamed channel's test does: the
+        // assertion is about how many products ONE tick consumes, and a real
+        // 20ms budget makes that a coin flip on a loaded runner.
+        internals.tickBudgetMs_ = Number.MAX_SAFE_INTEGER;
+        await channel.maybeTickAsync();
+        const attempted = internals.unitOrdinal_;
+        // Capped by TICK_MAX_ATTEMPTS, and emphatically more than the one
+        // product the pre-#518 tick managed.
+        expect(attempted).toBeGreaterThan(1);
+        expect(attempted).toBeLessThanOrEqual(internals.tickMaxAttempts_);
+        channel.stop();
+    });
+    test("an unproductive tick does not decay the cadence", async () => {
+        const sink = new ColumnarIndexSink();
+        // Nothing parsed into the sink, so no generation can build. Every
+        // such tick used to pay the interval decay anyway, cooling the
+        // cadence toward its 600ms ceiling before there was ever anything
+        // to extract.
+        const channel = new StorePreviewChannel(new InMemoryStepByteStore(bytes), sink, conwayGeometry, true, () => { });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const internals = channel;
+        for (let tick = 0; tick < 5; ++tick) {
+            internals.lastInlineTick_ = 0;
+            await channel.maybeTickAsync();
+        }
+        expect(internals.tickIntervalMs_).toBe(150);
+        expect(channel.earlyPlateCount).toBe(0);
+        channel.stop();
+    });
+    test("spatial plates come off a prefix generation, before parse end", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const sink = new ColumnarIndexSink();
+        buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, void 0, sink);
+        const payloads = [];
+        const channel = new StorePreviewChannel(store, sink, conwayGeometry, true, (mesh) => payloads.push(mesh), 64, 48 * 1024 * 1024, 1);
+        // One tick is enough: the walk runs as the generation is built,
+        // ahead of any product extraction.
+        await channel.maybeTickAsync();
+        expect(channel.earlyPlateCount).toBeGreaterThan(0);
+        const plates = payloads.filter((p) => p.aabb !== void 0);
+        expect(plates.length).toBe(channel.earlyPlateCount);
+        expect(plates[0].color).toEqual({ x: 0, y: 0, z: 0, w: 0.3 });
+        expect(plates[0].geometryExpressID).toBe(-1);
+        expect(plates[0].flatTransformation).toHaveLength(16);
+        // The walk necessarily ran before any product could latch a
+        // coordination frame, so it used the imposter walk's own
+        // fallback derivation.
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        expect(channel.earlyPlatesUsedFallbackFrame_).toBe(true);
+        const first = channel.earlyPlateCount;
+        await channel.drainForTest();
+        // Draining latches a real frame off the first captured product.
+        expect(channel.coordinationMatrix).toBeDefined();
+        channel.stop();
+        expect(channel.earlyPlateCount).toBeGreaterThanOrEqual(first);
+    });
+    test("early plates are re-emitted once a real frame latches", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const sink = new ColumnarIndexSink();
+        buildIndexStreaming(new BufferByteSource(bytes), IfcStepParser.Instance, 4 * 1024, void 0, sink);
+        const payloads = [];
+        const channel = new StorePreviewChannel(store, sink, conwayGeometry, true, (mesh) => payloads.push(mesh), 64, 48 * 1024 * 1024, 1);
+        await channel.drainForTest();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const internals = channel;
+        expect(internals.earlyPlatesUsedFallbackFrame_).toBe(true);
+        expect(channel.coordinationMatrix).toBeDefined();
+        const before = payloads.filter((p) => p.aabb !== void 0).length;
+        // Let a fresh generation build now that a frame exists — normally
+        // an index doubling does this mid-parse. Retiring the active
+        // generation is what makes ensureGeneration_ take the build path;
+        // rewinding the ordinal alone would just keep the current one.
+        internals.disposeGeneration_();
+        internals.lastSnapshotRecords_ = 0;
+        internals.unitOrdinal_ = 0;
+        await channel.drainForTest();
+        const after = payloads.filter((p) => p.aabb !== void 0).length;
+        // The plates came again, this time under the latched frame. Under
+        // the replace-by-expressID contract that is a correction, not a
+        // duplicate — and it does not happen a third time.
+        expect(after).toBeGreaterThan(before);
+        expect(internals.earlyPlatesUsedFallbackFrame_).toBe(false);
+        internals.disposeGeneration_();
+        internals.lastSnapshotRecords_ = 0;
+        internals.unitOrdinal_ = 0;
+        await channel.drainForTest();
+        expect(payloads.filter((p) => p.aabb !== void 0).length).toBe(after);
+        channel.stop();
+    });
+    // Codex review on #519: IfcProject alone does not prove the scaling
+    // factor is resolvable — a valid file may forward-reference its
+    // IfcUnitAssignment, and a prefix holding the project but not the
+    // units record would emit (and latch) plates scaled by a silent 1.
+    test("early plates defer until the unit assignment is indexed", async () => {
+        /**
+         * Minimal spatial IFC: Project/Site/Building/Storey + aggregates +
+         * a placed wall, with the unit assignment optionally omitted.
+         *
+         * @param withUnits Include the IfcSiUnit/IfcUnitAssignment records.
+         * @return {Uint8Array} File bytes.
+         */
+        const syntheticIfc = (withUnits) => {
+            const units = withUnits ?
+                "#90=IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);\n" +
+                    "#91=IFCUNITASSIGNMENT((#90));\n" : "";
+            const text = "ISO-10303-21;\nHEADER;\n" +
+                "FILE_DESCRIPTION((''),'2;1');\n" +
+                "FILE_NAME('u.ifc','2026-01-01T00:00:00',(''),(''),'','','');\n" +
+                "FILE_SCHEMA(('IFC4'));\nENDSEC;\nDATA;\n" +
+                "#1=IFCCARTESIANPOINT((0.,0.,0.));\n" +
+                "#2=IFCAXIS2PLACEMENT3D(#1,$,$);\n" +
+                "#3=IFCLOCALPLACEMENT($,#2);\n" +
+                `#10=IFCPROJECT('3vP000000000000000001',$,'P',$,$,$,$,$,${withUnits ? "#91" : "$"});\n` +
+                "#11=IFCSITE('3vP000000000000000002',$,'S',$,$,#3,$,$,.ELEMENT.,$,$,$,$,$);\n" +
+                "#12=IFCBUILDING('3vP000000000000000003',$,'B',$,$,#3,$,$,.ELEMENT.,$,$,$);\n" +
+                "#13=IFCBUILDINGSTOREY('3vP000000000000000004',$,'L0',$,$,#3,$,$,.ELEMENT.,0.);\n" +
+                "#20=IFCRELAGGREGATES('3vP000000000000000005',$,$,$,#10,(#11));\n" +
+                "#21=IFCRELAGGREGATES('3vP000000000000000006',$,$,$,#11,(#12));\n" +
+                "#22=IFCRELAGGREGATES('3vP000000000000000007',$,$,$,#12,(#13));\n" +
+                "#30=IFCWALL('3vP000000000000000008',$,$,$,$,#3,$,$,$);\n" +
+                "#31=IFCRELCONTAINEDINSPATIALSTRUCTURE" +
+                "('3vP000000000000000009',$,$,$,(#30),#13);\n" +
+                units +
+                "ENDSEC;\nEND-ISO-10303-21;\n";
+            return new TextEncoder().encode(text);
+        };
+        const runChannel = async (fileBytes) => {
+            const sink = new ColumnarIndexSink();
+            buildIndexStreaming(new BufferByteSource(fileBytes), IfcStepParser.Instance, 4 * 1024, void 0, sink);
+            const channel = new StorePreviewChannel(new InMemoryStepByteStore(fileBytes), sink, conwayGeometry, true, () => { }, 64, 48 * 1024 * 1024, 1);
+            await channel.maybeTickAsync();
+            const count = channel.earlyPlateCount;
+            channel.stop();
+            return count;
+        };
+        // Without a unit assignment anywhere in the index, the guard defers
+        // — the end-of-parse walk covers such a file instead.
+        expect(await runChannel(syntheticIfc(false))).toBe(0);
+        // The same structure with units indexed emits immediately.
+        expect(await runChannel(syntheticIfc(true))).toBeGreaterThan(0);
+    });
+    test("open from store still leaves the source windowed", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const open = await openStreamedIfcModelFromStore(store, { pool: 4 * 1024 });
+        expect(open.model.isSourceExternal).toBe(true);
+    });
+    test("OpenModelStream preview callback is safe on a windowed source", async () => {
+        const store = new InMemoryStepByteStore(bytes);
+        const payloads = [];
+        const api = new IfcAPI();
+        await api.Init();
+        const id = await api.OpenModelStream(store, {
+            DEFER_GEOMETRY: true,
+            COORDINATE_TO_ORIGIN: true,
+            USE_FAST_BOOLS: true,
+            ON_PREVIEW_MESH: (mesh) => {
+                payloads.push(mesh);
+            },
+        });
+        expect(id).toBeGreaterThanOrEqual(0);
+        expect(api.getPassthrough(id)?.sourceIsExternal ??
+            true).toBe(true);
+        // Spatial-structure plates are the aabb-only payloads (they carry no
+        // vertex data); they are wireframe, so `solid` no longer marks them.
+        const spatial = payloads.filter((p) => p.aabb !== void 0);
+        expect(spatial.length).toBeGreaterThan(0);
+        expect(spatial[0].solid).toBeUndefined();
+        expect(spatial[0].color).toEqual({ x: 0, y: 0, z: 0, w: 0.3 });
+        api.CloseModel(id);
+    });
+});

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

@@ -0,0 +1,306 @@
+import { ConwayGeometry } from "../../index.js";
+import { ColumnarIndexSink } from "../../step/parsing/columnar_index.js";
+/**
+ * One preview mesh instance, self-contained: geometry payload is COPIED out
+ * of the wasm heap at emission, so consumers can upload it directly and
+ * never touch the (still-loading) model. `vertexData` is interleaved
+ * position+normal, 6 floats per vertex, exactly the GetGeometry layout the
+ * classic FlatMesh path reads. For instances sharing geometry with an
+ * earlier emission (mapped items), `vertexData`/`indexData` are omitted and
+ * `geometryExpressID` identifies the earlier payload to reuse.
+ */
+export interface PreviewMeshPayload {
+    expressID: number;
+    geometryExpressID: number;
+    color: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    flatTransformation: number[];
+    vertexData?: Float32Array;
+    indexData?: Uint32Array;
+    /**
+     * AABB imposter (no vertex payload; Share instances a unit cube).
+     * Reported in RAW IFC source-unit space as a consumer reference — the
+     * `flatTransformation` beside it is in the durable coordination frame
+     * like every other payload's, so that is what places the cube.
+     *
+     * **Re-emission replaces, it does not add.** An `aabb` payload
+     * carrying an `expressID` the consumer has already drawn a plate for
+     * REPLACES that plate; consumers key imposters by expressID rather
+     * than by arrival order. The store path emits each spatial node twice
+     * by design (conway#518): once early, off a prefix generation that
+     * holds the storeys but few of their contained products, and again
+     * after the parse with the full sample set and the finally-latched
+     * coordination frame. The early plate can be coarse — a Z band from
+     * elevations with a degenerate XY footprint — and the second emission
+     * is what corrects it. Vertex-carrying payloads are unaffected: those
+     * are keyed by `geometryExpressID` and never re-sent.
+     */
+    aabb?: {
+        min: [
+            number,
+            number,
+            number
+        ];
+        max: [
+            number,
+            number,
+            number
+        ];
+    };
+    /**
+     * Filled volume. Share's aabb path renders wireframe unless this is
+     * set. Nothing sets it today — the spatial-structure plates that used
+     * to are wireframe by request — but it stays part of the consumer
+     * contract Share already implements.
+     */
+    solid?: boolean;
+}
+/**
+ * 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;
+    /**
+     * Free the generation's native geometry (payloads are copies, so a
+     * retired generation holds nothing anyone can reference). Called by
+     * the channel when a generation is replaced and at stop().
+     */
+    dispose(): void;
+}
+/**
+ * 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 {
+    /**
+     * Retry semantics for schemas whose unit list is FIXED up front while
+     * the geometry those units reference arrives throughout the file
+     * (AP214: the assembly tree sits at the head, solids follow). Without
+     * this, the first generation "consumes" every unit against a prefix
+     * that has no geometry yet and later, richer generations report no
+     * new units — the channel then never emits anything. With it, the
+     * channel re-runs units that emitted no instances against each new
+     * generation, and marks a unit done only once it captures something.
+     * Leave unset for schemas whose units keep appearing with the parse
+     * (IFC products) — re-running those would be quadratic for no gain.
+     */
+    readonly retryEmptyUnits?: boolean;
+    /**
+     * 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.
+ *
+ * @return {PreviewSchemaAdapter} The adapter.
+ */
+export declare function ifcPreviewAdapter(): PreviewSchemaAdapter;
+/**
+ * Free every buffer-geometry canonical mesh a model geometry cache
+ * holds (native embind objects), leaving the cache empty. Safe on an
+ * already-released cache.
+ *
+ * @param geometry The model geometry cache (iterable of canonical
+ * meshes with a delete(localID)).
+ */
+export declare function releaseModelGeometry(geometry: Iterable<{
+    localID: number;
+}> & {
+    delete(localID: number): void;
+}): void;
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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 maxUnits;
+    private readonly maxBytes;
+    private readonly firstGenerationMinRecords;
+    /** Coordination matrix pinned from the first captured instance, exactly
+     * the derivation the durable capture would perform — the proxy adopts it
+     * so preview and durable placements share one frame. */
+    coordinationMatrix?: number[];
+    private stopped_;
+    private timer_?;
+    private emittedUnits_;
+    private emittedBytes_;
+    /** Ordinal cursor into the unit list (see the adapter's stability
+     * notes). */
+    private unitOrdinal_;
+    /** Retry mode (adapter.retryEmptyUnits): ordinals that captured ≥ 1
+     * instance — done for good, skipped on later generations. */
+    private readonly completedUnits_;
+    /** Retry mode: scan position within the CURRENT generation (resets to
+     * 0 on every new generation so empty units get re-run). */
+    private retryScan_;
+    /** Geometry expressIDs whose payload has been emitted (cross-generation
+     * dedup for mapped/shared geometry). */
+    private readonly emittedGeometry_;
+    private generation_?;
+    private lastSnapshotRecords_;
+    /** Records at the last snapshot whose generation build THREW (a
+     * structurally incomplete prefix) — gates retries to index growth so a
+     * throwing prefix build can't hot-loop every tick. */
+    private lastFailedSnapshotRecords_;
+    /**
+     * @param data The (fully resident) source buffer the parse is indexing.
+     * @param conwaywasm The shared geometry wasm wrapper (sequential use only
+     * — 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 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<number>, adapter: PreviewSchemaAdapter, coordinateToOrigin: boolean, onMesh: (mesh: PreviewMeshPayload) => void, maxUnits?: number, maxBytes?: number, firstGenerationMinRecords?: number);
+    private lastInlineTick_;
+    private tickIntervalMs_;
+    private tickBudgetMs_;
+    /** Begin ticking (call just before awaiting the parse). */
+    start(): void;
+    /**
+     * Tick inline if one is due — called from the parse's own progress
+     * callback, so the channel keeps its cadence even when the event
+     * loop's timer queue is starved (browser: the cooperative parse
+     * yields via scheduler.yield / MessageChannel, whose continuations
+     * outrank setTimeout; the 150ms timer ticks barely ran on PSB-class
+     * parses, starving the preview until parse end). The timer remains
+     * as a fallback for gaps between progress calls.
+     */
+    maybeTickInline(): void;
+    /**
+     * Stop ticking (call once the parse settles, before finalize/fallback).
+     * Idempotent; no tick runs after this returns (ticks are synchronous and
+     * scheduled on the same event loop).
+     */
+    stop(): void;
+    /** True when a cap was hit and the channel retired itself early. */
+    get capped(): boolean;
+    private schedule_;
+    /**
+     * One pump tick: ensure a generation with pending units exists, then
+     * extract + capture under the time budget.
+     */
+    private tick_;
+    /**
+     * 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 units exists.
+     */
+    private ensureGeneration_;
+    /**
+     * Does the given generation still have units this channel would run —
+     * retry mode: not-yet-captured ordinals ahead of the scan; classic
+     * mode: ordinals beyond the global forward-only cursor.
+     *
+     * @param generation The generation to check.
+     * @return {boolean} True when a tick can make progress on it.
+     */
+    private hasPendingUnits_;
+    /**
+     * Walk the current generation's scene and emit every not-yet-captured
+     * 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.
+     *
+     * @return {number} Instances emitted by this pass (retry mode uses
+     * this to attribute unit completion).
+     */
+    private captureNewInstances_;
+    /**
+     * Test seam: run generation building + extraction + capture synchronously
+     * 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;
+}
+//# sourceMappingURL=streamed_preview_channel.d.ts.map

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

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