@weaveprotocol/core 0.2.1 → 0.2.3

package/dist/session/auth.js

@@ -8,12 +8,20 @@
  * 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.
+ * Three things, each with one job:
+ *
+ * - **The recovery code** is the account: the seed, written out as 26
+ *   characters. It needs nothing stored to work, so it restores the account on
+ *   a device or home that has never seen it. Shown once when the account is
+ *   made, and kept somewhere safe rather than typed every day.
+ * - **A passkey or a password** is the everyday way in. Each wraps the seed in
+ *   the account's vault, so it works wherever the vault is — this browser, or
+ *   a pod — and nowhere else. Setting one up is part of making an account.
+ * - **Pairing** hands the account to a new device from one already signed in.
+ *
+ * So a new account goes: name → recovery code → passkey or password → (a pod,
+ * if this browser can open one) → in. Where the data lives is asked only of
+ * people who already have something somewhere, or offered at the end.
  *
  * 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
@@ -24,7 +32,7 @@ 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 { withWrap, wrapSeedWithDeviceKey, unwrapSeedWithDeviceKey, wrapSeedWithPassphrase, unwrapSeedWithPassphrase, deviceWrapsFor, CLI_PASSPHRASE_LABEL, deriveVaultKey, deriveVaultKeyBytes, } from '../identity/account-vault.js';
 import { deriveContactKeyBytes, deriveMemberKeyBytes } from '../identity/contact-key.js';
 import { createDeviceKey, getDeviceKey, deleteDeviceKey } from '../identity/device-key.js';
 import { registerPasskey, authenticatePasskey, hasPlatformAuthenticator, renamePasskey } from '../identity/webauthn.js';
@@ -37,7 +45,10 @@ 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 { fromProposal, proposalSpaces, sameSubscription } from '../space/notify.js';
 import { clearPairingTicket, collectFromDesktop, offerToPhone as offerPairing, readPairingTicket, } from './pairing.js';
+/** The shortest password `setPassword` takes. It guards a copy of the seed in a folder that may be copied. */
+export const MIN_PASSWORD_LENGTH = 10;
 /** 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')) {
@@ -49,6 +60,39 @@ function describe(error) {
     return { message: error instanceof Error ? error.message : 'Something went wrong' };
 }
 const afterStorage = (accounts) => (accounts.length > 0 ? 'signIn' : 'welcome');
+/**
+ * The subscriptions an app's proposals become, for the ones the person kept.
+ * Checked whole before any is written: a proposal naming a space the app
+ * can't reach refuses them all, and so does a carrier naming a topic value —
+ * it can't read, so the tag it got back would tell it which records hold a
+ * value it picked.
+ */
+function subscriptionsFrom(proposals, kept, context) {
+    const made = [];
+    for (const [index, proposal] of proposals.entries()) {
+        if (kept && !kept.includes(index))
+            continue;
+        if (context.carrier && proposal.topic && !('me' in proposal.topic))
+            throw new Error('An extension can’t read your spaces, so it may only suggest “mentions me”, not a value of its choosing.');
+        const spaces = proposalSpaces(proposal, context.reach);
+        if (!spaces)
+            throw new Error(`“${proposal.label}” looks at a space it was not given.`);
+        made.push(fromProposal(proposal, { app: context.app, spaces, account: context.account }));
+    }
+    return made;
+}
+/** Adds each, unless the same origin already has the same one */
+async function addSubscriptions(node, origin, subscriptions) {
+    if (subscriptions.length === 0)
+        return [];
+    const existing = (await node.notifications.list()).filter((sub) => sub.app?.origin === origin);
+    const added = [];
+    for (const when of subscriptions) {
+        const made = existing.find((sub) => sameSubscription(sub, when)) ?? (await node.notifications.add(when));
+        added.push({ id: made.id, label: made.label });
+    }
+    return added;
+}
 /**
  * Creates the sign-in flow for this page.
  * @param config Where to connect once signed in, and what to call the app
@@ -62,7 +106,6 @@ export function createWeaveAuth(config = {}) {
     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;
@@ -87,6 +130,7 @@ export function createWeaveAuth(config = {}) {
         entry: null,
         session: null,
         freshCode: null,
+        setup: null,
         busy: false,
         error: null,
         folderAvailable: isFolderStorageAvailable(),
@@ -101,7 +145,7 @@ export function createWeaveAuth(config = {}) {
         for (const listener of listeners)
             listener(state);
     };
-    /** The seed behind the open session. Never leaves this closure except as the account password. */
+    /** The seed behind the open session. Never leaves this closure except as the recovery code. */
     let seed = null;
     let vaultKey = null;
     let stopFollowingName = null;
