@bldrs-ai/conway 1.409.1251 → 1.413.1255

package/compiled/examples/validator-bundled.cjs

@@ -944,7 +944,7 @@ var EntityTypesIfcCount = 909;
 var entity_types_ifc_gen_default = EntityTypesIfc;
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.409.1251";
+var versionString = "Conway v1.413.1255";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/src/core/demand_residency_pump.d.ts

@@ -0,0 +1,93 @@
+import { DemandGeometryQueue } from "./demand_geometry_queue.js";
+/**
+ * The async half of demand-driven geometry (Phase B): source-byte residency.
+ *
+ * Extraction is synchronous by design (the wasm extract reads source bytes
+ * through `StepBufferProvider.acquire`), but a windowed/streamed source pages
+ * bytes in asynchronously (`ensureResident`). This pump owns that seam: it
+ * admits demand, prefetches the source ranges for the most-wanted products,
+ * and only then forwards them to the synchronous {@link DemandGeometryQueue}
+ * — so a `pump()` never hits a non-resident range mid-extract.
+ */
+export interface ResidencyPrefetcher {
+    /**
+     * Page in the source byte ranges a product's extraction will read.
+     * `StepModelBase.ensureResidentByLocalID` satisfies this shape.
+     *
+     * @param localID The product's local ID.
+     * @return {Promise<void>} Resolves when resident.
+     */
+    ensureResidentByLocalID(localID: number): Promise<void>;
+}
+/** Outcome of one pump cycle, for telemetry and tests. */
+export interface PumpResult {
+    /** Tiles extracted this cycle (from the queue's pump). */
+    extracted: number;
+    /** Products whose prefetch failed this cycle (re-queued for retry). */
+    prefetchFailures: number;
+}
+/**
+ * Admission + prefetch orchestration in front of a {@link DemandGeometryQueue}.
+ *
+ * Consumers `request()` products as demand changes (the pump owns admission —
+ * don't request on the queue directly); each async `pump()` cycle:
+ *
+ *  1. selects the top-priority pending batch,
+ *  2. awaits source residency for the batch (failures re-queue for retry
+ *     and are reported, never thrown — one bad range must not stall the
+ *     viewport),
+ *  3. forwards the resident products to the queue and runs its synchronous
+ *     pump under the same batch cap.
+ *
+ * Re-entrant calls coalesce: a `pump()` while one is in flight returns the
+ * in-flight cycle's promise rather than interleaving prefetch batches.
+ * Products already resident in the queue skip prefetch entirely (their
+ * ranking refresh is forwarded immediately).
+ */
+export declare class DemandResidencyPump {
+    private readonly queue_;
+    private readonly prefetcher_;
+    private readonly batch_;
+    /** Pending admission: product localID → highest requested priority. */
+    private readonly pending_;
+    private inFlight_;
+    /**
+     * @param queue_ The synchronous demand queue (extraction + budget).
+     * @param prefetcher_ Source-byte residency (the model / buffer provider).
+     * @param batch_ Max products prefetched + extracted per pump cycle.
+     */
+    constructor(queue_: DemandGeometryQueue, prefetcher_: ResidencyPrefetcher, batch_?: number);
+    /**
+     * Request a product at a demand priority. Resident products forward
+     * immediately (ranking refresh); others queue for the next pump cycle at
+     * the highest priority requested so far.
+     *
+     * @param productLocalID The product to materialise.
+     * @param priority The demand priority (higher = more wanted).
+     */
+    request(productLocalID: number, priority: number): void;
+    /**
+     * @return {number} Products awaiting admission (not yet prefetched).
+     */
+    get pendingCount(): number;
+    /**
+     * Run one admission cycle (see class docs). Coalesces with an in-flight
+     * cycle.
+     *
+     * @return {Promise<PumpResult>} The cycle's outcome.
+     */
+    pump(): Promise<PumpResult>;
+    /**
+     * One cycle: select top batch → prefetch → forward + queue pump.
+     *
+     * @return {Promise<PumpResult>} The cycle's outcome.
+     */
+    private pumpCycle_;
+    /**
+     * Remove and return the top-priority pending entries, up to the batch cap.
+     *
+     * @return {[number, number][]} `[productLocalID, priority]` pairs.
+     */
+    private takeTopPending_;
+}
+//# sourceMappingURL=demand_residency_pump.d.ts.map

