@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/user-permissions.test.js

@@ -1,305 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const user_permissions_1 = require("./user-permissions");
-// Test the user permissions logic directly without ORM dependencies
-describe("User Permissions Logic", () => {
-    let testUser;
-    let userKeys;
-    let otherUserKeys;
-    beforeEach(() => {
-        userKeys = (0, keys_1.newKeys)();
-        otherUserKeys = (0, keys_1.newKeys)();
-        testUser = {
-            userId: "test-user-1",
-            name: "Test User",
-            publicKey: userKeys.publicKey,
-            publicBoxKey: userKeys.publicBoxKey,
-            signature: "",
-        };
-    });
-    describe("basic signature functionality", () => {
-        it("should add signature to user object", () => {
-            const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
-            expect(signedUser.signature).toBeTruthy();
-            expect(signedUser.signature).toContain(":");
-            expect(signedUser.userId).toBe(testUser.userId);
-            expect(signedUser.name).toBe(testUser.name);
-            expect(signedUser.publicKey).toBe(testUser.publicKey);
-        });
-        it("should verify valid signature", () => {
-            const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
-            const isValid = (0, keys_1.isObjectSignatureValid)(signedUser);
-            expect(isValid).toBe(true);
-        });
-        it("should reject invalid signature after modification", () => {
-            const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
-            // Modify the user after signing
-            signedUser.name = "Modified Name";
-            const isValid = (0, keys_1.isObjectSignatureValid)(signedUser);
-            expect(isValid).toBe(false);
-        });
-        it("should extract public key from signature", () => {
-            const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
-            const extractedPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedUser);
-            expect(extractedPublicKey).toBe(userKeys.publicKey);
-        });
-    });
-    describe("signUserObject helper", () => {
-        it("should sign user object correctly", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            expect(signedUser.signature).toBeTruthy();
-            expect((0, keys_1.isObjectSignatureValid)(signedUser)).toBe(true);
-            expect((0, keys_1.getPublicKeyFromObjectSignature)(signedUser)).toBe(userKeys.publicKey);
-        });
-    });
-    describe("verifyUserSignature", () => {
-        it("should verify valid signature for new user", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser)).not.toThrow();
-        });
-        it("should verify valid signature for existing user update", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                name: "Updated Name",
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).not.toThrow();
-        });
-        it("should reject signature that does not match user public key for new user", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser)).toThrow("User signature must be signed with their own public key");
-        });
-        it("should reject signature that does not match existing user public key", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                name: "Updated Name",
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow("User update must be signed by the user themselves");
-        });
-        it("should reject public key changes", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                publicKey: otherUserKeys.publicKey,
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow("Public key changes are not currently supported");
-        });
-        it("should allow missing signature when no existing record", () => {
-            const userWithoutSignature = { ...testUser };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(userWithoutSignature)).not.toThrow();
-        });
-    });
-    describe("verifyUserSignature - Group Context (With Signature)", () => {
-        it("should allow valid signature for new user in group context", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).not.toThrow();
-        });
-        it("should allow valid signature for existing user update in group context", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                name: "Updated Name",
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).not.toThrow();
-        });
-        it("should reject invalid signature in group context", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            // Tamper with the signature
-            signedUser.name = "Tampered Name";
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).toThrow();
-        });
-        it("should reject signature from wrong user for new user", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).toThrow();
-        });
-        it("should reject signature from wrong user for existing user update", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                name: "Updated Name",
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow();
-        });
-        it("should reject public key changes in group context", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                publicKey: otherUserKeys.publicKey, // Change public key
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow();
-        });
-        it("should allow changes with valid signature", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)({ ...testUser }, userKeys.secretKey);
-            const updatedUser = {
-                ...originalUser,
-                name: "Updated Name",
-                signature: "",
-            };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).not.toThrow();
-        });
-    });
-    describe("verifyUserSignature - Signature Requirements", () => {
-        it("should allow unsigned record when no existing record", () => {
-            const userWithoutSignature = { ...testUser };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(userWithoutSignature, undefined)).not.toThrow();
-        });
-        it("should accept valid signature when signature is provided", () => {
-            const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).not.toThrow();
-        });
-        it("should allow empty signature when no existing record", () => {
-            const userWithEmptySignature = { ...testUser, signature: "" };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(userWithEmptySignature, undefined)).not.toThrow();
-        });
-        it("should reject whitespace-only signature (treated as a bad signature, not a stub)", () => {
-            const userWithWhitespaceSignature = { ...testUser, signature: "   " };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(userWithWhitespaceSignature, undefined)).toThrow();
-        });
-    });
-    describe("verifyUserSignature - Unsigned stubs", () => {
-        it("should allow unsigned stub when no existing record", () => {
-            const stub = { ...testUser, signature: undefined };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(stub)).not.toThrow();
-        });
-        it("should allow unsigned stub to overwrite an existing unsigned stub", () => {
-            const existingStub = { ...testUser, signature: undefined };
-            const incomingStub = { ...testUser, name: "Updated Name", signature: undefined };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, existingStub)).not.toThrow();
-        });
-        it("should reject unsigned stub when a signed record already exists", () => {
-            const signedExisting = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const incomingStub = { ...testUser, signature: undefined };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, signedExisting)).toThrow("Cannot overwrite a signed user record with an unsigned one");
-        });
-        it("should reject unsigned stub with different keys when signed record exists", () => {
-            const signedExisting = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const incomingStub = {
-                ...testUser,
-                publicKey: otherUserKeys.publicKey,
-                signature: undefined,
-            };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, signedExisting)).toThrow("Cannot overwrite a signed user record with an unsigned one");
-        });
-        it("should allow a signed record to replace an unsigned stub", () => {
-            const existingStub = { ...testUser, signature: undefined };
-            const signedIncoming = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedIncoming, existingStub)).not.toThrow();
-        });
-    });
-    describe("verifyUserSignature - anchors are not part of the claim", () => {
-        // The anchor list on record is decided by the anchors, not by the row's author. A peer
-        // stores a confirmed row with the list on record, and a peer on an older release stores
-        // the row without the field at all. Both must still verify.
-        const anchorA = { type: "https", url: "https://a.example/peers-identity.json" };
-        const anchorB = { type: "https", url: "https://b.example/peers-identity.json" };
-        it("verifies a signed row after its anchor list is replaced or removed", () => {
-            const signed = (0, user_permissions_1.signUserObject)({ ...testUser, anchors: [anchorA] }, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)({ ...signed, anchors: [anchorB] })).not.toThrow();
-            const { anchors: _dropped, ...withoutAnchors } = signed;
-            expect(() => (0, user_permissions_1.verifyUserSignature)(withoutAnchors)).not.toThrow();
-        });
-        it("verifies a row signed without anchors after a list is added", () => {
-            const signed = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)({ ...signed, anchors: [anchorA] })).not.toThrow();
-        });
-        it("still rejects a change to any other field", () => {
-            const signed = (0, user_permissions_1.signUserObject)({ ...testUser, anchors: [anchorA] }, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)({ ...signed, name: "Someone else" })).toThrow();
-            expect(() => (0, user_permissions_1.verifyUserSignature)({ ...signed, publicBoxKey: otherUserKeys.publicBoxKey })).toThrow();
-        });
-        it("does not leave the anchors off the signed row", () => {
-            const signed = (0, user_permissions_1.signUserObject)({ ...testUser, anchors: [anchorA] }, userKeys.secretKey);
-            expect(signed.anchors).toEqual([anchorA]);
-        });
-    });
-    describe("edge cases and error handling", () => {
-        it("should handle undefined user gracefully", () => {
-            // @ts-expect-error - Testing edge case
-            expect(() => (0, user_permissions_1.verifyUserSignature)(undefined, undefined)).toThrow();
-        });
-        it("should handle malformed signature", () => {
-            const userWithBadSignature = { ...testUser, signature: "invalid-signature" };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(userWithBadSignature, undefined)).toThrow();
-        });
-        it("should handle missing public key in user object", () => {
-            const userWithoutPublicKey = { ...testUser, publicKey: "" };
-            const signedUser = (0, user_permissions_1.signUserObject)(userWithoutPublicKey, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).toThrow();
-        });
-        it("should handle existing user with missing public key", () => {
-            const originalUser = { ...testUser, publicKey: "" };
-            const updatedUser = { ...testUser, name: "Updated" };
-            const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow();
-        });
-        it("should handle various user values", () => {
-            const userWithValues = {
-                ...testUser,
-                name: "Complex Name",
-            };
-            const signedUser = (0, user_permissions_1.signUserObject)(userWithValues, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).not.toThrow();
-        });
-    });
-    describe("security scenarios", () => {
-        it("should prevent impersonation attacks", () => {
-            // Attacker tries to create a user record with victim's public key but signed with attacker's key
-            const victimUser = {
-                userId: "victim-user",
-                name: "Victim User",
-                publicKey: userKeys.publicKey, // Victim's public key
-                publicBoxKey: userKeys.publicBoxKey,
-                signature: "",
-            };
-            const maliciousSignedUser = (0, user_permissions_1.signUserObject)(victimUser, otherUserKeys.secretKey); // Signed with attacker's key
-            expect(() => (0, user_permissions_1.verifyUserSignature)(maliciousSignedUser, undefined)).toThrow();
-        });
-        it("should prevent profile takeover attacks", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            // Attacker tries to update the user's profile with their own signature
-            const maliciousUpdate = {
-                ...originalUser,
-                name: "Attacker Name",
-                signature: "",
-            };
-            const maliciousSignedUpdate = (0, user_permissions_1.signUserObject)(maliciousUpdate, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(maliciousSignedUpdate, originalUser)).toThrow();
-        });
-        it("should prevent public key rotation attacks", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            // Attacker tries to change the public key to their own
-            const keyRotationAttack = {
-                ...originalUser,
-                publicKey: otherUserKeys.publicKey, // Change to attacker's key
-                signature: "",
-            };
-            const signedAttack = (0, user_permissions_1.signUserObject)(keyRotationAttack, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedAttack, originalUser)).toThrow();
-        });
-        it("should allow legitimate name changes with proper signature", () => {
-            const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const legitimateUpdate = {
-                ...originalUser,
-                name: "New Legal Name",
-                signature: "",
-            };
-            const signedUpdate = (0, user_permissions_1.signUserObject)(legitimateUpdate, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdate, originalUser)).not.toThrow();
-        });
-    });
-});