@@ -221,11 +265,84 @@ export function createWeaveAuth(config = {}) {
             update({ busy: false });
         }
     }
-    /** Runs a way in, and goes to the app when it ends in a session. */
+    /** Whether an account can be opened here without its recovery code. */
+    const hasEverydayWay = (entry) => entry !== null && (entry.shortcuts.length > 0 || entry.hasPassword);
+    /**
+     * Lands a new session: in, or on through the setup screens.
+     *
+     * With no reason to set up, or a passkey or password already here, that is
+     * the app. Otherwise the recovery code is shown first — a new account's for
+     * the first time, a restored one's as a reminder to keep it apart from the
+     * password about to be set, which a password manager may file in its place —
+     * then a way in is chosen. A paired device skips the code: it was never
+     * shown one, and the device it came from keeps it.
+     */
+    async function arrive(session, setup) {
+        const place = state.place;
+        const entry = place ? await openEntry(place, session.account.id) : null;
+        const landed = {
+            session,
+            entry,
+            selectedId: session.account.id,
+            accounts: place ? await listAccounts(place) : state.accounts,
+        };
+        if (setup === null || hasEverydayWay(entry)) {
+            update({ ...landed, stage: 'ready', setup: null, freshCode: null });
+        }
+        else if (setup === 'paired') {
+            update({ ...landed, stage: 'unlock', setup });
+        }
+        else {
+            update({ ...landed, stage: 'recovery', setup, freshCode: seed ? seedToRecoveryCode(seed) : null });
+        }
+    }
+    /** After a way in is set up: offer a pod to a new account that could use one, or go in. */
+    function afterUnlock() {
+        const offerPod = state.setup === 'new' && state.folderAvailable && state.place?.kind === 'browser';
+        update(offerPod ? { stage: 'pod' } : { stage: 'ready', setup: null });
+    }
+    /** Runs a way in. One that took the recovery code may lead on to setting up an everyday one. */
     const enter = (open) => run(async () => {
-        const session = await open();
-        update({ session, stage: 'ready' });
+        const { session, byCode } = await open();
+        await arrive(session, byCode ? 'restored' : null);
     }).then(() => undefined);
+    /**
+     * Opens an account from its recovery code, filing it here if this place has
+     * not seen it.
+     * @param code The code, as typed or filled
+     * @param expected The account the person meant, when they picked one
+     */
+    async function openWithCode(code, expected) {
+        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 is not a recovery code.', 'A recovery code is 26 letters and digits, usually in groups of four. A password only opens the account where it was ' +
+                'set up — on a new device, use the recovery code, or add this device from one that is signed in.');
+        }
+        const unlocked = recoveryCodeToSeed(code);
+        const identity = await createIdentityManager().fromSeed(unlocked);
+        if (expected && identity.did !== expected.did) {
+            throw protocolError('VAULT_UNLOCK_FAILED', `That recovery code opens a different account, not ${expected.name}.`, `Check it is the code you kept for ${expected.name}, or restore the account it belongs to instead.`);
+        }
+        const known = (await listAccounts(place)).find((account) => account.did === identity.did);
+        if (known)
+            return begin(place, known, unlocked);
+        // New to this place — a new device, or a new home. File it, so there is
+        // somewhere to keep the passkey or password set up next.
+        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);
+    }
+    /** The account the person picked, if any */
+    const selectedAccount = () => state.accounts.find((account) => account.id === state.selectedId) ?? null;
     // ─── Passkeys ──────────────────────────────────────────────────────
     /**
      * Runs a passkey ceremony as a gate.
@@ -283,12 +400,14 @@ export function createWeaveAuth(config = {}) {
         update({ session: Object.freeze({ ...session, account: renamed }), accounts: await listAccounts(place) });
         return renamed;
     }
-    /** Changes to the open account's shortcuts, then re-reads them. */
+    /** Changes to the open account's shortcuts, then re-reads them. During setup, moves the flow on. */
     const changeShortcut = (apply) => run(async () => {
         if (!seed)
             throw new Error('Not signed in.');
         await apply(seed);
         await refreshEntry();
+        if (state.stage === 'unlock' && hasEverydayWay(state.entry))
+            afterUnlock();
     });
     /** Connected apps are remembered per account, on this device */
     function writeConnections(connections) {
@@ -323,9 +442,10 @@ export function createWeaveAuth(config = {}) {
                         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) });
