@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/device-pairing/device-pairing.test.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const device_1 = require("../device/device");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const _1 = require(".");
-const NOW = 1_800_000_000_000;
-const ORIGIN = "https://peers.app";
-const FINGERPRINT = Array.from({ length: 32 }, (_, index) => index.toString(16).padStart(2, "0"))
-    .join(":")
-    .toUpperCase();
-describe("pairing code", () => {
-    it("uses the full PGP word lists with no duplicates", () => {
-        expect(_1.PGP_EVEN_WORDS).toHaveLength(256);
-        expect(_1.PGP_ODD_WORDS).toHaveLength(256);
-        expect(new Set([..._1.PGP_EVEN_WORDS, ..._1.PGP_ODD_WORDS]).size).toBe(512);
-    });
-    it("generates even/odd/even words and round-trips through formatting and parsing", () => {
-        const words = (0, _1.generatePairingWords)();
-        expect(_1.PGP_EVEN_WORDS).toContain(words[0]);
-        expect(_1.PGP_ODD_WORDS).toContain(words[1]);
-        expect(_1.PGP_EVEN_WORDS).toContain(words[2]);
-        const text = (0, _1.formatPairingCode)(7, words);
-        expect(text).toBe(`7-${words.join("-")}`);
-        expect((0, _1.parsePairingCode)(text)).toEqual({ nameplate: 7, words });
-        expect((0, _1.parsePairingCode)(`  7 ${words.join(" ").toUpperCase()} `)).toEqual({
-            nameplate: 7,
-            words,
-        });
-    });
-    it("rejects wrong slots, unknown words, bad nameplates, and wrong lengths", () => {
-        expect(() => (0, _1.parsePairingCode)("7-adroitness-aardvark-absurd")).toThrow(/word 1/);
-        expect(() => (0, _1.parsePairingCode)("7-aardvark-absurd-acme")).toThrow(/word 2/);
-        expect(() => (0, _1.parsePairingCode)("7-aardvark-adroitness-nope")).toThrow(/word 3/);
-        expect(() => (0, _1.parsePairingCode)("0-aardvark-adroitness-acme")).toThrow(/room number/);
-        expect(() => (0, _1.parsePairingCode)("10000-aardvark-adroitness-acme")).toThrow(/room number/);
-        expect(() => (0, _1.parsePairingCode)("aardvark-adroitness-acme")).toThrow(/three words/);
-        expect(() => (0, _1.parsePairingCode)("7-aardvark-adroitness")).toThrow(/three words/);
-    });
-});
-describe("pairing PAKE and signaling", () => {
-    const code = (0, _1.parsePairingCode)("42-aardvark-adroitness-acme");
-    it("derives matching keys for the same code and different keys for a wrong code", () => {
-        const source = (0, _1.startPairingPake)("source", code, ORIGIN);
-        const destination = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        const sourceKeys = source.finish(destination.share);
-        const destinationKeys = destination.finish(source.share);
-        expect(sourceKeys).toEqual(destinationKeys);
-        expect(sourceKeys.signalingKey).not.toBe(sourceKeys.confirmKey);
-        const token = (0, _1.derivePairingWebSocketToken)(sourceKeys.signalingKey);
-        expect(token).toBe((0, _1.derivePairingWebSocketToken)(destinationKeys.signalingKey));
-        expect(token).not.toBe(sourceKeys.signalingKey);
-        expect(token).not.toBe(sourceKeys.confirmKey);
-        const wrong = (0, _1.startPairingPake)("source", (0, _1.parsePairingCode)("42-absurd-adroitness-acme"), ORIGIN);
-        const honest = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        expect(wrong.finish(honest.share)).not.toEqual(honest.finish(wrong.share));
-        const otherRoom = (0, _1.startPairingPake)("source", { ...code, nameplate: 43 }, ORIGIN);
-        const thisRoom = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        expect(otherRoom.finish(thisRoom.share)).not.toEqual(thisRoom.finish(otherRoom.share));
-    });
-    it("accepts the pake share unauthenticated and everything else only with the key", () => {
-        const share = (0, _1.startPairingPake)("source", code, ORIGIN).share;
-        const pake = (0, _1.createPairingPakeSignal)({
-            nameplate: 42,
-            senderRole: "source",
-            sequence: 1,
-            share,
-        });
-        expect((0, _1.verifyPairingSignal)(pake, undefined, {
-            nameplate: 42,
-            senderRole: "source",
-            nextSequence: 1,
-        })).toEqual(pake);
-        const keys = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        const signalingKey = keys.finish(share).signalingKey;
-        const options = (0, _1.signPairingSignal)({
-            version: 3,
-            nameplate: 42,
-            senderRole: "destination",
-            sequence: 2,
-            kind: "transport-options",
-            payload: {
-                endpointNonce: (0, keys_1.newToken)(32),
-                webrtc: false,
-                websocket: { urls: ["http://192.168.1.20:3341", "wss://peers.example.com"] },
-            },
-        }, signalingKey);
-        expect((0, _1.verifyPairingSignal)(options, signalingKey, {
-            nameplate: 42,
-            senderRole: "destination",
-            nextSequence: 2,
-        })).toEqual(options);
-        expect(() => (0, _1.signPairingSignal)({
-            ...options,
-            payload: { ...options.payload, websocket: { urls: ["ftp://nope"] } },
-        }, signalingKey)).toThrow();
-        const choice = (0, _1.signPairingSignal)({
-            version: 3,
-            nameplate: 42,
-            senderRole: "source",
-            sequence: 2,
-            kind: "transport-choice",
-            payload: { endpointNonce: (0, keys_1.newToken)(32), selected: "ws", url: "http://192.168.1.20:3341" },
-        }, signalingKey);
-        expect((0, _1.verifyPairingSignal)(choice, signalingKey, {
-            nameplate: 42,
-            senderRole: "source",
-            nextSequence: 2,
-        })).toEqual(choice);
-        const offerSdp = `v=0\r\na=fingerprint:sha-256 ${FINGERPRINT}\r\n`;
-        const signal = (0, _1.signPairingSignal)({
-            version: 3,
-            nameplate: 42,
-            senderRole: "source",
-            sequence: 3,
-            kind: "offer",
-            payload: { type: "offer", sdp: offerSdp },
-        }, signalingKey);
-        const expected = { nameplate: 42, senderRole: "source", nextSequence: 3 };
-        expect((0, _1.verifyPairingSignal)(signal, signalingKey, expected)).toEqual(signal);
-        expect(() => (0, _1.verifyPairingSignal)(signal, undefined, expected)).toThrow(/before authentication/);
-        expect(() => (0, _1.verifyPairingSignal)({ ...signal, payload: { ...signal.payload, sdp: `${offerSdp}modified` } }, signalingKey, expected)).toThrow(/authentication failed/);
-        expect(() => (0, _1.verifyPairingSignal)(signal, signalingKey, { ...expected, senderRole: "destination" })).toThrow(/out of order/);
-        expect(() => (0, _1.verifyPairingSignal)(signal, signalingKey, { ...expected, nextSequence: 4 })).toThrow(/out of order/);
-        expect(() => (0, _1.verifyPairingSignal)(signal, signalingKey, { ...expected, nameplate: 41 })).toThrow(/out of order/);
-    });
-});
-describe("pairing transcript, confirmation, and credentials", () => {
-    const source = new device_1.Device();
-    const destination = new device_1.Device();
-    const sdp = `v=0\r\na=fingerprint:sha-256 ${FINGERPRINT}\r\n`;
-    const transcript = {
-        version: 3,
-        serviceOrigin: ORIGIN,
-        nameplate: 42,
-        sourceIdentity: (0, keys_1.openSignedObject)(source.getDeviceInfo()),
-        destinationIdentity: (0, keys_1.openSignedObject)(destination.getDeviceInfo()),
-        sourceEndpointNonce: (0, keys_1.newToken)(32),
-        destinationEndpointNonce: (0, keys_1.newToken)(32),
-        transport: "wrtc",
-        transportBinding: (0, _1.webRtcPairingTransportBinding)(sdp, sdp),
-    };
-    it("hashes the transcript deterministically and changes with any input", () => {
-        const hash = (0, _1.computeDevicePairingTranscriptHash)(transcript);
-        expect((0, _1.computeDevicePairingTranscriptHash)(transcript)).toBe(hash);
-        expect((0, _1.computeDevicePairingTranscriptHash)({ ...transcript, nameplate: 43 })).not.toBe(hash);
-        expect(transcript.transportBinding).toBe(`${(0, _1.extractSha256SdpFingerprint)(sdp)}|${(0, _1.extractSha256SdpFingerprint)(sdp)}`);
-        expect((0, _1.computeDevicePairingTranscriptHash)({
-            ...transcript,
-            transportBinding: transcript.transportBinding.replace("00", "FF"),
-        })).not.toBe(hash);
-        expect((0, _1.computeDevicePairingTranscriptHash)({
-            ...transcript,
-            transport: "ws",
-            transportBinding: "http://192.168.1.20:3341",
-        })).not.toBe(hash);
-    });
-    it("confirms only with the same key, role, transcript, and identity", () => {
-        const code = (0, _1.parsePairingCode)("42-aardvark-adroitness-acme");
-        const sourcePake = (0, _1.startPairingPake)("source", code, ORIGIN);
-        const destinationPake = (0, _1.startPairingPake)("destination", code, ORIGIN);
-        const keys = sourcePake.finish(destinationPake.share);
-        const wrongKeys = (0, _1.startPairingPake)("destination", (0, _1.parsePairingCode)("42-absurd-adroitness-acme"), ORIGIN).finish((0, _1.startPairingPake)("source", code, ORIGIN).share);
-        const transcriptHash = (0, _1.computeDevicePairingTranscriptHash)(transcript);
-        const confirmation = (0, _1.createPairingConfirmation)({
-            role: "destination",
-            transcriptHash,
-            device: transcript.destinationIdentity,
-            presentation: { deviceName: "Phone", deviceType: "mobile" },
-        }, keys.confirmKey);
-        const expected = {
-            role: "destination",
-            transcriptHash,
-            device: transcript.destinationIdentity,
-        };
-        expect((0, _1.verifyPairingConfirmation)(confirmation, keys.confirmKey, expected)).toEqual(confirmation);
-        expect(() => (0, _1.verifyPairingConfirmation)(confirmation, wrongKeys.confirmKey, expected)).toThrow(/did not match/);
-        expect(() => (0, _1.verifyPairingConfirmation)(confirmation, keys.confirmKey, { ...expected, role: "source" })).toThrow(/does not match/);
-        expect(() => (0, _1.verifyPairingConfirmation)(confirmation, keys.confirmKey, {
-            ...expected,
-            device: transcript.sourceIdentity,
-        })).toThrow(/identity mismatch/);
-        expect(() => (0, _1.verifyPairingConfirmation)({ ...confirmation, presentation: { deviceName: "Evil" } }, keys.confirmKey, expected)).toThrow(/did not match/);
-    });
-    it("requires the expected identities and transcript for credentials and receipt", () => {
-        const transcriptHash = (0, keys_1.newToken)(32);
-        const expiresAt = NOW + 60_000;
-        const credentials = { userId: (0, utils_1.newid)(), secretKey: (0, keys_1.newKeys)().secretKey };
-        const destinationInfo = (0, keys_1.openSignedObject)(destination.getDeviceInfo());
-        const envelope = (0, _1.createPairingCredentialEnvelope)(source, destinationInfo, credentials, transcriptHash, expiresAt);
-        expect((0, _1.openPairingCredentialEnvelope)(destination, envelope, {
-            sourcePublicKey: source.publicKey,
-            sourcePublicBoxKey: source.publicBoxKey,
-            transcriptHash,
-            now: NOW,
-        })).toEqual({ version: 3, transcriptHash, expiresAt, ...credentials });
-        expect(() => (0, _1.openPairingCredentialEnvelope)(new device_1.Device(), envelope, {
-            sourcePublicKey: source.publicKey,
-            sourcePublicBoxKey: source.publicBoxKey,
-            transcriptHash,
-            now: NOW,
-        })).toThrow();
-        const initialized = new device_1.Device(credentials.userId);
-        const initializedInfo = (0, keys_1.openSignedObject)(initialized.getDeviceInfo());
-        const receipt = (0, _1.createSignedPairingInstallationReceipt)(destination, transcriptHash, initializedInfo, NOW);
-        expect((0, _1.verifySignedPairingInstallationReceipt)(receipt, {
-            temporaryDestinationPublicKey: destination.publicKey,
-            transcriptHash,
-        })).toEqual(initializedInfo);
-    });
-});