package/dist/data/user-trust-levels.test.d.ts

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

package/dist/data/user-trust-levels.test.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const socket_type_1 = require("../device/socket.type");
-const utils_1 = require("../utils");
-const user_trust_levels_1 = require("./user-trust-levels");
-function makeDataContext(userId, trustRecord) {
-    const get = jest.fn().mockResolvedValue(trustRecord);
-    const userContext = { userId };
-    const dataContext = {
-        userContext,
-        tableContainer: {
-            getTable: jest.fn().mockReturnValue({ get }),
-        },
-    };
-    Object.assign(userContext, { userDataContext: dataContext });
-    return { dataContext, get };
-}
-describe("getUserTrustLevel", () => {
-    it("derives Self from the supplied personal context without a global user context", async () => {
-        const userId = (0, utils_1.newid)();
-        const { dataContext, get } = makeDataContext(userId);
-        await expect((0, user_trust_levels_1.getUserTrustLevel)(dataContext, userId)).resolves.toBe(socket_type_1.TrustLevel.Self);
-        expect(get).not.toHaveBeenCalled();
-    });
-    it("reads explicit trust from the supplied context", async () => {
-        const remoteUserId = (0, utils_1.newid)();
-        const { dataContext, get } = makeDataContext((0, utils_1.newid)(), {
-            trustLevel: socket_type_1.TrustLevel.Trusted,
-        });
-        await expect((0, user_trust_levels_1.getUserTrustLevel)(dataContext, remoteUserId)).resolves.toBe(socket_type_1.TrustLevel.Trusted);
-        expect(get).toHaveBeenCalledWith(remoteUserId);
-    });
-    it("returns Unknown when the supplied context has no trust assignment", async () => {
-        const { dataContext } = makeDataContext((0, utils_1.newid)());
-        await expect((0, user_trust_levels_1.getUserTrustLevel)(dataContext, (0, utils_1.newid)())).resolves.toBe(socket_type_1.TrustLevel.Unknown);
-    });
-});

