@bldrs-ai/conway 1.404.1241 → 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.404.1241";
+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.404.1241";
+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.404.1241";
+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.404.1241";
+var versionString = "Conway v1.408.1248";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";

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

@@ -0,0 +1,63 @@
+import { StepEntityConstructorAbstract } from "../step/step_entity_constructor.js";
+import { EntityAddress } from "./model_uri.js";
+import { ModelRegistry } from "./model_registry.js";
+/**
+ * A model that can answer a type query — the minimum a federated model must
+ * expose to take part in cross-file composition. Both the resident model's
+ * type index and the streaming {@link IncrementalTypeIndex} satisfy this, so a
+ * composed view works whether its members are fully parsed or still streaming.
+ */
+export interface TypeQueryableModel<TypeIDType extends number> {
+    /**
+     * Express IDs of all records of the given types (including subtypes).
+     *
+     * @param types The entity constructors to query.
+     * @return {IterableIterator<number>} The matching express IDs.
+     */
+    expressIDsOfTypes(...types: StepEntityConstructorAbstract<TypeIDType>[]): IterableIterator<number>;
+}
+/**
+ * A composed view over every model in a {@link ModelRegistry} (M5 / design S3).
+ *
+ * Federation's read side: a site plan that references per-building files, or a
+ * project split across disciplines, is browsed as **one** model whose entities
+ * carry universal {@link EntityAddress}es (`modelURI#expressID`). A type query
+ * here fans out across all registered members and yields addresses, not bare
+ * express IDs — so "every `IfcWall` in the project" spans files, and each
+ * result round-trips back through {@link ModelRegistry.resolve} to the right
+ * model.
+ *
+ * This is the composition scaffold: it unions the members' type skeletons
+ * under the shared address space. The spatial-containment merge (a site's
+ * `IfcRelAggregates` linking to building files) layers on top by resolving the
+ * cross-file references the {@link CrossReferenceRegistry} discovers — the next
+ * increment, gated on the loader registering streamed models here.
+ */
+export declare class ComposedModelSkeleton<TypeIDType extends number, H extends TypeQueryableModel<TypeIDType>> {
+    private readonly registry_;
+    /**
+     * @param registry_ The registry whose models this composes over.
+     */
+    constructor(registry_: ModelRegistry<H>);
+    /**
+     * @return {ModelRegistry<H>} The registry backing this composed view.
+     */
+    get registry(): ModelRegistry<H>;
+    /**
+     * Yield the universal address of every entity of the given types across all
+     * registered models.
+     *
+     * @param types The entity constructors to query (subtype closures unioned).
+     * @return {IterableIterator<EntityAddress>} Addresses of matching entities.
+     * @yields {EntityAddress} Each matching entity's universal address.
+     */
+    entitiesOfType(...types: StepEntityConstructorAbstract<TypeIDType>[]): IterableIterator<EntityAddress>;
+    /**
+     * Count entities of the given types across all registered models.
+     *
+     * @param types The entity constructors to count.
+     * @return {number} The total across the federation.
+     */
+    countOfType(...types: StepEntityConstructorAbstract<TypeIDType>[]): number;
+}
+//# sourceMappingURL=composed_model_skeleton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composed_model_skeleton.d.ts","sourceRoot":"","sources":["../../../src/core/composed_model_skeleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAA;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAGhD;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB,CAAC,UAAU,SAAS,MAAM;IAE3D;;;;;OAKG;IACH,iBAAiB,CACf,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GAAI,gBAAgB,CAAC,MAAM,CAAC,CAAA;CACpF;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAqB,CAChC,UAAU,SAAS,MAAM,EACzB,CAAC,SAAS,kBAAkB,CAAC,UAAU,CAAC;IAK3B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAHvC;;OAEG;gBAC2B,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC;IAEzD;;OAEG;IACH,IAAW,QAAQ,IAAI,aAAa,CAAC,CAAC,CAAC,CAEtC;IAED;;;;;;;OAOG;IACK,cAAc,CAClB,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GACrD,gBAAgB,CAAC,aAAa,CAAC;IAgBnC;;;;;OAKG;IACI,WAAW,CACd,GAAG,KAAK,EAAE,6BAA6B,CAAC,UAAU,CAAC,EAAE,GAAI,MAAM;CAapE"}

package/compiled/src/core/composed_model_skeleton.js