package/dist/hlc.test.d.ts

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

package/dist/hlc.test.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hlc_1 = require("./hlc");
-const peer_device_1 = require("./types/peer-device");
-describe("HybridLogicalClock", () => {
-    it("is monotonic when now goes backward", () => {
-        let t = 1000;
-        const clock = new hlc_1.HybridLogicalClock({ now: () => t });
-        const first = clock.tick();
-        t = 100;
-        const second = clock.tick();
-        expect(second).toBe(first + 1);
-    });
-    it("advances by 1 on the same millisecond", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 5000 });
-        expect(clock.tick()).toBe(5000);
-        expect(clock.tick()).toBe(5001);
-        expect(clock.tick()).toBe(5002);
-    });
-    it("observe advances last so the next tick is after the observed time", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 1000 });
-        expect(clock.observe(2500)).toBe(true);
-        expect(clock.tick()).toBe(2501);
-    });
-    it("observe ignores timestamps beyond the skew bound", () => {
-        const now = 10_000;
-        const clock = new hlc_1.HybridLogicalClock({ now: () => now });
-        const future = now + peer_device_1.PeerDeviceConsts.CHANGE_TIMESTAMP_TOLERANCE_MS + 1;
-        expect(clock.observe(future)).toBe(false);
-        expect(clock.tick()).toBe(now);
-    });
-    it("seed raises last without going backward", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 1000 });
-        clock.seed(2000);
-        clock.seed(1500);
-        expect(clock.tick()).toBe(2001);
-    });
-    it("now peeks physical time without advancing", () => {
-        const clock = new hlc_1.HybridLogicalClock({ now: () => 42 });
-        expect(clock.now()).toBe(42);
-        expect(clock.now()).toBe(42);
-        expect(clock.value).toBe(0);
-        expect(clock.tick()).toBe(42);
-    });
-});