package/compiled/src/core/demand_residency_pump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demand_residency_pump.d.ts","sourceRoot":"","sources":["../../../src/core/demand_residency_pump.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAG7D;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAElC;;;;;;OAMG;IACH,uBAAuB,CAAE,OAAO,EAAE,MAAM,GAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1D;AAGD,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IAEzB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAA;IAEjB,uEAAuE;IACvE,gBAAgB,EAAE,MAAM,CAAA;CACzB;AASD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,mBAAmB;IAa5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAbzB,uEAAuE;IACvE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IAErD,OAAO,CAAC,SAAS,CAAiC;IAElD;;;;OAIG;gBAEgB,MAAM,EAAE,mBAAmB,EAC3B,WAAW,EAAE,mBAAmB,EAChC,MAAM,GAAE,MAAsB;IAOjD;;;;;;;OAOG;IACI,OAAO,CAAE,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAI,IAAI;IAchE;;OAEG;IACH,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;;;;OAKG;IACI,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC;IAalC;;;;OAIG;YACW,UAAU;IAkCxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAkBxB"}

package/compiled/src/core/demand_residency_pump.js

@@ -0,0 +1,120 @@
+// Defaults chosen for frame-cooperative pumping: enough per cycle to fill
+// quickly, small enough that a cycle stays well under a frame budget once
+// extraction costs are real. Both are tunable per call site.
+const DEFAULT_BATCH = 32;
+/**
+ * Admission + prefetch orchestration in front of a {@link DemandGeometryQueue}.
+ *
+ * Consumers `request()` products as demand changes (the pump owns admission —
+ * don't request on the queue directly); each async `pump()` cycle:
+ *
+ *  1. selects the top-priority pending batch,
+ *  2. awaits source residency for the batch (failures re-queue for retry
+ *     and are reported, never thrown — one bad range must not stall the
+ *     viewport),
+ *  3. forwards the resident products to the queue and runs its synchronous
+ *     pump under the same batch cap.
+ *
+ * Re-entrant calls coalesce: a `pump()` while one is in flight returns the
+ * in-flight cycle's promise rather than interleaving prefetch batches.
+ * Products already resident in the queue skip prefetch entirely (their
+ * ranking refresh is forwarded immediately).
+ */
+export class DemandResidencyPump {
+    /**
+     * @param queue_ The synchronous demand queue (extraction + budget).
+     * @param prefetcher_ Source-byte residency (the model / buffer provider).
+     * @param batch_ Max products prefetched + extracted per pump cycle.
+     */
+    constructor(queue_, prefetcher_, batch_ = DEFAULT_BATCH) {
+        this.queue_ = queue_;
+        this.prefetcher_ = prefetcher_;
+        this.batch_ = batch_;
+        /** Pending admission: product localID → highest requested priority. */
+        this.pending_ = new Map();
+        if (batch_ < 1) {
+            throw new Error(`Invalid batch ${batch_}`);
+        }
+    }
+    /**
+     * Request a product at a demand priority. Resident products forward
+     * immediately (ranking refresh); others queue for the next pump cycle at
+     * the highest priority requested so far.
+     *
+     * @param productLocalID The product to materialise.
+     * @param priority The demand priority (higher = more wanted).
+     */
+    request(productLocalID, priority) {
+        if (this.queue_.isResident(productLocalID)) {
+            this.queue_.request(productLocalID, priority);
+            return;
+        }
+        const existing = this.pending_.get(productLocalID);
+        this.pending_.set(productLocalID, existing === void 0 ? priority : Math.max(existing, priority));
+    }
+    /**
+     * @return {number} Products awaiting admission (not yet prefetched).
+     */
+    get pendingCount() {
+        return this.pending_.size;
+    }
+    /**
+     * Run one admission cycle (see class docs). Coalesces with an in-flight
+     * cycle.
+     *
+     * @return {Promise<PumpResult>} The cycle's outcome.
+     */
+    pump() {
+        if (this.inFlight_ !== void 0) {
+            return this.inFlight_;
+        }
+        this.inFlight_ = this.pumpCycle_().finally(() => {
+            this.inFlight_ = void 0;
+        });
+        return this.inFlight_;
+    }
+    /**
+     * One cycle: select top batch → prefetch → forward + queue pump.
+     *
+     * @return {Promise<PumpResult>} The cycle's outcome.
+     */
+    async pumpCycle_() {
+        const batch = this.takeTopPending_();
+        if (batch.length === 0) {
+            // Nothing to admit; still give the queue a chance to fill from its own
+            // pending set (e.g. entries deferred by an earlier budget refusal).
+            return { extracted: this.queue_.pump(this.batch_), prefetchFailures: 0 };
+        }
+        const outcomes = await Promise.allSettled(batch.map(([productLocalID]) => this.prefetcher_.ensureResidentByLocalID(productLocalID)));
+        let prefetchFailures = 0;
+        for (let where = 0; where < batch.length; ++where) {
+            const [productLocalID, priority] = batch[where];
+            if (outcomes[where].status === 'fulfilled') {
+                this.queue_.request(productLocalID, priority);
+                continue;
+            }
+            // Failed prefetch: re-queue for a later cycle (transient store errors
+            // retry; persistent ones keep surfacing in the failure count).
+            ++prefetchFailures;
+            this.request(productLocalID, priority);
+        }
+        return { extracted: this.queue_.pump(this.batch_), prefetchFailures };
+    }
+    /**
+     * Remove and return the top-priority pending entries, up to the batch cap.
+     *
+     * @return {[number, number][]} `[productLocalID, priority]` pairs.
+     */
+    takeTopPending_() {
+        if (this.pending_.size === 0) {
+            return [];
+        }
+        const entries = [...this.pending_.entries()];
+        entries.sort((a, b) => b[1] - a[1]);
+        const batch = entries.slice(0, this.batch_);
+        for (const [productLocalID] of batch) {
+            this.pending_.delete(productLocalID);
+        }
+        return batch;
+    }
+}