@@ -0,0 +1,66 @@
+/**
+ * A composed view over every model in a {@link ModelRegistry} (M5 / design S3).
+ *
+ * Federation's read side: a site plan that references per-building files, or a
+ * project split across disciplines, is browsed as **one** model whose entities
+ * carry universal {@link EntityAddress}es (`modelURI#expressID`). A type query
+ * here fans out across all registered members and yields addresses, not bare
+ * express IDs — so "every `IfcWall` in the project" spans files, and each
+ * result round-trips back through {@link ModelRegistry.resolve} to the right
+ * model.
+ *
+ * This is the composition scaffold: it unions the members' type skeletons
+ * under the shared address space. The spatial-containment merge (a site's
+ * `IfcRelAggregates` linking to building files) layers on top by resolving the
+ * cross-file references the {@link CrossReferenceRegistry} discovers — the next
+ * increment, gated on the loader registering streamed models here.
+ */
+export class ComposedModelSkeleton {
+    /**
+     * @param registry_ The registry whose models this composes over.
+     */
+    constructor(registry_) {
+        this.registry_ = registry_;
+    }
+    /**
+     * @return {ModelRegistry<H>} The registry backing this composed view.
+     */
+    get registry() {
+        return this.registry_;
+    }
+    /**
+     * Yield the universal address of every entity of the given types across all
+     * registered models.
+     *
+     * @param types The entity constructors to query (subtype closures unioned).
+     * @return {IterableIterator<EntityAddress>} Addresses of matching entities.
+     * @yields {EntityAddress} Each matching entity's universal address.
+     */
+    *entitiesOfType(...types) {
+        for (const modelURI of this.registry_.uris()) {
+            const model = this.registry_.get(modelURI);
+            if (model === void 0) {
+                continue;
+            }
+            for (const expressID of model.expressIDsOfTypes(...types)) {
+                yield { modelURI, expressID };
+            }
+        }
+    }
+    /**
+     * Count entities of the given types across all registered models.
+     *
+     * @param types The entity constructors to count.
+     * @return {number} The total across the federation.
+     */
+    countOfType(...types) {
+        let total = 0;
+        for (const model of this.registry_.models()) {
+            for (const expressID of model.expressIDsOfTypes(...types)) {
+                void expressID;
+                ++total;
+            }
+        }
+        return total;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,69 @@
+/* eslint-disable no-magic-numbers */
+// M5: the composed view fans a type query across every registered model and
+// yields universal addresses, so "every wall in the project" spans files and
+// each result round-trips back through the registry to its model.
+import { describe, expect, test } from "@jest/globals";
+import { ComposedModelSkeleton } from "./composed_model_skeleton.js";
+import { ModelRegistry } from "./model_registry.js";
+import { SharedByteBudget } from "./shared_byte_budget.js";
+/**
+ * A fake type-queryable model returning a fixed express-ID set regardless of
+ * the queried types (the query-closure matching itself is covered by the
+ * incremental-type-index tests; here we exercise cross-model composition).
+ */
+class FakeModel {
+    /**
+     * @param ids The express IDs this model reports for any query.
+     */
+    constructor(ids) {
+        this.ids = ids;
+    }
+    /**
+     * @return {IterableIterator<number>} The fixed express IDs.
+     */
+    *expressIDsOfTypes() {
+        yield* this.ids;
+    }
+}
+// A dummy constructor to satisfy the query signature (unused by FakeModel).
+const ANY_TYPE = { query: [1] };
+describe("ComposedModelSkeleton", () => {
+    /**
+     * A composed view over two fake models.
+     *
+     * @return {ComposedModelSkeleton} The composed view.
+     */
+    function composed() {
+        const registry = new ModelRegistry(new SharedByteBudget(1000));
+        registry.register("site/a.ifc", new FakeModel([1, 2]));
+        registry.register("site/b.ifc", new FakeModel([10, 11, 12]));
+        return new ComposedModelSkeleton(registry);
+    }
+    test("yields universal addresses across every registered model", () => {
+        const view = composed();
+        const addresses = [...view.entitiesOfType(ANY_TYPE)];
+        expect(addresses).toEqual([
+            { modelURI: "site/a.ifc", expressID: 1 },
+            { modelURI: "site/a.ifc", expressID: 2 },
+            { modelURI: "site/b.ifc", expressID: 10 },
+            { modelURI: "site/b.ifc", expressID: 11 },
+            { modelURI: "site/b.ifc", expressID: 12 },
+        ]);
+    });
+    test("counts across the federation", () => {
+        expect(composed().countOfType(ANY_TYPE)).toBe(5);
+    });
+    test("each composed address resolves back to its own model", () => {
+        const view = composed();
+        for (const address of view.entitiesOfType(ANY_TYPE)) {
+            const resolved = view.registry.resolve(address);
+            expect(resolved).toBeDefined();
+            expect(resolved?.expressID).toBe(address.expressID);
+        }
+    });
+    test("an empty registry composes to nothing", () => {
+        const view = new ComposedModelSkeleton(new ModelRegistry(new SharedByteBudget(10)));
+        expect([...view.entitiesOfType(ANY_TYPE)]).toEqual([]);
+        expect(view.countOfType(ANY_TYPE)).toBe(0);
+    });
+});

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);
+    });
+});