package/dist/host-credentials.test.d.ts

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

package/dist/host-credentials.test.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const host_credentials_1 = require("./host-credentials");
-const keys_1 = require("./keys");
-const utils_1 = require("./utils");
-describe("host credential record", () => {
-    const userId = (0, utils_1.newid)();
-    const k1 = (0, keys_1.newKeys)();
-    const k2 = (0, keys_1.newKeys)();
-    it("parses the legacy userId::secretKey form and derives the legacy db secret", () => {
-        const record = (0, host_credentials_1.parseCredentialRecord)(`${userId}::${k1.secretKey}`);
-        expect(record).toEqual({
-            userId,
-            secretKey: k1.secretKey,
-            dbSecret: (0, keys_1.hashValue)(k1.secretKey),
-        });
-        expect((0, host_credentials_1.legacyDbSecret)(k1.secretKey)).toBe((0, keys_1.hashValue)(k1.secretKey));
-    });
-    it("parses the JSON form, filling a missing dbSecret with the legacy value", () => {
-        expect((0, host_credentials_1.parseCredentialRecord)(JSON.stringify({ userId, secretKey: k1.secretKey }))).toEqual({
-            userId,
-            secretKey: k1.secretKey,
-            dbSecret: (0, keys_1.hashValue)(k1.secretKey),
-        });
-        const full = {
-            userId,
-            secretKey: k2.secretKey,
-            dbSecret: "db",
-            previousPublicKeys: [{ publicKey: k1.publicKey, replacedAt: "2026-10-02T00:00:00.000Z" }],
-        };
-        expect((0, host_credentials_1.parseCredentialRecord)((0, host_credentials_1.serializeCredentialRecord)(full))).toEqual(full);
-    });
-    it("returns null for garbage", () => {
-        expect((0, host_credentials_1.parseCredentialRecord)(null)).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("")).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("{not json")).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)(JSON.stringify({ userId }))).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("::")).toBeNull();
-        expect((0, host_credentials_1.parseCredentialRecord)("nosep")).toBeNull();
-    });
-    it("mints a random dbSecret only when asked", () => {
-        const fresh = (0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey }, { freshDbSecret: true });
-        expect(fresh.dbSecret).not.toBe((0, keys_1.hashValue)(k1.secretKey));
-        expect(fresh.dbSecret.length).toBeGreaterThan(30);
-        const kept = (0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey, dbSecret: "keep" }, {
-            freshDbSecret: true,
-        });
-        expect(kept.dbSecret).toBe("keep");
-    });
-    it("rotates the secret while keeping dbSecret and remembering the old key", () => {
-        const current = (0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey });
-        const at = new Date("2026-10-03T00:00:00.000Z");
-        const rotated = (0, host_credentials_1.rotateCredentialRecord)(current, {
-            secretKey: k2.secretKey,
-            oldPublicKey: k1.publicKey,
-            reason: "compromised",
-            at,
-        });
-        expect(rotated).toEqual({
-            userId,
-            secretKey: k2.secretKey,
-            dbSecret: (0, keys_1.hashValue)(k1.secretKey),
-            previousPublicKeys: [
-                { publicKey: k1.publicKey, replacedAt: at.toISOString(), reason: "compromised" },
-            ],
-            rewrapFrom: { publicKey: k1.publicKey, secretKey: k1.secretKey },
-        });
-    });
-    it("keeps the retired secret through storage until the re-wrap is finished", () => {
-        // Secrets in the personal database are re-wrapped one by one after the new key is stored.
-        // A crash in between must not lose the only key that can still open the rest.
-        const rotated = (0, host_credentials_1.rotateCredentialRecord)((0, host_credentials_1.normalizeCredentialRecord)({ userId, secretKey: k1.secretKey }), { secretKey: k2.secretKey, oldPublicKey: k1.publicKey });
-        const stored = (0, host_credentials_1.parseCredentialRecord)((0, host_credentials_1.serializeCredentialRecord)(rotated));
-        expect(stored?.rewrapFrom).toEqual({ publicKey: k1.publicKey, secretKey: k1.secretKey });
-        expect(stored?.secretKey).toBe(k2.secretKey);
-        const finished = (0, host_credentials_1.completeCredentialRewrap)(rotated);
-        expect(finished.rewrapFrom).toBeUndefined();
-        expect(finished.secretKey).toBe(k2.secretKey);
-        expect(finished.previousPublicKeys).toEqual(rotated.previousPublicKeys);
-        expect((0, host_credentials_1.parseCredentialRecord)((0, host_credentials_1.serializeCredentialRecord)(finished))?.rewrapFrom).toBeUndefined();
-        // A half-written slot is not a key to re-wrap from.
-        expect((0, host_credentials_1.parseCredentialRecord)(JSON.stringify({
-            userId,
-            secretKey: k2.secretKey,
-            rewrapFrom: { publicKey: k1.publicKey },
-        }))?.rewrapFrom).toBeUndefined();
-    });
-});

