@peers-app/peers-sdk 0.21.0 → 0.21.2

package/dist/context/user-context.d.ts

@@ -23,10 +23,17 @@ export declare class UserContext {
     constructor(userId: string, dataSourceFactory: DataSourceFactory, ephemeral?: boolean | undefined);
     private init;
     /**
-     * We want to load all packages as part of user context initialization
-     * so any tables in packages have been registered are available at sync time
+     * Loads all packages for the user's personal data context and every group
+     * they are a part of.
+     *
+     * Callers that `await` this (e.g. device init) block until every package
+     * bundle has been evaluated. That is intentional when tools/contracts must
+     * be ready before the device is considered initialized, but it does add
+     * package-load latency to startup compared to fire-and-forget loading.
      */
-    private loadAllPackages;
+    loadAllPackages(opts?: {
+        force?: boolean;
+    }): Promise<void>;
     private loadGroupContexts;
     getDataContext(groupId: string): DataContext;
     /** Wait for any pending `currentlyActiveGroupId` pvar write to be flushed to the DB. */

package/dist/context/user-context.js

@@ -44,22 +44,22 @@ class UserContext {
             await this.loadUserContextObservablesFromDB();
         }
         await this.loadGroupContexts();
-        await this.loadAllPackages();
         return this;
     }
     /**
-     * We want to load all packages as part of user context initialization
-     * so any tables in packages have been registered are available at sync time
+     * Loads all packages for the user's personal data context and every group
+     * they are a part of.
+     *
+     * Callers that `await` this (e.g. device init) block until every package
+     * bundle has been evaluated. That is intentional when tools/contracts must
+     * be ready before the device is considered initialized, but it does add
+     * package-load latency to startup compared to fire-and-forget loading.
      */
