Derive the personal drive DID from the agent key

TESTING_COVERAGE.md

@@ -259,3 +259,27 @@ must compute the same differing set on either end of the wire. Both carry the
 same test names. A fix to one is a fix to the other; the golden-vector tests
 (`item_fingerprint_matches_golden_vector`) pin the hashing, but the *traversal*
 is only kept in step by mirroring the tests, so do that deliberately.
+
+`lib/src/genesis.rs` ↔ `browser/lib/src/genesis.ts` also share a personal-drive
+derivation (`personal_drive_subject` / `personalDriveSubject`). The cross-lang
+vector (`personal_drive_cross_lang_vector`) pins the nonce, signature, and DID.
+
+## Personal drive identity
+
+| Flow | Where |
+|---|---|
+| Same agent key → same personal-drive DID | `lib/src/genesis.rs`, `browser/lib/src/genesis.test.ts` |
+| Cross-language personal-drive vector | `genesis.rs` + `genesis.test.ts` |
+| Repeat genesis for that DID merges Loro state | `lib/src/commit.rs::repeat_personal_drive_genesis_merges` |
+| Repeat genesis without a cert is still rejected | `lib/src/commit.rs::repeat_genesis_without_cert_is_still_rejected` |
+| `createDrive({ personal: true })` uses the derived DID | `browser/lib/src/store.personal-drive.test.ts` |
+| Two stores with the same key mint the same subject | `store.personal-drive.test.ts` |
+| Extra drives are listed on the derived personal drive | `store.personal-drive.test.ts` |
+| Lists from a previous random-DID home are unioned onto the derived drive | `store.personal-drive.test.ts` |
+| `Agent.personalDriveSubject` matches the genesis helper | `agent.test.ts` |
+| `Db::setup` / `ensure_personal_drive` use the derived DID and are idempotent | `lib/src/db.rs::personal_drive_tests` |
+| Extra `Db::create_drive` is listed on the personal drive | `lib/src/db.rs::personal_drive_tests` |
+
+Not covered: Flutter `create_drive` still mints a random DID (the Rust
+`ensure_personal_drive` helper exists for `setup()`). E2E sign-in on a second
+machine with the old machine offline.

browser/data-browser/package.json

