frontend/apps/desktop, package @shm/desktop: Electron 39 with Electron Forge and Vite 6, React 18, tRPC over Electron IPC, React Query, Tailwind. The main process is src/main.ts, the preload is src/preload.ts, and the renderer starts at src/root.tsx and dispatches routes from src/pages/main.tsx. The editor is @shm/editor. The agents interface is the shared @shm/ui agents code. Run it with ./dev run-desktop after ./dev has built the daemon, or pnpm desktop alone.

The app is four processes. The main process spawns the daemon with -http.port, -grpc.port, -p2p.port and -data-dir, waits for /debug/version, then starts its own HTTP server and finally a local agents server.

The renderer and the main process both talk to the daemon over gRPC-web on the HTTP port. TypeScript does not use the native gRPC port. The renderer and main process talk to each other over tRPC. The API bridge on 56004 serves the same typed /api/<Key> protocol as a web site, from the same code. So the CLI, the local agents server and the renderer itself can use the Seed API against the local node. The bridge refuses cross-site browser requests.

Two things run once per app in the main process rather than once per window. The sync service, src/app-sync.ts, keeps a reference-counted list of the resources any window is showing, runs discovery for each of them on a loop, polls the daemon's activity feed, and broadcasts React Query invalidations to every window. Its intervals stretch ten times when no window is focused. The notification store described on Notify lives there too. Windows also share hover state: pointing at a block or a resource broadcasts hypermediaHoverIn over IPC, and every window highlights the elements with the matching data-blockid or data-resourceid.

User data is Electron's per-platform application-data folder: ~/Library/Application Support/Seed on macOS, ~/.config/Seed on Linux, %APPDATA%\Seed on Windows. Inside it, daemon/ is the daemon's data directory with the SQLite database, the device key and the encrypted vault. drafts/ holds drafts as files. Drafts and navigation state belong to the app, and the daemon does not store them. So drafts do not sync between devices. Published documents and private documents do sync. In development the folder is Seed-local, so a dev app and a production app can run side by side.

Every document goes through the same four states: loading, viewing, editing, publishing.

Loading. The app asks the local daemon. If the document is not there, the daemon discovers it from peers.

Viewing. Read-only. If you have edit access and left a draft, the app reopens it in editing mode.

Editing. Autosave writes a draft about half a second after you stop typing. It creates the draft on the first change and updates it after that. Saves queue, so keystrokes during a save are never lost. Cancel discards the draft.

Publishing. The draft becomes a signed change and ref, published through the daemon. On success the draft is deleted. On failure you are back in editing with the draft intact.

Switching to an account without edit access saves the draft and leaves editing. If a newer version is published elsewhere while you edit, the app notes it and does not force it on you. The whole flow is one state machine in @shm/shared, shared with the web app.

"New" on a document creates a child draft in place: a card with an editable title appears at the bottom of the parent, and opening it goes to the full editor. Every unpublished child draft of the document you are viewing shows as a card there. The parent is not changed until the child publishes, so there is nothing to discard on it. The write is built by buildInlineDraftWrite in @shm/shared and stored like any other draft.

@shm/editor (frontend/packages/editor) is a TipTap 2 editor over ProseMirror, derived from BlockNote. Its ProseMirror schema is three layers: blockChildren (a list with a listType of Group, Unordered, Ordered or Blockquote) holds blockNodes, and each blockNode holds one content block (paragraph, heading, image, embed, query and so on) and an optional blockChildren of its own. The rendered DOM carries data-node-type, data-content-type and data-id so styles and tests can target blocks without depending on class names. The block format on the wire is the SDK's HMBlock; the conversion both ways lives in the SDK (hmblock-to-editorblock), and the editor never changes it.

Pasted HTML arrives from ProseMirror's parser as a flat list, so transformPasted in BlockChildren.ts hands it to normalizeFragment.ts, which rebuilds the nested blockNode structure before insertion.

Typography is one class. .hm-prose, defined in @shm/ui (src/hm-prose.css) on top of @tailwindcss/typography, sets the font stacks, heading scale and block rhythm in relative units, keyed off the data-node-type and data-content-type attributes. The same class is applied to the draft editor, the read-only viewer, embeds, comment bodies (.hm-prose.is-comment) and the server-rendered HTML on the web, so a document looks the same in all of them. Size modifiers .hm-prose-sm, -base, -lg and -xl scale a whole surface.

Two desktop-only surfaces expose the protocol directly.

The metadata editor is a tab on every document. It edits metadata as a form or as JSON and stages patches through the same document machine as the settings panel. Removing a key stages an explicit null, so the published change clears it. Renaming stages a removal and an addition. Lists are disabled because the attribute operation has no list value type yet.

The blob editor, the raw-blob route, opens any ipfs:// CID that decodes as DAG-CBOR and shows it as DAG-JSON. You can edit it and publish it as a new blob with a sha2-256 CID. It reads through the daemon's /ipfs/<cid>.dagjson route, which searches the network if the blob is not local. Links and bytes are converted back to real IPLD values before encoding, so republishing a blob with links does not corrupt them.

A blob you publish this way is stored but is not public until a public change, comment or profile links its CID. See Files.

CLI

SDK

Web API

Agents

Notifications

The daemon, The agents service, The CLI, The web app

Documents, Identity, Publish a folder

Seed Hosting