package/dist/define/also-implements.test.d.ts

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

package/dist/define/also-implements.test.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const frozen_contracts_1 = require("../contracts/frozen-contracts");
-const registry_1 = require("../contracts/registry");
-const isolated_artifact_1 = require("../package-loader/isolated-artifact");
-const peer_id_1 = require("../peer-id");
-const index_1 = require("./index");
-const manifest_1 = require("./manifest");
-const packageId = (0, peer_id_1.newid)();
-const contractId = (0, peer_id_1.newid)();
-/** Notes vN: `add` takes a title, and each later version adds an optional field. */
-function notes(version, extra = {}, alsoImplements) {
-    return (0, index_1.defineContract)({
-        contractId,
-        version,
-        name: "Notes",
-        tools: [
-            (0, index_1.defineTool)({
-                name: "add",
-                usageDescription: "Add a note.",
-                accessLevel: index_1.AccessLevel.Writer,
-                inputSchema: index_1.z.object({ title: index_1.z.string(), ...extra }),
-                outputSchema: index_1.z.object({ id: index_1.z.string() }),
-                handler: () => ({ id: "n1" }),
-            }),
-        ],
-        ...(alsoImplements ? { alsoImplements } : {}),
-    });
-}
-const pkg = (...contracts) => (0, index_1.definePackage)((builder) => {
-    builder.packageId = packageId;
-    builder.version = "2.0.0";
-    for (const contract of contracts)
-        builder.provides(contract);
-});
-/** What `frozen-contracts.json` holds after a stable release that provided `contracts`. */
-function frozenAfter(...contracts) {
-    const manifest = (0, manifest_1.buildPackageManifest)(pkg(...contracts));
-    return (0, frozen_contracts_1.freezeContracts)(undefined, manifest.provides.map((contract) => (0, isolated_artifact_1.isolatedContractToDefinition)(contract, [])), "1.0.0").frozen;
-}
-describe("alsoImplements in /define", () => {
-    it("takes older versions by number and declarations, and refuses itself, repeats, and the rest", () => {
-        expect(notes(2, {}, [1]).alsoImplements).toEqual([1]);
-        expect(() => notes(2, {}, [2])).toThrow("can't also implement itself");
-        expect(() => notes(2, {}, [3])).toThrow("alsoImplements v3 must be older than v2");
-        expect(() => notes(3, {}, [1, 1])).toThrow(`also implements ${contractId}@1 twice`);
-        expect(() => notes(2, {}, [0])).toThrow("must be a positive integer");
-        expect(() => (0, index_1.defineContract)({ contractId, version: 2, name: "Notes", alsoImplements: [{}] })).toThrow("takes version numbers and declarations from declareContract");
-        // Its own older version by declaration would skip the shape its stable release froze.
-        const NotesV1 = (0, index_1.declareContract)({ contractId, version: 1, name: "Notes" });
-        expect(() => (0, index_1.defineContract)({ contractId, version: 2, name: "Notes", alsoImplements: [NotesV1] })).toThrow("takes its own contract's older versions by number, not by declaration");
-    });
-    it("carries an older version's frozen shape in the manifest, so the host can register it", () => {
-        const frozen = frozenAfter(notes(1));
-        const manifest = (0, manifest_1.buildPackageManifest)(pkg(notes(2, { tag: index_1.z.string().optional() }, [1])), {
-            frozen,
-        });
-        const [entry] = manifest.provides[0].alsoImplements ?? [];
-        expect(entry).toMatchObject({ contractId, version: 1, definition: { contractId, version: 1 } });
-        expect(entry.definition).not.toHaveProperty("frozenBy");
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)({ manifest, providerSource: "void 0;" }, { strict: true })).not.toThrow();
-        // A cold start: the registry has never seen v1, and still routes it to v2.
-        const registry = new registry_1.ContractRegistry();
-        registry.registerBatch(packageId, manifest.provides.map((contract) => ({
-            definition: (0, isolated_artifact_1.isolatedContractToDefinition)(contract, []),
-            alsoImplements: contract.alsoImplements,
-        })));
-        expect(registry.getProviderPackageId(contractId, 1)).toBe(packageId);
-        expect(registry.getProviderImplementation(contractId, 1, packageId)).toEqual({
-            contractId,
-            version: 2,
-        });
-    });
-    it("needs the older version frozen, and refuses one the contract no longer satisfies", () => {
-        expect(() => (0, manifest_1.buildPackageManifest)(pkg(notes(2, {}, [1])))).toThrow("also implements v1, which frozen-contracts.json doesn't record");
-        const frozen = frozenAfter(notes(1));
-        // v1 callers may leave out an optional field, so v2 can't require one.
-        expect(() => (0, manifest_1.buildPackageManifest)(pkg(notes(2, { tag: index_1.z.string() }, [1])), { frozen })).toThrow(/doesn't satisfy Notes .*@1.*extra required input field 'tag'/);
-        expect(() => (0, manifest_1.buildPackageManifest)(pkg(notes(1), notes(2, {}, [1])), { frozen })).toThrow(`also implements ${contractId}@1, which the package provides with pkg.provides`);
-    });
-    it("takes another contract's declaration, and implementContract takes alsoImplements too", () => {
-        const otherId = (0, peer_id_1.newid)();
-        const Other = (0, index_1.declareContract)({
-            contractId: otherId,
-            version: 1,
-            name: "Other",
-            tools: [
-                (0, index_1.declareTool)({
-                    name: "add",
-                    usageDescription: "Add.",
-                    accessLevel: index_1.AccessLevel.Writer,
-                    inputSchema: index_1.z.object({ title: index_1.z.string() }),
-                    outputSchema: index_1.z.object({ id: index_1.z.string() }),
-                }),
-            ],
-        });
-        const manifest = (0, manifest_1.buildPackageManifest)(pkg(notes(2, {}, [Other])));
-        expect(manifest.provides[0].alsoImplements?.[0]).toMatchObject({
-            contractId: otherId,
-            version: 1,
-            definition: { name: "Other", tools: [expect.objectContaining({ name: "add" })] },
-        });
-        const NotesV2 = (0, index_1.declareContract)({
-            contractId,
-            version: 2,
-            name: "Notes",
-            tools: [
-                (0, index_1.declareTool)({
-                    name: "add",
-                    usageDescription: "Add a note.",
-                    accessLevel: index_1.AccessLevel.Writer,
-                    inputSchema: index_1.z.object({ title: index_1.z.string() }),
-                    outputSchema: index_1.z.object({ id: index_1.z.string() }),
-                }),
-            ],
-        });
-        const implemented = (0, index_1.implementContract)(NotesV2, {
-            tools: { add: () => ({ id: "n1" }) },
-            alsoImplements: [1],
-        });
-        expect(implemented.alsoImplements).toEqual([1]);
-    });
-});

package/dist/define/declare-contract.test.d.ts

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