@peers-app/peers-sdk 0.27.2 → 0.27.4

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

@@ -1,991 +0,0 @@
-"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 types_2 = require("../types");
-const validate_1 = require("../validate");
-const DEFAULT_CONTRACT_ID = (0, utils_1.newid)();
-/** Helper to build a minimal contract definition for tests. */
-function makeContract(overrides = {}) {
-    return {
-        contractId: DEFAULT_CONTRACT_ID,
-        version: 1,
-        name: "Test Contract",
-        description: "A test contract",
-        tables: [],
-        tools: [],
-        observables: [],
-        events: [],
-        ...overrides,
-    };
-}
-describe("validateProviderSatisfiesContract", () => {
-    describe("tables", () => {
-        it("passes when implementation has the same fields as the contract", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "title", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const impl = makeContract({ tables: [...contract.tables] });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-            expect(result.errors).toHaveLength(0);
-        });
-        it("passes when implementation has extra optional fields", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "title", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "title", type: field_type_1.FieldType.string },
-                            { name: "priority", type: field_type_1.FieldType.number, optional: true },
-                        ],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-        });
-        it("fails when implementation is missing a required field", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "title", type: field_type_1.FieldType.string },
-                            { name: "status", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "title", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors).toHaveLength(1);
-            expect(result.errors[0].message).toContain("status");
-            expect(result.errors[0].message).toContain("missing");
-        });
-        it("allows missing optional contract fields in the implementation", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "notes", type: field_type_1.FieldType.string, optional: true },
-                        ],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-        });
-        it("fails when a field has the wrong type", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "count", type: field_type_1.FieldType.number },
-                        ],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "Tasks table",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "count", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("type mismatch");
-        });
-        it("fails when contract requires required but implementation has optional", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "title", type: field_type_1.FieldType.string }],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "title", type: field_type_1.FieldType.string, optional: true }],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("optional");
-        });
-        it("fails when contract table is entirely missing from implementation", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({ tables: [] });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].kind).toBe("table");
-            expect(result.errors[0].message).toContain("not provided");
-        });
-        it("fails when primary key names differ", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("primary key");
-        });
-        it("fails when implementation has extra required fields not in contract", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "Tasks",
-                        description: "d",
-                        primaryKeyName: "taskId",
-                        fields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "internalField", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("extra required field");
-        });
-        it("validates isArray compatibility", () => {
-            const contract = makeContract({
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [
-                            { name: "id", type: field_type_1.FieldType.id },
-                            { name: "tags", type: field_type_1.FieldType.string, isArray: true },
-                        ],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tables: [
-                    {
-                        name: "T",
-                        description: "d",
-                        primaryKeyName: "id",
-                        fields: [
-                            { name: "id", type: field_type_1.FieldType.id },
-                            { name: "tags", type: field_type_1.FieldType.string },
-                        ],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("array");
-        });
-    });
-    describe("tools", () => {
-        it("passes when tool signatures match", () => {
-            const contract = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "Creates a task",
-                        inputFields: [{ name: "title", type: field_type_1.FieldType.string }],
-                        outputFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({ tools: [...contract.tools] });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-        });
-        it("fails when a required tool is missing", () => {
-            const contract = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "Creates a task",
-                        inputFields: [],
-                        outputFields: [],
-                    },
-                ],
-            });
-            const impl = makeContract({ tools: [] });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].kind).toBe("tool");
-        });
-        it("allows extra optional input fields in implementation", () => {
-            const contract = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "d",
-                        inputFields: [{ name: "title", type: field_type_1.FieldType.string }],
-                        outputFields: [],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "d",
-                        inputFields: [
-                            { name: "title", type: field_type_1.FieldType.string },
-                            { name: "priority", type: field_type_1.FieldType.number, optional: true },
-                        ],
-                        outputFields: [],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-        });
-        it("fails when implementation has extra required input fields", () => {
-            const contract = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "d",
-                        inputFields: [{ name: "title", type: field_type_1.FieldType.string }],
-                        outputFields: [],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "d",
-                        inputFields: [
-                            { name: "title", type: field_type_1.FieldType.string },
-                            { name: "mandatory", type: field_type_1.FieldType.string },
-                        ],
-                        outputFields: [],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("extra required input");
-        });
-        it("allows extra output fields in implementation (returns more data)", () => {
-            const contract = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "d",
-                        inputFields: [],
-                        outputFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                tools: [
-                    {
-                        name: "create-task",
-                        usageDescription: "d",
-                        inputFields: [],
-                        outputFields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "createdAt", type: field_type_1.FieldType.Date },
-                        ],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-        });
-    });
-    describe("observables", () => {
-        it("passes when observables match", () => {
-            const contract = makeContract({
-                observables: [
-                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
-                ],
-            });
-            const impl = makeContract({ observables: [...contract.observables] });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(true);
-        });
-        it("fails when an observable is missing", () => {
-            const contract = makeContract({
-                observables: [
-                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
-                ],
-            });
-            const impl = makeContract({ observables: [] });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].kind).toBe("observable");
-        });
-        it("fails on value type mismatch", () => {
-            const contract = makeContract({
-                observables: [
-                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
-                ],
-            });
-            const impl = makeContract({
-                observables: [
-                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.string, writable: false },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("type mismatch");
-        });
-        it("fails when contract requires writable but impl is read-only", () => {
-            const contract = makeContract({
-                observables: [
-                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: true },
-                ],
-            });
-            const impl = makeContract({
-                observables: [
-                    { name: "taskCount", description: "d", valueType: field_type_1.FieldType.number, writable: false },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain("writable");
-        });
-    });
-    describe("events", () => {
-        it("passes when an implementation event has compatible payload fields", () => {
-            const contract = makeContract({
-                events: [
-                    {
-                        name: "taskChanged",
-                        description: "A task changed",
-                        payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                events: [
-                    {
-                        name: "taskChanged",
-                        description: "A task changed",
-                        payloadFields: [
-                            { name: "taskId", type: field_type_1.FieldType.id },
-                            { name: "source", type: field_type_1.FieldType.string, optional: true },
-                        ],
-                    },
-                ],
-            });
-            expect((0, validate_1.validateProviderSatisfiesContract)(impl, contract)).toEqual({
-                valid: true,
-                errors: [],
-            });
-        });
-        it("fails when a required event is missing", () => {
-            const contract = makeContract({
-                events: [
-                    {
-                        name: "taskChanged",
-                        description: "A task changed",
-                        payloadFields: [],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(makeContract(), contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0]).toEqual(expect.objectContaining({ kind: "event", name: "taskChanged" }));
-        });
-        it("fails when an event payload field is incompatible", () => {
-            const contract = makeContract({
-                events: [
-                    {
-                        name: "taskChanged",
-                        description: "A task changed",
-                        payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                    },
-                ],
-            });
-            const impl = makeContract({
-                events: [
-                    {
-                        name: "taskChanged",
-                        description: "A task changed",
-                        payloadFields: [{ name: "taskId", type: field_type_1.FieldType.number }],
-                    },
-                ],
-            });
-            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0]).toEqual(expect.objectContaining({
-                kind: "field",
-                name: "taskChanged.payload.taskId",
-                message: expect.stringMatching(/type mismatch/),
-            }));
-        });
-    });
-});
-describe("validateImmutability", () => {
-    it("allows any change for dev contracts", () => {
-        const existing = makeContract({ devTag: "dev", tables: [] });
-        const incoming = makeContract({
-            devTag: "dev",
-            tables: [
-                {
-                    name: "New",
-                    description: "d",
-                    primaryKeyName: "id",
-                    fields: [{ name: "id", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateImmutability)(existing, incoming);
-        expect(result.valid).toBe(true);
-    });
-    it("rejects registering a dev version when stable version already exists", () => {
-        const existing = makeContract({
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const incoming = makeContract({
-            devTag: "dev",
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateImmutability)(existing, incoming);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toContain("frozen");
-    });
-    it("passes when a frozen contract is re-published identically", () => {
-        const contract = makeContract({
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateImmutability)(contract, { ...contract });
-        expect(result.valid).toBe(true);
-    });
-    it("fails when a frozen contract shape is modified", () => {
-        const existing = makeContract({
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const incoming = makeContract({
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "title", type: field_type_1.FieldType.string },
-                    ],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateImmutability)(existing, incoming);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toContain("frozen");
-    });
-    it.each([
-        [
-            "addition",
-            [
-                {
-                    name: "taskChanged",
-                    description: "A task changed",
-                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-                {
-                    name: "taskDeleted",
-                    description: "A task was deleted",
-                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        ],
-        ["removal", []],
-        [
-            "rename",
-            [
-                {
-                    name: "taskUpdated",
-                    description: "A task changed",
-                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        ],
-        [
-            "payload change",
-            [
-                {
-                    name: "taskChanged",
-                    description: "A task changed",
-                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.number }],
-                },
-            ],
-        ],
-    ])("rejects frozen event %s", (_change, incomingEvents) => {
-        const existing = makeContract({
-            events: [
-                {
-                    name: "taskChanged",
-                    description: "A task changed",
-                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateImmutability)(existing, makeContract({ events: incomingEvents }));
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toContain("frozen");
-    });
-});
-describe("validateImmutability compares shapes, not text", () => {
-    const tool = (inputFields) => ({
-        name: "setMode",
-        usageDescription: "Set the mode.",
-        inputFields,
-        outputFields: [{ name: "ok", type: field_type_1.FieldType.boolean }],
-    });
-    const mode = { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] };
-    const note = { name: "note", type: field_type_1.FieldType.string, optional: true, description: "A note." };
-    const frozen = makeContract({
-        tools: [tool([mode, note])],
-        observables: [
-            {
-                name: "state",
-                description: "The state.",
-                valueType: field_type_1.FieldType.object,
-                value: { type: field_type_1.FieldType.object, fields: [{ name: "on", type: field_type_1.FieldType.boolean }] },
-                writable: false,
-            },
-        ],
-    });
-    it("allows new descriptions and any member, field, or key order", () => {
-        const incoming = makeContract({
-            observables: [
-                {
-                    writable: false,
-                    value: { fields: [{ type: field_type_1.FieldType.boolean, name: "on" }], type: field_type_1.FieldType.object },
-                    valueType: field_type_1.FieldType.object,
-                    description: "Deprecated: use v2.",
-                    name: "state",
-                },
-            ],
-            tools: [
-                {
-                    ...tool([
-                        { ...note, description: "Don't use this." },
-                        { ...mode, enumValues: ["off", "on"] },
-                    ]),
-                    usageDescription: "Deprecated: use v2.",
-                },
-            ],
-        });
-        expect((0, validate_1.validateImmutability)(frozen, incoming).valid).toBe(true);
-    });
-    it("matches a shape built before fields, enumValues, and value existed", () => {
-        const older = makeContract({
-            tools: [
-                tool([
-                    { name: "mode", type: field_type_1.FieldType.string },
-                    { name: "note", type: field_type_1.FieldType.string, optional: true },
-                ]),
-            ],
-            observables: [
-                { name: "state", description: "", valueType: field_type_1.FieldType.object, writable: false },
-            ],
-        });
-        expect((0, validate_1.validateImmutability)(frozen, older).valid).toBe(true);
-        expect((0, validate_1.validateImmutability)(older, frozen).valid).toBe(true);
-    });
-    it("ignores duplicate enum entries when comparing sets", () => {
-        const incoming = makeContract({
-            tools: [tool([{ ...mode, enumValues: ["off", "on", "on"] }, note])],
-            observables: frozen.observables,
-        });
-        expect((0, validate_1.validateImmutability)(frozen, incoming).valid).toBe(true);
-        expect((0, validate_1.validateImmutability)(incoming, frozen).valid).toBe(true);
-    });
-    it("matches unchanged legacy default factories across schema rebuilds and JSON storage", () => {
-        const factory = jest.fn(() => "generated");
-        const legacy = () => makeContract({
-            tables: [
-                {
-                    name: "Records",
-                    description: "",
-                    primaryKeyName: "id",
-                    fields: (0, types_1.schemaToFields)(zod_1.z.object({
-                        id: zod_1.z.string().default(() => factory()),
-                        label: zod_1.z.string().default("untitled"),
-                    })),
-                },
-            ],
-        });
-        const first = legacy();
-        const rebuilt = legacy();
-        const stored = JSON.parse(JSON.stringify(first));
-        expect((0, validate_1.validateImmutability)(first, rebuilt).valid).toBe(true);
-        expect((0, validate_1.validateImmutability)(stored, rebuilt).valid).toBe(true);
-        expect((0, validate_1.validateImmutability)(rebuilt, stored).valid).toBe(true);
-        expect(factory).not.toHaveBeenCalled();
-    });
-    it("compares default objects as data, including descriptions and array order", () => {
-        const contract = (defaultValue) => makeContract({
-            tools: [tool([{ ...mode, defaultValue }])],
-        });
-        const first = contract({ description: "data", values: ["a", "b"] });
-        expect((0, validate_1.validateImmutability)(first, contract({ values: ["a", "b"], description: "data" })).valid).toBe(true);
-        expect((0, validate_1.validateImmutability)(first, contract({ description: "changed", values: ["a", "b"] })).valid).toBe(false);
-        expect((0, validate_1.validateImmutability)(first, contract({ description: "data", values: ["b", "a"] })).valid).toBe(false);
-    });
-    it.each([
-        ["an enum value", tool([{ ...mode, enumValues: ["on"] }, note])],
-        ["optional", tool([mode, { ...note, optional: false }])],
-        ["a default value", tool([{ ...mode, defaultValue: "on" }, note])],
-        ["a type", tool([mode, { ...note, type: field_type_1.FieldType.number }])],
-    ])("rejects a changed %s", (_change, changed) => {
-        const result = (0, validate_1.validateImmutability)(frozen, makeContract({ tools: [changed], observables: frozen.observables }));
-        expect(result.valid).toBe(false);
-    });
-    it("rejects a changed observable value shape when both have one", () => {
-        const [state] = frozen.observables;
-        const incoming = makeContract({
-            tools: frozen.tools,
-            observables: [
-                {
-                    ...state,
-                    value: { type: field_type_1.FieldType.object, fields: [{ name: "on", type: field_type_1.FieldType.string }] },
-                },
-            ],
-        });
-        expect((0, validate_1.validateImmutability)(frozen, incoming).valid).toBe(false);
-    });
-    it("ignores a tool's policy, which isn't part of its shape", () => {
-        const tool = {
-            name: "run",
-            usageDescription: "Run.",
-            inputFields: [{ name: "id", type: field_type_1.FieldType.id }],
-            outputFields: [],
-        };
-        const frozen = makeContract({ tools: [{ ...tool, remoteAccessLevel: 40 }] });
-        const incoming = makeContract({
-            tools: [{ ...tool, remoteAccessLevel: 60, requiresWorkflowRun: true }],
-        });
-        expect((0, validate_1.validateImmutability)(frozen, incoming)).toEqual({ valid: true, errors: [] });
-    });
-    it("names what changed", () => {
-        const field = { name: "id", type: field_type_1.FieldType.id };
-        const tool = (name, inputFields = [field]) => ({
-            name,
-            usageDescription: name,
-            inputFields,
-            outputFields: [],
-        });
-        const frozen = makeContract({ tools: [tool("keep"), tool("change"), tool("drop")] });
-        const incoming = makeContract({
-            tools: [tool("keep"), tool("change", [{ ...field, type: field_type_1.FieldType.string }]), tool("new")],
-        });
-        expect((0, validate_1.contractShapeChanges)(frozen, incoming)).toEqual([
-            "tool change changed",
-            "tool drop was removed",
-            "tool new was added",
-        ]);
-        expect((0, validate_1.validateImmutability)(frozen, incoming).errors[0].message).toContain("(tool change changed; tool drop was removed; tool new was added)");
-    });
-    it.each([
-        "tables",
-        "tools",
-        "observables",
-        "events",
-    ])("does not hide added or changed duplicate %s behind the last member", (kind) => {
-        const member = { name: "duplicate", description: "Original" };
-        const before = makeContract({ [kind]: [member] });
-        const after = makeContract({ [kind]: [{ ...member, extra: true }, member] });
-        expect((0, validate_1.validateImmutability)(before, after).valid).toBe(false);
-        expect((0, validate_1.validateImmutability)(after, before).valid).toBe(false);
-        const changedDuplicate = makeContract({ [kind]: [{ ...member, extra: false }, member] });
-        expect((0, validate_1.validateImmutability)(after, changedDuplicate).valid).toBe(false);
-    });
-});
-describe("validateAlsoImplements", () => {
-    const contractStore = new Map();
-    const TASKS_CONTRACT_ID = (0, utils_1.newid)();
-    const FANCY_TASKS_CONTRACT_ID = (0, utils_1.newid)();
-    const NONEXISTENT_ID = (0, utils_1.newid)();
-    function getContract(id, ver) {
-        return contractStore.get((0, types_2.contractKey)(id, ver));
-    }
-    beforeEach(() => {
-        contractStore.clear();
-    });
-    it("passes when implementation is a superset of the target contract", () => {
-        const targetV1 = makeContract({
-            contractId: TASKS_CONTRACT_ID,
-            version: 1,
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "title", type: field_type_1.FieldType.string },
-                    ],
-                },
-            ],
-        });
-        contractStore.set((0, types_2.contractKey)(TASKS_CONTRACT_ID, 1), targetV1);
-        const impl = makeContract({
-            contractId: FANCY_TASKS_CONTRACT_ID,
-            version: 1,
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "title", type: field_type_1.FieldType.string },
-                        { name: "priority", type: field_type_1.FieldType.number, optional: true },
-                    ],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: TASKS_CONTRACT_ID, version: 1 }], getContract);
-        expect(result.valid).toBe(true);
-    });
-    it("validates all versions in a range", () => {
-        const v1 = makeContract({
-            contractId: TASKS_CONTRACT_ID,
-            version: 1,
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "title", type: field_type_1.FieldType.string },
-                    ],
-                },
-            ],
-        });
-        const v2 = makeContract({
-            contractId: TASKS_CONTRACT_ID,
-            version: 2,
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "title", type: field_type_1.FieldType.string },
-                        { name: "status", type: field_type_1.FieldType.string, optional: true },
-                    ],
-                },
-            ],
-        });
-        contractStore.set((0, types_2.contractKey)(TASKS_CONTRACT_ID, 1), v1);
-        contractStore.set((0, types_2.contractKey)(TASKS_CONTRACT_ID, 2), v2);
-        // Implementation satisfies both: has all fields from both versions.
-        // 'status' is optional so v1 consumers can still write valid rows.
-        const impl = makeContract({
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "title", type: field_type_1.FieldType.string },
-                        { name: "status", type: field_type_1.FieldType.string, optional: true },
-                    ],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: TASKS_CONTRACT_ID, version: { from: 1, to: 2 } }], getContract);
-        expect(result.valid).toBe(true);
-    });
-    it("fails when implementation is missing a field from one version in range", () => {
-        const v1 = makeContract({
-            contractId: TASKS_CONTRACT_ID,
-            version: 1,
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const v2 = makeContract({
-            contractId: TASKS_CONTRACT_ID,
-            version: 2,
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [
-                        { name: "taskId", type: field_type_1.FieldType.id },
-                        { name: "assignee", type: field_type_1.FieldType.string },
-                    ],
-                },
-            ],
-        });
-        contractStore.set((0, types_2.contractKey)(TASKS_CONTRACT_ID, 1), v1);
-        contractStore.set((0, types_2.contractKey)(TASKS_CONTRACT_ID, 2), v2);
-        // Implementation only satisfies v1 (missing 'assignee')
-        const impl = makeContract({
-            tables: [
-                {
-                    name: "Tasks",
-                    description: "d",
-                    primaryKeyName: "taskId",
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id }],
-                },
-            ],
-        });
-        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: TASKS_CONTRACT_ID, version: { from: 1, to: 2 } }], getContract);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toContain("v2");
-        expect(result.errors[0].message).toContain("assignee");
-    });
-    it("fails when a referenced contract does not exist", () => {
-        const impl = makeContract({ tables: [] });
-        const result = (0, validate_1.validateAlsoImplements)(impl, [{ contractId: NONEXISTENT_ID, version: 1 }], getContract);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toContain("not found");
-    });
-});