@weaveprotocol/core 0.1.0

package/dist/session/auth.js

@@ -0,0 +1,783 @@
+/**
+ * @module session/auth
+ * Signing in, as one object any UI can draw.
+ *
+ * `createWeaveAuth` holds the whole flow — where the data lives, which account,
+ * the ways into it, creating one, arriving from a phone-pairing link — as a
+ * state you read and actions you call. The `<weave-auth>` element draws it, a
+ * React hook follows it, and an app that wants its own screens can draw it
+ * itself. None of them see the seed: it stays inside this object.
+ *
+ * The credential is a generated 26-character code. It is the seed, written out,
+ * which is what makes it work on a domain that has never heard of you — there is
+ * nothing stored for it to unlock. A password manager holds it exactly as it
+ * holds any generated password. The passkey and the short password are
+ * conveniences layered on top, local to one site, so the code only has to be
+ * fetched once per site.
+ *
+ * The identity key never signs a record. Signing in starts a node, which makes
+ * a throwaway session key and asks the identity for one note saying that key
+ * may write for it; everything after is signed by the session key.
+ */
+import { createIdentityManager } from '../identity/identity-manager.js';
+import { createLocalRootSigner } from '../identity/root-signer.js';
+import { AGENT_FACT } from '../identity/agent-note.js';
+import { accountDataPath, newAccountId, createBrowserAccountStore } from '../identity/account-store.js';
+import { createVault } from '../identity/folder-account.js';
+import { withWrap, wrapSeedWithDeviceKey, unwrapSeedWithDeviceKey, unwrapSeedWithPassphrase, deviceWrapsFor, deriveVaultKey, deriveVaultKeyBytes, } from '../identity/account-vault.js';
+import { createDeviceKey, getDeviceKey, deleteDeviceKey } from '../identity/device-key.js';
+import { registerPasskey, authenticatePasskey, hasPlatformAuthenticator, renamePasskey } from '../identity/webauthn.js';
+import { generateSeed, seedToRecoveryCode, recoveryCodeToSeed, isValidRecoveryCode } from '../identity/recovery-code.js';
+import { isFolderStorageAvailable } from '../storage/directory-access.js';
+import { base64UrlEncode } from '../utils/encoding.js';
+import { createNode } from '../node/node.js';
+import { copyAccountData } from '../node/copy.js';
+import { isProtocolError, protocolError } from '../utils/errors.js';
+import { deleteBrowserData, forgetPod, inspectPod, listAccounts, pickPod, recallPod, rememberPod, storesFor, } from './places.js';
+import { createStaySignedIn } from './stay-signed-in.js';
+import { grantCapabilities, MAX_GRANT_DAYS } from './connect.js';
+import { clearPairingTicket, collectFromDesktop, offerToPhone as offerPairing, readPairingTicket, } from './pairing.js';
+/** Turns a thrown value into something worth showing, ignoring a dismissed prompt. */
+function describe(error) {
+    if (error instanceof DOMException && (error.name === 'NotAllowedError' || error.name === 'AbortError')) {
+        return null; // the person dismissed a passkey or folder prompt
+    }
+    if (isProtocolError(error)) {
+        return { message: error.message, code: error.code, ...(error.hint ? { hint: error.hint } : {}) };
+    }
+    return { message: error instanceof Error ? error.message : 'Something went wrong' };
+}
+const afterStorage = (accounts) => (accounts.length > 0 ? 'signIn' : 'welcome');
+/**
+ * Creates the sign-in flow for this page.
+ * @param config Where to connect once signed in, and what to call the app
+ */
+export function createWeaveAuth(config = {}) {
+    const rpId = config.rpId ?? globalThis.location?.hostname ?? 'localhost';
+    const appName = config.appName ?? 'Weave';
+    const prefix = config.storageKey ?? 'weave';
+    const storage = config.storage !== undefined ? config.storage : (globalThis.localStorage ?? null);
+    const stay = createStaySignedIn(storage, rpId, prefix);
+    const browserAccounts = config.browser?.accounts ?? createBrowserAccountStore;
+    const browserStores = config.browser?.stores ?? ((account) => storesFor(account));
+    const LAST_ACCOUNT = `${prefix}.last-account`;
+    const BROWSER_CHOSEN = `${prefix}.storage-choice`;
+    const get = (key) => {
+        try {
+            return storage?.getItem(key) ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const set = (key, value) => {
+        try {
+            storage?.setItem(key, value);
+        }
+        catch {
+            // Remembering is a convenience, never a requirement.
+        }
+    };
+    let state = Object.freeze({
+        stage: 'starting',
+        place: null,
+        accounts: [],
+        selectedId: null,
+        entry: null,
+        session: null,
+        freshCode: null,
+        busy: false,
+        error: null,
+        folderAvailable: isFolderStorageAvailable(),
+        pairing: readPairingTicket(),
+        pairingStage: null,
+        podChoice: null,
+        moved: null,
+    });
+    const listeners = new Set();
+    const update = (patch) => {
+        state = Object.freeze({ ...state, ...patch });
+        for (const listener of listeners)
+            listener(state);
+    };
+    /** The seed behind the open session. Never leaves this closure except as the account password. */
+    let seed = null;
+    let vaultKey = null;
+    let stopFollowingName = null;
+    let started = null;
+    const browserPlace = async () => ({ kind: 'browser', store: await browserAccounts(), directory: null });
+    const storesOf = (place, account, key) => place.directory ? storesFor(account, { directory: place.directory, vaultKey: key }) : browserStores(account);
+    // ─── Accounts in a place ───────────────────────────────────────────
+    async function openEntry(place, id) {
+        const [summary, vault] = await Promise.all([
+            listAccounts(place).then((accounts) => accounts.find((account) => account.id === id)),
+            place.store.read(id),
+        ]);
+        if (!summary || !vault)
+            return null;
+        // A wrap whose key is missing from this browser cannot be offered, however
+        // confidently the vault lists it.
+        const usable = await Promise.all(deviceWrapsFor(vault, rpId).map(async (wrap) => ((await getDeviceKey(wrap.deviceKeyId).catch(() => null)) ? wrap : null)));
+        return {
+            summary,
+            vault,
+            shortcuts: usable.filter((wrap) => wrap !== null),
+            hasPassword: vault.wraps.some((wrap) => wrap.kind === 'passphrase'),
+        };
+    }
+    /** Re-reads the accounts in a place and picks one to expand. */
+    async function refresh(place) {
+        const accounts = await listAccounts(place);
+        const remembered = get(LAST_ACCOUNT);
+        const chosen = accounts.find((account) => account.id === remembered) ?? accounts[0] ?? null;
+        update({
+            place,
+            accounts,
+            selectedId: chosen?.id ?? null,
+            entry: chosen ? await openEntry(place, chosen.id) : null,
+        });
+        return accounts;
+    }
+    async function refreshEntry() {
+        if (state.place && state.session)
+            update({ entry: await openEntry(state.place, state.session.account.id) });
+    }
+    // ─── Sessions ──────────────────────────────────────────────────────
+    /**
+     * Stops the open session's node. The session stays in the state until
+     * something replaces it — a restart swaps one session for the next, and
+     * signing out moves off the signed-in screens in the same change — so a
+     * screen never sees "ready" with no session.
+     */
+    async function stopNode(node = state.session?.node) {
+        stopFollowingName?.();
+        stopFollowingName = null;
+        seed = null;
+        vaultKey = null;
+        await node?.close();
+    }
+    /** Starts the node for an unlocked account. */
+    async function startSession(place, account, unlocked) {
+        await stopNode();
+        const manager = createIdentityManager();
+        const identity = await manager.fromSeed(unlocked);
+        const key = await deriveVaultKey(unlocked);
+        const node = await createNode({
+            signer: createLocalRootSigner(identity, manager.getProvider()),
+            accountKey: await deriveVaultKeyBytes(unlocked),
+            stores: storesOf(place, account, key),
+            ...(config.network ? { network: config.network } : {}),
+        });
+        seed = unlocked;
+        vaultKey = key;
+        const session = Object.freeze({ account, did: identity.did, sessionDid: node.sessionDid, node });
+        // The account's name follows it: a rename on another device or site
+        // arrives through the account registry and is taken here too.
+        const adopt = async () => {
+            const profile = await node.account.profile().catch(() => null);
+            const current = state.session;
+            if (!profile || !current || current.node !== node || profile.name === current.account.name)
+                return;
+            await adoptName(profile.name).catch(() => { });
+        };
+        stopFollowingName = node.subscribe((event) => {
+            if (event.type === 'account')
+                void adopt();
+        });
+        void adopt();
+        return session;
+    }
+    /** Records that an account was just used, and starts its session. */
+    async function begin(place, summary, unlocked) {
+        const used = { ...summary, lastUsedAt: new Date().toISOString() };
+        try {
+            const vault = await place.store.read(summary.id);
+            if (vault)
+                await place.store.write(used, vault);
+        }
+        catch {
+            // The order the picker opens in is not worth failing a sign-in over.
+        }
+        set(LAST_ACCOUNT, summary.id);
+        const session = await startSession(place, used, unlocked);
+        // So a refresh does not ask again — for as long as the setting allows.
+        await stay.remember(summary.id, place.kind, unlocked).catch(() => { });
+        return session;
+    }
+    /** Runs something that may fail, showing the failure; true when it worked. */
+    async function run(work) {
+        update({ busy: true, error: null });
+        try {
+            await work();
+            return true;
+        }
+        catch (error) {
+            update({ error: describe(error) });
+            return false;
+        }
+        finally {
+            update({ busy: false });
+        }
+    }
+    /** Runs a way in, and goes to the app when it ends in a session. */
+    const enter = (open) => run(async () => {
+        const session = await open();
+        update({ session, stage: 'ready' });
+    }).then(() => undefined);
+    // ─── Passkeys ──────────────────────────────────────────────────────
+    /**
+     * Runs a passkey ceremony as a gate.
+     *
+     * Nothing is read out of it. The ceremony proves a person with the
+     * authenticator is present, and the key that actually opens the account
+     * lives in this site's storage — which is why every passkey provider works,
+     * including the ones that store passkeys without the PRF extension.
+     *
+     * Steers to this device's own authenticator when it has one: the key this
+     * gates never leaves the browser, so a passkey synced by a manager gates
+     * nothing anywhere else.
+     */
+    async function passkeyGate(mode, options = {}) {
+        const preferPlatform = mode === 'create' ? await hasPlatformAuthenticator() : false;
+        const steer = preferPlatform ? { hints: ['client-device'] } : {};
+        if (mode === 'create') {
+            const registration = await registerPasskey({
+                rpId,
+                rpName: appName,
+                userName: options.label ?? appName,
+                ...steer,
+                ...(preferPlatform ? { attachment: 'platform' } : {}),
+            });
+            return { credentialId: registration.credentialId, userHandle: registration.userHandle };
+        }
+        const auth = await authenticatePasskey(options.credentialId, { rpId, ...steer });
+        return { credentialId: auth.credentialId };
+    }
+    /** Rewrites the open account's vault. */
+    async function updateVault(make) {
+        const { place, session } = state;
+        if (!place || !session)
+            throw new Error('Not signed in.');
+        const current = await place.store.read(session.account.id);
+        if (!current)
+            throw new Error('That account is no longer here.');
+        await place.store.write(session.account, await make(current));
+    }
+    /** Takes a name for the open account here: the label it is filed under, and its passkey's label. */
+    async function adoptName(name) {
+        const { place, session } = state;
+        if (!place || !session)
+            throw new Error('Not signed in.');
+        const renamed = { ...session.account, name: name.trim() || session.account.name };
+        const vault = await place.store.read(session.account.id);
+        if (!vault)
+            throw new Error('That account is no longer here.');
+        await place.store.write(renamed, { ...vault, label: renamed.name });
+        // Recent browsers let a site relabel its passkey; older ones ignore it.
+        for (const wrap of deviceWrapsFor(vault, rpId)) {
+            if (wrap.userHandle)
+                await renamePasskey({ rpId, userHandle: wrap.userHandle, name: renamed.name }).catch(() => false);
+        }
+        update({ session: Object.freeze({ ...session, account: renamed }), accounts: await listAccounts(place) });
+        return renamed;
+    }
+    /** Changes to the open account's shortcuts, then re-reads them. */
+    const changeShortcut = (apply) => run(async () => {
+        if (!seed)
+            throw new Error('Not signed in.');
+        await apply(seed);
+        await refreshEntry();
+    });
+    /** Connected apps are remembered per account, on this device */
+    function writeConnections(connections) {
+        const account = state.session?.account.id;
+        if (account)
+            set(`${prefix}.connections:${account}`, JSON.stringify(connections));
+        update({});
+    }
+    // ─── The flow ──────────────────────────────────────────────────────
+    const auth = {
+        getState: () => state,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        start() {
+            started ??= (async () => {
+                try {
+                    // Asks nothing of the person: only whether what was granted before is still live.
+                    const pod = await recallPod(false).catch(() => null);
+                    const place = pod ?? (await browserPlace());
+                    const accounts = await refresh(place);
+                    if (accounts.length > 0) {
+                        const kept = await stay.recall(place.kind).catch(() => null);
+                        const summary = kept && accounts.find((account) => account.id === kept.accountId);
+                        if (kept && summary) {
+                            update({ session: await begin(place, summary, kept.seed), stage: 'ready' });
+                            return;
+                        }
+                    }
+                    if (state.pairing) {
+                        update({ stage: 'pair' });
+                        return;
+                    }
+                    // Nothing here yet and the storage question never answered: ask it first.
+                    const undecided = !pod && accounts.length === 0 && state.folderAvailable && get(BROWSER_CHOSEN) !== 'browser';
+                    update({ stage: undecided ? 'where' : afterStorage(accounts) });
+                }
+                catch (error) {
+                    update({ error: describe(error), stage: 'welcome' });
+                }
+            })();
+            return started;
+        },
+        async choosePod() {
+            await run(async () => {
+                const pod = await pickPod();
+                const { session, place } = state;
+                // Signed in: look before leaping. The picker needed the click, but
+                // switching waits for an answer.
+                if (session && place) {
+                    const contents = await inspectPod(pod, place, session.account.did);
+                    if (contents.same)
+                        throw new Error('That is the pod you are already using.');
+                    update({ podChoice: { pod, contents, from: place } });
+                    return;
+                }
+                await rememberPod(pod);
+                update({ stage: afterStorage(await refresh(pod)) });
+            });
+        },
+        async useBrowser() {
+            set(BROWSER_CHOSEN, 'browser');
+            await run(async () => {
+                if (state.place?.kind === 'folder')
+                    await forgetPod();
+                const place = state.place?.kind === 'browser' ? state.place : await browserPlace();
+                update({ stage: afterStorage(await refresh(place)) });
+            });
+        },
+        changeStorage() {
+            update({ error: null, stage: 'where' });
+        },
+        async select(accountId) {
+            update({ selectedId: accountId, error: null });
+            if (state.place)
+                update({ entry: await openEntry(state.place, accountId) });
+        },
+        signInWithCode(code) {
+            return enter(async () => {
+                const place = state.place;
+                if (!place)
+                    throw new Error('No place to sign in to yet.');
+                if (!isValidRecoveryCode(code)) {
+                    throw protocolError('VAULT_UNLOCK_FAILED', 'That does not look like an account password.', 'It is 26 letters and digits, usually shown in groups of four.');
+                }
+                const unlocked = recoveryCodeToSeed(code);
+                const identity = await createIdentityManager().fromSeed(unlocked);
+                const expected = state.accounts.find((account) => account.id === state.selectedId);
+                if (expected && identity.did !== expected.did) {
+                    throw protocolError('VAULT_UNLOCK_FAILED', `That password opens a different account, not ${expected.name}.`, 'With more than one account saved for this site, a password manager fills whichever it saw last ' +
+                        `unless you pick. Choose the entry named ${expected.name}, or open the account it did fill.`);
+                }
+                const known = (await listAccounts(place)).find((account) => account.did === identity.did);
+                if (known)
+                    return begin(place, known, unlocked);
+                // New to this place — the second-site case. File it, so next time there
+                // is something to add a passkey to.
+                const id = newAccountId();
+                const summary = {
+                    id,
+                    name: expected?.name ?? 'My account',
+                    did: identity.did,
+                    createdAt: new Date().toISOString(),
+                    dataPath: accountDataPath(id),
+                };
+                await place.store.write(summary, createVault({ did: identity.did, label: summary.name, wraps: [] }));
+                return begin(place, summary, unlocked);
+            });
+        },
+        signInWithPassword(password) {
+            return enter(async () => {
+                const { place, entry } = state;
+                const wrap = entry?.vault.wraps.find((candidate) => candidate.kind === 'passphrase');
+                if (!place || !entry || !wrap || wrap.kind !== 'passphrase') {
+                    throw protocolError('VAULT_UNLOCK_FAILED', 'No password is set for this account here.', 'Use your account password instead.');
+                }
+                return begin(place, entry.summary, await unwrapSeedWithPassphrase(wrap, password));
+            });
+        },
+        signInWithPasskey() {
+            return enter(async () => {
+                const { place, entry } = state;
+                const target = entry?.shortcuts[entry.shortcuts.length - 1];
+                if (!place || !entry || !target) {
+                    throw protocolError('VAULT_UNLOCK_FAILED', 'No passkey on this device can open that account.', 'Use your account password, and you can set one up afterwards.');
+                }
+                // The gate first, so the key is never reached for without someone present.
+                if (target.credentialId)
+                    await passkeyGate('get', { credentialId: target.credentialId });
+                const key = await getDeviceKey(target.deviceKeyId);
+                if (!key) {
+                    throw protocolError('VAULT_UNLOCK_FAILED', 'The key for that passkey is not in this browser any more.', 'Clearing site data removes it. Your account password still works, and a new passkey can be set up afterwards.');
+                }
+                return begin(place, entry.summary, await unwrapSeedWithDeviceKey(target, key));
+            });
+        },
+        startCreating() {
+            update({ error: null, stage: 'create' });
+        },
+        showSignIn() {
+            update({ error: null, stage: 'signIn' });
+        },
+        async createAccount(name) {
+            await run(async () => {
+                const place = state.place;
+                if (!place)
+                    throw new Error('No place to keep the account yet.');
+                // The seed is random, and the password shown afterwards is that seed
+                // written out — not a backup of it.
+                const unlocked = generateSeed();
+                const identity = await createIdentityManager().fromSeed(unlocked);
+                const id = newAccountId();
+                const summary = {
+                    id,
+                    name: name.trim(),
+                    did: identity.did,
+                    createdAt: new Date().toISOString(),
+                    dataPath: accountDataPath(id),
+                };
+                // No wraps yet: the password is the way in, and it needs none.
+                await place.store.write(summary, createVault({ did: identity.did, label: summary.name, wraps: [] }));
+                const session = await begin(place, summary, unlocked);
+                // The name travels with the account, so the next site it is opened on
+                // shows it. Only at creation and on rename — never on a plain start,
+                // where a device that has not synced yet would publish a stale name.
+                await session.node.account.setName(summary.name).catch(() => { });
+                update({ session, freshCode: seedToRecoveryCode(unlocked), accounts: await listAccounts(place) });
+            });
+        },
+        codeSaved() {
+            update({ freshCode: null, stage: 'ready' });
+        },
+        async acceptPairing() {
+            const ticket = state.pairing;
+            if (!ticket)
+                return;
+            if (!state.place)
+                update({ place: await browserPlace() });
+            await auth.signInWithCode(ticket.code);
+            const session = state.session;
+            if (!session)
+                return;
+            clearPairingTicket();
+            await collectFromDesktop(session.node, ticket, (stage) => update({ pairingStage: stage }));
+            update({ pairing: null });
+        },
+        dismissPairing() {
+            clearPairingTicket();
+            update({ pairing: null, pairingStage: null, stage: state.session ? 'ready' : afterStorage(state.accounts) });
+        },
+        clearError() {
+            update({ error: null });
+        },
+        async rename(name) {
+            const session = state.session;
+            if (!session)
+                return false;
+            return run(async () => {
+                const renamed = await adoptName(name);
+                // Every other device and site that opens the account follows.
+                await session.node.account.setName(renamed.name).catch(() => { });
+            });
+        },
+        addPasskey: () => changeShortcut(async (unlocked) => {
+            const session = state.session;
+            const place = state.place;
+            const { credentialId, userHandle } = await passkeyGate('create', { label: session.account.name });
+            const deviceKey = await createDeviceKey();
+            const wrap = await wrapSeedWithDeviceKey(unlocked, deviceKey, {
+                rpId,
+                credentialId,
+                ...(userHandle ? { userHandle } : {}),
+                label: rpId,
+            });
+            // Replacing an older passkey leaves its key behind, opening nothing.
+            const previous = deviceWrapsFor((await place.store.read(session.account.id)), rpId);
+            await updateVault(async (vault) => withWrap(vault, wrap));
+            for (const stale of previous)
+                await deleteDeviceKey(stale.deviceKeyId);
+        }),
+        removeShortcut: (kind) => changeShortcut(async () => {
+            const session = state.session;
+            if (kind === 'passkey') {
+                const vault = await state.place.store.read(session.account.id);
+                for (const wrap of vault ? deviceWrapsFor(vault, rpId) : [])
+                    await deleteDeviceKey(wrap.deviceKeyId);
+            }
+            // Removing every shortcut leaves the account as a new one starts:
+            // openable by its password. Another site's passkey is not this one's to remove.
+            await updateVault(async (vault) => ({
+                ...vault,
+                wraps: vault.wraps.filter((wrap) => kind === 'passkey' ? !(wrap.kind === 'device' && wrap.rpId === rpId) : wrap.kind !== 'passphrase'),
+            }));
+        }),
+        async confirmPod(how) {
+            const choice = state.podChoice;
+            const session = state.session;
+            if (!choice || !session || !seed || !vaultKey)
+                return;
+            const unlocked = seed;
+            const key = vaultKey;
+            await run(async () => {
+                const { pod, contents, from } = choice;
+                if (!pod.directory)
+                    throw new Error('That is not a folder.');
+                if (how === 'switch' && contents.account) {
+                    // Use the pod's own copy and bring nothing; what was only here stays here.
+                    await rememberPod(pod);
+                    const started = await begin(pod, contents.account, unlocked);
+                    update({ session: started, place: pod, accounts: await listAccounts(pod), podChoice: null, moved: null });
+                    return;
+                }
+                // Combine: every record is signed and named by its content, and deletes
+                // are records too, so two copies merge by keeping everything from both.
+                const existing = contents.account;
+                const id = existing?.id ?? newAccountId();
+                const summary = existing
+                    ? { ...existing, lastUsedAt: new Date().toISOString() }
+                    : { ...session.account, id, dataPath: accountDataPath(id), lastUsedAt: new Date().toISOString() };
+                // Ways of unlocking: the pod's, plus any from here it lacks.
+                const here = await from.store.read(session.account.id);
+                let vault = (existing ? await pod.store.read(existing.id) : null) ??
+                    createVault({ did: session.account.did, label: session.account.name, wraps: [] });
+                for (const wrap of here?.wraps ?? []) {
+                    if (!vault.wraps.some((kept) => kept.id === wrap.id))
+                        vault = withWrap(vault, wrap);
+                }
+                await pod.store.write(summary, vault);
+                const copied = await copyAccountData({
+                    from: storesOf(from, session.account, key),
+                    to: storesOf(pod, summary, key),
+                    did: session.account.did,
+                    accountKey: await deriveVaultKeyBytes(unlocked),
+                });
+                await rememberPod(pod);
+                const started = await begin(pod, summary, unlocked);
+                update({
+                    session: started,
+                    place: pod,
+                    accounts: await listAccounts(pod),
+                    podChoice: null,
+                    moved: {
+                        merged: existing !== null,
+                        spacesAdded: copied.spacesAdded,
+                        recordsAdded: copied.recordsAdded,
+                        from: from.kind === 'folder' ? (from.directory?.name ?? 'your old pod') : null,
+                    },
+                });
+            });
+        },
+        cancelPod() {
+            update({ podChoice: null, error: null });
+        },
+        async forgetBrowserCopy() {
+            const session = state.session;
+            if (!session)
+                return;
+            await run(async () => {
+                const browser = await browserAccounts();
+                const copy = (await browser.list()).find((entry) => entry.did === session.account.did);
+                if (copy) {
+                    await browser.remove(copy.id);
+                    await deleteBrowserData(copy);
+                }
+                update({ moved: null });
+            });
+        },
+        dismissMoved() {
+            update({ moved: null });
+        },
+        accountPassword() {
+            return seed ? seedToRecoveryCode(seed) : null;
+        },
+        offerToPhone(onStage) {
+            const session = state.session;
+            if (!session || !seed)
+                return Promise.reject(new Error('Sign in first.'));
+            const location = globalThis.location;
+            return offerPairing({
+                node: session.node,
+                seed,
+                relays: config.network?.relays ?? [],
+                link: config.pairingLink ?? (location ? `${location.origin}${location.pathname}` : ''),
+            }, onStage);
+        },
+        async grant(choice) {
+            const session = state.session;
+            if (!session || !seed)
+                throw new Error('Sign in first.');
+            const { node } = session;
+            const { request } = choice;
+            if (request.access === 'carry')
+                throw new Error('A carrier is given passes, not a note — use grantCarry.');
+            const access = request.access;
+            const agent = request.agent === true;
+            if (agent && request.create?.length)
+                throw new Error('An agent works in spaces that exist — none are made for it.');
+            const whole = request.scope === 'account';
+            const created = [];
+            for (const params of request.create ?? [])
+                created.push(await node.spaces.create(params));
+            const ids = [...new Set([...choice.spaceIds, ...created.map((space) => space.id)])];
+            const spaces = [];
+            for (const id of ids) {
+                const space = await node.spaces.get(id);
+                if (!space)
+                    throw new Error(`No space ${id} in this account.`);
+                // Read-only: what lets the app write is the note, under this account's own role — never a secret of the space's.
+                const invite = await node.spaces.invite(id, { write: false });
+                spaces.push({ id, name: space.name, invite });
+            }
+            const days = Math.min(Math.max(choice.days ?? request.days ?? 7, 1 / 24), MAX_GRANT_DAYS);
+            const expiresAt = Math.floor(Date.now() / 1000) + Math.round(days * 24 * 3600);
+            const manager = createIdentityManager();
+            const root = createLocalRootSigner(await manager.fromSeed(seed), manager.getProvider());
+            const token = await root.delegate({
+                audience: request.audience,
+                capabilities: grantCapabilities(access, whole ? 'all' : ids),
+                expiration: expiresAt,
+                ...(agent ? { facts: [AGENT_FACT] } : {}),
+            });
+            const connection = {
+                origin: choice.origin,
+                name: request.name?.slice(0, 80) ?? null,
+                audience: request.audience,
+                access,
+                scope: whole ? 'account' : 'spaces',
+                spaces: spaces.map(({ id, name }) => ({ id, name })),
+                grantedAt: new Date().toISOString(),
+                expiresAt,
+                token: token.encoded,
+                ...(agent ? { agent: true } : {}),
+            };
+            // Connecting again replaces the old note. An agent is its own key: connecting one replaces only that one.
+            const replaced = (known) => (agent ? known.audience === request.audience : known.origin === choice.origin && !known.agent);
+            writeConnections([connection, ...auth.connections().filter((known) => !replaced(known))]);
+            return {
+                v: 1,
+                did: session.did,
+                name: session.account.name,
+                token: token.encoded,
+                access,
+                scope: whole ? 'account' : 'spaces',
+                spaces,
+                ...(whole ? { accountKey: base64UrlEncode(await deriveVaultKeyBytes(seed)) } : {}),
+                ...(config.network?.relays?.length ? { relays: [...config.network.relays] } : {}),
+                expiresAt,
+                ...(agent ? { agent: true } : {}),
+            };
+        },
+        async grantCarry({ origin, request }) {
+            const session = state.session;
+            if (!session || !seed)
+                throw new Error('Sign in first.');
+            const { node } = session;
+            // Connecting again replaces the old one: one carrier per origin.
+            const previous = auth.connections().find((known) => known.origin === origin);
+            if (previous?.carrySpace)
+                await node.carriers.remove(previous.carrySpace).catch(() => { });
+            const name = request.name?.slice(0, 80) || 'Browser extension';
+            const carry = await node.carriers.add({ did: request.audience, name });
+            const connection = {
+                origin,
+                name,
+                audience: request.audience,
+                access: 'carry',
+                scope: 'account',
+                spaces: [],
+                grantedAt: new Date().toISOString(),
+                // Carrying has no end date: a pass reads nothing, and the carrier writes nothing.
+                expiresAt: 0,
+                carrySpace: carry.space,
+            };
+            writeConnections([connection, ...auth.connections().filter((known) => known.origin !== origin)]);
+            const place = state.place;
+            return {
+                v: 1,
+                kind: 'carry',
+                did: session.did,
+                name: session.account.name,
+                carry,
+                pod: place?.kind === 'folder' ? { dataPath: session.account.dataPath, folder: place.directory?.name ?? 'your pod' } : null,
+                ...(config.network?.relays?.length ? { relays: [...config.network.relays] } : {}),
+            };
+        },
+        connections() {
+            const account = state.session?.account.id;
+            if (!account)
+                return [];
+            try {
+                return JSON.parse(get(`${prefix}.connections:${account}`) ?? '[]');
+            }
+            catch {
+                return [];
+            }
+        },
+        connectedElsewhere(origin) {
+            const current = state.session?.account.id;
+            return state.accounts
+                .filter((account) => account.id !== current)
+                .filter((account) => {
+                try {
+                    const known = JSON.parse(get(`${prefix}.connections:${account.id}`) ?? '[]');
+                    return known.some((connection) => connection.origin === origin);
+                }
+                catch {
+                    return false;
+                }
+            })
+                .map((account) => ({ id: account.id, name: account.name }));
+        },
+        async disconnect(origin, options = {}) {
+            // The app goes with the agents connected through it; an agent can go alone.
+            const goes = (known) => options.audience !== undefined
+                ? known.audience === options.audience
+                : known.origin === origin && (!options.agent || !!known.agent);
+            const going = auth.connections().filter(goes);
+            const node = state.session?.node;
+            for (const connection of going) {
+                if (connection.carrySpace && node)
+                    await node.carriers.remove(connection.carrySpace);
+                if (connection.token && connection.access === 'write' && node) {
+                    const covered = connection.scope === 'account'
+                        ? (await node.spaces.list()).filter((space) => space.writable).map((space) => space.id)
+                        : connection.spaces.map((space) => space.id);
+                    for (const spaceId of covered) {
+                        // A space that is gone, or that this account no longer writes in, has nothing to revoke.
+                        await node.spaces.revoke(spaceId, connection.token).catch(() => { });
+                    }
+                    // A whole-account app could also add spaces to the account's list, and rename it.
+                    if (connection.scope === 'account')
+                        await node.account.revoke(connection.token).catch(() => { });
+                }
+            }
+            writeConnections(auth.connections().filter((known) => !goes(known)));
+        },
+        staySignedIn: {
+            choice: () => stay.choice(),
+            setChoice: (choice) => stay.setChoice(choice),
+            until: () => stay.until(),
+        },
+        async signOut() {
+            await stay.forget();
+            const leaving = state.session?.node;
+            update({ stage: 'starting', session: null, entry: null, freshCode: null, podChoice: null, moved: null });
+            await stopNode(leaving).catch(() => { });
+            const place = state.place;
+            update({ stage: place ? afterStorage(await refresh(place)) : 'welcome' });
+        },
+    };
+    return auth;
+}
+//# sourceMappingURL=auth.js.map