package/compiled/src/core/demand_residency_pump.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=demand_residency_pump.test.d.ts.map

package/compiled/src/core/demand_residency_pump.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demand_residency_pump.test.d.ts","sourceRoot":"","sources":["../../../src/core/demand_residency_pump.test.ts"],"names":[],"mappings":""}

package/compiled/src/core/demand_residency_pump.test.js

@@ -0,0 +1,148 @@
+/* eslint-disable no-magic-numbers */
+// Phase B: the pump must guarantee source residency BEFORE the synchronous
+// extract runs, admit strictly by priority under the batch cap, coalesce
+// re-entrant cycles, and survive prefetch failures without stalling.
+import { describe, expect, test } from "@jest/globals";
+import { DemandGeometryQueue } from "./demand_geometry_queue.js";
+import { DemandResidencyPump } from "./demand_residency_pump.js";
+/**
+ * A mock tiles backend that records extraction order and asserts every
+ * extracted product was made resident first.
+ *
+ * @param residentSource Set the prefetcher fills.
+ * @return {object} `{ tiles, extracted }`.
+ */
+function residencyCheckedTiles(residentSource) {
+    const extracted = [];
+    const tiles = {
+        extract(id) {
+            if (!residentSource.has(id)) {
+                throw new Error(`extract(${id}) before source residency`);
+            }
+            extracted.push(id);
+            return 10;
+        },
+        release() { },
+    };
+    return { tiles, extracted };
+}
+/**
+ * A controllable prefetcher: records call order; optionally fails given ids.
+ *
+ * @param residentSource The set fulfilled prefetches add to.
+ * @param failIDs IDs whose prefetch rejects.
+ * @return {object} `{ prefetcher, calls }`.
+ */
+function mockPrefetcher(residentSource, failIDs = new Set()) {
+    const calls = [];
+    const prefetcher = {
+        ensureResidentByLocalID: async (localID) => {
+            calls.push(localID);
+            if (failIDs.has(localID)) {
+                throw new Error(`range fetch failed for ${localID}`);
+            }
+            residentSource.add(localID);
+        },
+    };
+    return { prefetcher, calls };
+}
+describe("DemandResidencyPump", () => {
+    test("prefetches source bytes before any synchronous extract", async () => {
+        const residentSource = new Set();
+        const { tiles, extracted } = residencyCheckedTiles(residentSource);
+        const { prefetcher, calls } = mockPrefetcher(residentSource);
+        const pump = new DemandResidencyPump(new DemandGeometryQueue(tiles, 1000), prefetcher);
+        pump.request(1, 10);
+        pump.request(2, 20);
+        const result = await pump.pump();
+        // The residency-checked tiles throw if this ordering ever breaks.
+        expect(result.extracted).toBe(2);
+        expect(new Set(calls)).toEqual(new Set([1, 2]));
+        expect(extracted).toEqual([2, 1]); // still priority-ordered
+    });
+    test("admits strictly by priority under the batch cap", async () => {
+        const residentSource = new Set();
+        const { tiles, extracted } = residencyCheckedTiles(residentSource);
+        const { prefetcher, calls } = mockPrefetcher(residentSource);
+        const queue = new DemandGeometryQueue(tiles, 1000000);
+        const pump = new DemandResidencyPump(queue, prefetcher, 3);
+        for (let id = 0; id < 10; ++id) {
+            pump.request(id, id); // rising priority: 7, 8, 9 are most wanted
+        }
+        await pump.pump();
+        expect(new Set(calls)).toEqual(new Set([7, 8, 9]));
+        expect(extracted).toEqual([9, 8, 7]);
+        expect(pump.pendingCount).toBe(7);
+        await pump.pump();
+        expect(extracted).toEqual([9, 8, 7, 6, 5, 4]);
+    });
+    test("requesting a resident product refreshes ranking without prefetch", async () => {
+        const residentSource = new Set();
+        const { tiles } = residencyCheckedTiles(residentSource);
+        const { prefetcher, calls } = mockPrefetcher(residentSource);
+        const queue = new DemandGeometryQueue(tiles, 1000);
+        const pump = new DemandResidencyPump(queue, prefetcher);
+        pump.request(1, 10);
+        await pump.pump();
+        expect(calls).toEqual([1]);
+        // Re-request while resident: no new prefetch, no new pending entry.
+        pump.request(1, 99);
+        expect(pump.pendingCount).toBe(0);
+        await pump.pump();
+        expect(calls).toEqual([1]);
+    });
+    test("a failed prefetch re-queues and later retries; others proceed", async () => {
+        const residentSource = new Set();
+        const { tiles, extracted } = residencyCheckedTiles(residentSource);
+        const failIDs = new Set([2]);
+        const { prefetcher } = mockPrefetcher(residentSource, failIDs);
+        const pump = new DemandResidencyPump(new DemandGeometryQueue(tiles, 1000), prefetcher);
+        pump.request(1, 10);
+        pump.request(2, 20);
+        const first = await pump.pump();
+        expect(first.prefetchFailures).toBe(1);
+        expect(extracted).toEqual([1]);
+        expect(pump.pendingCount).toBe(1); // 2 re-queued
+        // The transient failure clears; the retry succeeds.
+        failIDs.clear();
+        const second = await pump.pump();
+        expect(second.prefetchFailures).toBe(0);
+        expect(extracted).toEqual([1, 2]);
+    });
+    test("re-entrant pump calls coalesce onto the in-flight cycle", async () => {
+        const residentSource = new Set();
+        const { tiles } = residencyCheckedTiles(residentSource);
+        const { prefetcher, calls } = mockPrefetcher(residentSource);
+        const pump = new DemandResidencyPump(new DemandGeometryQueue(tiles, 1000), prefetcher);
+        pump.request(1, 10);
+        const a = pump.pump();
+        const b = pump.pump();
+        expect(b).toBe(a); // same promise, no interleaved second cycle
+        await a;
+        expect(calls).toEqual([1]);
+        // After settling, pump() starts a fresh cycle.
+        pump.request(2, 5);
+        await pump.pump();
+        expect(calls).toEqual([1, 2]);
+    });
+    test("an empty admission cycle still drains the queue-side pending set", async () => {
+        const residentSource = new Set([1, 2]);
+        const { tiles, extracted } = residencyCheckedTiles(residentSource);
+        const { prefetcher } = mockPrefetcher(residentSource);
+        // Tiny budget: only one of the two fits per pump; the loser stays
+        // pending inside the QUEUE (deferred by budget), not the pump.
+        const queue = new DemandGeometryQueue(tiles, 10);
+        const pump = new DemandResidencyPump(queue, prefetcher);
+        pump.request(1, 10);
+        pump.request(2, 20);
+        await pump.pump();
+        expect(extracted).toEqual([2]);
+        expect(queue.stats.pendingCount).toBe(1);
+        // No new admissions; the cycle still gives the queue its pump call.
+        // (1 cannot displace 2 at this budget, so it stays pending — the point
+        // is the queue got the chance.)
+        const result = await pump.pump();
+        expect(result.extracted).toBe(0);
+        expect(queue.stats.pendingCount).toBe(1);
+    });
+});

