@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/contracts/__tests__/contract-transport.test.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const contract_proxy_1 = require("../contract-proxy");
-const contract_transport_1 = require("../contract-transport");
-describe("inProcessTransportPair", () => {
-    it("delivers a request to the peer handler and resolves with its return (ack)", async () => {
-        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
-        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, (x, y) => x + y);
-        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, 2, 3)).resolves.toBe(5);
-    });
-    it("awaits async handlers before resolving the emit", async () => {
-        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
-        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, async (value) => {
-            await new Promise((r) => setTimeout(r, 5));
-            return `handled:${value}`;
-        });
-        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, "x")).resolves.toBe("handled:x");
-    });
-    it("propagates a thrown handler error as a rejected emit", async () => {
-        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
-        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, () => {
-            throw new Error("boom");
-        });
-        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {})).rejects.toThrow("boom");
-    });
-    it("propagates a rejected async handler as a rejected emit", async () => {
-        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
-        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, async () => {
-            throw new Error("async-boom");
-        });
-        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {})).rejects.toThrow("async-boom");
-    });
-    it("resolves undefined when the peer has no handler for the channel", async () => {
-        const [a] = (0, contract_transport_1.inProcessTransportPair)();
-        await expect(a.emit("no-such-channel", 1)).resolves.toBeUndefined();
-    });
-    it("stops delivering after unsubscribe", async () => {
-        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
-        const handler = jest.fn(() => "ok");
-        const unsubscribe = b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, handler);
-        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, 1)).resolves.toBe("ok");
-        expect(handler).toHaveBeenCalledTimes(1);
-        unsubscribe();
-        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, 1)).resolves.toBeUndefined();
-        expect(handler).toHaveBeenCalledTimes(1);
-    });
-    it("is bidirectional: either end can emit and handle", async () => {
-        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
-        a.on("ping", (msg) => `a-got:${msg}`);
-        b.on("ping", (msg) => `b-got:${msg}`);
-        // a -> b uses b's handler; b -> a uses a's handler.
-        await expect(a.emit("ping", "hi")).resolves.toBe("b-got:hi");
-        await expect(b.emit("ping", "yo")).resolves.toBe("a-got:yo");
-    });
-    it("supports provider->consumer pushes on the notify channel (fire-and-forget)", async () => {
-        const [consumer, provider] = (0, contract_transport_1.inProcessTransportPair)();
-        const received = [];
-        consumer.on(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, (payload) => {
-            received.push(payload);
-        });
-        // The provider pushes and ignores the returned promise, exactly as a notification would.
-        void provider.emit(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, { event: "changed", id: "abc" });
-        // The ack is still available if awaited, but pushes typically drop it.
-        await expect(provider.emit(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, { event: "again" })).resolves.toBeUndefined();
-        expect(received).toEqual([{ event: "changed", id: "abc" }, { event: "again" }]);
-    });
-    it("rejects multiple request handlers instead of using last-result-wins", () => {
-        const [, provider] = (0, contract_transport_1.inProcessTransportPair)();
-        provider.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, () => "first");
-        expect(() => provider.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, () => "second")).toThrow(/one provider router/);
-    });
-});
-describe("connectionContractTransport", () => {
-    it("delegates emit to the underlying emitter", async () => {
-        const emit = jest.fn(async () => "result");
-        const emitter = { emit, on: jest.fn() };
-        const transport = (0, contract_transport_1.connectionContractTransport)(emitter);
-        await expect(transport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, { a: 1 })).resolves.toBe("result");
-        expect(emit).toHaveBeenCalledWith(contract_transport_1.CONTRACT_REQUEST_CHANNEL, { a: 1 });
-    });
-    it("removes only the requested handler from a shared channel dispatcher", async () => {
-        const listeners = new Map();
-        const on = jest.fn((channel, listener) => {
-            listeners.set(channel, listener);
-        });
-        const emitter = { emit: jest.fn(), on };
-        const transportA = (0, contract_transport_1.connectionContractTransport)(emitter);
-        const transportB = (0, contract_transport_1.connectionContractTransport)(emitter);
-        const handlerA = jest.fn();
-        const handlerB = jest.fn();
-        const unsubscribeA = transportA.on(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, handlerA);
-        transportB.on(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, handlerB);
-        expect(on).toHaveBeenCalledTimes(1);
-        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.("first");
-        expect(handlerA).toHaveBeenCalledWith("first");
-        expect(handlerB).toHaveBeenCalledWith("first");
-        unsubscribeA();
-        unsubscribeA();
-        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.("second");
-        expect(handlerA).toHaveBeenCalledTimes(1);
-        expect(handlerB).toHaveBeenLastCalledWith("second");
-    });
-    it("lets two consumers share notify traffic and dispose independently", async () => {
-        const listeners = new Map();
-        const emitter = {
-            emit: jest.fn(async () => undefined),
-            on: (channel, listener) => {
-                listeners.set(channel, listener);
-            },
-        };
-        const transport = (0, contract_transport_1.connectionContractTransport)(emitter);
-        const contract = {
-            contractId: (0, utils_1.newid)(),
-            version: 1,
-            devTag: "dev",
-            name: "Shared transport",
-            description: "Shared notify channel",
-            tables: [],
-            tools: [],
-            observables: [],
-            events: [
-                {
-                    name: "changed",
-                    description: "Changed",
-                    payloadFields: [{ name: "id", type: field_type_1.FieldType.id }],
-                },
-            ],
-        };
-        const consumerA = (0, contract_proxy_1.createContractConsumer)(contract, transport);
-        const consumerB = (0, contract_proxy_1.createContractConsumer)(contract, transport);
-        const receivedA = [];
-        const receivedB = [];
-        consumerA.events.changed.subscribe((value) => receivedA.push(value));
-        consumerB.events.changed.subscribe((value) => receivedB.push(value));
-        const subscribeCalls = emitter.emit.mock.calls
-            .filter(([channel, call]) => channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL && call.operation === "subscribe")
-            .map(([, call]) => call);
-        const consumerASubscriptionId = subscribeCalls[0].subscriptionId;
-        const consumerBSubscriptionId = subscribeCalls[1].subscriptionId;
-        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.({
-            subscriptionId: consumerASubscriptionId,
-            value: "for-a",
-        });
-        expect(receivedA).toEqual(["for-a"]);
-        expect(receivedB).toEqual([]);
-        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.({
-            subscriptionId: consumerBSubscriptionId,
-            value: "before",
-        });
-        expect(receivedA).toEqual(["for-a"]);
-        expect(receivedB).toEqual(["before"]);
-        consumerA.dispose();
-        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.({
-            subscriptionId: consumerBSubscriptionId,
-            value: "after",
-        });
-        expect(receivedA).toEqual(["for-a"]);
-        expect(receivedB).toEqual(["before", "after"]);
-        consumerB.dispose();
-    });
-});

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

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

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

