@bldrs-ai/conway 1.403.1239 → 1.405.1243

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.403.1239";
+var versionString = "Conway v1.405.1243";
 
 // 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.403.1239";
+var versionString = "Conway v1.405.1243";
 
 // 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.403.1239";
+var versionString = "Conway v1.405.1243";
 
 // 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.403.1239";
+var versionString = "Conway v1.405.1243";
 
 // 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/model_registry.d.ts

@@ -0,0 +1,87 @@
+import { EntityAddress } from "./model_uri.js";
+import { SharedByteBudget } from "./shared_byte_budget.js";
+/**
+ * A model resolved from the registry, paired with the express ID an address
+ * selected within it.
+ */
+export interface ResolvedEntity<H> {
+    model: H;
+    expressID: number;
+}
+/**
+ * The set of open models in one browser session (M5 / design S3).
+ *
+ * Federation is a registry of loader instances keyed by **model URI**, all
+ * sharing one {@link SharedByteBudget} so total resident memory is bounded per
+ * browser rather than per model. An {@link EntityAddress} (`modelURI#expressID`)
+ * resolves through here to the live model handle; a URI with no registered
+ * model is the signal to open a sibling loader (its own sidecar/stream) and
+ * register it.
+ *
+ * The registry is deliberately generic over the model handle `H` — it owns
+ * identity, resolution and the shared budget, not the loader. The streaming
+ * loader registers its model instance; higher layers (the composed skeleton,
+ * the UI link layer) query through the same addresses.
+ */
+export declare class ModelRegistry<H> {
+    private readonly byURI_;
+    private readonly budget_;
+    /**
+     * @param budget The shared per-browser byte budget every registered model
+     * draws from.
+     */
+    constructor(budget: SharedByteBudget);
+    /**
+     * @return {SharedByteBudget} The shared budget all registered models draw
+     * from.
+     */
+    get budget(): SharedByteBudget;
+    /**
+     * @return {number} The number of registered models.
+     */
+    get size(): number;
+    /**
+     * @return {IterableIterator<string>} The URIs of all registered models.
+     */
+    uris(): IterableIterator<string>;
+    /**
+     * @return {IterableIterator<H>} The registered model handles.
+     */
+    models(): IterableIterator<H>;
+    /**
+     * Register (or replace) the model for a URI.
+     *
+     * @param uri The model URI (no `#` fragment).
+     * @param model The model handle.
+     */
+    register(uri: string, model: H): void;
+    /**
+     * Remove a model from the registry.
+     *
+     * @param uri The model URI.
+     * @return {boolean} True if a model was removed.
+     */
+    unregister(uri: string): boolean;
+    /**
+     * @param uri The model URI.
+     * @return {boolean} True if a model is registered for the URI.
+     */
+    has(uri: string): boolean;
+    /**
+     * @param uri The model URI.
+     * @return {H | undefined} The registered model, or undefined.
+     */
+    get(uri: string): H | undefined;
+    /**
+     * Resolve an entity address to its model + express ID. Returns undefined
+     * when the address's model isn't registered — the caller's cue to open and
+     * register it, then resolve again.
+     *
+     * @param address The entity address, as a URI string or a parsed
+     * {@link EntityAddress}.
+     * @return {ResolvedEntity | undefined} The resolved model + express ID, or
+     * undefined if the model isn't registered.
+     */
+    resolve(address: string | EntityAddress): ResolvedEntity<H> | undefined;
+}
+//# sourceMappingURL=model_registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model_registry.d.ts","sourceRoot":"","sources":["../../../src/core/model_registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAsB,MAAM,aAAa,CAAA;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAGvD;;;GAGG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,KAAK,EAAE,CAAC,CAAA;IACR,SAAS,EAAE,MAAM,CAAA;CAClB;AAGD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,aAAa,CAAC,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAE9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAE1C;;;OAGG;gBACU,MAAM,EAAE,gBAAgB;IAIrC;;;OAGG;IACH,IAAW,MAAM,IAAI,gBAAgB,CAEpC;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACI,IAAI,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAIvC;;OAEG;IACI,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAIpC;;;;;OAKG;IACI,QAAQ,CAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAI,IAAI;IAS9C;;;;;OAKG;IACI,UAAU,CAAE,GAAG,EAAE,MAAM,GAAI,OAAO;IAIzC;;;OAGG;IACI,GAAG,CAAE,GAAG,EAAE,MAAM,GAAI,OAAO;IAIlC;;;OAGG;IACI,GAAG,CAAE,GAAG,EAAE,MAAM,GAAI,CAAC,GAAG,SAAS;IAIxC;;;;;;;;;OASG;IACI,OAAO,CAAE,OAAO,EAAE,MAAM,GAAG,aAAa,GAAI,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS;CASjF"}