package/compiled/src/core/geometry_tile_bindings.d.ts

@@ -0,0 +1,110 @@
+import { ChunkedPool } from "./mem/chunked_pool.js";
+import { GeometryAsset, GeometryTilePool } from "./geometry_tile_pool.js";
+/**
+ * The wasm module's geometry tile pool surface (conway-geom
+ * `tile_pool_api.h` via the embind bindings in conway-api.cpp) — Phase B of
+ * the demand-geometry track. Typed narrowly here rather than through the
+ * vendored module d.ts; asset ids and sizes cross the boundary as JS numbers
+ * (< 2^53 by construction).
+ *
+ * Division of labour (see "Resident memory: two regimes" in the design doc):
+ * the TS side (`ChunkedPool` + `SharedAssetPool` + `GeometryTilePool`) is the
+ * accounting/policy layer — it holds no payload bytes — while the wasm
+ * `TilePool` owns the physical chunks. In this composition the TS layer calls
+ * `materialize`/`discard` exactly once per residency, so the wasm-side
+ * refcount stays at 1 for TS-managed tiles; the wasm refcounting exists for
+ * future direct-C++ holders, not for this path.
+ */
+export interface GeometryTilePoolBindings {
+    initGeometryTilePool(budgetBytes: number, chunkBytes: number): boolean;
+    geometryTilePoolInitialized(): boolean;
+    commitGeometryTileBytes(assetID: number, sourceAddress: number, byteLength: number): boolean;
+    retainGeometryTile(assetID: number): boolean;
+    releaseGeometryTile(assetID: number): boolean;
+    geometryTileResident(assetID: number): boolean;
+    geometryTileRefCount(assetID: number): number;
+    geometryTileByteSize(assetID: number): number;
+    geometryTileSegmentCount(assetID: number): number;
+    geometryTileSegmentAddress(assetID: number, segment: number): number;
+    geometryTileSegmentByteLength(assetID: number, segment: number): number;
+    geometryTileVertexByteLength(assetID: number): number;
+    geometryTileIndexByteLength(assetID: number): number;
+    geometryTilePoolBytesInUse(): number;
+    geometryTilePoolTotalBytes(): number;
+    geometryTilePoolFreeChunks(): number;
+    geometryTilePoolFailedCommits(): number;
+}
+/**
+ * The domain extractor the wasm-backed source delegates to: which assets a
+ * product is made of, and how to run the wasm extract → tessellate →
+ * `commitGeometryTile` for one asset. Implemented over the real extraction
+ * pipeline in the Phase B wiring of `IfcModelGeometry`; tests use recording
+ * fakes.
+ */
+export interface TileAssetExtractor {
+    /**
+     * The assets (representation geometries) a product requires resident,
+     * with their reified byte sizes. Mapped items return the same assetID from
+     * many products — the sharing the pools are built around.
+     *
+     * @param productLocalID The product's local ID.
+     * @return {GeometryAsset<number>[]} The product's assets.
+     */
+    assetsOf(productLocalID: number): GeometryAsset<number>[];
+    /**
+     * Extract + tessellate one asset and commit its reified payload into the
+     * wasm tile pool (`commitGeometryTile`). Called exactly once per residency.
+     * Must throw if the commit fails — under the budget invariant it cannot,
+     * so a failure is a contract violation, not a recoverable state.
+     *
+     * @param assetID The asset to materialise.
+     */
+    extractIntoTile(assetID: number): void;
+}
+/**
+ * The Phase B backend composition: the TS accounting stack
+ * (`ChunkedPool` → `GeometryTilePool`) wired over the wasm tile pool, ready
+ * to hand to `DemandGeometryQueue`.
+ */
+export interface WasmTileBackend {
+    /** The TS accounting pool (mirrors the wasm pool's budget and chunking). */
+    pool: ChunkedPool;
+    /** The `GeometryTiles` backend for the demand queue. */
+    tiles: GeometryTilePool<number>;
+}
+/**
+ * Initialise the wasm tile pool and build the TS accounting stack over it,
+ * with identical budget and chunking on both sides so the TS all-or-nothing
+ * admission mirrors the wasm pool's exactly (the queue-budget ≤ pool-budget
+ * invariant then guarantees a wasm commit can never fail mid-extract).
+ *
+ * @param bindings The wasm module's tile pool surface.
+ * @param extractor The domain extract/commit implementation.
+ * @param budgetBytes The resident geometry budget (both sides).
+ * @param chunkBytes The chunk size (both sides; ≥ the wasm 16-byte floor).
+ * @return {WasmTileBackend} The composed backend.
+ */
+export declare function createWasmTileBackend(bindings: GeometryTilePoolBindings, extractor: TileAssetExtractor, budgetBytes: number, chunkBytes: number): WasmTileBackend;
+/**
+ * A resident tile's reified payload, gathered from the wasm pool's segments
+ * into typed arrays ready for GPU upload (three.js BufferAttributes). The
+ * arrays are standalone copies — valid after the tile is evicted.
+ */
+export interface GeometryTilePayload {
+    vertexData: Float32Array;
+    indexData: Uint32Array;
+}
+/**
+ * Gather a resident tile's payload out of the wasm heap by walking its
+ * (generally non-contiguous) segments. This is the copying consumption path;
+ * a zero-copy per-segment upload can walk the same segment accessors
+ * directly.
+ *
+ * @param bindings The wasm module's tile pool surface.
+ * @param heap The module's HEAPU8 view (re-read after any wasm memory
+ * growth; pass the module's current view, do not cache across calls).
+ * @param assetID The resident tile to read.
+ * @return {GeometryTilePayload} The gathered payload.
+ */
+export declare function readGeometryTilePayload(bindings: GeometryTilePoolBindings, heap: Uint8Array, assetID: number): GeometryTilePayload;
+//# sourceMappingURL=geometry_tile_bindings.d.ts.map