package/dist/identity/account-email.test.d.ts

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

package/dist/identity/account-email.test.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const account_email_1 = require("./account-email");
-describe("account email statements", () => {
-    const keys = (0, keys_1.newKeys)();
-    const userId = "00maccountemailstatements";
-    const issuedAt = new Date().toISOString();
-    const bind = (0, account_email_1.signEmailBind)({ purpose: "peers-account-email-bind", userId, email: "ada@example.com", issuedAt }, keys.secretKey);
-    const status = (0, account_email_1.signEmailStatus)({ purpose: "peers-account-email-status", userId, issuedAt }, keys.secretKey);
-    const unbind = (0, account_email_1.signEmailUnbind)({ purpose: "peers-account-email-unbind", userId, issuedAt }, keys.secretKey);
-    it("accepts each statement for the purpose it was signed for", () => {
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: bind,
-            userId,
-            email: "ada@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(true);
-        expect((0, account_email_1.verifyEmailStatus)({ signed: status, userId, recordPublicKey: keys.publicKey })).toBe(true);
-        expect((0, account_email_1.verifyEmailUnbind)({ signed: unbind, userId, recordPublicKey: keys.publicKey })).toBe(true);
-    });
-    it("does not let a statement signed for one purpose stand in for another", () => {
-        // A captured read request must not be able to remove the mailbox or bind a new one.
-        expect((0, account_email_1.verifyEmailUnbind)({ signed: status, userId, recordPublicKey: keys.publicKey })).toBe(false);
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: status,
-            userId,
-            email: "ada@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-        expect((0, account_email_1.verifyEmailStatus)({ signed: unbind, userId, recordPublicKey: keys.publicKey })).toBe(false);
-    });
-    it("refuses a statement for another user, another mailbox, or from another key", () => {
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: bind,
-            userId: "00maccountemailotheruser0",
-            email: "ada@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-        expect((0, account_email_1.verifyEmailBind)({
-            signed: bind,
-            userId,
-            email: "eve@example.com",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-        expect((0, account_email_1.verifyEmailUnbind)({ signed: unbind, userId, recordPublicKey: (0, keys_1.newKeys)().publicKey })).toBe(false);
-    });
-    it("refuses a statement whose contents were changed after signing", () => {
-        const forged = {
-            ...unbind,
-            contents: { ...unbind.contents, userId: "00maccountemailotheruser0" },
-        };
-        expect((0, account_email_1.verifyEmailUnbind)({
-            signed: forged,
-            userId: "00maccountemailotheruser0",
-            recordPublicKey: keys.publicKey,
-        })).toBe(false);
-    });
-});