@@ -134,10 +134,10 @@
   },
   "scripts": {
     "build": "if [ \"$SKIP_WASM_BUILD\" = \"1\" ]; then echo 'SKIP_WASM_BUILD=1, skipping wasm-pack'; else pnpm build:wasm; fi && vite build",
-    "build:tauri": "pnpm build:wasm && TAURI=1 vite build",
+    "build:tauri": "pnpm --filter \"@tomic/lib\" --filter \"@tomic/react\" run build && pnpm build:wasm && TAURI=1 vite build",
     "build:wasm": "cd ../../wasm && export CARGO_TARGET_DIR=../target/wasm-pack && cargo bin wasm-pack --version && env -u CARGO_ENCODED_RUSTFLAGS -u RUSTFLAGS cargo bin wasm-pack build --target web --out-dir pkg && cp pkg/atomic_wasm.js pkg/atomic_wasm_bg.wasm ../browser/data-browser/public/wasm/",
     "dev": "vite",
-    "dev:tauri": "TAURI=1 vite",
+    "dev:tauri": "pnpm --filter \"@tomic/lib\" --filter \"@tomic/react\" run build && TAURI=1 vite",
     "format-check": "oxfmt -c ../.oxfmtrc.json --check ./src",
     "format": "oxfmt -c ../.oxfmtrc.json ./src",
     "lint": "oxlint -c ../.oxlintrc.json . && pnpm format-check",

browser/data-browser/src/App.tsx

@@ -112,7 +112,28 @@ const store = new Store({
 const initialDrive = driveStorage.get();
 
 if (initialDrive) {
-  store.setDrive(initialDrive);
+  // `setDrive` reads an http(s) subject as a SERVER ORIGIN and repoints the
+  // app at it. That is intended when the user opens an external drive, but
+  // restoring the last session is not that choice — and a stored URL from a
+  // previous switch would re-apply it on every launch, stranding the app on a
+  // server it cannot authenticate against with no obvious way back.
+  const restoresForeignServer =
+    /^https?:\/\//.test(initialDrive) &&
+    (() => {
+      try {
+        return new URL(initialDrive).origin !== new URL(serverUrl).origin;
+      } catch {
+        return true;
+      }
+    })();
+
+  if (restoresForeignServer) {
+    console.warn(
+      `[atomic] Ignoring stored drive '${initialDrive}': opening it would move this app to another server. Pick it from the drive switcher to switch deliberately.`,
+    );
+  } else {
+    store.setDrive(initialDrive);
+  }
 }
 
 // A deep link into a resource (share/show `?subject=` entry URL) starts the

browser/data-browser/src/chunks/RTE/useLoroSync.ts

@@ -73,7 +73,23 @@ export function useLoroSync(
     const unsub = store.subscribeLoroEphemeral(
       subject,
       (update: Uint8Array) => {
-        ephemeralStore.apply(update);
+        try {
+          ephemeralStore.apply(update);
+        } catch (e) {
+          // A cursor can arrive before the content it points into. Positions
+          // reference Loro containers, and a peer editing a document this
+          // device has not caught up on yet names containers the local doc
+          // does not have — Loro throws "The container does not exist in the
+          // doc". That became routine once presence started crossing peer
+          // links: the update travels on its own channel and does not wait for
+          // document state.
+          //
+          // Dropping it is correct. Presence is a snapshot of right now, so
+          // there is nothing to replay — the next update after the document
+          // catches up applies cleanly. Throwing here only produced an uncaught
+          // error per keystroke of someone else's typing.
+          console.debug('[presence] skipped a cursor for unsynced content:', e);
+        }
       },
     );
 

browser/data-browser/src/chunks/TablePage/QuickAddBar.tsx

@@ -1,5 +1,5 @@
 import { useStore, type Property, type Resource } from '@tomic/react';
-import { useState, type JSX } from 'react';
+import { useRef, useState, type JSX } from 'react';
 import { styled } from 'styled-components';
 import { FaPlus } from 'react-icons/fa6';
 import toast from 'react-hot-toast';
@@ -36,20 +36,20 @@ export function QuickAddBar({
   const store = useStore();
   const [typed, setTyped] = useState('');
   const [busy, setBusy] = useState(false);
+  /**
+   * Named while a save was still in flight, waiting its turn.
+   *
+   * A ref, not state: `submit` below reads it from inside a promise callback,
+   * where a state value would be whatever it was when that callback was
+   * created.
+   */
+  const queued = useRef<string[]>([]);
 
   // A spec with a field is asking for a value; creating a blank row instead
   // would be a worse guess than doing nothing.
   const ready = !spec.field || typed.trim() !== '';
 
-  const create = () => {
-    if (!ready || busy) {
-      return;
-    }
-
-    const value = typed.trim();
-    // Cleared up front, not after the save: anything typed while the save is in
-    // flight would otherwise be wiped when the reset landed.
-    setTyped('');
+  const submit = (value: string) => {
     setBusy(true);
 
     void createQuickAddRow(store, {
@@ -66,7 +66,41 @@ export function QuickAddBar({
         console.error('Failed to quick-add a row', error);
         toast.error(`Could not add the ${tableClass.title.toLowerCase()}`);
       })
-      .finally(() => setBusy(false));
+      .finally(() => {
+        const next = queued.current.shift();
+
+        if (next === undefined) {
+          setBusy(false);
+
+          return;
+        }
+
+        submit(next);
+      });
+  };
+
+  const create = () => {
+    if (!ready) {
+      return;
+    }
+
+    const value = typed.trim();
+    // Cleared up front, not after the save: anything typed while the save is in
+    // flight would otherwise be wiped when the reset landed.
+    setTyped('');
+
+    // Queued rather than dropped. This used to return early while a save was in
+    // flight, which lost the keystroke in silence — type, press enter, and
+    // nothing happens: no row, no error, the text still sitting in the field.
+    // Queueing keeps that from happening without letting the bar fire saves
+    // concurrently, which is load this runs under on the slowest devices.
+    if (busy) {
+      queued.current.push(value);
+
+      return;
+    }
+
+    submit(value);
   };
 
   return (

browser/data-browser/src/chunks/TablePage/TableResource.tsx

@@ -679,6 +679,33 @@ export const TableResource: React.FC<TableResourceProps> = ({
   // missing rows (surfacing as an unhandled rejection in
   // `useMemberFromCollection`). The clamp guards that instant; the filter
   // rebase effect below then recaptures a fresh baseline.
+  // A row can also arrive from somewhere this session knows nothing about: a
+  // paired peer, or another tab on the same drive. That grows the collection
+  // without going through the new-row flow, so the frozen baseline never moves
+  // and the grid keeps rendering the count it captured at load — the row is in
+  // the collection, in the store, complete, and simply never drawn. Measured
+  // against a paired node: `totalMembers` 8, `aria-setsize` 5.
+  //
+  // Freezing exists to stop a materialising session row from remounting; it was
+  // never meant to hide other people's rows. So account for what this session
+  // contributed — each materialised draft adds a member while still rendering
+  // from `newRowSubjects` — and let anything beyond that raise the baseline.
+  //
+  // Only ever raises it. Shrink stays with `decrementMemberCount` and the clamp
+  // below, and session rows keep their `_new:` key through the index shift
+  // (`itemKey` offsets by `memberCount`), so nothing remounts.
+  if (baselineMemberCountRef.current !== null) {
+    const materialisedSessionRows = newRowSubjects.filter(subject =>
+      store.isAliased(subject),
+    ).length;
+    const accountedFor =
+      baselineMemberCountRef.current + materialisedSessionRows;
+
+    if (collection.totalMembers > accountedFor) {
+      baselineMemberCountRef.current += collection.totalMembers - accountedFor;
+    }
+  }
+
   const memberCount = Math.min(
     baselineMemberCountRef.current ?? collection.totalMembers,
     collection.totalMembers,

browser/data-browser/src/helpers/agentStorage.ts

@@ -1,4 +1,9 @@
-import { Agent, SubtleCryptoProvider, JSCryptoProvider } from '@tomic/react';
+import {
+  Agent,
+  SubtleCryptoProvider,
+  JSCryptoProvider,
+  legacySubjectFromSecret,
+} from '@tomic/react';
 import { del, get, set } from 'idb-keyval';
 import { adoptAgentOnDevice } from './adoptAgent';
 import { clearSessionDbKeys, ensureDbKeyOnSignIn } from './localDbKey';
@@ -8,6 +13,24 @@ const AGENT_IDB_KEY = 'atomic.agent';
 interface StoredAgent {
   keyPair: CryptoKeyPair;
   subject: string;
+  /**
+   * Carried across restarts because they only exist on the secret, and the
+   * secret is read exactly once — at sign-in. Without them a restored Agent
+   * looks brand-new to the pre-DID migration, which reads both and returns at
+   * its first line, so a returning user's drives are never adopted. The
+   * migration then appears to do nothing forever, having run only in the
+   * session where the secret was pasted.
+   */
+  legacySubject?: string;
+  initialDrive?: string;
+  /**
+   * The derived personal-drive DID. Stored because it cannot be recomputed
+   * from the non-extractable keypair beside it: deriving it means signing, and
+   * WebCrypto signatures are not reproducible (see
+   * `Agent.personalDriveSubject`). Written at sign-in, while the secret is
+   * still readable.
+   */
+  personalDrive?: string;
 }
 
 /**
@@ -17,6 +40,11 @@ interface StoredAgent {
 interface StoredAgentFallback {
   privateKey: string;
   subject: string;
+  /** See {@link StoredAgent}. */
+  legacySubject?: string;
+  initialDrive?: string;
+  /** See {@link StoredAgent}. */
+  personalDrive?: string;
 }
 
 const AGENT_FALLBACK_KEY = 'atomic.agent.fallback';
@@ -44,7 +72,13 @@ export async function getAgentFromIDB(): Promise<Agent | undefined> {
         // readable copy below — a corrupt keypair must not lock the user out.
         await provider.sign('atomic-key-check');
 
-        const agent = new Agent(provider, storedAgent.subject);
+        const agent = new Agent(
+          provider,
+          storedAgent.subject,
+          storedAgent.initialDrive,
+        );
+        agent.legacySubject = storedAgent.legacySubject;
+        agent.personalDrive = storedAgent.personalDrive;
 
         // Heal installs written while the readable key was saved
         // unconditionally: a plaintext copy beside a non-extractable key hands
@@ -68,10 +102,15 @@ export async function getAgentFromIDB(): Promise<Agent | undefined> {
 
   if (fallback) {
     try {
-      return new Agent(
+      const agent = new Agent(
         new JSCryptoProvider(fallback.privateKey),
         fallback.subject,
+        fallback.initialDrive,
       );
+      agent.legacySubject = fallback.legacySubject;
+      agent.personalDrive = fallback.personalDrive;
+
+      return agent;
     } catch (e) {
       console.error('Failed to load agent from fallback:', e);
     }
@@ -135,9 +174,20 @@ export async function saveAgentToIDB(
     throw new Error('Subject is required');
   }
 
+  // Preserve the secret-only fields: this overload re-stores a keypair and
+  // has no secret to re-derive them from, and dropping them would silently
+  // disable the migration for a returning user.
+  const previous = (await get(AGENT_IDB_KEY)) as StoredAgent | undefined;
+
   await set(AGENT_IDB_KEY, {
     keyPair: keyPairOrSecret,
     subject,
+    legacySubject:
+      previous?.subject === subject ? previous.legacySubject : undefined,
+    initialDrive:
+      previous?.subject === subject ? previous.initialDrive : undefined,
+    personalDrive:
+      previous?.subject === subject ? previous.personalDrive : undefined,
   } satisfies StoredAgent);
 }
 
@@ -149,6 +199,9 @@ async function storeSecret(secret: string): Promise<void> {
   // the only moment it passes through JS once the keypair is stored
   // non-extractably.
   const decoded = JSON.parse(atob(secret));
+  // Derived here, once, from the raw key — the stored keypair cannot
+  // reproduce it. See `StoredAgent.personalDrive`.
+  const personalDrive = await Agent.personalDriveSubjectFromSecret(secret);
 
   {
     // Prefer the non-extractable keypair. Once stored this way the private key
@@ -161,6 +214,9 @@ async function storeSecret(secret: string): Promise<void> {
         await set(AGENT_IDB_KEY, {
           keyPair,
           subject: resolvedSubject,
+          legacySubject: legacySubjectFromSecret(secret),
+          initialDrive: decoded.initialDrive,
+          personalDrive,
         } satisfies StoredAgent);
         await del(AGENT_FALLBACK_KEY);
 
@@ -179,6 +235,9 @@ async function storeSecret(secret: string): Promise<void> {
     await set(AGENT_FALLBACK_KEY, {
       privateKey: decoded.privateKey,
       subject: newSubject,
+      legacySubject: legacySubjectFromSecret(secret),
+      initialDrive: decoded.initialDrive,
+      personalDrive,
     } satisfies StoredAgentFallback);
     // Drop a keypair from a previous account, so it can't be loaded instead.
     await del(AGENT_IDB_KEY);

browser/data-browser/src/helpers/managedServer.ts

@@ -9,6 +9,11 @@ export type ServerPeer = {
   deviceName: string | null;
   /** Whether it holds a connection to the server right now. */
   live: boolean;
+  /** Unix millis of the last successful sync, if it has ever synced. */
+  lastSeen?: number;
+  /** Resources moved by that last sync, each way. Not lifetime totals. */
+  lastSent?: number;
+  lastReceived?: number;
 };
 
 /**
@@ -90,6 +95,18 @@ export async function fetchManagedInfo(
                   nodeId,
                   deviceName: readString(p?.[peerProps.deviceName]),
                   live: p?.[peerProps.live] === true,
+                  lastSeen:
+                    typeof p?.[peerProps.lastSeen] === 'number'
+                      ? (p[peerProps.lastSeen] as number)
+                      : undefined,
+                  lastSent:
+                    typeof p?.[peerProps.lastSent] === 'number'
+                      ? (p[peerProps.lastSent] as number)
+                      : undefined,
+                  lastReceived:
+                    typeof p?.[peerProps.lastReceived] === 'number'
+                      ? (p[peerProps.lastReceived] as number)
+                      : undefined,
                 }
               : null;
           })