@@ -1,145 +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 extract_1 = require("../extract");
-// Wire in the real schemaToFields before tests run so we don't trigger the
-// lazy require (which would pull in the full DI chain in some environments).
-beforeAll(() => {
-    (0, extract_1.setSchemaToFieldsFn)(types_1.schemaToFields);
-});
-describe("extractTableShape", () => {
-    it("extracts shape from a Zod schema via schemaToFields", () => {
-        const schema = zod_1.z.object({
-            taskId: zod_1.z.string().describe("Primary key"),
-            title: zod_1.z.string().describe("Task title"),
-            done: zod_1.z.boolean().optional().describe("Completion flag"),
-        });
-        const def = {
-            metaData: {
-                name: "Tasks",
-                description: "Task tracking table",
-                primaryKeyName: "taskId",
-                fields: [],
-            },
-            schema,
-        };
-        const shape = (0, extract_1.extractTableShape)(def);
-        expect(shape.name).toBe("Tasks");
-        expect(shape.description).toBe("Task tracking table");
-        expect(shape.primaryKeyName).toBe("taskId");
-        expect(shape.fields).toHaveLength(3);
-        const taskIdField = shape.fields.find((f) => f.name === "taskId");
-        expect(taskIdField?.type).toBe(field_type_1.FieldType.string);
-        const titleField = shape.fields.find((f) => f.name === "title");
-        expect(titleField?.type).toBe(field_type_1.FieldType.string);
-        const doneField = shape.fields.find((f) => f.name === "done");
-        expect(doneField?.type).toBe(field_type_1.FieldType.boolean);
-        expect(doneField?.optional).toBe(true);
-    });
-    it("falls back to metaData.fields when no schema is provided", () => {
-        const def = {
-            metaData: {
-                name: "Legacy",
-                description: "A legacy table",
-                primaryKeyName: "legacyId",
-                fields: [
-                    { name: "legacyId", type: field_type_1.FieldType.id, description: "Primary key" },
-                    { name: "label", type: field_type_1.FieldType.string, description: "Label" },
-                ],
-            },
-        };
-        const shape = (0, extract_1.extractTableShape)(def);
-        expect(shape.name).toBe("Legacy");
-        expect(shape.fields).toHaveLength(2);
-        expect(shape.fields[0].name).toBe("legacyId");
-        expect(shape.fields[1].name).toBe("label");
-    });
-    it("does not mutate the original metaData.fields array", () => {
-        const originalFields = [{ name: "id", type: field_type_1.FieldType.id, description: "PK" }];
-        const def = {
-            metaData: {
-                name: "Test",
-                description: "Test",
-                primaryKeyName: "id",
-                fields: originalFields,
-            },
-        };
-        const shape = (0, extract_1.extractTableShape)(def);
-        shape.fields.push({ name: "extra", type: field_type_1.FieldType.string });
-        expect(originalFields).toHaveLength(1);
-    });
-    it("handles arrays and complex Zod types", () => {
-        const schema = zod_1.z.object({
-            recordId: zod_1.z.string().describe("PK"),
-            tags: zod_1.z.string().array().describe("Tag list"),
-            metadata: zod_1.z.object({}).optional().describe("Arbitrary metadata"),
-        });
-        const def = {
-            metaData: {
-                name: "Records",
-                description: "Records with arrays",
-                primaryKeyName: "recordId",
-                fields: [],
-            },
-            schema,
-        };
-        const shape = (0, extract_1.extractTableShape)(def);
-        const tagsField = shape.fields.find((f) => f.name === "tags");
-        expect(tagsField?.type).toBe(field_type_1.FieldType.string);
-        expect(tagsField?.isArray).toBe(true);
-        const metadataField = shape.fields.find((f) => f.name === "metadata");
-        expect(metadataField?.type).toBe(field_type_1.FieldType.object);
-        expect(metadataField?.optional).toBe(true);
-    });
-});
-describe("extractToolShape", () => {
-    it("extracts name and usageDescription from the tool", () => {
-        const inst = {
-            tool: {
-                name: "create-task",
-                usageDescription: "Creates a new task",
-                inputSchema: { fields: [] },
-                outputSchema: { fields: [] },
-            },
-        };
-        const shape = (0, extract_1.extractToolShape)(inst);
-        expect(shape.name).toBe("create-task");
-        expect(shape.usageDescription).toBe("Creates a new task");
-    });
-    it("extracts input and output fields from IOSchema", () => {
-        const inst = {
-            tool: {
-                name: "create-task",
-                usageDescription: "Creates a task",
-                inputSchema: {
-                    fields: [
-                        { name: "title", type: field_type_1.FieldType.string, description: "Task title" },
-                        { name: "priority", type: field_type_1.FieldType.number, description: "Priority level" },
-                    ],
-                },
-                outputSchema: {
-                    fields: [{ name: "taskId", type: field_type_1.FieldType.id, description: "Created task ID" }],
-                },
-            },
-        };
-        const shape = (0, extract_1.extractToolShape)(inst);
-        expect(shape.inputFields).toHaveLength(2);
-        expect(shape.inputFields[0].name).toBe("title");
-        expect(shape.inputFields[1].name).toBe("priority");
-        expect(shape.outputFields).toHaveLength(1);
-        expect(shape.outputFields[0].name).toBe("taskId");
-    });
-    it("returns empty field arrays when schemas are missing", () => {
-        const inst = {
-            tool: {
-                name: "no-io-tool",
-                usageDescription: "A tool with no I/O",
-            },
-        };
-        const shape = (0, extract_1.extractToolShape)(inst);
-        expect(shape.inputFields).toEqual([]);
-        expect(shape.outputFields).toEqual([]);
-    });
-});

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

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

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

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const frozen_contracts_1 = require("../frozen-contracts");
-function contract(contractId, version, fieldType = field_type_1.FieldType.string) {
-    return {
-        contractId,
-        version,
-        devTag: "dev",
-        name: `Contract ${version}`,
-        description: "",
-        tables: [],
-        tools: [
-            {
-                name: "run",
-                usageDescription: "Run.",
-                inputFields: [{ name: "value", type: fieldType }],
-                outputFields: [],
-            },
-        ],
-        observables: [],
-        events: [],
-    };
-}
-describe("frozen contracts", () => {
-    const id = (0, utils_1.newid)();
-    it("freezes what a release provides, without its dev tag, and keeps what it froze before", () => {
-        const first = (0, frozen_contracts_1.freezeContracts)(undefined, [contract(id, 1)], "1.0.0");
-        expect(first.added.map((frozen) => [frozen.version, frozen.frozenBy])).toEqual([[1, "1.0.0"]]);
-        expect(first.frozen.contracts[0]).not.toHaveProperty("devTag");
-        const second = (0, frozen_contracts_1.freezeContracts)(first.frozen, [contract(id, 1), contract(id, 2)], "1.1.0");
-        expect(second.frozen.contracts.map((frozen) => [frozen.version, frozen.frozenBy])).toEqual([
-            [1, "1.0.0"],
-            [2, "1.1.0"],
-        ]);
-        expect(second.added.map((frozen) => frozen.version)).toEqual([2]);
-    });
-    it("refuses a changed shape, allows new descriptions, and notes a version no longer provided", () => {
-        const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [contract(id, 1), contract(id, 2)], "1.0.0");
-        const described = { ...contract(id, 1), description: "Use v2 instead." };
-        described.tools = [{ ...described.tools[0], usageDescription: "Deprecated." }];
-        expect((0, frozen_contracts_1.checkFrozenContracts)(frozen, [described, contract(id, 2)])).toEqual({
-            changed: [],
-            notProvided: [],
-        });
-        const changed = (0, frozen_contracts_1.checkFrozenContracts)(frozen, [contract(id, 1, field_type_1.FieldType.number)]);
-        expect(changed.changed.map(({ changes }) => changes)).toEqual([["tool run changed"]]);
-        expect(changed.notProvided.map((frozen) => frozen.version)).toEqual([2]);
-        expect((0, frozen_contracts_1.describeFrozenContractChanges)(changed)).toEqual([
-            `Contract 1 (${id}@1), frozen by 1.0.0: tool run changed. Declare a new version instead.`,
-        ]);
-        const refused = (0, frozen_contracts_1.freezeContracts)(frozen, [contract(id, 1, field_type_1.FieldType.number)], "1.1.0");
-        expect(refused.added).toEqual([]);
-        expect(refused.frozen).toBe(frozen);
-    });
-    it("rejects duplicate provided identities instead of hiding a changed shape or freezing duplicates", () => {
-        const original = contract(id, 1);
-        const changed = contract(id, 1, field_type_1.FieldType.number);
-        const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [original], "1.0.0");
-        for (const provided of [
-            [changed, original],
-            [original, changed],
-            [original, original],
-        ]) {
-            expect(() => (0, frozen_contracts_1.checkFrozenContracts)(frozen, provided)).toThrow(`Duplicate provided contract ${id}@1`);
-            expect(() => (0, frozen_contracts_1.freezeContracts)(undefined, provided, "1.0.0")).toThrow("Duplicate provided contract");
-            expect(() => (0, frozen_contracts_1.freezeContracts)(frozen, provided, "1.1.0")).toThrow("Duplicate provided contract");
-        }
-    });
-});
-const sample = {
-    contractId: (0, utils_1.newid)(),
-    version: 1,
-    name: "All members",
-    description: "",
-    tables: [
-        {
-            name: "Rows",
-            description: "",
-            primaryKeyName: "id",
-            fields: [{ name: "id", type: field_type_1.FieldType.id }],
-        },
-    ],
-    tools: [
-        {
-            name: "run",
-            usageDescription: "",
-            inputFields: [{ name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] }],
-            outputFields: [
-                {
-                    name: "result",
-                    type: field_type_1.FieldType.object,
-                    fields: [{ name: "ok", type: field_type_1.FieldType.boolean }],
-                },
-            ],
-        },
-    ],
-    observables: [
-        {
-            name: "state",
-            description: "",
-            valueType: field_type_1.FieldType.string,
-            writable: false,
-            value: { type: field_type_1.FieldType.string, enumValues: ["on", "off"] },
-        },
-    ],
-    events: [
-        { name: "changed", description: "", payloadFields: [{ name: "id", type: field_type_1.FieldType.id }] },
-    ],
-};
-test.each([
-    "tables",
-    "tools",
-    "observables",
-    "events",
-])("detects added and removed %s", (kind) => {
-    const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [sample], "1.0.0");
-    const removed = { ...sample, [kind]: [] };
-    const added = {
-        ...sample,
-        [kind]: [...(sample[kind] ?? []), { ...(sample[kind] ?? [])[0], name: "another" }],
-    };
-    for (const changed of [removed, added]) {
-        expect((0, frozen_contracts_1.checkFrozenContracts)(frozen, [changed]).changed).toHaveLength(1);
-    }
-});
-test.each([
-    [
-        "primary key",
-        (value) => {
-            value.tables[0].primaryKeyName = "other";
-        },
-    ],
-    [
-        "table field type",
-        (value) => {
-            value.tables[0].fields[0].type = field_type_1.FieldType.string;
-        },
-    ],
-    [
-        "tool optionality",
-        (value) => {
-            value.tools[0].inputFields[0].optional = true;
-        },
-    ],
-    [
-        "enum values",
-        (value) => {
-            value.tools[0].inputFields[0].enumValues = ["on"];
-        },
-    ],
-    [
-        "nested field",
-        (value) => {
-            (value.tools[0].outputFields[0].fields ?? [])[0].type = field_type_1.FieldType.string;
-        },
-    ],
-    [
-        "observable type",
-        (value) => {
-            value.observables[0].valueType = field_type_1.FieldType.object;
-        },
-    ],
-    [
-        "observable writability",
-        (value) => {
-            value.observables[0].writable = true;
-        },
-    ],
-    [
-        "observable enum",
-        (value) => {
-            value.observables[0].value = { type: field_type_1.FieldType.string, enumValues: ["on"] };
-        },
-    ],
-    [
-        "event field",
-        (value) => {
-            (value.events ?? [])[0].payloadFields[0].isArray = true;
-        },
-    ],
-])("detects changed %s", (_label, mutate) => {
-    const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [sample], "1.0.0");
-    const changed = structuredClone(sample);
-    mutate(changed);
-    expect((0, frozen_contracts_1.checkFrozenContracts)(frozen, [changed]).changed).toHaveLength(1);
-});
-test("does not freeze without a package version", () => {
-    expect(() => (0, frozen_contracts_1.freezeContracts)(undefined, [sample], "")).toThrow("no version");
-});