-    loadAllPackages() {
-        this.userDataContext.packageLoader
-            .loadAllPackages()
-            .catch((err) => console.error("[UserContext] loadAllPackages failed for userDataContext:", err));
-        for (const groupContext of this.groupDataContexts.values()) {
-            groupContext.packageLoader
-                .loadAllPackages()
-                .catch((err) => console.error("[UserContext] loadAllPackages failed for groupContext:", err));
-        }
+    async loadAllPackages(opts) {
+        await Promise.all([
+            this.userDataContext.packageLoader.loadAllPackages(opts),
+            ...[...this.groupDataContexts.values()].map((ctx) => ctx.packageLoader.loadAllPackages(opts)),
+        ]);
     }
     async loadGroupContexts() {
         const groupsTable = (0, data_1.Groups)(this.userDataContext);

package/dist/contracts/__tests__/builder.test.js

@@ -97,10 +97,12 @@ describe("definePackage", () => {
         expect(result.contracts[1].contractId).toBe(NOTES_ID);
     });
     it("records consumed contracts", () => {
+        let tasksHandle;
+        let authHandle;
         const result = (0, builder_1.definePackage)((pkg) => {
             pkg.packageId = TEST_PKG_ID;
-            pkg.consumes(TASKS_ID, 1);
-            pkg.consumes(AUTH_ID, 2);
+            tasksHandle = pkg.consumes(TASKS_ID, 1);
+            authHandle = pkg.consumes(AUTH_ID, 2);
             const projects = pkg.contract(PROJECTS_ID, 1, "Projects");
             projects.tables = [
                 {
@@ -114,8 +116,160 @@ describe("definePackage", () => {
             ];
         });
         expect(result.consumes).toHaveLength(2);
-        expect(result.consumes[0]).toEqual({ contractId: TASKS_ID, version: 1 });
-        expect(result.consumes[1]).toEqual({ contractId: AUTH_ID, version: 2 });
+        expect(result.consumes[0].contractId).toBe(TASKS_ID);
+        expect(result.consumes[0].version).toBe(1);
+        expect(result.consumes[0].handle).toBe(tasksHandle);
+        expect(result.consumes[1].contractId).toBe(AUTH_ID);
+        expect(result.consumes[1].version).toBe(2);
+        expect(result.consumes[1].handle).toBe(authHandle);
+    });
+    it("preserves consume options and returns a deferred handle", () => {
+        const preferredProviderId = (0, utils_1.newid)();
+        const result = (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = TEST_PKG_ID;
+            pkg.consumes(TASKS_ID, 1, {
+                providerPackageIds: [preferredProviderId],
+                fallbackToDefaultProvider: true,
+            });
+            pkg.consumes(AUTH_ID, 2, {
+                optional: true,
+                providerPackageIds: [preferredProviderId],
+                fallbackToDefaultProvider: false,
+            });
+        });
+        const [required, optional] = result.consumes;
+        expect(required).toMatchObject({
+            contractId: TASKS_ID,
+            version: 1,
+            providerPackageIds: [preferredProviderId],
+            fallbackToDefaultProvider: true,
+        });
+        expect(required.optional).toBeUndefined();
+        expect(required.handle).toBeDefined();
+        expect(typeof required.handle?.consumer.then).toBe("function");
+        // Handle itself must not be thenable (naive await on the return value must not wait).
+        expect(required.handle.then).toBeUndefined();
+        expect(optional).toMatchObject({
+            contractId: AUTH_ID,
+            version: 2,
+            optional: true,
+            providerPackageIds: [preferredProviderId],
+            fallbackToDefaultProvider: false,
+        });
+        expect(optional.handle).toBeDefined();
+    });
+    it("accepts a type argument that narrows the resolved consumer", () => {
+        (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = TEST_PKG_ID;
+            const required = pkg.consumes(TASKS_ID, 1);
+            const optional = pkg.consumes(AUTH_ID, 1, { optional: true });
+            // Compile-time checks: required → TypedConsumer; optional → TypedConsumer | undefined.
+            void (async () => {
+                const requiredConsumer = await required.consumer;
+                const optionalConsumer = await optional.consumer;
+                void requiredConsumer;
+                void optionalConsumer;
+                // Named table methods (not only dataChanged) must be present on ITableProxy.
+                const _list = requiredConsumer.tables.ConsoleLogs.list;
+                const _deleteOldLogs = requiredConsumer.tables.ConsoleLogs.deleteOldLogs;
+                void _list;
+                void _deleteOldLogs;
+                // Typed consumers may omit empty bags — these must not exist on TypedConsumer.
+                // @ts-expect-error no tools bag on slim typed consumer
+                void requiredConsumer.tools;
+                // @ts-expect-error no events bag on slim typed consumer
+                void requiredConsumer.events;
+                // @ts-expect-error no observables bag on slim typed consumer
+                void requiredConsumer.observables;
+                // @ts-expect-error optional consume must allow undefined
+                const tooNarrow = await optional.consumer;
+                void tooNarrow;
+            })();
+        });
+    });
+    it("ILogsConsumer exposes ConsoleLogs as ITableProxy without empty bags", () => {
+        (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = TEST_PKG_ID;
+            const handle = pkg.consumes(TASKS_ID, 1, { optional: true });
+            void (async () => {
+                const logs = await handle.consumer;
+                if (!logs)
+                    return;
+                const _list = logs.tables.ConsoleLogs.list;
+                const _deleteOldLogs = logs.tables.ConsoleLogs.deleteOldLogs;
+                void _list;
+                void _deleteOldLogs;
+                // @ts-expect-error ILogsConsumer has no tools bag
+                void logs.tools;
+                // @ts-expect-error ILogsConsumer has no events bag
+                void logs.events;
+                // @ts-expect-error ILogsConsumer has no observables bag
+                void logs.observables;
+            })();
+        });
+    });
+    it("settles required handles with a consumer and optional handles with undefined", async () => {
+        const { settleConsumedContractHandle, rejectConsumedContractHandle } = await Promise.resolve().then(() => require("../builder"));
+        const result = (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = TEST_PKG_ID;
+            pkg.consumes(TASKS_ID, 1);
+            pkg.consumes(AUTH_ID, 1, { optional: true });
+        });
+        const requiredHandle = result.consumes[0].handle;
+        const optionalHandle = result.consumes[1].handle;
+        expect(requiredHandle).toBeDefined();
+        expect(optionalHandle).toBeDefined();
+        if (!requiredHandle || !optionalHandle) {
+            throw new Error("expected consumes handles");
+        }
+        const fakeConsumer = {
+            contractId: TASKS_ID,
+            version: 1,
+            tables: {},
+            tools: {},
+            observables: {},
+            events: {},
+            loadingPromise: Promise.resolve(),
+            dispose: () => { },
+        };
+        settleConsumedContractHandle(requiredHandle, fakeConsumer);
+        settleConsumedContractHandle(optionalHandle, undefined);
+        await expect(requiredHandle.consumer).resolves.toBe(fakeConsumer);
+        await expect(optionalHandle.consumer).resolves.toBeUndefined();
+        expect(() => settleConsumedContractHandle(requiredHandle, fakeConsumer)).toThrow("already been settled");
+        expect(() => rejectConsumedContractHandle(optionalHandle, new Error("late"))).toThrow("already been settled");
+    });
+    it("rejects a required consume handle once", async () => {
+        const { rejectConsumedContractHandle } = await Promise.resolve().then(() => require("../builder"));
+        const result = (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = TEST_PKG_ID;
+            pkg.consumes(TASKS_ID, 1);
+        });
+        const requiredHandle = result.consumes[0].handle;
+        expect(requiredHandle).toBeDefined();
+        if (!requiredHandle) {
+            throw new Error("expected consumes handle");
+        }
+        const err = new Error("No provider for Tasks");
+        rejectConsumedContractHandle(requiredHandle, err);
+        await expect(requiredHandle.consumer).rejects.toThrow("No provider for Tasks");
+        expect(() => rejectConsumedContractHandle(requiredHandle, err)).toThrow("already been settled");
+    });
+    it("throws when consumes providerPackageIds contains an invalid peer ID", () => {
+        expect(() => {
+            (0, builder_1.definePackage)((pkg) => {
+                pkg.packageId = TEST_PKG_ID;
+                pkg.consumes(TASKS_ID, 1, { providerPackageIds: ["not-valid"] });
+            });
+        }).toThrow("providerPackageIds");
+    });
+    it("throws when consumes version is not a positive integer", () => {
+        expect(() => {
+            (0, builder_1.definePackage)((pkg) => {
+                pkg.packageId = TEST_PKG_ID;
+                pkg.consumes(TASKS_ID, 0);
+            });
+        }).toThrow("positive integer");
     });
     it("records alsoImplements declarations", () => {
         const result = (0, builder_1.definePackage)((pkg) => {

package/dist/contracts/__tests__/registry.test.js

@@ -1,324 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const field_type_1 = require("../../types/field-type");
 const utils_1 = require("../../utils");
 const registry_1 = require("../registry");
-const DEFAULT_CONTRACT_ID = (0, utils_1.newid)();
-function makeContract(overrides = {}) {
+function makeDefinition(contractId, version, name = "Test Contract") {
     return {
-        contractId: DEFAULT_CONTRACT_ID,
-        version: 1,
-        name: "Test Contract",
-        description: "A test contract",
+        contractId,
+        version,
+        devTag: "dev",
+        name,
+        description: "test",
         tables: [],
         tools: [],
         observables: [],
-        ...overrides,
+        events: [],
     };
 }
-describe("ContractRegistry", () => {
+describe("ContractRegistry.selectProvider", () => {
+    const contractId = (0, utils_1.newid)();
+    const packageA = (0, utils_1.newid)();
+    const packageB = (0, utils_1.newid)();
+    const packageC = (0, utils_1.newid)();
     let registry;
     beforeEach(() => {
         registry = new registry_1.ContractRegistry();
+        registry.register(packageA, makeDefinition(contractId, 1, "A"));
+        registry.register(packageB, makeDefinition(contractId, 1, "B"));
     });
-    describe("register and resolve", () => {
-        it("registers a provider and resolves it", () => {
-            const def = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgId = (0, utils_1.newid)();
-            const result = registry.register(pkgId, def);
-            expect(result.valid).toBe(true);
-            const resolved = registry.resolve(DEFAULT_CONTRACT_ID, 1);
-            expect(resolved).toBeDefined();
-            expect(resolved?.tables[0].name).toBe("Tasks");
-        });
-        it("returns the provider package ID", () => {
-            const def = makeContract();
-            const pkgId = (0, utils_1.newid)();
-            registry.register(pkgId, def);
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBe(pkgId);
-        });
-        it("returns undefined for unregistered contracts", () => {
-            const unknownId = (0, utils_1.newid)();
-            expect(registry.resolve(unknownId, 1)).toBeUndefined();
-            expect(registry.getProviderPackageId(unknownId, 1)).toBeUndefined();
-        });
-        it("auto-activates the first registered provider", () => {
-            const def = makeContract();
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBe(pkgA);
-        });
-        it("does not auto-switch when a second provider is registered", () => {
-            const def = makeContract();
-            const pkgA = (0, utils_1.newid)();
-            const pkgB = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            registry.register(pkgB, def);
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBe(pkgA);
-        });
+    it("returns registered provider ids in registration order", () => {
+        expect(registry.getRegisteredProviderIds(contractId, 1)).toEqual([packageA, packageB]);
     });
-    describe("setActiveProvider", () => {
-        it("switches the active provider", () => {
-            const def = makeContract();
-            const pkgA = (0, utils_1.newid)();
-            const pkgB = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            registry.register(pkgB, def);
-            const switched = registry.setActiveProvider(DEFAULT_CONTRACT_ID, 1, pkgB);
-            expect(switched).toBe(true);
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBe(pkgB);
-        });
-        it("returns false if the target package is not registered", () => {
-            const def = makeContract();
-            const pkgA = (0, utils_1.newid)();
-            const unknownPkg = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            const switched = registry.setActiveProvider(DEFAULT_CONTRACT_ID, 1, unknownPkg);
-            expect(switched).toBe(false);
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBe(pkgA);
-        });
-        it("returns false for unknown contracts", () => {
-            const unknownId = (0, utils_1.newid)();
-            const pkgA = (0, utils_1.newid)();
-            expect(registry.setActiveProvider(unknownId, 1, pkgA)).toBe(false);
-        });
+    it("selects the active provider when no preference is given", () => {
+        const selected = registry.selectProvider({ contractId, version: 1 });
+        expect(selected?.providerPackageId).toBe(packageA);
     });
-    describe("unregister", () => {
-        it("removes a provider and its resolution", () => {
-            const def = makeContract();
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            registry.unregister(pkgA);
-            expect(registry.resolve(DEFAULT_CONTRACT_ID, 1)).toBeUndefined();
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBeUndefined();
-        });
-        it("falls back to next provider when active is removed", () => {
-            const def = makeContract();
-            const pkgA = (0, utils_1.newid)();
-            const pkgB = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            registry.register(pkgB, def);
-            registry.unregister(pkgA);
-            expect(registry.getProviderPackageId(DEFAULT_CONTRACT_ID, 1)).toBe(pkgB);
-        });
-        it("is a no-op for unknown packages", () => {
-            const unknownPkg = (0, utils_1.newid)();
-            expect(() => registry.unregister(unknownPkg)).not.toThrow();
-        });
-        it("handles a package that provides multiple contracts", () => {
-            const contractId1 = (0, utils_1.newid)();
-            const contractId2 = (0, utils_1.newid)();
-            const def1 = makeContract({ contractId: contractId1 });
-            const def2 = makeContract({ contractId: contractId2 });
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, def1);
-            registry.register(pkgA, def2);
-            registry.unregister(pkgA);
-            expect(registry.resolve(contractId1, 1)).toBeUndefined();
-            expect(registry.resolve(contractId2, 1)).toBeUndefined();
-        });
+    it("selects the first preferred provider that is registered", () => {
+        const dep = {
+            contractId,
+            version: 1,
+            providerPackageIds: [packageC, packageB, packageA],
+        };
+        expect(registry.selectProvider(dep)?.providerPackageId).toBe(packageB);
     });
-    describe("checkConsumerDependencies", () => {
-        it("reports all satisfied when providers exist", () => {
-            const tasksId = (0, utils_1.newid)();
-            const authId = (0, utils_1.newid)();
-            const pkgA = (0, utils_1.newid)();
-            const pkgB = (0, utils_1.newid)();
-            registry.register(pkgA, makeContract({ contractId: tasksId }));
-            registry.register(pkgB, makeContract({ contractId: authId }));
-            const result = registry.checkConsumerDependencies([
-                { contractId: tasksId, version: 1 },
-                { contractId: authId, version: 1 },
-            ]);
-            expect(result.satisfied).toHaveLength(2);
-            expect(result.missing).toHaveLength(0);
-        });
-        it("reports missing when no provider exists", () => {
-            const tasksId = (0, utils_1.newid)();
-            const authId = (0, utils_1.newid)();
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, makeContract({ contractId: tasksId }));
-            const result = registry.checkConsumerDependencies([
-                { contractId: tasksId, version: 1 },
-                { contractId: authId, version: 1 },
-            ]);
-            expect(result.satisfied).toHaveLength(1);
-            expect(result.missing).toHaveLength(1);
-            expect(result.missing[0].contractId).toBe(authId);
-        });
-        it("reports all missing when registry is empty", () => {
-            const tasksId = (0, utils_1.newid)();
-            const result = registry.checkConsumerDependencies([{ contractId: tasksId, version: 1 }]);
-            expect(result.satisfied).toHaveLength(0);
-            expect(result.missing).toHaveLength(1);
-        });
-        it("returns empty lists for empty consumer list", () => {
-            const result = registry.checkConsumerDependencies([]);
-            expect(result.satisfied).toHaveLength(0);
-            expect(result.missing).toHaveLength(0);
-        });
+    it("falls back to the active provider when preferred are missing and fallback is enabled", () => {
+        const dep = {
+            contractId,
+            version: 1,
+            providerPackageIds: [packageC],
+            fallbackToDefaultProvider: true,
+        };
+        expect(registry.selectProvider(dep)?.providerPackageId).toBe(packageA);
     });
-    describe("immutability enforcement", () => {
-        it("rejects re-registration of a frozen contract with a different shape", () => {
-            const def1 = makeContract({
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, def1);
-            const def2 = makeContract({
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [
-                            { name: "id", type: field_type_1.FieldType.id },
-                            { name: "extra", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const pkgB = (0, utils_1.newid)();
-            const result = registry.register(pkgB, def2);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("frozen");
-        });
-        it("allows re-registration of a dev contract with a different shape", () => {
-            const def1 = makeContract({
-                devTag: "dev",
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, def1);
-            const def2 = makeContract({
-                devTag: "dev",
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [
-                            { name: "id", type: field_type_1.FieldType.id },
-                            { name: "extra", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const pkgB = (0, utils_1.newid)();
-            const result = registry.register(pkgB, def2);
-            expect(result.valid).toBe(true);
-        });
-        it("rejects dev registration after a stable version exists", () => {
-            const stableDef = makeContract({
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, stableDef);
-            const devDef = makeContract({
-                devTag: "dev",
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgB = (0, utils_1.newid)();
-            const result = registry.register(pkgB, devDef);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("frozen");
-        });
-        it("allows dev-to-stable transition, then rejects subsequent dev registration", () => {
-            const devDef = makeContract({
-                devTag: "dev",
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, devDef);
-            const stableDef = makeContract({
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [
-                            { name: "id", type: field_type_1.FieldType.id },
-                            { name: "title", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const pkgB = (0, utils_1.newid)();
-            const stableResult = registry.register(pkgB, stableDef);
-            expect(stableResult.valid).toBe(true);
-            const devDef2 = makeContract({
-                devTag: "dev",
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const pkgC = (0, utils_1.newid)();
-            const devResult = registry.register(pkgC, devDef2);
-            expect(devResult.valid).toBe(false);
-            expect(devResult.errors[0].message).toContain("frozen");
-        });
+    it("returns undefined when preferred are missing and fallback is disabled", () => {
+        const dep = {
+            contractId,
+            version: 1,
+            providerPackageIds: [packageC],
+            fallbackToDefaultProvider: false,
+        };
+        expect(registry.selectProvider(dep)).toBeUndefined();
     });
-    describe("getDefinition", () => {
-        it("returns the stored definition", () => {
-            const def = makeContract({ name: "My Contract" });
-            const pkgA = (0, utils_1.newid)();
-            registry.register(pkgA, def);
-            const stored = registry.getDefinition(DEFAULT_CONTRACT_ID, 1);
-            expect(stored).toBeDefined();
-            expect(stored?.name).toBe("My Contract");
-        });
-        it("returns undefined for unknown contracts", () => {
-            const unknownId = (0, utils_1.newid)();
-            expect(registry.getDefinition(unknownId, 1)).toBeUndefined();
-        });
+    it("returns undefined when no providers are registered", () => {
+        const empty = new registry_1.ContractRegistry();
+        expect(empty.selectProvider({ contractId, version: 1 })).toBeUndefined();
     });
 });

package/dist/contracts/__tests__/system-contracts.test.d.ts

@@ -0,0 +1 @@
+import "../system";

package/dist/contracts/__tests__/system-contracts.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const system_ids_1 = require("../../system-ids");
+const utils_1 = require("../../utils");
+const contract_resolvers_1 = require("../contract-resolvers");
+const registry_1 = require("../registry");
+const system_contracts_1 = require("../system-contracts");
+// Populate the catalog with built-in system contracts.
+require("../system");
+describe("system contract catalog", () => {
+    it("self-registers Logs and Device Operations", () => {
+        const ids = (0, system_contracts_1.listSystemContracts)()
+            .map((entry) => entry.contractId)
+            .filter(Boolean);
+        expect(ids).toEqual(expect.arrayContaining([system_ids_1.logsContractId, system_ids_1.deviceOperationsContractId]));
+    });
+    it("registers the Logs live resolver", async () => {
+        await new Promise((resolve) => queueMicrotask(resolve));
+        expect((0, contract_resolvers_1.getContractResolver)(system_ids_1.logsContractId, 1)).toEqual(expect.any(Function));
+    });
+    it("installSystemContracts seeds a registry with system providers", () => {
+        const registry = new registry_1.ContractRegistry();
+        (0, system_contracts_1.installSystemContracts)(registry);
+        expect(registry.resolve(system_ids_1.logsContractId, 1)?.name).toBe("System Logs");
+        expect(registry.getProviderPackageId(system_ids_1.logsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
+        expect(registry.resolve(system_ids_1.deviceOperationsContractId, 1)?.name).toBe("System Device Operations");
+        expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
+    });
+    it("registerSystemContract makes new contracts installable without loader changes", () => {
+        const fakeContractId = (0, utils_1.newid)();
+        const providerPackageId = (0, utils_1.newid)();
+        (0, system_contracts_1.registerSystemContract)({
+            providerPackageId,
+            contractId: fakeContractId,
+            version: 1,
+            getDefinition: () => ({
+                contractId: fakeContractId,
+                version: 1,
+                devTag: "dev",
+                name: "Fake System Contract",
+                description: "test",
+                tables: [],
+                tools: [],
+                observables: [],
+                events: [],
+            }),
+        });
+        const registry = new registry_1.ContractRegistry();
+        (0, system_contracts_1.installSystemContracts)(registry);
+        expect(registry.getProviderPackageId(fakeContractId, 1)).toBe(providerPackageId);
+    });
+});