@peers-app/peers-sdk 0.25.13 → 0.25.15

package/dist/context/user-context-identity.test.d.ts

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

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

@@ -0,0 +1,220 @@
+"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/context/user-context.d.ts

@@ -62,9 +62,13 @@ export declare class UserContext {
     getMe(): Promise<{
         name: string;
         publicKey: string;
-        publicBoxKey: string;
         userId: string;
+        publicBoxKey: string;
         signature?: string | undefined;
+        anchors?: {
+            type: "peers-services" | "https";
+            url: string;
+        }[] | undefined;
     } | undefined>;
     /**
      * Sign and persist this user's identity, then copy it into every loaded

package/dist/context/user-context.js

@@ -4,6 +4,7 @@ exports.UserContext = void 0;
 const lodash_1 = require("lodash");
 const data_context_1 = require("../context/data-context");
 const data_1 = require("../data");
+const user_permissions_1 = require("../data/user-permissions");
 const events_1 = require("../events");
 const keys_1 = require("../keys");
 const observable_1 = require("../observable");
@@ -234,13 +235,41 @@ class UserContext {
             };
         }
         me.name = me.name.slice(0, data_1.DISPLAY_NAME_MAX_LENGTH);
-        me.publicKey = keys.publicKey;
-        me.publicBoxKey = keys.publicBoxKey;
-        const meSigned = (0, keys_1.addSignatureToObject)(me, keys.secretKey);
-        // sync my user to personal db
-        if (!(0, lodash_1.isEqual)(me, meSigned)) {
-            (0, keys_1.verifyObjectSignature)(meSigned);
-            await (0, data_1.Users)(this.userDataContext).save(meSigned, { weakInsert: true });
+        let rowFollowsDevice = true;
+        let anchorsConfirmed = false;
+        if (me.publicKey && me.publicKey !== keys.publicKey) {
+            // The row on record holds another key. The anchors on record decide: when they list the
+            // key this device holds (a rotation that stored the new secret but stopped before
+            // re-signing the row, or credentials an operator replaced after publishing the key) the
+            // row follows the device. Otherwise this device's key is the one that was rotated away,
+            // and it must not be put back over the row.
+            const { evaluatePresentedKey } = await Promise.resolve().then(() => require("../identity/key-change"));
+            const decision = await evaluatePresentedKey({
+                dataContext: this.userDataContext,
+                userId,
+                presentedKey: keys.publicKey,
+                presentedBoxKey: keys.publicBoxKey,
+                adopt: false,
+            });
+            rowFollowsDevice = decision.accepted;
+            anchorsConfirmed = decision.accepted;
+            if (!rowFollowsDevice) {
+                console.warn(`The profile row for ${userId} holds a key this device does not (${decision.state}); leaving it alone`);
+            }
+        }
+        if (rowFollowsDevice) {
+            // A "pair this device again" notice from before is stale once this device holds the key
+            // it named, or a key the anchors have just confirmed (paired again after a later rotation).
+            const { clearRotatedAwayNotice } = await Promise.resolve().then(() => require("../identity/key-change"));
+            await clearRotatedAwayNotice({ userId, deviceKey: keys.publicKey, anchorsConfirmed });
+            const { signature: _previous, ...profile } = me;
+            me = { ...profile, publicKey: keys.publicKey, publicBoxKey: keys.publicBoxKey };
+            const meSigned = (0, user_permissions_1.signUserObject)(me, keys.secretKey);
+            // sync my user to personal db
+            if (!(0, lodash_1.isEqual)(me, meSigned)) {
+                (0, user_permissions_1.verifyUserSignature)(meSigned);
+                await (0, data_1.Users)(this.userDataContext).save(meSigned, { weakInsert: true });
+            }
         }
         await this.syncMyUserToAllGroups();
         // sync group objects to my personal db
@@ -313,9 +342,35 @@ class UserContext {
                 return;
             }
             const groupMe = await (0, data_1.Users)(dataContext).get(currentUser.userId);
-            if (!(0, lodash_1.isEqual)(groupMe, currentUser)) {
+            if ((0, lodash_1.isEqual)(groupMe, currentUser)) {
+                return;
+            }
+            if (groupMe && groupMe.publicKey !== currentUser.publicKey) {
+                // The group holds another key for us. A confirmed successor of our key means this
+                // device was rotated away. A confirmed successor of the group's key means our row
+                // is ahead and may be copied. Anything else leaves the group row alone.
+                const { detectIdentityRotatedAway, evaluatePresentedKey } = await Promise.resolve().then(() => require("../identity/key-change"));
+                const rotatedAway = await detectIdentityRotatedAway({ userId: currentUser.userId, publicKey: currentUser.publicKey }, groupMe);
+                if (rotatedAway)
+                    return;
+                const ahead = await evaluatePresentedKey({
+                    dataContext: this.userDataContext,
+                    userId: currentUser.userId,
+                    presentedKey: currentUser.publicKey,
+                    presentedBoxKey: currentUser.publicBoxKey,
+                    record: groupMe,
+                });
+                if (!ahead.accepted) {
+                    console.warn(`Group ${contextId} holds my profile under another key; leaving it alone until anchors confirm`);
+                    return;
+                }
+            }
+            try {
                 await (0, data_1.Users)(dataContext).save(currentUser);
             }
+            catch (err) {
+                console.error(`Error syncing my user row to group ${contextId}:`, err);
+            }
         });
         this.groupUserSyncs.set(contextId, currentSync);
         try {

package/dist/contracts/index.d.ts

@@ -13,7 +13,7 @@ export { PersistentContractRegistry } from "./persistent-registry";
 export { ContractRegistry, type IContractProviderRegistration } from "./registry";
 export { createRemoteContractEndpoint, getRemoteContractTransportFactory, type IRemoteContractHost, type IRemoteContractTarget, type RemoteContractTransportFactory, resolveRemoteTargetEndpoint, setRemoteContractTransportFactory, } from "./remote-contract-transport";
 export { DEVICE_OPERATIONS_CONTRACT_VERSION, DEVICE_OPERATIONS_MAX_QUERY_LENGTH, DEVICE_OPERATIONS_MAX_RESULT_BYTES, DEVICE_OPERATIONS_MAX_ROWS, DEVICE_OPERATIONS_MAX_TOOLS, type DeviceOperationCapability, deviceOperationsProviderPackageId, deviceOperationsToolIds, getDeviceOperationsContractDefinition, type IDeviceDatabaseQueryInput, type IDeviceDatabaseQueryResult, type IDeviceOperationStatus, type IDeviceToolListInput, type IDeviceToolLookupInput, type IDeviceToolLookupResult, type IDeviceToolRunInput, } from "./system/device-operations-contract";
-export { getIdentityContractDefinition, IDENTITY_CONTRACT_VERSION, type IIdentityConsumer, type IIdentitySessionInfo, } from "./system/identity-contract";
+export { getIdentityContractDefinition, IDENTITY_CONTRACT_VERSION, type IIdentityConsumer, type IIdentityKeyInfo, type IIdentityRegistryKey, type IIdentityRotateKeyInput, type IIdentityRotateKeyResult, type IIdentitySessionInfo, } from "./system/identity-contract";
 export { getInvitesContractDefinition, type IAcceptInviteResult, type ICreatedInvite, type IInvitePreview, type IInvitesConsumer, INVITES_CONTRACT_VERSION, } from "./system/invites-contract";
 export { getLocalFoldersContractDefinition, type ILocalFolderAssembleInput, type ILocalFolderAssembleResult, type ILocalFolderChange, type ILocalFolderChangedEvent, type ILocalFolderEntry, type ILocalFolderFileBlocks, type ILocalFolderFileBlocksInput, type ILocalFolderGrantInfo, type ILocalFolderIndexInput, type ILocalFolderIndexResult, type ILocalFolderJobFinishedEvent, type ILocalFolderJobHandle, type ILocalFolderJobInfo, type ILocalFolderJobProgressEvent, type ILocalFolderListInput, type ILocalFolderManifestBlock, type ILocalFolderMoveInput, type ILocalFolderPathInput, type ILocalFolderPurgeTrashInput, type ILocalFolderReadRangeInput, type ILocalFolderReadRangeResult, type ILocalFolderRequestGrantInput, type ILocalFolderStatInput, LOCAL_FOLDERS_ASSEMBLE_STALL_MS, LOCAL_FOLDERS_CHUNK_AVG, LOCAL_FOLDERS_CHUNK_MAX, LOCAL_FOLDERS_CHUNK_MIN, LOCAL_FOLDERS_CONTRACT_VERSION, LOCAL_FOLDERS_GETBLOCKS_MAX_BLOCKS, LOCAL_FOLDERS_GETBLOCKS_MAX_BYTES, LOCAL_FOLDERS_HAVE_BATCH, LOCAL_FOLDERS_JOB_TTL_MS, LOCAL_FOLDERS_READ_RANGE_MAX, LOCAL_FOLDERS_RESERVED_DIR, type LocalFolderChangeKind, type LocalFolderEntryKind, type LocalFolderJobKind, type LocalFolderMode, localFoldersProviderPackageId, } from "./system/local-folders-contract";
 export { getLogsContractDefinition, type ILogsConsumer, LOGS_CONTRACT_VERSION, resolveLogsContract, } from "./system/logs-contract";

package/dist/contracts/system/identity-contract.d.ts

@@ -1,4 +1,6 @@
 import type { DevicePairingCeremonyAction, DevicePairingStartDestinationInput, DevicePairingStartSourceInput, DevicePairingState } from "../../device-pairing";
+import type { IPreviousPublicKey, KeyRotationReason } from "../../host-credentials";
+import type { IAnchorDocument, IAnchorRef } from "../../identity/anchor-document";
 import type { Observable } from "../../observable";
 import type { IContractConsumerBase } from "../contract-proxy";
 import type { IContractDefinition } from "../types";
@@ -11,6 +13,82 @@ export interface IIdentitySessionInfo {
     /** True when this user has completed peers-services registration on this device. */
     registered: boolean;
 }