package/dist/identity/anchor-document.test.d.ts

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

package/dist/identity/anchor-document.test.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const anchor_document_1 = require("./anchor-document");
-describe("normalizeAnchorList", () => {
-    it("allows http for peers-services and requires https for a page anchor", () => {
-        const list = (0, anchor_document_1.normalizeAnchorList)([
-            { type: "peers-services", url: "http://127.0.0.1:4000/api/v1/keys/abc" },
-            { type: "https", url: "https://example.com/peers.json" },
-        ]);
-        expect(list.map((anchor) => anchor.url)).toEqual([
-            "https://example.com/peers.json",
-            "http://127.0.0.1:4000/api/v1/keys/abc",
-        ]);
-        expect(() => (0, anchor_document_1.normalizeAnchorList)([{ type: "https", url: "http://example.com/peers.json" }])).toThrow(/https/);
-    });
-});

package/dist/identity/anchor-resolution.test.d.ts

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

package/dist/identity/anchor-resolution.test.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../index");
-const anchor_document_1 = require("./anchor-document");
-const anchor_resolution_1 = require("./anchor-resolution");
-const userId = (0, index_1.newid)();
-const record = (0, index_1.newKeys)();
-const next = (0, index_1.newKeys)();
-const anchor = {
-    type: "https",
-    url: "https://example.com/.well-known/peers-identity.json",
-};
-function document(keys) {
-    return {
-        version: 1,
-        userId,
-        keys,
-        anchors: [anchor],
-        updatedAt: "2026-10-03T18:00:00.000Z",
-    };
-}
-function confirm(entry) {
-    return { outcome: "document", document: document([entry]), maxAgeSeconds: 30 };
-}
-describe("resolvePresentedKey", () => {
-    const issuedAt = "2026-10-03T18:00:00.000Z";
-    it("confirms a rotation when the key on record co-signed and nobody vetoes", () => {
-        const signed = (0, anchor_document_1.signSuccession)({ purpose: "peers-key-succession", userId, publicKey: next.publicKey, issuedAt }, record.secretKey);
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [
-                confirm({
-                    publicKey: next.publicKey,
-                    issuedAt,
-                    reason: "rotation",
-                    authorizedBy: { publicKey: signed.publicKey, signature: signed.signature },
-                }),
-                { outcome: "abstain" },
-            ],
-        });
-        expect(resolution.state).toBe("confirmed-rotation");
-        expect(resolution.successionByRecordKey).toBe(true);
-        expect(resolution.cacheSeconds).toBe(30);
-    });
-    it("treats a listed key without the record key's signature as recovery", () => {
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [confirm({ publicKey: next.publicKey, issuedAt, reason: "lost" })],
-        });
-        expect(resolution.state).toBe("confirmed-recovery");
-    });
-    it("vetoes when any anchor omits the presented key", () => {
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [
-                confirm({ publicKey: next.publicKey, issuedAt }),
-                confirm({ publicKey: record.publicKey, issuedAt }),
-            ],
-        });
-        expect(resolution.state).toBe("vetoed");
-    });
-    it("vetoes a document for another user and a 404", () => {
-        const other = document([{ publicKey: next.publicKey, issuedAt }]);
-        other.userId = (0, index_1.newid)();
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [{ outcome: "document", document: other }, { outcome: "veto" }],
-        });
-        expect(resolution.state).toBe("vetoed");
-    });
-    it("stays pending when every anchor abstains", () => {
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [{ outcome: "abstain" }, { outcome: "abstain" }],
-        });
-        expect(resolution.state).toBe("pending");
-    });
-    it("rejects a co-signature that is not the key on record", () => {
-        const imposter = (0, index_1.newKeys)();
-        const signed = (0, anchor_document_1.signSuccession)({ purpose: "peers-key-succession", userId, publicKey: next.publicKey, issuedAt }, imposter.secretKey);
-        const resolution = (0, anchor_resolution_1.resolvePresentedKey)({
-            userId,
-            recordPublicKey: record.publicKey,
-            presentedPublicKey: next.publicKey,
-            outcomes: [
-                confirm({
-                    publicKey: next.publicKey,
-                    issuedAt,
-                    authorizedBy: { publicKey: signed.publicKey, signature: signed.signature },
-                }),
-            ],
-        });
-        expect(resolution.state).toBe("confirmed-recovery");
-    });
-});
-describe("resolvePresentedAnchors", () => {
-    const next = [anchor, { type: "https", url: "https://example.com/other.json" }];
-    it("confirms when an anchor publishes the new list and none veto", () => {
-        const decision = (0, anchor_resolution_1.resolvePresentedAnchors)({
-            userId,
-            presented: next,
-            outcomes: [
-                { outcome: "document", document: { ...document([]), anchors: [...next].reverse() } },
-                { outcome: "abstain" },
-            ],
-        });
-        expect(decision).toBe("confirmed");
-    });
-    it("vetoes when an anchor still publishes a different list", () => {
-        const decision = (0, anchor_resolution_1.resolvePresentedAnchors)({
-            userId,
-            presented: next,
-            outcomes: [
-                { outcome: "document", document: document([]) },
-                { outcome: "document", document: { ...document([]), anchors: next } },
-            ],
-        });
-        expect(decision).toBe("vetoed");
-    });
-});

package/dist/identity/key-change.test.d.ts

@@ -1 +0,0 @@
-import "./user-row-change";