@bldrs-ai/conway 1.405.1243 → 1.408.1248

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.405.1243";
+var versionString = "Conway v1.408.1248";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

package/compiled/examples/cli-bundled.cjs

@@ -14965,7 +14965,7 @@ ${t5.join("\n")}` : "";
 var import_process = require("process");
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.405.1243";
+var versionString = "Conway v1.408.1248";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

package/compiled/examples/cli-step-bundled.cjs

@@ -15943,7 +15943,7 @@ var ParsingBuffer = class {
 };
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.405.1243";
+var versionString = "Conway v1.408.1248";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 function pThreadsAllowed() {

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.405.1243";
+var versionString = "Conway v1.408.1248";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

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

@@ -0,0 +1,99 @@
+import { GeometryTiles } from "./demand_geometry_queue.js";
+import { ChunkedPool } from "./mem/chunked_pool.js";
+import { SharedAssetPool } from "./mem/shared_asset_pool.js";
+/**
+ * One shareable geometry payload an instance needs resident: the asset's
+ * identity and its byte size. For IFC, the asset is a representation's
+ * tessellated geometry and `byteSize` comes from the wasm-side extract.
+ */
+export interface GeometryAsset<AssetID> {
+    assetID: AssetID;
+    byteSize: number;
+}
+/**
+ * The domain half the tile pool delegates to: what assets an instance is made
+ * of, and how to materialise / discard one asset's payload. This is the seam
+ * the production conway-geom surface implements (extract → tessellate into
+ * the asset's chunks; discard on last release); tests implement it with
+ * recording mocks.
+ */
+export interface InstanceAssetSource<AssetID> {
+    /**
+     * The assets an instance requires resident, with their byte sizes. For a
+     * simple product this is one asset; mapped/instanced representations return
+     * the same assetID from many instances — that sharing is the point.
+     *
+     * @param instanceID The instance (product local ID in the geometry case).
+     * @return {GeometryAsset<AssetID>[]} The instance's assets.
+     */
+    assetsOf(instanceID: number): GeometryAsset<AssetID>[];
+    /**
+     * Materialise an asset's payload (called exactly once per residency, on
+     * the 0→1 reference). In production: run the wasm extract/tessellate and
+     * write the result into the asset's pool chunks.
+     *
+     * @param assetID The asset to materialise.
+     */
+    materialize(assetID: AssetID): void;
+    /**
+     * Discard an asset's payload (called exactly once per residency, on the
+     * 1→0 reference, after its chunks are already back in the pool).
+     *
+     * @param assetID The asset to discard.
+     */
+    discard(assetID: AssetID): void;
+}
+/**
+ * The geometry narrowing of the general memory system (`src/core/mem/`): a
+ * {@link GeometryTiles} backend where a product's "tile" is a set of
+ * refcounted, chunk-resident **assets** in a {@link SharedAssetPool}.
+ *
+ * Composed with {@link DemandGeometryQueue} this completes the M3 resident
+ * design: the queue owns demand ordering and the logical budget; this pool
+ * owns physical residency. Two accounting views, one invariant:
+ *
+ * - **Logical (queue-side):** `extract` charges an instance the full
+ *   chunk-rounded cost of *every* asset it references, shared or not. Sharing
+ *   is thus double-charged logically — deliberately conservative: summed
+ *   logical charges always cover physical use, so with the queue's budget set
+ *   to the pool's budget, an acquire can never fail mid-extract. (Heavy
+ *   sharing under-utilises the logical budget; the production wiring can
+ *   widen the queue budget once measured. The safe direction first.)
+ * - **Physical (pool-side):** `bytesInUse` counts real chunks. Shared assets
+ *   are stored once, refcounted, and freed only on the last release — so
+ *   evicting product A never discards the representation product B still
+ *   renders (the mapped-item correctness rule, held structurally).
+ */
+export declare class GeometryTilePool<AssetID> implements GeometryTiles {
+    private readonly assets_;
+    private readonly source_;
+    /** Assets each extracted instance holds references on. */
+    private readonly held_;
+    /**
+     * @param pool The chunk pool residents live in.
+     * @param source The domain half (asset composition + materialise/discard).
+     */
+    constructor(pool: ChunkedPool, source: InstanceAssetSource<AssetID>);
+    /**
+     * @return {SharedAssetPool<AssetID>} The refcounted asset layer (physical
+     * accounting lives here / on its pool).
+     */
+    get assets(): SharedAssetPool<AssetID>;
+    /**
+     * Materialise an instance's tile: take a reference on each of its assets,
+     * materialising the ones not yet resident.
+     *
+     * @param instanceID The instance (product local ID).
+     * @return {number} The instance's logical byte cost (chunk-rounded, every
+     * asset fully charged — see class docs for why sharing is double-charged).
+     */
+    extract(instanceID: number): number;
+    /**
+     * Release an instance's tile: drop the reference on each of its assets,
+     * discarding those this instance was the last holder of.
+     *
+     * @param instanceID The instance (product local ID).
+     */
+    release(instanceID: number): void;
+}
+//# sourceMappingURL=geometry_tile_pool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_tile_pool.d.ts","sourceRoot":"","sources":["../../../src/core/geometry_tile_pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAGzD;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,OAAO;IACpC,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAGD;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB,CAAC,OAAO;IAE1C;;;;;;;OAOG;IACH,QAAQ,CAAE,UAAU,EAAE,MAAM,GAAI,aAAa,CAAC,OAAO,CAAC,EAAE,CAAA;IAExD;;;;;;OAMG;IACH,WAAW,CAAE,OAAO,EAAE,OAAO,GAAI,IAAI,CAAA;IAErC;;;;;OAKG;IACH,OAAO,CAAE,OAAO,EAAE,OAAO,GAAI,IAAI,CAAA;CAClC;AAGD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAgB,CAAC,OAAO,CAAE,YAAW,aAAa;IAE7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAElD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IAEtD,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8C;IAEpE;;;OAGG;gBACU,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,CAAC,OAAO,CAAC;IAKpE;;;OAGG;IACH,IAAW,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC,CAE5C;IAED;;;;;;;OAOG;IACI,OAAO,CAAE,UAAU,EAAE,MAAM,GAAI,MAAM;IAoD5C;;;;;OAKG;IACI,OAAO,CAAE,UAAU,EAAE,MAAM,GAAI,IAAI;CAgB3C"}

package/compiled/src/core/geometry_tile_pool.js

@@ -0,0 +1,104 @@
+import { SharedAssetPool } from "./mem/shared_asset_pool.js";
+/**
+ * The geometry narrowing of the general memory system (`src/core/mem/`): a
+ * {@link GeometryTiles} backend where a product's "tile" is a set of
+ * refcounted, chunk-resident **assets** in a {@link SharedAssetPool}.
+ *
+ * Composed with {@link DemandGeometryQueue} this completes the M3 resident
+ * design: the queue owns demand ordering and the logical budget; this pool
+ * owns physical residency. Two accounting views, one invariant:
+ *
+ * - **Logical (queue-side):** `extract` charges an instance the full
+ *   chunk-rounded cost of *every* asset it references, shared or not. Sharing
+ *   is thus double-charged logically — deliberately conservative: summed
+ *   logical charges always cover physical use, so with the queue's budget set
+ *   to the pool's budget, an acquire can never fail mid-extract. (Heavy
+ *   sharing under-utilises the logical budget; the production wiring can
+ *   widen the queue budget once measured. The safe direction first.)
+ * - **Physical (pool-side):** `bytesInUse` counts real chunks. Shared assets
+ *   are stored once, refcounted, and freed only on the last release — so
+ *   evicting product A never discards the representation product B still
+ *   renders (the mapped-item correctness rule, held structurally).
+ */
+export class GeometryTilePool {
+    /**
+     * @param pool The chunk pool residents live in.
+     * @param source The domain half (asset composition + materialise/discard).
+     */
+    constructor(pool, source) {
+        /** Assets each extracted instance holds references on. */
+        this.held_ = new Map();
+        this.assets_ = new SharedAssetPool(pool);
+        this.source_ = source;
+    }
+    /**
+     * @return {SharedAssetPool<AssetID>} The refcounted asset layer (physical
+     * accounting lives here / on its pool).
+     */
+    get assets() {
+        return this.assets_;
+    }
+    /**
+     * Materialise an instance's tile: take a reference on each of its assets,
+     * materialising the ones not yet resident.
+     *
+     * @param instanceID The instance (product local ID).
+     * @return {number} The instance's logical byte cost (chunk-rounded, every
+     * asset fully charged — see class docs for why sharing is double-charged).
+     */
+    extract(instanceID) {
+        if (this.held_.has(instanceID)) {
+            throw new Error(`Instance ${instanceID} already extracted`);
+        }
+        const assets = this.source_.assetsOf(instanceID);
+        const pool = this.assets_.pool;
+        // Validate and price every asset BEFORE taking any references, so a bad
+        // byte size (a source bug) throws at zero state instead of mid-extract
+        // with references already taken. chunkRound throws on negatives.
+        let logicalBytes = 0;
+        for (const asset of assets) {
+            logicalBytes += pool.chunkRound(asset.byteSize);
+        }
+        for (const asset of assets) {
+            const { retained, wasAbsent } = this.assets_.retain(asset.assetID, asset.byteSize);
+            if (!retained) {
+                // Unwind references already taken so a failed extract has no effect —
+                // keeping the materialize/discard pairing: an asset this unwind takes
+                // to zero references must be discarded like any other last release.
+                for (const taken of assets) {
+                    if (taken === asset) {
+                        break;
+                    }
+                    if (this.assets_.release(taken.assetID)) {
+                        this.source_.discard(taken.assetID);
+                    }
+                }
+                throw new Error(`Geometry pool exhausted materialising instance ${instanceID} — ` +
+                    "the scheduler budget must not exceed the pool budget");
+            }
+            if (wasAbsent) {
+                this.source_.materialize(asset.assetID);
+            }
+        }
+        this.held_.set(instanceID, assets);
+        return logicalBytes;
+    }
+    /**
+     * Release an instance's tile: drop the reference on each of its assets,
+     * discarding those this instance was the last holder of.
+     *
+     * @param instanceID The instance (product local ID).
+     */
+    release(instanceID) {
+        const assets = this.held_.get(instanceID);
+        if (assets === void 0) {
+            throw new Error(`Release of un-extracted instance ${instanceID}`);
+        }
+        this.held_.delete(instanceID);
+        for (const asset of assets) {
+            if (this.assets_.release(asset.assetID)) {
+                this.source_.discard(asset.assetID);
+            }
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,180 @@
+/* eslint-disable no-magic-numbers */
+// M3 production design: the geometry narrowing of the mem system, alone and
+// composed with DemandGeometryQueue. The load-bearing assertions: shared
+// representations are stored once and never freed while any product still
+// holds them, and the queue's logical budget always covers the pool's
+// physical use (so an extract can never blow the pool mid-flight).
+import { describe, expect, test } from "@jest/globals";
+import { DemandGeometryQueue } from "./demand_geometry_queue.js";
+import { GeometryTilePool } from "./geometry_tile_pool.js";
+import { ChunkedPool } from "./mem/chunked_pool.js";
+/**
+ * A recording mock of the domain half: instance → assets from a fixture map,
+ * with materialize/discard calls captured.
+ *
+ * @param composition Instance → assets fixture.
+ * @return {object} `{ source, materialized, discarded }`.
+ */
+function mockSource(composition) {
+    const materialized = [];
+    const discarded = [];
+    const source = {
+        assetsOf: (instanceID) => composition[instanceID] ?? [],
+        materialize: (assetID) => {
+            materialized.push(assetID);
+        },
+        discard: (assetID) => {
+            discarded.push(assetID);
+        },
+    };
+    return { source, materialized, discarded };
+}
+describe("GeometryTilePool", () => {
+    test("a shared representation is materialised once and stored once", () => {
+        // Products 1 and 2 both instance rep-X (mapped item); 2 also has its own.
+        const { source, materialized } = mockSource({
+            1: [{ assetID: "rep-X", byteSize: 100 }],
+            2: [{ assetID: "rep-X", byteSize: 100 }, { assetID: "rep-Y", byteSize: 100 }],
+        });
+        const tiles = new GeometryTilePool(new ChunkedPool(1000, 100), source);
+        tiles.extract(1);
+        tiles.extract(2);
+        expect(materialized).toEqual(["rep-X", "rep-Y"]);
+        // Physically: two assets, 200 bytes — not 300.
+        expect(tiles.assets.pool.bytesInUse).toBe(200);
+        expect(tiles.assets.refCountOf("rep-X")).toBe(2);
+    });
+    test("evicting one product never discards a representation another still renders", () => {
+        const { source, discarded } = mockSource({
+            1: [{ assetID: "rep-X", byteSize: 100 }],
+            2: [{ assetID: "rep-X", byteSize: 100 }],
+        });
+        const tiles = new GeometryTilePool(new ChunkedPool(1000, 100), source);
+        tiles.extract(1);
+        tiles.extract(2);
+        tiles.release(1);
+        expect(discarded).toEqual([]);
+        expect(tiles.assets.isResident("rep-X")).toBe(true);
+        tiles.release(2);
+        expect(discarded).toEqual(["rep-X"]);
+        expect(tiles.assets.pool.bytesInUse).toBe(0);
+    });
+    test("extract charges the logical (chunk-rounded, fully-charged) cost", () => {
+        const { source } = mockSource({
+            1: [{ assetID: "a", byteSize: 150 }, { assetID: "b", byteSize: 10 }],
+            2: [{ assetID: "a", byteSize: 150 }],
+        });
+        const tiles = new GeometryTilePool(new ChunkedPool(1000, 100), source);
+        // 150 → 200 rounded, 10 → 100 rounded.
+        expect(tiles.extract(1)).toBe(300);
+        // Sharing is deliberately double-charged logically (conservative)...
+        expect(tiles.extract(2)).toBe(200);
+        // ...while physical stays single-stored.
+        expect(tiles.assets.pool.bytesInUse).toBe(300);
+    });
+    test("a failed extract unwinds cleanly, discarding what it materialised", () => {
+        // Asset a fits; asset b cannot (pool holds 2 chunks, b needs 3). The
+        // extract must throw, and the unwind must keep the materialize/discard
+        // pairing for a (which it took to zero references) and leave the pool
+        // exactly as before — a failed extract has no effect.
+        const { source, materialized, discarded } = mockSource({
+            1: [{ assetID: "a", byteSize: 100 }, { assetID: "b", byteSize: 300 }],
+        });
+        const pool = new ChunkedPool(200, 100);
+        const tiles = new GeometryTilePool(pool, source);
+        expect(() => tiles.extract(1)).toThrow(/exhausted/);
+        expect(materialized).toEqual(["a"]);
+        expect(discarded).toEqual(["a"]);
+        expect(pool.bytesInUse).toBe(0);
+        expect(tiles.assets.isResident("a")).toBe(false);
+    });
+    test("a failed extract never discards an asset another instance still holds", () => {
+        // Instance 1 holds shared. Instance 2 wants shared + big; big fails.
+        // The unwind drops 2's reference on shared but must NOT discard it —
+        // instance 1 still renders it.
+        const { source, discarded } = mockSource({
+            1: [{ assetID: "shared", byteSize: 100 }],
+            2: [{ assetID: "shared", byteSize: 100 }, { assetID: "big", byteSize: 300 }],
+        });
+        const pool = new ChunkedPool(200, 100);
+        const tiles = new GeometryTilePool(pool, source);
+        tiles.extract(1);
+        expect(() => tiles.extract(2)).toThrow(/exhausted/);
+        expect(discarded).toEqual([]);
+        expect(tiles.assets.isResident("shared")).toBe(true);
+        expect(tiles.assets.refCountOf("shared")).toBe(1);
+        expect(pool.bytesInUse).toBe(100);
+    });
+    test("double extract and unmatched release are errors", () => {
+        const { source } = mockSource({ 1: [{ assetID: "a", byteSize: 10 }] });
+        const tiles = new GeometryTilePool(new ChunkedPool(1000, 100), source);
+        tiles.extract(1);
+        expect(() => tiles.extract(1)).toThrow(/already extracted/);
+        expect(() => tiles.release(2)).toThrow(/un-extracted/);
+    });
+    test("a malformed byte size throws before any state changes", () => {
+        // A buggy source returning a negative size must fail at zero state —
+        // no references taken, nothing materialised, pool untouched.
+        const { source, materialized } = mockSource({
+            1: [{ assetID: "ok", byteSize: 100 }, { assetID: "bad", byteSize: -5 }],
+        });
+        const pool = new ChunkedPool(1000, 100);
+        const tiles = new GeometryTilePool(pool, source);
+        expect(() => tiles.extract(1)).toThrow(/Invalid byte size/);
+        expect(materialized).toEqual([]);
+        expect(pool.bytesInUse).toBe(0);
+        expect(tiles.assets.isResident("ok")).toBe(false);
+    });
+    test("composed with the demand queue: budget holds, shared reps survive eviction", () => {
+        // 20 products all sharing one heavy rep, each with a light unique rep —
+        // the mapped-item shape (fixtures, repeated windows).
+        const composition = {};
+        for (let id = 0; id < 20; ++id) {
+            composition[id] = [
+                { assetID: "shared-heavy", byteSize: 400 },
+                { assetID: `unique-${id}`, byteSize: 100 },
+            ];
+        }
+        const { source, materialized, discarded } = mockSource(composition);
+        const pool = new ChunkedPool(4000, 100);
+        const tiles = new GeometryTilePool(pool, source);
+        // Queue budget == pool budget: the safety invariant under test.
+        const queue = new DemandGeometryQueue(tiles, 4000);
+        // Stream demand across all 20 products with rising priority.
+        for (let id = 0; id < 20; ++id) {
+            queue.request(id, id);
+            queue.pump();
+            // Physical use never exceeds the logical budget the queue enforces.
+            expect(pool.bytesInUse).toBeLessThanOrEqual(queue.stats.residentBytes);
+            expect(queue.stats.residentBytes).toBeLessThanOrEqual(4000);
+        }
+        // The shared rep was materialised exactly once across all that churn...
+        expect(materialized.filter((a) => a === "shared-heavy").length).toBe(1);
+        // ...and never discarded, because some product always held it.
+        expect(discarded).not.toContain("shared-heavy");
+        // Evicting everything finally discards it and empties the pool.
+        queue.evictAll();
+        expect(discarded).toContain("shared-heavy");
+        expect(pool.bytesInUse).toBe(0);
+    });
+    test("composed queue at exact pool budget never exhausts the pool", () => {
+        // Every product unique (worst case for the invariant: no sharing slack).
+        const composition = {};
+        for (let id = 0; id < 50; ++id) {
+            composition[id] = [{ assetID: `u-${id}`, byteSize: 190 }];
+        }
+        const { source } = mockSource(composition);
+        const pool = new ChunkedPool(1000, 100);
+        const tiles = new GeometryTilePool(pool, source);
+        const queue = new DemandGeometryQueue(tiles, 1000);
+        // 190 rounds to 200 → 5 tiles fit. Churn all 50 through; extract must
+        // never throw pool-exhausted because logical charges cover physical.
+        for (let id = 0; id < 50; ++id) {
+            queue.request(id, id);
+            queue.pump();
+        }
+        expect(queue.stats.residentCount).toBe(5);
+        expect(pool.bytesInUse).toBe(1000);
+        expect(pool.stats.failedAcquires).toBe(0);
+    });
+});

package/compiled/src/core/mem/chunked_pool.d.ts

@@ -0,0 +1,116 @@
+/**
+ * A fixed-chunk budget pool — the resident-memory primitive (M3 production
+ * design; see "Resident memory: two regimes" in the design doc).
+ *
+ * The wasm heap grows and never shrinks: `free()` returns bytes to the
+ * allocator's freelists, not to the browser, so the tab pays the heap's
+ * **high-water mark forever** and external fragmentation is a permanent leak,
+ * not a throughput nuisance. General-purpose allocation is therefore the
+ * wrong tool for large, evictable resident data. This pool is the explicit
+ * alternative: one region carved into fixed-size chunks with a freelist —
+ * acquire rounds up to whole chunks, release is O(chunks), and the region's
+ * high-water mark is the budget, by construction. Fragmentation is confined
+ * to bounded internal waste (the tail of the last chunk).
+ *
+ * This TS class is the pool's **accounting/policy half** and the executable
+ * spec for its C++ twin in conway-geom (which owns real bytes inside the wasm
+ * heap). It is also usable directly for JS-side resident budgets (property
+ * caches, sidecar caches) — the abstraction is deliberately not
+ * geometry-specific. The intended layering:
+ *
+ *   ChunkedPool                — chunks and bytes (this file)
+ *   SharedAssetPool            — refcounted assets living in those chunks
+ *   GeometryTilePool           — the geometry narrowing (products ⇄ assets)
+ *
+ * Lifetime regimes, for orientation: *phase-bounded* scratch (tessellation
+ * temporaries) stays on the AFTP bump arenas — reset, never freed piecemeal.
+ * *Demand-bounded* residents (data that lives until evicted) live here. The
+ * general allocator keeps only the small, messy-lifetime residual.
+ */
+/**
+ * An acquired run of chunks. `chunks` are chunk indices into the pool's
+ * region (index × chunkBytes = byte offset in the C++ twin); `byteSize` is
+ * the caller's requested size, ≤ `chunks.length × chunkBytes`.
+ */
+export interface ChunkSpan {
+    chunks: number[];
+    byteSize: number;
+}
+/** Runtime counters for a pool, for tests and telemetry. */
+export interface ChunkedPoolStats {
+    totalChunks: number;
+    freeChunks: number;
+    bytesInUse: number;
+    acquires: number;
+    releases: number;
+    failedAcquires: number;
+}
+/**
+ * A budgeted pool of fixed-size chunks with a freelist. Purely accounting —
+ * see the module docs for how it maps onto real memory.
+ */
+export declare class ChunkedPool {
+    private readonly chunkBytes_;
+    private readonly totalChunks_;
+    /** Free chunk indices (LIFO for locality in the C++ twin). */
+    private readonly freeList_;
+    private acquires_;
+    private releases_;
+    private failedAcquires_;
+    /**
+     * @param budgetBytes The pool's total byte budget (rounded down to whole
+     * chunks; must fit at least one chunk).
+     * @param chunkBytes The fixed chunk size in bytes.
+     */
+    constructor(budgetBytes: number, chunkBytes: number);
+    /**
+     * @return {number} The fixed chunk size in bytes.
+     */
+    get chunkBytes(): number;
+    /**
+     * @return {number} Total chunks in the pool.
+     */
+    get totalChunks(): number;
+    /**
+     * @return {number} Chunks currently free.
+     */
+    get freeChunks(): number;
+    /**
+     * @return {number} The pool's total byte capacity (whole chunks).
+     */
+    get totalBytes(): number;
+    /**
+     * @return {number} Physical bytes currently acquired (chunk-rounded).
+     */
+    get bytesInUse(): number;
+    /**
+     * The physical (chunk-rounded) cost of a byte size — what an acquire of
+     * `bytes` actually consumes. Use this for any budget accounting layered
+     * above the pool so logical charges cover physical use.
+     *
+     * @param bytes The byte size to round.
+     * @return {number} The chunk-rounded byte cost.
+     */
+    chunkRound(bytes: number): number;
+    /**
+     * Acquire chunks to hold `bytes`. All-or-nothing: returns undefined (and
+     * changes nothing) if the free chunks can't cover the request — the
+     * caller's cue to evict and retry.
+     *
+     * @param bytes The byte size to hold (0 is allowed and acquires no chunks).
+     * @return {ChunkSpan | undefined} The span, or undefined if it can't fit.
+     */
+    acquire(bytes: number): ChunkSpan | undefined;
+    /**
+     * Return a span's chunks to the freelist. The span must not be used (or
+     * released) again afterwards.
+     *
+     * @param span The span to release.
+     */
+    release(span: ChunkSpan): void;
+    /**
+     * @return {ChunkedPoolStats} A snapshot of runtime counters.
+     */
+    get stats(): ChunkedPoolStats;
+}
+//# sourceMappingURL=chunked_pool.d.ts.map

package/compiled/src/core/mem/chunked_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunked_pool.d.ts","sourceRoot":"","sources":["../../../../src/core/mem/chunked_pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAGD,4DAA4D;AAC5D,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;CACvB;AAGD;;;GAGG;AACH,qBAAa,WAAW;IAEtB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IAEpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IAErC,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IAEpC,OAAO,CAAC,SAAS,CAAI;IAErB,OAAO,CAAC,SAAS,CAAI;IAErB,OAAO,CAAC,eAAe,CAAI;IAE3B;;;;OAIG;gBACU,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAsBpD;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;OAEG;IACH,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;;;;OAOG;IACI,UAAU,CAAE,KAAK,EAAE,MAAM,GAAI,MAAM;IAS1C;;;;;;;OAOG;IACI,OAAO,CAAE,KAAK,EAAE,MAAM,GAAI,SAAS,GAAG,SAAS;IAoBtD;;;;;OAKG;IACI,OAAO,CAAE,IAAI,EAAE,SAAS,GAAI,IAAI;IAUvC;;OAEG;IACH,IAAW,KAAK,IAAI,gBAAgB,CASnC;CACF"}