@peers-app/peers-sdk 0.16.5 → 0.17.0

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

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const types_1 = require("../../data/orm/types");
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const builder_1 = require("../builder");
+const extract_1 = require("../extract");
+const registry_1 = require("../registry");
+const types_2 = require("../types");
+beforeAll(() => {
+    (0, extract_1.setSchemaToFieldsFn)(types_1.schemaToFields);
+});
+/**
+ * End-to-end integration tests that exercise the full flow:
+ * definePackage -> register in registry -> check dependencies -> resolve -> swap provider.
+ */
+describe("Package Contracts — integration", () => {
+    let registry;
+    beforeEach(() => {
+        registry = new registry_1.ContractRegistry();
+    });
+    const TASKS_CONTRACT_ID = (0, utils_1.newid)();
+    const PROJECTS_CONTRACT_ID = (0, utils_1.newid)();
+    const FANCY_TASKS_CONTRACT_ID = (0, utils_1.newid)();
+    function defineTasksPackage() {
+        return (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = (0, utils_1.newid)();
+            const tasks = pkg.contract(TASKS_CONTRACT_ID, 1, "Tasks");
+            tasks.tables = [
+                {
+                    metaData: {
+                        name: "Tasks",
+                        description: "Task management table",
+                        primaryKeyName: "taskId",
+                        fields: [],
+                    },
+                    schema: zod_1.z.object({
+                        taskId: zod_1.z.string().describe("Primary key"),
+                        title: zod_1.z.string().describe("Task title"),
+                        status: zod_1.z.string().describe("Task status"),
+                        sortOrder: zod_1.z.number().describe("Sort order"),
+                    }),
+                },
+            ];
+            tasks.tools = [
+                {
+                    tool: {
+                        name: "create-task",
+                        usageDescription: "Creates a new task",
+                        inputSchema: {
+                            fields: [
+                                { name: "title", type: field_type_1.FieldType.string, description: "Task title" },
+                                {
+                                    name: "status",
+                                    type: field_type_1.FieldType.string,
+                                    description: "Initial status",
+                                    optional: true,
+                                },
+                            ],
+                        },
+                        outputSchema: {
+                            fields: [{ name: "taskId", type: field_type_1.FieldType.id, description: "Created task ID" }],
+                        },
+                    },
+                },
+            ];
+            tasks.observables = [
+                {
+                    name: "taskCount",
+                    description: "Total task count",
+                    valueType: field_type_1.FieldType.number,
+                    writable: false,
+                },
+            ];
+        });
+    }
+    function defineProjectsPackage() {
+        return (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = (0, utils_1.newid)();
+            pkg.consumes(TASKS_CONTRACT_ID, 1);
+            const projects = pkg.contract(PROJECTS_CONTRACT_ID, 1, "Projects");
+            projects.tables = [
+                {
+                    metaData: {
+                        name: "Projects",
+                        description: "Project management",
+                        primaryKeyName: "projectId",
+                        fields: [],
+                    },
+                    schema: zod_1.z.object({
+                        projectId: zod_1.z.string().describe("PK"),
+                        name: zod_1.z.string().describe("Project name"),
+                    }),
+                },
+            ];
+        });
+    }
+    function defineFancyTasksPackage() {
+        return (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = (0, utils_1.newid)();
+            const fancy = pkg.contract(FANCY_TASKS_CONTRACT_ID, 1, "Fancy Tasks");
+            fancy.alsoImplements(TASKS_CONTRACT_ID, 1);
+            fancy.tables = [
+                {
+                    metaData: {
+                        name: "Tasks",
+                        description: "Enhanced task table",
+                        primaryKeyName: "taskId",
+                        fields: [],
+                    },
+                    schema: zod_1.z.object({
+                        taskId: zod_1.z.string().describe("Primary key"),
+                        title: zod_1.z.string().describe("Task title"),
+                        status: zod_1.z.string().describe("Task status"),
+                        sortOrder: zod_1.z.number().describe("Sort order"),
+                        priority: zod_1.z.number().optional().describe("Priority level"),
+                        tags: zod_1.z.string().array().optional().describe("Tags"),
+                    }),
+                },
+            ];
+            fancy.tools = [
+                {
+                    tool: {
+                        name: "create-task",
+                        usageDescription: "Creates a fancy task",
+                        inputSchema: {
+                            fields: [
+                                { name: "title", type: field_type_1.FieldType.string, description: "Task title" },
+                                {
+                                    name: "status",
+                                    type: field_type_1.FieldType.string,
+                                    description: "Initial status",
+                                    optional: true,
+                                },
+                                {
+                                    name: "priority",
+                                    type: field_type_1.FieldType.number,
+                                    description: "Priority",
+                                    optional: true,
+                                },
+                            ],
+                        },
+                        outputSchema: {
+                            fields: [{ name: "taskId", type: field_type_1.FieldType.id, description: "Created task ID" }],
+                        },
+                    },
+                },
+            ];
+            fancy.observables = [
+                {
+                    name: "taskCount",
+                    description: "Total task count",
+                    valueType: field_type_1.FieldType.number,
+                    writable: false,
+                },
+            ];
+        });
+    }
+    it("defines a Tasks package and registers it as a provider", () => {
+        const tasksPkg = defineTasksPackage();
+        expect(tasksPkg.contracts).toHaveLength(1);
+        const pkgId = (0, utils_1.newid)();
+        const result = registry.register(pkgId, tasksPkg.contracts[0]);
+        expect(result.valid).toBe(true);
+        const resolved = registry.resolve(TASKS_CONTRACT_ID, 1);
+        expect(resolved).toBeDefined();
+        expect(resolved?.tables[0].name).toBe("Tasks");
+        expect(resolved?.tools[0].name).toBe("create-task");
+        expect(resolved?.observables[0].name).toBe("taskCount");
+    });
+    it("defines a Projects package that consumes Tasks, and verifies dependencies", () => {
+        const tasksPkg = defineTasksPackage();
+        const tasksPkgId = (0, utils_1.newid)();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        const projectsPkg = defineProjectsPackage();
+        const projectsPkgId = (0, utils_1.newid)();
+        registry.register(projectsPkgId, projectsPkg.contracts[0]);
+        // Projects consumes Tasks — check that the dependency is satisfied
+        const deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.satisfied).toHaveLength(1);
+        expect(deps.satisfied[0].contractId).toBe(TASKS_CONTRACT_ID);
+        expect(deps.missing).toHaveLength(0);
+    });
+    it("rejects Projects installation when Tasks provider is missing", () => {
+        const projectsPkg = defineProjectsPackage();
+        const projectsPkgId = (0, utils_1.newid)();
+        registry.register(projectsPkgId, projectsPkg.contracts[0]);
+        const deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(1);
+        expect(deps.missing[0].contractId).toBe(TASKS_CONTRACT_ID);
+    });
+    it("FancyTasks provides alsoImplements(tasks:v1) and passes validation", () => {
+        // Register the original tasks contract first (so alsoImplements can find it)
+        const tasksPkg = defineTasksPackage();
+        const tasksPkgId = (0, utils_1.newid)();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        // Now register the fancy tasks package with alsoImplements
+        const fancyPkg = defineFancyTasksPackage();
+        const fancyContract = fancyPkg.contracts[0];
+        const key = (0, types_2.contractKey)(FANCY_TASKS_CONTRACT_ID, 1);
+        const alsoImpl = fancyPkg.alsoImplements.get(key) ?? [];
+        const fancyPkgId = (0, utils_1.newid)();
+        const result = registry.register(fancyPkgId, fancyContract, alsoImpl);
+        expect(result.valid).toBe(true);
+    });
+    it("swaps Tasks provider from original to FancyTasks", () => {
+        // Register both providers for the tasks contract
+        const tasksPkg = defineTasksPackage();
+        const tasksPkgId = (0, utils_1.newid)();
+        const fancyPkgId = (0, utils_1.newid)();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        // Register FancyTasks as an additional provider for the TASKS contract
+        const fancyPkg = defineFancyTasksPackage();
+        const fancyContract = fancyPkg.contracts[0];
+        // Register the fancy tasks contract under its own ID
+        const key = (0, types_2.contractKey)(FANCY_TASKS_CONTRACT_ID, 1);
+        const alsoImpl = fancyPkg.alsoImplements.get(key) ?? [];
+        registry.register(fancyPkgId, fancyContract, alsoImpl);
+        // Also register it as a provider for the original tasks contract
+        registry.register(fancyPkgId, tasksPkg.contracts[0]);
+        // Verify original is still active
+        expect(registry.getProviderPackageId(TASKS_CONTRACT_ID, 1)).toBe(tasksPkgId);
+        // Swap to fancy
+        const switched = registry.setActiveProvider(TASKS_CONTRACT_ID, 1, fancyPkgId);
+        expect(switched).toBe(true);
+        expect(registry.getProviderPackageId(TASKS_CONTRACT_ID, 1)).toBe(fancyPkgId);
+        // Projects still resolves — it doesn't care which provider is active
+        const projectsPkg = defineProjectsPackage();
+        const deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.satisfied).toHaveLength(1);
+        expect(deps.missing).toHaveLength(0);
+    });
+    it("removing the active provider falls back to the alternative", () => {
+        const tasksPkg = defineTasksPackage();
+        const tasksPkgId = (0, utils_1.newid)();
+        const backupPkgId = (0, utils_1.newid)();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        registry.register(backupPkgId, tasksPkg.contracts[0]);
+        expect(registry.getProviderPackageId(TASKS_CONTRACT_ID, 1)).toBe(tasksPkgId);
+        registry.unregister(tasksPkgId);
+        expect(registry.getProviderPackageId(TASKS_CONTRACT_ID, 1)).toBe(backupPkgId);
+        // Consumer dependency still satisfied
+        const projectsPkg = defineProjectsPackage();
+        const deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(0);
+    });
+    it("removing the only provider makes consumer dependencies unsatisfied", () => {
+        const tasksPkg = defineTasksPackage();
+        const tasksPkgId = (0, utils_1.newid)();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        const projectsPkg = defineProjectsPackage();
+        // Satisfied before removal
+        let deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(0);
+        registry.unregister(tasksPkgId);
+        // Now unsatisfied
+        deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(1);
+    });
+    it("FancyTasks alsoImplements validation fails when it is missing an observable", () => {
+        // Register original tasks with an observable
+        const tasksPkg = defineTasksPackage();
+        const tasksPkgId = (0, utils_1.newid)();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        // Define a broken fancy tasks that is missing the taskCount observable
+        const brokenFancy = (0, builder_1.definePackage)((pkg) => {
+            pkg.packageId = (0, utils_1.newid)();
+            const fancy = pkg.contract(FANCY_TASKS_CONTRACT_ID, 1, "Broken Fancy Tasks", "dev");
+            fancy.alsoImplements(TASKS_CONTRACT_ID, 1);
+            fancy.tables = [
+                {
+                    metaData: {
+                        name: "Tasks",
+                        description: "d",
+                        primaryKeyName: "taskId",
+                        fields: [],
+                    },
+                    schema: zod_1.z.object({
+                        taskId: zod_1.z.string().describe("PK"),
+                        title: zod_1.z.string().describe("Title"),
+                        status: zod_1.z.string().describe("Status"),
+                        sortOrder: zod_1.z.number().describe("Sort"),
+                    }),
+                },
+            ];
+            fancy.tools = [
+                {
+                    tool: {
+                        name: "create-task",
+                        usageDescription: "Creates a task",
+                        inputSchema: {
+                            fields: [
+                                { name: "title", type: field_type_1.FieldType.string, description: "Title" },
+                                { name: "status", type: field_type_1.FieldType.string, description: "Status", optional: true },
+                            ],
+                        },
+                        outputSchema: {
+                            fields: [{ name: "taskId", type: field_type_1.FieldType.id, description: "ID" }],
+                        },
+                    },
+                },
+            ];
+            // Deliberately omit observables
+        });
+        const brokenContract = brokenFancy.contracts[0];
+        const key = (0, types_2.contractKey)(FANCY_TASKS_CONTRACT_ID, 1);
+        const alsoImpl = brokenFancy.alsoImplements.get(key) ?? [];
+        const brokenPkgId = (0, utils_1.newid)();
+        const result = registry.register(brokenPkgId, brokenContract, alsoImpl);
+        expect(result.valid).toBe(false);
+        expect(result.errors.some((e) => e.message.includes("taskCount"))).toBe(true);
+    });
+    it("full lifecycle: define, register, consume, upgrade, swap, remove", () => {
+        const tasksPkgId = (0, utils_1.newid)();
+        const projectsPkgId = (0, utils_1.newid)();
+        const fancyPkgId = (0, utils_1.newid)();
+        // 1. Register Tasks v1
+        const tasksPkg = defineTasksPackage();
+        registry.register(tasksPkgId, tasksPkg.contracts[0]);
+        // 2. Register Projects (consumes tasks:v1)
+        const projectsPkg = defineProjectsPackage();
+        registry.register(projectsPkgId, projectsPkg.contracts[0]);
+        let deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(0);
+        // 3. Register FancyTasks (provides its own contract + alsoImplements tasks:v1)
+        const fancyPkg = defineFancyTasksPackage();
+        const fancyKey = (0, types_2.contractKey)(FANCY_TASKS_CONTRACT_ID, 1);
+        registry.register(fancyPkgId, fancyPkg.contracts[0], fancyPkg.alsoImplements.get(fancyKey) ?? []);
+        // 4. Also register FancyTasks as a provider of the original tasks contract
+        registry.register(fancyPkgId, tasksPkg.contracts[0]);
+        // 5. Swap tasks:v1 active provider to FancyTasks
+        registry.setActiveProvider(TASKS_CONTRACT_ID, 1, fancyPkgId);
+        expect(registry.getProviderPackageId(TASKS_CONTRACT_ID, 1)).toBe(fancyPkgId);
+        // 6. Projects' dependencies still satisfied
+        deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(0);
+        // 7. Remove original tasks package — fancy is still providing
+        registry.unregister(tasksPkgId);
+        deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(0);
+        expect(registry.getProviderPackageId(TASKS_CONTRACT_ID, 1)).toBe(fancyPkgId);
+        // 8. Remove fancy — now projects' dependency is unsatisfied
+        registry.unregister(fancyPkgId);
+        deps = registry.checkConsumerDependencies(projectsPkg.consumes);
+        expect(deps.missing).toHaveLength(1);
+    });
+});

package/dist/contracts/__tests__/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,324 @@
+"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 = {}) {
+    return {
+        contractId: DEFAULT_CONTRACT_ID,
+        version: 1,
+        name: "Test Contract",
+        description: "A test contract",
+        tables: [],
+        tools: [],
+        observables: [],
+        ...overrides,
+    };
+}
+describe("ContractRegistry", () => {
+    let registry;
+    beforeEach(() => {
+        registry = new registry_1.ContractRegistry();
+    });
+    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);
+        });
+    });
+    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);
+        });
+    });
+    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();
+        });
+    });
+    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);
+        });
+    });
+    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");
+        });
+    });
+    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();
+        });
+    });
+});

package/dist/contracts/__tests__/validate.test.d.ts

@@ -0,0 +1 @@
+export {};