package/compiled/src/core/model_registry.js

@@ -0,0 +1,101 @@
+import { parseEntityAddress } from "./model_uri.js";
+/**
+ * The set of open models in one browser session (M5 / design S3).
+ *
+ * Federation is a registry of loader instances keyed by **model URI**, all
+ * sharing one {@link SharedByteBudget} so total resident memory is bounded per
+ * browser rather than per model. An {@link EntityAddress} (`modelURI#expressID`)
+ * resolves through here to the live model handle; a URI with no registered
+ * model is the signal to open a sibling loader (its own sidecar/stream) and
+ * register it.
+ *
+ * The registry is deliberately generic over the model handle `H` — it owns
+ * identity, resolution and the shared budget, not the loader. The streaming
+ * loader registers its model instance; higher layers (the composed skeleton,
+ * the UI link layer) query through the same addresses.
+ */
+export class ModelRegistry {
+    /**
+     * @param budget The shared per-browser byte budget every registered model
+     * draws from.
+     */
+    constructor(budget) {
+        this.byURI_ = new Map();
+        this.budget_ = budget;
+    }
+    /**
+     * @return {SharedByteBudget} The shared budget all registered models draw
+     * from.
+     */
+    get budget() {
+        return this.budget_;
+    }
+    /**
+     * @return {number} The number of registered models.
+     */
+    get size() {
+        return this.byURI_.size;
+    }
+    /**
+     * @return {IterableIterator<string>} The URIs of all registered models.
+     */
+    uris() {
+        return this.byURI_.keys();
+    }
+    /**
+     * @return {IterableIterator<H>} The registered model handles.
+     */
+    models() {
+        return this.byURI_.values();
+    }
+    /**
+     * Register (or replace) the model for a URI.
+     *
+     * @param uri The model URI (no `#` fragment).
+     * @param model The model handle.
+     */
+    register(uri, model) {
+        if (uri.includes("#")) {
+            throw new Error(`Model URI must not contain '#': ${uri}`);
+        }
+        this.byURI_.set(uri, model);
+    }
+    /**
+     * Remove a model from the registry.
+     *
+     * @param uri The model URI.
+     * @return {boolean} True if a model was removed.
+     */
+    unregister(uri) {
+        return this.byURI_.delete(uri);
+    }
+    /**
+     * @param uri The model URI.
+     * @return {boolean} True if a model is registered for the URI.
+     */
+    has(uri) {
+        return this.byURI_.has(uri);
+    }
+    /**
+     * @param uri The model URI.
+     * @return {H | undefined} The registered model, or undefined.
+     */
+    get(uri) {
+        return this.byURI_.get(uri);
+    }
+    /**
+     * Resolve an entity address to its model + express ID. Returns undefined
+     * when the address's model isn't registered — the caller's cue to open and
+     * register it, then resolve again.
+     *
+     * @param address The entity address, as a URI string or a parsed
+     * {@link EntityAddress}.
+     * @return {ResolvedEntity | undefined} The resolved model + express ID, or
+     * undefined if the model isn't registered.
+     */
+    resolve(address) {
+        const { modelURI, expressID } = typeof address === "string" ? parseEntityAddress(address) : address;
+        const model = this.byURI_.get(modelURI);
+        return model === void 0 ? void 0 : { model, expressID };
+    }
+}

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

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

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

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

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