+/** One key as the key registry reports it, for {@link IIdentityKeyInfo}. */
+export interface IIdentityRegistryKey {
+    publicKey: string;
+    status: "active" | "retired" | "revoked";
+    reason?: string;
+}
+/** The signed-in user's current and previous signing keys. */
+export interface IIdentityKeyInfo {
+    userId: string;
+    /** Current Ed25519 public key. */
+    publicKey: string;
+    /** Current X25519 box public key. */
+    publicBoxKey: string;
+    /** Keys this host retired by rotating, newest last. */
+    previousPublicKeys: IPreviousPublicKey[];
+    /** Whether this host can rotate (false when the identity comes from the environment). */
+    canRotate: boolean;
+    /** Anchors on record, and what each one currently lists. */
+    anchors?: {
+        onRecord: IAnchorRef[];
+        views: {
+            type: IAnchorRef["type"];
+            url: string;
+            /** Public keys the anchor currently lists. Absent when it vetoed or did not answer. */
+            publicKeys?: string[];
+            error?: string;
+        }[];
+    };
+    /** What the key registry knows, when one is configured and reachable. */
+    registry?: {
+        url: string;
+        /** `undefined` when the registry has never seen this user. */
+        keys?: IIdentityRegistryKey[];
+        /** Set when the registry could not be reached. */
+        error?: string;
+    };
+}
+/** Input for the `rotateKey` tool. */
+export interface IIdentityRotateKeyInput {
+    /** `rotation` (default) retires the old key; `compromised` or `lost` revokes it. */
+    reason?: KeyRotationReason;
+    /**
+     * `anchors` (default) writes through an installed writer for each on-record anchor that has
+     * one (peers-services accepts that write during an anchor session opened with the recovery
+     * email) and polls the rest. `manual` writes nowhere and polls every on-record anchor.
+     * Either way the key changes only once every anchor on record lists it.
+     */
+    publish?: "anchors" | "manual";
+    /**
+     * When an anchor on record must be updated by hand (`manual`, or `anchors` with an https
+     * anchor on record), `false` returns the document and does not change the key, and `true`
+     * waits for every anchor to list the staged key and then rotates.
+     */
+    confirm?: boolean;
+}
+/** One anchor's answer while publishing a new key. */
+export interface IAnchorPublishOutcome {
+    type: IAnchorRef["type"];
+    url: string;
+    result: "accepted" | "refused";
+}
+/** Output of the `rotateKey` tool. A committed rotation restarts the host shortly after. */
+export interface IIdentityRotateKeyResult {
+    oldPublicKey: string;
+    newPublicKey: string;
+    reason: KeyRotationReason;
+    /** True once the local key has changed. A staged rotation is false. */
+    committed: boolean;
+    restartRequired: boolean;
+    rewrappedSecrets: number;
+    /** Per-anchor results. Every entry is `accepted` when committed; empty when only staged. */
+    anchors: IAnchorPublishOutcome[];
+    /** Document to place at the anchors that must be updated by hand, when staged. */
+    manualDocument?: IAnchorDocument;
+    warnings: string[];
+}
 /**
  * Local-only host contract for device pairing and the signed-in session.
  *
@@ -36,6 +114,84 @@ export interface IIdentityConsumer extends IContractConsumerBase {
         registerWithPeersServices(): Promise<{
             token: string;
         }>;
+        getKeyInfo(): Promise<IIdentityKeyInfo>;
+        rotateKey(input?: IIdentityRotateKeyInput): Promise<IIdentityRotateKeyResult>;
+        getRecoveryEmail(): Promise<{
+            email?: string;
+        }>;
+        bindEmailStart(input: {
+            email: string;
+        }): Promise<{
+            status: string;
+        }>;
+        bindEmailVerify(input: {
+            email: string;
+            code: string;
+        }): Promise<{
+            email: string;
+        }>;
+        unbindEmail(): Promise<{
+            status: string;
+        }>;
+        startAnchorSession(input?: {
+            userId?: string;
+        }): Promise<{
+            status: string;
+        }>;
+        confirmAnchorSession(input: {
+            code: string;
+            userId?: string;
+        }): Promise<{
+            expiresIn: number;
+        }>;
+        contestRecovery(input: {
+            pendingKey: string;
+        }): Promise<{
+            status: string;
+        }>;
+        acceptRecovery(input: {
+            userId: string;
+            pendingKey: string;
+        }): Promise<{
+            status: string;
+        }>;
+        recoverKey(input: {
+            userId: string;
+            publish?: "anchors" | "manual";
+            confirm?: boolean;
+        }): Promise<{
+            publicKey: string;
+            committed: boolean;
+            manualDocument?: IAnchorDocument;
+            warnings: string[];
+        }>;
+        setAnchors(input: {
+            anchors: IAnchorRef[];
+        }): Promise<{
+            anchors: IAnchorRef[];
+        }>;
+        passkeyRegisterStart(input: {
+            origin: string;
+        }): Promise<{
+            options: Record<string, unknown>;
+        }>;
+        passkeyRegisterFinish(input: {
+            response: Record<string, unknown>;
+        }): Promise<{
+            status: string;
+        }>;
+        passkeyAuthStart(input: {
+            origin: string;
+            userId?: string;
+        }): Promise<{
+            options: Record<string, unknown>;
+        }>;
+        passkeyAuthFinish(input: {
+            response: Record<string, unknown>;
+            userId?: string;
+        }): Promise<{
+            expiresIn: number;
+        }>;
     };
     observables: {
         state: Observable<DevicePairingState>;