@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/context/user-context-identity.test.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const sql_data_source_1 = require("../data/orm/sql.data-source");
-const user_permissions_1 = require("../data/user-permissions");
-const users_1 = require("../data/users");
-const anchor_document_1 = require("../identity/anchor-document");
-const anchor_resolution_1 = require("../identity/anchor-resolution");
-const key_change_1 = require("../identity/key-change");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const user_context_1 = require("./user-context");
-const user_context_singleton_1 = require("./user-context-singleton");
-// Installs the UsersTable guard.
-require("../identity/user-row-change");
-class DBHarness {
-    _db = null;
-    get db() {
-        if (!this._db) {
-            this._db = new SQLiteDB(":memory:");
-            this._db.pragma("journal_mode = WAL");
-        }
-        return this._db;
-    }
-    async get(sql, params = []) {
-        return this.db.prepare(sql).get(params);
-    }
-    async all(sql, params = []) {
-        return this.db.prepare(sql).all(params);
-    }
-    async exec(sql, params = []) {
-        const result = this.db.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    async close() {
-        this._db?.close();
-        this._db = null;
-    }
-}
-describe("UserContext.syncUserAndGroupObjects and the profile row's key", () => {
-    const anchor = {
-        type: "https",
-        url: "https://example.com/.well-known/peers-identity.json",
-    };
-    // The process-wide user context can be installed once, so one context serves every case;
-    // each case starts by writing the profile row it needs (the owner's own row is unrestricted).
-    const db = new DBHarness();
-    const userId = (0, utils_1.newid)();
-    let userContext;
-    beforeAll(async () => {
-        const dataSourceFactory = (metaData, schema) => new sql_data_source_1.SQLDataSource(db, metaData, schema);
-        userContext = new user_context_1.UserContext(userId, dataSourceFactory, true);
-        await userContext.loadingPromise;
-        userContext.deviceId((0, utils_1.newid)());
-        (0, user_context_singleton_1.setUserContext)(userContext);
-    });
-    afterEach(() => {
-        (0, anchor_resolution_1.setAnchorFetcher)(undefined);
-    });
-    afterAll(async () => {
-        userContext.dispose();
-        await db.close();
-    });
-    function document(publicKey, authorizedBy) {
-        return {
-            outcome: "document",
-            document: {
-                version: 1,
-                userId,
-                keys: [{ publicKey, issuedAt: "2026-10-03T18:00:00.000Z", authorizedBy }],
-                anchors: [anchor],
-                updatedAt: "2026-10-03T18:00:00.000Z",
-            },
-        };
-    }
-    it("signs a fresh profile with the device key", async () => {
-        const keys = (0, keys_1.newKeys)();
-        await userContext.syncUserAndGroupObjects(userId, keys);
-        const me = await (0, users_1.Users)(userContext.userDataContext).get(userId);
-        expect(me?.publicKey).toBe(keys.publicKey);
-        expect(() => (0, user_permissions_1.verifyUserSignature)(me)).not.toThrow();
-    });
-    it("re-signs a profile the anchors say this device's key succeeded", async () => {
-        // A rotation stored the new secret and then stopped before re-signing the row, or an
-        // operator replaced the secret in credentials.json after publishing the key. The anchors
-        // list the device key with the old key's co-signature, so the row follows the device.
-        const k1 = (0, keys_1.newKeys)();
-        const k2 = (0, keys_1.newKeys)();
-        await (0, users_1.Users)(userContext.userDataContext).save((0, user_permissions_1.signUserObject)({
-            userId,
-            name: "Alice",
-            publicKey: k1.publicKey,
-            publicBoxKey: k1.publicBoxKey,
-            anchors: [anchor],
-        }, k1.secretKey));
-        const succession = (0, anchor_document_1.signSuccession)({
-            purpose: "peers-key-succession",
-            userId,
-            publicKey: k2.publicKey,
-            issuedAt: "2026-10-03T18:00:00.000Z",
-        }, k1.secretKey);
-        (0, anchor_resolution_1.setAnchorFetcher)(async () => document(k2.publicKey, { publicKey: succession.publicKey, signature: succession.signature }));
-        await userContext.syncUserAndGroupObjects(userId, k2);
-        const me = await (0, users_1.Users)(userContext.userDataContext).get(userId);
-        expect(me?.publicKey).toBe(k2.publicKey);
-        expect(me?.publicBoxKey).toBe(k2.publicBoxKey);
-        expect(me?.name).toBe("Alice");
-        expect(me?.anchors).toEqual([anchor]);
-        expect(() => (0, user_permissions_1.verifyUserSignature)(me)).not.toThrow();
-    });
-    it("does not put the device key back over a row the anchors still confirm", async () => {
-        // The row holds K2 and the anchors list only K2: this device's K1 was rotated away. The
-        // row must not be re-signed with K1, or the device would publish a retired key.
-        const k1 = (0, keys_1.newKeys)();
-        const k2 = (0, keys_1.newKeys)();
-        const row = (0, user_permissions_1.signUserObject)({
-            userId,
-            name: "Alice",
-            publicKey: k2.publicKey,
-            publicBoxKey: k2.publicBoxKey,
-            anchors: [anchor],
-        }, k2.secretKey);
-        await (0, users_1.Users)(userContext.userDataContext).save(row);
-        (0, anchor_resolution_1.setAnchorFetcher)(async () => document(k2.publicKey));
-        await userContext.syncUserAndGroupObjects(userId, k1);
-        const me = await (0, users_1.Users)(userContext.userDataContext).get(userId);
-        expect(me?.publicKey).toBe(k2.publicKey);
-        expect(me?.signature).toBe(row.signature);
-    });
-    it("leaves the row alone while the anchors have not answered", async () => {
-        const k1 = (0, keys_1.newKeys)();
-        const k2 = (0, keys_1.newKeys)();
-        const row = (0, user_permissions_1.signUserObject)({
-            userId,
-            name: "Alice",
-            publicKey: k1.publicKey,
-            publicBoxKey: k1.publicBoxKey,
-            anchors: [anchor],
-        }, k1.secretKey);
-        await (0, users_1.Users)(userContext.userDataContext).save(row);
-        (0, anchor_resolution_1.setAnchorFetcher)(async () => ({ outcome: "abstain" }));
-        await userContext.syncUserAndGroupObjects(userId, k2);
-        const me = await (0, users_1.Users)(userContext.userDataContext).get(userId);
-        expect(me?.publicKey).toBe(k1.publicKey);
-        expect(me?.signature).toBe(row.signature);
-    });
-    describe("the rotated-away notice", () => {
-        const noticeFor = (oldKey, newKey) => ({
-            userId,
-            oldPublicKey: oldKey,
-            newPublicKey: newKey,
-            detectedAt: "2026-10-03T18:00:00.000Z",
-        });
-        afterEach(async () => {
-            await key_change_1.identityRotatedAwayVar.loadingPromise;
-            (0, key_change_1.identityRotatedAwayVar)(null);
-        });
-        it("is cleared once this device holds the key the anchors confirmed", async () => {
-            // The device was told its K1 was rotated away, then paired again onto the same
-            // database and now holds K2. The banner must not outlive the problem.
-            const k1 = (0, keys_1.newKeys)();
-            const k2 = (0, keys_1.newKeys)();
-            await (0, users_1.Users)(userContext.userDataContext).save((0, user_permissions_1.signUserObject)({
-                userId,
-                name: "Alice",
-                publicKey: k2.publicKey,
-                publicBoxKey: k2.publicBoxKey,
-                anchors: [anchor],
-            }, k2.secretKey));
-            await key_change_1.identityRotatedAwayVar.loadingPromise;
-            (0, key_change_1.identityRotatedAwayVar)(noticeFor(k1.publicKey, k2.publicKey));
-            await userContext.syncUserAndGroupObjects(userId, k2);
-            expect((0, key_change_1.identityRotatedAwayVar)()).toBeNull();
-        });
-        it("is cleared when the anchors confirm the key this device now holds", async () => {
-            // Paired again after a further rotation: the notice names K2, the device holds K3, and
-            // the row on disk is still K1 until the anchors answer.
-            const k1 = (0, keys_1.newKeys)();
-            const k2 = (0, keys_1.newKeys)();
-            const k3 = (0, keys_1.newKeys)();
-            await (0, users_1.Users)(userContext.userDataContext).save((0, user_permissions_1.signUserObject)({
-                userId,
-                name: "Alice",
-                publicKey: k1.publicKey,
-                publicBoxKey: k1.publicBoxKey,
-                anchors: [anchor],
-            }, k1.secretKey));
-            const succession = (0, anchor_document_1.signSuccession)({
-                purpose: "peers-key-succession",
-                userId,
-                publicKey: k3.publicKey,
-                issuedAt: "2026-10-03T18:00:00.000Z",
-            }, k1.secretKey);
-            (0, anchor_resolution_1.setAnchorFetcher)(async () => document(k3.publicKey, {
-                publicKey: succession.publicKey,
-                signature: succession.signature,
-            }));
-            await key_change_1.identityRotatedAwayVar.loadingPromise;
-            (0, key_change_1.identityRotatedAwayVar)(noticeFor(k1.publicKey, k2.publicKey));
-            await userContext.syncUserAndGroupObjects(userId, k3);
-            expect((0, key_change_1.identityRotatedAwayVar)()).toBeNull();
-        });
-        it("stays on a device that still holds the retired key", async () => {
-            const k1 = (0, keys_1.newKeys)();
-            const k2 = (0, keys_1.newKeys)();
-            await (0, users_1.Users)(userContext.userDataContext).save((0, user_permissions_1.signUserObject)({
-                userId,
-                name: "Alice",
-                publicKey: k1.publicKey,
-                publicBoxKey: k1.publicBoxKey,
-                anchors: [anchor],
-            }, k1.secretKey));
-            await key_change_1.identityRotatedAwayVar.loadingPromise;
-            const notice = noticeFor(k1.publicKey, k2.publicKey);
-            (0, key_change_1.identityRotatedAwayVar)(notice);
-            await userContext.syncUserAndGroupObjects(userId, k1);
-            expect((0, key_change_1.identityRotatedAwayVar)()).toEqual(notice);
-        });
-    });
-});

package/dist/contracts/__tests__/action-dispatch.test.d.ts

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

package/dist/contracts/__tests__/action-dispatch.test.js

@@ -1,319 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_member_roles_1 = require("../../data/group-member-roles");
-const utils_1 = require("../../utils");
-/** Voice Hub's contract, whose `voice-hub-run-action` declares preserve. */
-const VOICE_HUB_CONTRACT_ID = "00mskqamhdq1327mqehy58pps";
-/** The contract whose tools a test's entry tool dispatches to. */
-const TARGETS = (0, utils_1.newid)();
-const contract_provider_router_1 = require("../contract-provider-router");
-const contract_proxy_1 = require("../contract-proxy");
-const contract_transport_1 = require("../contract-transport");
-const target_dispatch_1 = require("./target-dispatch");
-function groupContext() {
-    const userId = (0, utils_1.newid)();
-    const groupId = (0, utils_1.newid)();
-    const founderUserId = (0, utils_1.newid)();
-    let role = group_member_roles_1.GroupMemberRole.Writer;
-    const dataContext = {
-        dataContextId: groupId,
-        groupId,
-        tableContainer: {
-            getTable: (meta) => {
-                if (meta.name === "Groups")
-                    return { get: async () => ({ groupId, founderUserId }) };
-                if (meta.name === "GroupMembers")
-                    return { findOne: async () => ({ userId, role }) };
-                throw new Error(`Unexpected table ${meta.name}`);
-            },
-        },
-    };
-    Object.assign(dataContext, {
-        userContext: {
-            userId,
-            loadingPromise: Promise.resolve(),
-            userDataContext: dataContext,
-            getDataContext: () => dataContext,
-        },
-    });
-    return {
-        dataContext,
-        userId,
-        groupId,
-        setRole: (value) => {
-            role = value;
-        },
-    };
-}
-function tool(name, level, toolFn) {
-    return {
-        tool: {
-            name,
-            toolId: (0, utils_1.newid)(),
-            usageDescription: name,
-            accessLevel: level,
-            code: "",
-            inputSchema: { type: "simple", fields: [] },
-            outputSchema: { type: "simple", fields: [] },
-        },
-        toolFn,
-    };
-}
-/** A tool that runs the target `name` through `context.dispatchTool`. */
-function hop(name, level, target) {
-    return tool(name, level, (_, context) => context.dispatchTool?.({ contractId: TARGETS, version: 1, toolName: target }, {}));
-}
-describe("strict delegated tool dispatch in a group", () => {
-    it("leaves ordinary host-tool admission outside the action scope on its existing user-role path", async () => {
-        const group = groupContext();
-        const contractId = (0, utils_1.newid)();
-        const effect = jest.fn(async () => "written");
-        const dispatch = (0, contract_proxy_1.createContractProvider)({
-            contractId,
-            version: 1,
-            tools: { write: tool("write", 40, effect) },
-        });
-        const call = {
-            contractId,
-            version: 1,
-            member: "tool",
-            name: "write",
-            operation: "run",
-            args: [{}],
-        };
-        const context = {
-            callerUserId: group.userId,
-            dataContext: group.dataContext,
-            authority: {
-                userId: group.userId,
-                userAccessLevel: 40,
-                assistantAccessLevel: 20,
-                callingToolAccessLevel: 20,
-                strictActionScope: false,
-            },
-        };
-        await expect(dispatch(call, context)).resolves.toBe("written");
-        group.setRole(group_member_roles_1.GroupMemberRole.Reader);
-        await expect(dispatch(call, context)).rejects.toThrow("Reader (20)");
-        expect(effect).toHaveBeenCalledTimes(1);
-    });
-    function setup(authority) {
-        const group = groupContext();
-        const writes = jest.fn(async () => ({ result: "milk" }));
-        const targets = {
-            list: tool("list", 20, async () => ({ result: [] })),
-            add: tool("add", 40, writes),
-            reader: hop("reader", 20, "add"),
-            writer: hop("writer", 40, "history"),
-            "writer-self": hop("writer-self", 40, "self"),
-            history: tool("history", 80, writes),
-            self: tool("self", undefined, writes),
-        };
-        const resolution = {
-            contractId: VOICE_HUB_CONTRACT_ID,
-            version: 1,
-            forwardCallContext: true,
-            tools: {
-                invoke: tool("invoke", 20, (input, context) => context.dispatchTool?.({ contractId: TARGETS, version: 1, toolName: input.tool }, input.args ?? {})),
-            },
-        };
-        Object.assign(resolution.tools.invoke.tool, { authorityPropagation: "preserve" });
-        const context = {
-            callerUserId: group.userId,
-            localUserId: group.userId,
-            dataContext: group.dataContext,
-            authority,
-        };
-        const [client, server] = (0, contract_transport_1.inProcessTransportPair)();
-        const session = (0, contract_proxy_1.createContractProviderSession)(resolution, server, {
-            context,
-            dispatchTool: (0, target_dispatch_1.targetDispatch)(TARGETS, targets),
-        });
-        const consumer = (0, contract_proxy_1.createContractConsumer)({
-            contractId: VOICE_HUB_CONTRACT_ID,
-            version: 1,
-            name: "Hub",
-            description: "",
-            tables: [],
-            observables: [],
-            events: [],
-            tools: [{ name: "invoke", usageDescription: "invoke", inputFields: [], outputFields: [] }],
-        }, client, { dataContextId: group.groupId });
-        return {
-            ...group,
-            writes,
-            targets,
-            context,
-            consumer,
-            dispose: () => {
-                consumer.dispose();
-                session.dispose();
-            },
-        };
-    }
-    it("allows direct Writer dispatch while a group Reader can only list, ignoring payload grants", async () => {
-        const p = setup();
-        try {
-            await expect(p.consumer.tools.invoke({ tool: "add", args: { name: "milk" } })).resolves.toEqual({ result: "milk" });
-            p.setRole(group_member_roles_1.GroupMemberRole.Reader);
-            await expect(p.consumer.tools.invoke({ tool: "list" })).resolves.toEqual({
-                result: [],
-            });
-            await expect(p.consumer.tools.invoke({
-                tool: "add",
-                args: {
-                    name: "milk",
-                    userId: p.userId,
-                    userAccessLevel: 100,
-                    assistantAccessLevel: 100,
-                    directUserInvocation: true,
-                    hostApprovedApprovalId: (0, utils_1.newid)(),
-                },
-            })).rejects.toThrow("Permission denied");
-            expect(p.writes).toHaveBeenCalledTimes(1);
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("caps Reader tools through invoke, and denies Owner and Self from Writer tools", async () => {
-        const p = setup();
-        try {
-            await expect(p.consumer.tools.invoke({ tool: "reader" })).rejects.toThrow("Permission denied");
-            await expect(p.consumer.tools.invoke({ tool: "writer" })).rejects.toThrow("Permission denied");
-            await expect(p.consumer.tools.invoke({ tool: "self" })).rejects.toThrow("Permission denied");
-            p.setRole(group_member_roles_1.GroupMemberRole.Owner);
-            await expect(p.consumer.tools.invoke({ tool: "writer" })).rejects.toThrow("Permission denied");
-            p.setRole(group_member_roles_1.GroupMemberRole.Founder);
-            await expect(p.consumer.tools.invoke({ tool: "writer-self" })).rejects.toThrow("Permission denied");
-            expect(p.writes).not.toHaveBeenCalled();
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("rechecks role and live metadata on every call", async () => {
-        const p = setup();
-        try {
-            p.setRole(group_member_roles_1.GroupMemberRole.Reader);
-            await expect(p.consumer.tools.invoke({ tool: "add" })).rejects.toThrow("Permission denied");
-            p.setRole(group_member_roles_1.GroupMemberRole.Writer);
-            p.targets.add.tool.accessLevel = 80;
-            await expect(p.consumer.tools.invoke({ tool: "add" })).rejects.toThrow("Permission denied");
-            await expect(p.consumer.tools.invoke({ tool: "invented" })).rejects.toThrow("does not provide tool 'invented'");
-            expect(p.writes).not.toHaveBeenCalled();
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("retains a delegated Reader frame from a trusted caller and fails missing identity closed", async () => {
-        const p = setup({ userAccessLevel: 40, assistantAccessLevel: 20, strictActionScope: true });
-        try {
-            await expect(p.consumer.tools.invoke({ tool: "add" })).rejects.toThrow("Permission denied");
-            delete p.context.callerUserId;
-            delete p.context.localUserId;
-            await expect(p.consumer.tools.invoke({ tool: "list", args: { callerUserId: p.userId } })).rejects.toThrow("missing caller identity");
-            expect(p.writes).not.toHaveBeenCalled();
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("refuses remote forwarding rather than dropping a strict ceiling", async () => {
-        const [client, server] = (0, contract_transport_1.inProcessTransportPair)();
-        const resolveEndpoint = jest.fn();
-        const router = (0, contract_provider_router_1.createContractProviderRouter)(server, {
-            context: {
-                authority: { userAccessLevel: 40, assistantAccessLevel: 20, strictActionScope: true },
-            },
-            authorizeCall: () => ({ context: {} }),
-            resolveEndpoint,
-        });
-        try {
-            await expect(client.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-                contractId: (0, utils_1.newid)(),
-                version: 1,
-                member: "tool",
-                name: "write",
-                operation: "run",
-                args: [],
-                targetDeviceId: (0, utils_1.newid)(),
-            })).rejects.toThrow("cannot target another device");
-            expect(resolveEndpoint).not.toHaveBeenCalled();
-        }
-        finally {
-            router.dispose();
-        }
-    });
-});
-describe("declared tool authority propagation", () => {
-    it.each([
-        [60, undefined, 20, true, 60, true],
-        [60, 20, 20, true, 40, false],
-        [60, undefined, 20, false, 40, false],
-        [0, undefined, undefined, true, 0, true],
-        [0, undefined, undefined, true, 20, false],
-        [20, undefined, 40, true, 20, false],
-    ])("generic host propagation U=%s A=%s entry=%s preserve=%s target=%s", async (userLevel, ceiling, entryLevel, preserve, targetLevel, allowed) => {
-        const group = groupContext();
-        group.setRole(userLevel);
-        const effect = jest.fn(() => "executed");
-        const router = hop("route", entryLevel, "target");
-        if (preserve)
-            Object.assign(router.tool, { authorityPropagation: "preserve" });
-        const contractId = (0, utils_1.newid)();
-        const dispatch = (0, contract_proxy_1.createContractProvider)({ contractId, version: 1, tools: { route: router }, forwardCallContext: true }, { dispatchTool: (0, target_dispatch_1.targetDispatch)(TARGETS, { target: tool("target", targetLevel, effect) }) });
-        const result = dispatch({ contractId, version: 1, member: "tool", name: "route", operation: "run", args: [{}] }, {
-            callerUserId: group.userId,
-            dataContext: group.dataContext,
-            authority: { userAccessLevel: userLevel, assistantAccessLevel: ceiling },
-        });
-        if (allowed)
-            await expect(result).resolves.toBe("executed");
-        else
-            await expect(result).rejects.toThrow(/Permission denied/);
-        expect(effect).toHaveBeenCalledTimes(allowed ? 1 : 0);
-    });
-    it("honors declared preserve on Voice Hub's voice-hub-run-action without raising an inherited ceiling", async () => {
-        const contractId = VOICE_HUB_CONTRACT_ID;
-        const version = 4;
-        const name = "voice-hub-run-action";
-        const group = groupContext();
-        const effect = jest.fn(() => ({ writerTargetExecuted: true }));
-        const resolution = {
-            contractId,
-            version,
-            forwardCallContext: true,
-            tools: { [name]: hop(name, 20, "write") },
-        };
-        const dispatchTool = (0, target_dispatch_1.targetDispatch)(TARGETS, { write: tool("write", 40, effect) });
-        const call = {
-            contractId,
-            version,
-            member: "tool",
-            name,
-            operation: "run",
-            args: [{}],
-        };
-        const context = { callerUserId: group.userId, dataContext: group.dataContext };
-        // An ordinary Reader wrapper caps a direct Writer at Reader inside the action scope.
-        const capped = (0, contract_proxy_1.createContractProvider)(resolution, { dispatchTool });
-        await expect(capped(call, context)).rejects.toThrow("Permission denied: strict delegation");
-        expect(effect).not.toHaveBeenCalled();
-        // The same wrapper declared preserve passes the Writer through to a Writer target.
-        Object.assign(resolution.tools[name].tool, { authorityPropagation: "preserve" });
-        const preserving = (0, contract_proxy_1.createContractProvider)(resolution, { dispatchTool });
-        await expect(preserving(call, context)).resolves.toEqual({ writerTargetExecuted: true });
-        // An inherited Reader frame from an upstream ordinary tool is never raised.
-        await expect(preserving(call, {
-            ...context,
-            authority: {
-                userAccessLevel: 40,
-                assistantAccessLevel: 20,
-                strictActionScope: true,
-            },
-        })).rejects.toThrow("Permission denied: strict delegation");
-        expect(effect).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/contracts/__tests__/also-implements.test.d.ts

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

package/dist/contracts/__tests__/also-implements.test.js

@@ -1,110 +0,0 @@
-"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 validate_1 = require("../validate");
-const contractId = (0, utils_1.newid)();
-/** Notes vN with one `add` tool taking `inputs`, returning `outputs`, and one `Notes` table. */
-function notes(version, { inputs = [], outputs = [], rows = [], } = {}, devTag) {
-    return {
-        contractId,
-        version,
-        ...(devTag ? { devTag } : {}),
-        name: "Notes",
-        description: "",
-        tables: [
-            {
-                name: "Notes",
-                description: "",
-                primaryKeyName: "noteId",
-                fields: [{ name: "noteId", type: field_type_1.FieldType.id }, ...rows],
-            },
-        ],
-        tools: [{ name: "add", usageDescription: "Add.", inputFields: inputs, outputFields: outputs }],
-        observables: [],
-        events: [],
-    };
-}
-const field = (name, optional = false) => ({
-    name,
-    type: field_type_1.FieldType.string,
-    ...(optional ? { optional } : {}),
-});
-describe("alsoImplements compatibility, by what callers send and receive", () => {
-    const satisfies = (implementation, target) => (0, validate_1.validateProviderSatisfiesContract)(implementation, target).valid;
-    it("lets an input become optional, but not an optional one required", () => {
-        expect(satisfies(notes(2, { inputs: [field("title", true)] }), notes(1, { inputs: [field("title")] }))).toBe(true);
-        expect(satisfies(notes(2, { inputs: [field("title")] }), notes(1, { inputs: [field("title", true)] }))).toBe(false);
-    });
-    it("keeps a required output required, and a table field's optionality as it was", () => {
-        expect(satisfies(notes(2, { outputs: [field("id", true)] }), notes(1, { outputs: [field("id")] }))).toBe(false);
-        expect(satisfies(notes(2, { outputs: [field("id")] }), notes(1, { outputs: [field("id", true)] }))).toBe(true);
-        expect(satisfies(notes(2, { rows: [field("title", true)] }), notes(1, { rows: [field("title")] }))).toBe(false);
-        expect(satisfies(notes(2, { rows: [field("title")] }), notes(1, { rows: [field("title", true)] }))).toBe(false);
-    });
-    it("keeps a required event payload field required, while allowing optional ones to become required", () => {
-        const event = (optional) => ({
-            ...notes(1),
-            events: [{ name: "added", description: "", payloadFields: [field("title", optional)] }],
-        });
-        expect(satisfies(event(true), event(false))).toBe(false);
-        expect(satisfies(event(false), event(true))).toBe(true);
-    });
-});
-describe("a carried alsoImplements definition", () => {
-    const providerId = (0, utils_1.newid)();
-    const v1 = notes(1, { inputs: [field("title")] });
-    const v2 = notes(2, { inputs: [field("title"), field("tag", true)] });
-    const alias = (definition = v1) => ({
-        definition: v2,
-        alsoImplements: [{ contractId, version: 1, definition }],
-    });
-    it("registers the target when the registry has none, and keeps one it already has", () => {
-        const cold = new registry_1.ContractRegistry();
-        expect(cold.registerBatch(providerId, [alias()]).valid).toBe(true);
-        expect(cold.getDefinition(contractId, 1)).toEqual(v1);
-        expect(cold.getProviderImplementation(contractId, 1, providerId)).toEqual({
-            contractId,
-            version: 2,
-        });
-        const warm = new registry_1.ContractRegistry();
-        const devV1 = { ...v1, devTag: "dev" };
-        warm.registerBatch((0, utils_1.newid)(), [{ definition: devV1 }]);
-        warm.registerBatch(providerId, [alias()]);
-        expect(warm.getDefinition(contractId, 1)).toEqual(devV1);
-    });
-    it("must match a frozen registered target, and be the version it declares", () => {
-        const registry = new registry_1.ContractRegistry();
-        registry.registerBatch((0, utils_1.newid)(), [{ definition: v1 }]);
-        const changed = notes(1, { inputs: [field("title"), field("body", true)] });
-        const refused = registry.registerBatch(providerId, [alias(changed)]);
-        expect(refused.valid).toBe(false);
-        expect(refused.errors[0].message).toContain("is frozen and cannot be modified");
-        expect(registry.getProviderPackageId(contractId, 2)).toBeUndefined();
-        const mislabeled = new registry_1.ContractRegistry().registerBatch(providerId, [
-            alias(notes(3, { inputs: [field("title")] })),
-        ]);
-        expect(mislabeled.errors[0].message).toContain("alsoImplements carries a definition that isn't");
-    });
-});
-test("legacy ranges retain explicitly provided handlers and alias the remaining versions", () => {
-    const registry = new registry_1.ContractRegistry();
-    const providerId = (0, utils_1.newid)();
-    expect(registry.register((0, utils_1.newid)(), notes(2)).valid).toBe(true);
-    expect(registry.registerBatch(providerId, [
-        { definition: notes(1) },
-        {
-            definition: notes(3),
-            alsoImplements: [{ contractId, version: { from: 1, to: 2 } }],
-        },
-    ]).valid).toBe(true);
-    expect(registry.getProviderImplementation(contractId, 1, providerId)).toEqual({
-        contractId,
-        version: 1,
-    });
-    expect(registry.getProviderImplementation(contractId, 2, providerId)).toEqual({
-        contractId,
-        version: 3,
-    });
-});

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

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