@@ -0,0 +1,60 @@
+/* eslint-disable no-magic-numbers */
+// M5: the registry keys open models by URI, resolves universal addresses to
+// the live model, and hands every model the one shared budget.
+import { describe, expect, test } from "@jest/globals";
+import { ModelRegistry } from "./model_registry.js";
+import { SharedByteBudget } from "./shared_byte_budget.js";
+describe("ModelRegistry", () => {
+    /**
+     * A registry with two registered fake models.
+     *
+     * @return {ModelRegistry} The populated registry.
+     */
+    function twoModels() {
+        const registry = new ModelRegistry(new SharedByteBudget(1000));
+        registry.register("https://ex.com/a.ifc", { uri: "a" });
+        registry.register("https://ex.com/b.ifc", { uri: "b" });
+        return registry;
+    }
+    test("registers, looks up and counts models", () => {
+        const registry = twoModels();
+        expect(registry.size).toBe(2);
+        expect(registry.has("https://ex.com/a.ifc")).toBe(true);
+        expect(registry.get("https://ex.com/b.ifc")?.uri).toBe("b");
+        expect([...registry.uris()].sort()).toEqual(["https://ex.com/a.ifc", "https://ex.com/b.ifc"]);
+    });
+    test("resolves an address string to the model and express ID", () => {
+        const registry = twoModels();
+        const resolved = registry.resolve("https://ex.com/b.ifc#42");
+        expect(resolved?.model.uri).toBe("b");
+        expect(resolved?.expressID).toBe(42);
+    });
+    test("resolves a pre-parsed address object too", () => {
+        const registry = twoModels();
+        const resolved = registry.resolve({ modelURI: "https://ex.com/a.ifc", expressID: 7 });
+        expect(resolved?.model.uri).toBe("a");
+        expect(resolved?.expressID).toBe(7);
+    });
+    test("returns undefined for an unregistered model (open-then-retry cue)", () => {
+        const registry = twoModels();
+        expect(registry.resolve("https://ex.com/missing.ifc#1"))
+            .toBeUndefined();
+    });
+    test("unregister removes a model", () => {
+        const registry = twoModels();
+        expect(registry.unregister("https://ex.com/a.ifc")).toBe(true);
+        expect(registry.has("https://ex.com/a.ifc")).toBe(false);
+        expect(registry.size).toBe(1);
+    });
+    test("rejects registering a URI with a fragment", () => {
+        const registry = new ModelRegistry(new SharedByteBudget(10));
+        expect(() => registry.register("a.ifc#1", { uri: "a" })).toThrow(/#/);
+    });
+    test("exposes the one shared budget every model draws from", () => {
+        const budget = new SharedByteBudget(1000);
+        const registry = new ModelRegistry(budget);
+        expect(registry.budget).toBe(budget);
+        registry.budget.reserve(400);
+        expect(registry.budget.available).toBe(600);
+    });
+});

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

@@ -0,0 +1,57 @@
+/**
+ * Cross-model entity addressing (M5 / design S3).
+ *
+ * Federation turns "thousands of cross-referenced files" from a loader problem
+ * into an addressing problem: every entity has a **universal address** of a
+ * model URI plus an express ID — `https://…/part-B.ifc#4022`. The engine never
+ * holds all the files; it holds a registry of models keyed by URI (see
+ * {@link ModelRegistry}) and resolves an address to a (model, expressID) pair
+ * on demand, opening a sibling loader for a URI it hasn't seen.
+ *
+ * The URI is opaque to the engine except for its `#expressID` fragment: the
+ * scheme, host, path and any version identity live entirely in the model URI,
+ * so "many versions side by side" is expressible without an engine change.
+ */
+/**
+ * A universal entity address: which model, and which express ID within it.
+ */
+export interface EntityAddress {
+    /** The model's URI (everything left of the `#expressID` fragment). */
+    modelURI: string;
+    /** The entity's express ID within that model. */
+    expressID: number;
+}
+/**
+ * Format a model URI + express ID as a single entity address URI.
+ *
+ * @param modelURI The model URI (must not itself contain a `#`).
+ * @param expressID The express ID (a non-negative integer).
+ * @return {string} The `modelURI#expressID` address.
+ */
+export declare function formatEntityAddress(modelURI: string, expressID: number): string;
+/**
+ * Parse an entity address URI into its model URI and express ID.
+ *
+ * The split is on the **last** `#`, so a fragment is required; the model URI
+ * is everything before it. A missing or non-integer fragment is an error —
+ * an address without an express ID isn't an entity address.
+ *
+ * @param uri The `modelURI#expressID` address.
+ * @return {EntityAddress} The parsed address.
+ */
+export declare function parseEntityAddress(uri: string): EntityAddress;
+/**
+ * Resolve a (possibly relative) reference URI against a base model URI, so an
+ * `IfcExternalReference.Location` like `../shared/grid.ifc` becomes an absolute
+ * model URI addressable in the registry. Absolute references (with a scheme,
+ * or protocol-relative) pass through unchanged.
+ *
+ * Uses the standard URL resolver when the base is absolute; falls back to a
+ * plain path join when the base has no scheme (e.g. a bare filename in tests).
+ *
+ * @param base The base model URI the reference was found in.
+ * @param reference The reference URI (absolute or relative).
+ * @return {string} The resolved absolute reference URI.
+ */
+export declare function resolveReference(base: string, reference: string): string;
+//# sourceMappingURL=model_uri.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model_uri.d.ts","sourceRoot":"","sources":["../../../src/core/model_uri.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,MAAM,WAAW,aAAa;IAE5B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAA;IAEhB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAA;CAClB;AAOD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAI,MAAM,CAWjF;AAGD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAE,GAAG,EAAE,MAAM,GAAI,aAAa,CAgB/D;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAI,MAAM,CAgB1E"}