package/compiled/src/core/geometry_tile_bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_tile_bindings.d.ts","sourceRoot":"","sources":["../../../src/core/geometry_tile_bindings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EACL,aAAa,EACb,gBAAgB,EAEjB,MAAM,sBAAsB,CAAA;AAG7B;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,wBAAwB;IAEvC,oBAAoB,CAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAI,OAAO,CAAA;IACxE,2BAA2B,IAAI,OAAO,CAAA;IAEtC,uBAAuB,CACrB,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAI,OAAO,CAAA;IAEvE,kBAAkB,CAAE,OAAO,EAAE,MAAM,GAAI,OAAO,CAAA;IAC9C,mBAAmB,CAAE,OAAO,EAAE,MAAM,GAAI,OAAO,CAAA;IAC/C,oBAAoB,CAAE,OAAO,EAAE,MAAM,GAAI,OAAO,CAAA;IAChD,oBAAoB,CAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IAC/C,oBAAoB,CAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IAE/C,wBAAwB,CAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IACnD,0BAA0B,CAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IACtE,6BAA6B,CAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IACzE,4BAA4B,CAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IACvD,2BAA2B,CAAE,OAAO,EAAE,MAAM,GAAI,MAAM,CAAA;IAEtD,0BAA0B,IAAI,MAAM,CAAA;IACpC,0BAA0B,IAAI,MAAM,CAAA;IACpC,0BAA0B,IAAI,MAAM,CAAA;IACpC,6BAA6B,IAAI,MAAM,CAAA;CACxC;AAGD;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAEjC;;;;;;;OAOG;IACH,QAAQ,CAAE,cAAc,EAAE,MAAM,GAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAA;IAE3D;;;;;;;OAOG;IACH,eAAe,CAAE,OAAO,EAAE,MAAM,GAAI,IAAI,CAAA;CACzC;AAGD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAE9B,4EAA4E;IAC5E,IAAI,EAAE,WAAW,CAAA;IAEjB,wDAAwD;IACxD,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAChC;AAGD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,wBAAwB,EAClC,SAAS,EAAE,kBAAkB,EAC7B,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GAAI,eAAe,CAwBxC;AAGD;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,YAAY,CAAA;IACxB,SAAS,EAAE,WAAW,CAAA;CACvB;AAOD;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,wBAAwB,EAClC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,GAAI,mBAAmB,CAyCzC"}