package/dist/contracts/__tests__/generic-tool-dispatch.test.d.ts

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

package/dist/contracts/__tests__/generic-tool-dispatch.test.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../../index");
-const target_dispatch_1 = require("./target-dispatch");
-test.each([
-    true,
-    false,
-])("host preserve admission is None and forwards context (explicit forwarding: %s)", async (forwardCallContext) => {
-    const userId = (0, index_1.newid)();
-    const groupId = (0, index_1.newid)();
-    const contractId = (0, index_1.newid)();
-    let role = index_1.GroupMemberRole.None;
-    const dc = {
-        dataContextId: groupId,
-        groupId,
-        tableContainer: {
-            getTable: (meta) => meta.name === "Groups"
-                ? { get: async () => ({ founderUserId: (0, index_1.newid)() }) }
-                : { findOne: async () => ({ role }) },
-        },
-    };
-    Object.assign(dc, {
-        userContext: {
-            userId,
-            loadingPromise: Promise.resolve(),
-            userDataContext: dc,
-            getDataContext: () => dc,
-        },
-    });
-    const targetsId = (0, index_1.newid)();
-    const route = {
-        tool: { toolId: (0, index_1.newid)(), name: "route", authorityPropagation: "preserve" },
-        toolFn: (name, ctx) => ctx.dispatchTool?.({ contractId: targetsId, version: 1, toolName: name }, {}),
-    };
-    const ordinary = {
-        tool: { toolId: (0, index_1.newid)(), name: "ordinary" },
-        toolFn: () => "ordinary",
-    };
-    const targets = Object.fromEntries([0, 20].map((level) => [
-        String(level),
-        {
-            tool: { toolId: (0, index_1.newid)(), name: String(level), accessLevel: level },
-            toolFn: () => "executed",
-        },
-    ]));
-    const provider = (0, index_1.createContractProvider)({ contractId, version: 1, forwardCallContext, tools: { route, ordinary } }, { dispatchTool: (0, target_dispatch_1.targetDispatch)(targetsId, targets) });
-    const call = (name, target = "0") => provider({
-        contractId,
-        version: 1,
-        member: "tool",
-        name,
-        operation: "run",
-        args: [target],
-        dataContextId: groupId,
-    }, { callerUserId: userId, dataContext: dc });
-    role = index_1.GroupMemberRole.None;
-    await expect(call("route")).resolves.toBe("executed");
-    await expect(call("route", "20")).rejects.toThrow(/Permission denied/);
-    await expect(call("ordinary")).rejects.toThrow(/Permission denied/);
-    role = index_1.GroupMemberRole.Admin;
-    await expect(call("route", "20")).resolves.toBe("executed");
-    // The same wrapper without a preserve declaration is an ordinary unclassified (Self) tool.
-    route.tool.authorityPropagation = undefined;
-    await expect(call("route", "20")).rejects.toThrow(/Permission denied/);
-});
-test("host tool schema retains omitted admission for request-based defaults", () => {
-    const tool = index_1.toolSchema.parse({
-        toolId: (0, index_1.newid)(),
-        name: "route",
-        usageDescription: "route",
-        inputSchema: { type: "simple" },
-        outputSchema: { type: "simple" },
-        authorityPropagation: "preserve",
-    });
-    expect(tool.accessLevel).toBeUndefined();
-});
-test("generic dispatch binds a capped strict frame and rejects cross-context and remote targets", async () => {
-    const userId = (0, index_1.newid)();
-    const groupId = (0, index_1.newid)();
-    const contractId = (0, index_1.newid)();
-    const dc = {
-        dataContextId: groupId,
-        groupId,
-        tableContainer: {
-            getTable: (meta) => meta.name === "Groups"
-                ? { get: async () => ({ founderUserId: (0, index_1.newid)() }) }
-                : { findOne: async () => ({ role: index_1.GroupMemberRole.Admin }) },
-        },
-    };
-    Object.assign(dc, {
-        userContext: {
-            userId,
-            loadingPromise: Promise.resolve(),
-            userDataContext: dc,
-            getDataContext: () => dc,
-        },
-    });
-    const selected = {
-        contractId: (0, index_1.newid)(),
-        version: 1,
-        toolName: "write",
-        providerPackageId: (0, index_1.newid)(),
-    };
-    const bridge = jest.fn(async (_ref, _args, context) => {
-        expect(context.authority).toMatchObject({
-            userId,
-            assistantAccessLevel: 20,
-            strictActionScope: true,
-        });
-        return "routed";
-    });
-    const router = {
-        tool: { name: "route", toolId: (0, index_1.newid)(), accessLevel: 20 },
-        toolFn: (args, ctx) => ctx.dispatchTool(args, {}),
-    };
-    const dispatch = (0, index_1.createContractProvider)({ contractId, version: 1, forwardCallContext: true, tools: { route: router } }, { dispatchTool: bridge });
-    const call = (ref) => dispatch({
-        contractId,
-        version: 1,
-        member: "tool",
-        name: "route",
-        operation: "run",
-        args: [ref],
-        dataContextId: groupId,
-    }, { callerUserId: userId, dataContext: dc });
-    await expect(call(selected)).resolves.toBe("routed");
-    await expect(call({ ...selected, dataContextId: (0, index_1.newid)() })).rejects.toThrow("Cross-context");
-    await expect(call({ ...selected, targetDeviceId: (0, index_1.newid)() })).rejects.toThrow("cannot target another device");
-    expect(bridge).toHaveBeenCalledTimes(1);
-});

package/dist/contracts/__tests__/host-contract-client.test.d.ts

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