+                    // Where the data lives is not asked up front: someone new has
+                    // nothing anywhere, and someone who does finds their pod under
+                    // "I already have an account".
+                    update({ stage: afterStorage(accounts) });
                 }
                 catch (error) {
                     update({ error: describe(error), stage: 'welcome' });
@@ -334,7 +454,7 @@ export function createWeaveAuth(config = {}) {
             return started;
         },
         async choosePod() {
-            await run(async () => {
+            const picked = await run(async () => {
                 const pod = await pickPod();
                 const { session, place } = state;
                 // Signed in: look before leaping. The picker needed the click, but
@@ -349,9 +469,17 @@ export function createWeaveAuth(config = {}) {
                 await rememberPod(pod);
                 update({ stage: afterStorage(await refresh(pod)) });
             });
+            // Setting up a new account there is nothing to decide: no pod has it
+            // yet, so it moves, and the browser copy it leaves is only a shell.
+            if (picked && state.stage === 'pod' && state.podChoice) {
+                await auth.confirmPod('combine');
+                if (state.podChoice)
+                    return;
+                await auth.forgetBrowserCopy();
+                update({ stage: 'ready', setup: null });
+            }
         },
         async useBrowser() {
-            set(BROWSER_CHOSEN, 'browser');
             await run(async () => {
                 if (state.place?.kind === 'folder')
                     await forgetPod();
@@ -359,54 +487,33 @@ export function createWeaveAuth(config = {}) {
                 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);
-            });
+            return enter(async () => ({ session: await openWithCode(code, selectedAccount()), byCode: true }));
         },
         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.');
+                // The account's password, and the CLI's passphrase if a pod has one: either opens it.
+                const wraps = (entry?.vault.wraps ?? []).filter((candidate) => candidate.kind === 'passphrase');
+                // Before passwords, the recovery code was this site's login, and a
+                // password manager still fills it here. It opens the account either way.
+                const code = isValidRecoveryCode(password) ? password : null;
+                let failed = null;
+                for (const wrap of place && entry ? wraps : []) {
+                    const unlocked = await unwrapSeedWithPassphrase(wrap, password).catch((error) => ((failed = error), null));
+                    if (unlocked)
+                        return { session: await begin(place, entry.summary, unlocked), byCode: false };
                 }
-                return begin(place, entry.summary, await unwrapSeedWithPassphrase(wrap, password));
+                if (failed && !code)
+                    throw failed;
+                if (code)
+                    return { session: await openWithCode(code, entry?.summary ?? selectedAccount()), byCode: true };
+                throw protocolError('VAULT_UNLOCK_FAILED', 'No password is set for this account here.', 'Use your recovery code, and you can set one up afterwards.');
             });
         },
         signInWithPasskey() {
@@ -414,16 +521,16 @@ export function createWeaveAuth(config = {}) {
                 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.');
+                    throw protocolError('VAULT_UNLOCK_FAILED', 'No passkey on this device can open that account.', 'Use your recovery code, 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.');
+                    throw protocolError('VAULT_UNLOCK_FAILED', 'The key for that passkey is not in this browser any more.', 'Clearing site data removes it. Your recovery code still works, and a new passkey can be set up afterwards.');
                 }
-                return begin(place, entry.summary, await unwrapSeedWithDeviceKey(target, key));
+                return { session: await begin(place, entry.summary, await unwrapSeedWithDeviceKey(target, key)), byCode: false };
             });
         },
         startCreating() {
@@ -432,13 +539,20 @@ export function createWeaveAuth(config = {}) {
         showSignIn() {
             update({ error: null, stage: 'signIn' });
         },
+        showWelcome() {
+            update({ error: null, stage: 'welcome' });
+        },
+        showExisting() {
+            update({ error: null, stage: 'existing' });
+        },
+        showRestore() {
+            update({ error: null, stage: 'restore' });
+        },
         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();
@@ -449,18 +563,29 @@ export function createWeaveAuth(config = {}) {
                     createdAt: new Date().toISOString(),
                     dataPath: accountDataPath(id),
                 };
-                // No wraps yet: the password is the way in, and it needs none.
+                // No wraps yet: the passkey or password comes after the recovery code.
                 await place.store.write(summary, createVault({ did: identity.did, label: summary.name, wraps: [] }));
+                // Kept only in this browser, the account is only as safe as the
+                // browser's willingness to keep it. Asking costs nothing.
+                if (place.kind === 'browser')
+                    await globalThis.navigator?.storage?.persist?.().catch(() => false);
                 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) });