package/compiled/src/core/geometry_tile_bindings.js

@@ -0,0 +1,76 @@
+import { ChunkedPool } from "./mem/chunked_pool.js";
+import { GeometryTilePool, } from "./geometry_tile_pool.js";
+/**
+ * Initialise the wasm tile pool and build the TS accounting stack over it,
+ * with identical budget and chunking on both sides so the TS all-or-nothing
+ * admission mirrors the wasm pool's exactly (the queue-budget ≤ pool-budget
+ * invariant then guarantees a wasm commit can never fail mid-extract).
+ *
+ * @param bindings The wasm module's tile pool surface.
+ * @param extractor The domain extract/commit implementation.
+ * @param budgetBytes The resident geometry budget (both sides).
+ * @param chunkBytes The chunk size (both sides; ≥ the wasm 16-byte floor).
+ * @return {WasmTileBackend} The composed backend.
+ */
+export function createWasmTileBackend(bindings, extractor, budgetBytes, chunkBytes) {
+    // TS pool first: if the config is invalid on the TS side (non-integer or
+    // degenerate chunking), fail before touching the wasm pool so no
+    // initialized-but-unowned wasm region is left behind.
+    const pool = new ChunkedPool(budgetBytes, chunkBytes);
+    if (!bindings.initGeometryTilePool(budgetBytes, chunkBytes)) {
+        throw new Error(`Wasm tile pool rejected init (budget ${budgetBytes}, ` +
+            `chunk ${chunkBytes})`);
+    }
+    const source = {
+        assetsOf: (productLocalID) => extractor.assetsOf(productLocalID),
+        materialize: (assetID) => {
+            extractor.extractIntoTile(assetID);
+        },
+        discard: (assetID) => {
+            bindings.releaseGeometryTile(assetID);
+        },
+    };
+    return { pool, tiles: new GeometryTilePool(pool, source) };
+}
+// Geometry tile payload layout (tile_pool_api.h): 8-byte header of two u32
+// byte lengths, then float vertex data, then u32 index data.
+const TILE_HEADER_BYTES = 8;
+/**
+ * Gather a resident tile's payload out of the wasm heap by walking its
+ * (generally non-contiguous) segments. This is the copying consumption path;
+ * a zero-copy per-segment upload can walk the same segment accessors
+ * directly.
+ *
+ * @param bindings The wasm module's tile pool surface.
+ * @param heap The module's HEAPU8 view (re-read after any wasm memory
+ * growth; pass the module's current view, do not cache across calls).
+ * @param assetID The resident tile to read.
+ * @return {GeometryTilePayload} The gathered payload.
+ */
+export function readGeometryTilePayload(bindings, heap, assetID) {
+    const byteSize = bindings.geometryTileByteSize(assetID);
+    if (byteSize < TILE_HEADER_BYTES) {
+        throw new Error(`Tile ${assetID} is not resident or has no header`);
+    }
+    const gathered = new Uint8Array(byteSize);
+    let copied = 0;
+    const segments = bindings.geometryTileSegmentCount(assetID);
+    for (let segment = 0; segment < segments; ++segment) {
+        const address = bindings.geometryTileSegmentAddress(assetID, segment);
+        const length = bindings.geometryTileSegmentByteLength(assetID, segment);
+        gathered.set(heap.subarray(address, address + length), copied);
+        copied += length;
+    }
+    const view = new DataView(gathered.buffer);
+    const vertexBytes = view.getUint32(0, true);
+    const indexBytes = view.getUint32(4, true);
+    if (TILE_HEADER_BYTES + vertexBytes + indexBytes !== byteSize) {
+        throw new Error(`Tile ${assetID} header inconsistent with payload size ` +
+            `(${vertexBytes} + ${indexBytes} + ${TILE_HEADER_BYTES} !== ${byteSize})`);
+    }
+    // Slice to aligned standalone buffers (gathered's offsets are 8/`+vertex`,
+    // which may misalign Float32Array/Uint32Array views over the same buffer).
+    const vertexData = new Float32Array(gathered.buffer.slice(TILE_HEADER_BYTES, TILE_HEADER_BYTES + vertexBytes));
+    const indexData = new Uint32Array(gathered.buffer.slice(TILE_HEADER_BYTES + vertexBytes, TILE_HEADER_BYTES + vertexBytes + indexBytes));
+    return { vertexData, indexData };
+}

package/compiled/src/core/geometry_tile_bindings.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geometry_tile_bindings.test.d.ts.map

package/compiled/src/core/geometry_tile_bindings.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_tile_bindings.test.d.ts","sourceRoot":"","sources":["../../../src/core/geometry_tile_bindings.test.ts"],"names":[],"mappings":""}