+                await arrive(session, 'new');
             });
         },
         codeSaved() {
-            update({ freshCode: null, stage: 'ready' });
+            if (!state.session)
+                return;
+            update({ freshCode: null, stage: 'unlock' });
+        },
+        finishSetup() {
+            if (!state.session)
+                return;
+            update({ stage: 'ready', setup: null, error: null });
         },
         async acceptPairing() {
             const ticket = state.pairing;
@@ -468,9 +593,10 @@ export function createWeaveAuth(config = {}) {
                 return;
             if (!state.place)
                 update({ place: await browserPlace() });
-            await auth.signInWithCode(ticket.code);
+            // The link says which account; whichever was last used here is beside the point.
+            const opened = await run(async () => arrive(await openWithCode(ticket.code, null), 'paired'));
             const session = state.session;
-            if (!session)
+            if (!opened || !session)
                 return;
             clearPairingTicket();
             await collectFromDesktop(session.node, ticket, (stage) => update({ pairingStage: stage }));
@@ -510,6 +636,17 @@ export function createWeaveAuth(config = {}) {
             for (const stale of previous)
                 await deleteDeviceKey(stale.deviceKeyId);
         }),
+        setPassword: (password) => changeShortcut(async (unlocked) => {
+            if (password.length < MIN_PASSWORD_LENGTH) {
+                throw new Error(`Use at least ${MIN_PASSWORD_LENGTH} characters. Your password manager can make one for you.`);
+            }
+            const wrap = await wrapSeedWithPassphrase(unlocked, password, 'Password');
+            // One password: the new one replaces the last. The CLI's passphrase is its own, and stays.
+            await updateVault(async (vault) => ({
+                ...vault,
+                wraps: [...vault.wraps.filter((kept) => kept.kind !== 'passphrase' || kept.label === CLI_PASSPHRASE_LABEL), wrap],
+            }));
+        }),
         removeShortcut: (kind) => changeShortcut(async () => {
             const session = state.session;
             if (kind === 'passkey') {
@@ -517,8 +654,8 @@ export function createWeaveAuth(config = {}) {
                 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.
+            // Removing every shortcut leaves the account openable by its recovery
+            // code alone. 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'),
@@ -600,9 +737,12 @@ export function createWeaveAuth(config = {}) {
         dismissMoved() {
             update({ moved: null });
         },
-        accountPassword() {
+        recoveryCode() {
             return seed ? seedToRecoveryCode(seed) : null;
         },
+        accountPassword() {
+            return auth.recoveryCode();
+        },
         offerToPhone(onStage) {
             const session = state.session;
             if (!session || !seed)
@@ -630,12 +770,19 @@ export function createWeaveAuth(config = {}) {
             if (agent && request.contacts)
                 throw new Error('An agent is not given your contacts.');
             const whole = request.scope === 'account';
+            const app = { origin: choice.origin, ...(request.name ? { name: request.name.slice(0, 80) } : {}) };
+            // A proposal looking at a space the app isn't given is refused before anything is made. (It can't name one made for it.)
+            if (!agent && !whole)
+                subscriptionsFrom(request.notify ?? [], choice.notify, { app, reach: choice.spaceIds, carrier: false, account: session.did });
             const created = [];
             for (const params of request.create ?? [])
                 created.push(await node.spaces.create(params));
             // With the whole account the app derives the contacts space itself; otherwise it is one more space it is given.
             const contactsSpace = request.contacts && !whole ? await node.contacts.space() : null;
             const ids = [...new Set([...choice.spaceIds, ...created.map((space) => space.id), ...(contactsSpace ? [contactsSpace] : [])])];
+            // Subscriptions the app proposed and the person kept.
+            const looked = whole ? 'all' : ids.filter((id) => id !== contactsSpace);
+            const proposed = agent || (looked !== 'all' && looked.length === 0) ? [] : subscriptionsFrom(request.notify ?? [], choice.notify, { app, reach: looked, carrier: false, account: session.did });
             const spaces = [];
             for (const id of ids) {
                 const space = await node.spaces.get(id);
@@ -672,6 +819,8 @@ export function createWeaveAuth(config = {}) {
             // 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))]);
+            // Written by the home for the app. Connecting again adds nothing twice.
+            const notify = await addSubscriptions(node, choice.origin, proposed);
             return {
                 v: 1,
                 did: session.did,
@@ -687,8 +836,30 @@ export function createWeaveAuth(config = {}) {
                 ...(config.network?.relays?.length ? { relays: [...config.network.relays] } : {}),
                 expiresAt,
                 ...(agent ? { agent: true } : {}),
+                ...(notify.length ? { notify } : {}),
             };
         },
+        async propose({ origin, request, notify: kept }) {
+            const session = state.session;
+            if (!session)
+                throw new Error('Sign in first.');
+            const { node } = session;
+            const connection = auth.connections().find((known) => known.origin === origin && !known.agent);
+            if (!connection)
+                throw new Error('Only an app or extension connected to your account here may suggest what to notify you about. Connect it first.');
+            const carrier = connection.access === 'carry';
+            // What it may reach: every space for a carrier or a whole-account app, else the spaces it was given, less the contacts space.
+            let reach = 'all';
+            if (!carrier && connection.scope === 'spaces') {
+                const contactsSpace = connection.spaces.length ? await node.contacts.space().catch(() => null) : null;
+                reach = connection.spaces.map((space) => space.id).filter((id) => id !== contactsSpace);
+                if (reach.length === 0)
+                    throw new Error('It was given no spaces to notify you about.');
+            }
+            const app = { origin, ...(connection.name ? { name: connection.name } : request.name ? { name: request.name.slice(0, 80) } : {}) };
+            const when = subscriptionsFrom(request.notify, kept, { app, reach, carrier, account: session.did });
+            return { v: 1, kind: 'proposed', notify: await addSubscriptions(node, origin, when) };
+        },
         async grantCarry({ origin, request }) {
             const session = state.session;
             if (!session || !seed)
@@ -773,6 +944,13 @@ export function createWeaveAuth(config = {}) {
                     if (connection.scope === 'account')
                         await node.account.revoke(connection.token).catch(() => { });
                 }
+                // The app's own subscriptions go with it, and a carrier's: what they look for is theirs to know.
+                if (!connection.agent && node) {
+                    for (const sub of await node.notifications.list()) {
+                        if (sub.app?.origin === connection.origin)
+                            await node.notifications.remove(sub.id).catch(() => { });
+                    }
+                }
             }
             writeConnections(auth.connections().filter((known) => !goes(known)));
         },
@@ -784,7 +962,7 @@ export function createWeaveAuth(config = {}) {
         async signOut() {
             await stay.forget();
             const leaving = state.session?.node;
-            update({ stage: 'starting', session: null, entry: null, freshCode: null, podChoice: null, moved: null });
+            update({ stage: 'starting', session: null, entry: null, freshCode: null, setup: null, podChoice: null, moved: null });
             await stopNode(leaving).catch(() => { });
             const place = state.place;
             update({ stage: place ? afterStorage(await refresh(place)) : 'welcome' });