diff --git a/.agents/settings.json b/.agents/settings.json
deleted file mode 100644
index b7cc7ae5..00000000
--- a/.agents/settings.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "hooks": {
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "statusMessage": "Checking added comments",
-            "command": "cd \"${CLAUDE_PROJECT_DIR:-.}\" && git diff HEAD -U0 -- src | grep -E '^\\+' | grep -v '^+++' | grep -E '//|/\\*|\\*/|<!--' | sed 's/^+[[:space:]]*//' | jq -R -s 'select(length > 0) | {systemMessage: (\"Comment lines added to src/ — check each against the Cleanup Pass rule in AGENTS.md. Only genuinely surprising things: a workaround, an external constraint, an invariant not visible from the code. Not restating the next line, not justifying an ordinary decision.\\n\\n\" + .)}' 2>/dev/null || true"
-          }
-        ]
-      }
-    ]
-  }
-}
diff --git a/.agents/skills/welshman-app/SKILL.md b/.agents/skills/welshman-app/SKILL.md
index 9b35287c..c2d33f18 100644
--- a/.agents/skills/welshman-app/SKILL.md
+++ b/.agents/skills/welshman-app/SKILL.md
@@ -1,634 +1,279 @@
 ---
 name: welshman-app
-description: "Use this skill when working with @welshman/app: high-level Svelte stores for nostr apps, session management, WoT (web of trust), making requests, publishing events, user data, or relay selection at the app layer."
+description: "Use this skill when working with @welshman/app: the App instance and its plugins, sessions and login, publishing via Commands and Thunks, app policies, WoT, feeds, sync, or relay selection at the app layer."
 ---
 
-# welshman/app — Application Layer Stores
+# welshman/app — The App Instance and its Plugins
 
-`@welshman/app` is the top-level application framework in the welshman stack. It wires together `@welshman/net` (subscriptions/publishing), `@welshman/store` (reactive collections), `@welshman/router` (relay selection), and `@welshman/signer` (key management) into ready-to-use Svelte stores and high-level utilities. It powers production apps like Coracle and Flotilla.
+`@welshman/app` composes `net`, `store`, `domain`, `signer`, and `feeds` into an application
+framework built around a single `App` object.
 
 ## Installation
 
 ```bash
-npm install @welshman/app
-# or
-pnpm add @welshman/app
-yarn add @welshman/app
+npm i @welshman/app
 ```
 
-## Key Exports
+## The App
 
-### Core Singletons
+```typescript
+import {App, createApp, User} from "@welshman/app"
 
-| Export | Description |
+const app = createApp({
+  user: await User.fromSigner(signer),   // omit for a signed-out app
+  config: {
+    dufflepudUrl: "https://dufflepud.example.com",
+    getDefaultRelays: () => ["wss://relay.example.com"],
+    getIndexerRelays: () => ["wss://indexer.example.com"],
+    getSearchRelays: () => ["wss://search.example.com"],
+  },
+  getAdapter,                            // optional: custom net adapters (tests, mocks)
+  policies,                              // optional: overrides the defaults
+})
+```
+
+An `App` owns everything scoped to one identity:
+
+| Property | What it is |
 |---|---|
-| `repository` | Singleton `Repository` from `@welshman/net`; non-DVM, non-ephemeral events received from the pool are stored here. WRAP (NIP-59) events are handled separately via `unwrapAndStore` and require `shouldUnwrap` to be set to `true` to process. |
-| `tracker` | Singleton `Tracker`; maps event IDs to the relays they were seen on |
+| `app.user` | the signed-in `User`, or `undefined` |
+| `app.config` | the `AppConfig` above |
+| `app.repository` | this identity's event store |
+| `app.tracker` | which relays each event was seen on |
+| `app.pool` | socket pool |
+| `app.wrapManager` | NIP-59 gift wrap bookkeeping |
+| `app.netContext` | `{pool, repository, getAdapter}` for the net layer |
+| `app.use(Plugin)` | resolve a per-app plugin singleton |
+| `app.cleanup()` | run policy teardown and clear pool/tracker/repository |
 
-### Session Management
+`createApp` is `new App` plus `defaultAppPolicies`. Use `new App({policies: [...]})` for a bare app.
 
-| Export | Description |
+**An app is scoped to one identity.** To log in, build a *new* app and `cleanup()` the old one —
+never attach a user to an existing app. That's what keeps one account's data out of another's
+repository.
+
+## Plugins
+
+`app.use(Ctor)` constructs the plugin on first use and memoizes it per app, so calling it inline
+is cheap and idiomatic:
+
+```typescript
+app.use(Profiles).load(pubkey)
+app.use(RelayLists).writeUrls(pubkey).get()
+```
+
+### Plugin base classes
+
+| Base | Shape |
 |---|---|
-| `pubkey` | `Writable<string \| undefined>` — active session's pubkey |
-| `session` | `Readable<Session \| undefined>` — derived from `pubkey` + `sessions` |
-| `sessions` | `Writable<Record<string, Session>>` — all loaded sessions |
-| `signer` | `Readable<ISigner \| undefined>` — signer for the active session |
-| `signerLog` | `WritableWithGetter<SignerLogEntry[]>` — writable store that the session layer appends signer-operation entries to (useful for UI feedback during remote signing) |
-| `SessionMethod` | Enum: `Nip01`, `Nip07`, `Nip46`, `Nip55`, `Pomade`, `Pubkey`, `Anonymous` |
+| `MapPlugin<T>` | a plain keyed map of non-event data (relay stats, NIP-11 info) |
+| `LoadableMapPlugin<T>` | a `MapPlugin` that knows how to `fetch(key)` from the network |
+| `DerivedPlugin<T>` | a keyed collection **derived from the repository** — the repository is the source of truth, never a duplicated map |
+| `RelayScopedDerivedPlugin<T>` | keyed by `getKey(item, url)` per relay, for data that only means something relative to a relay |
+| `RelaySignedDerivedPlugin<T>` | the same, but only accepts events authored by the relay's NIP-11 `self` pubkey (NIP-29 room state, relay membership/roles) |
 
-**Login functions** (all call `addSession` internally):
+Derived plugins expose:
+
+- `index` — `Projection<ItemsByKey<T>>`
+- `all` — `Projection<T[]>`
+- `one(key)` — a store for a single key, loading it on first subscribe
+- `get(key)` — synchronous snapshot
+- `load(key)` / `forceLoad(key)` — network fetch (cached / uncached)
+- `project(key, read)` — a `Projection` derived from one key
+
+A **`Projection<T>` is `{get(): T, $: Readable<T>}`** — bind `.$` in markup, call `.get()` in
+callbacks and hot paths. Build new ones with `projection(store)` or `projectFrom(source, read)`.
+
+### Available plugins
+
+**Core:** `Network`, `Router`, `Domain`, `Thunks`, `Sync`, `Logger`, `Plaintext`
+
+**Relays:** `Relays` (NIP-11), `RelayStats`, `RelayManagement` (NIP-86), `RelayLists`,
+`BlockedRelayLists`, `SearchRelayLists`, `MessagingRelayLists`, `BlossomServerLists`
+
+**People:** `Profiles`, `FollowLists`, `MuteLists`, `Handles`, `Zappers`, `Wot`, `Topics`
+
+**Content:** `Reactions`, `Deletes`, `Pins`, `Pinboards`, `Feeds`, `FeedLists`, `Wraps`
+
+**NIP-29 / membership:** `Rooms`, `RoomLists`, `RoomPinLists`, `RelayMemberLists`, `RelayRoles`
+
+## Sessions and login
+
+A `Session` is `{method, ...data}`, serializable so you can persist it. Handlers convert one into
+a signer: `nip01`, `nip07`, `nip46`, `nip55`, `pomade`, plus `registerSessionHandler` for your own.
 
 ```typescript
-loginWithNip01(secret: string): void
-loginWithNip07(pubkey: string): void
-loginWithNip46(pubkey, clientSecret, signerPubkey, relays): void
-loginWithNip55(pubkey: string, signerPackageName: string): void
-loginWithPomade(pubkey, email, clientOptions): void
-loginWithPubkey(pubkey: string): void   // read-only
+import {User, createApp, nip07, toSession} from "@welshman/app"
+
+const session = toSession(nip07, {pubkey})
+const user = await User.fromSession(session)   // undefined if the handler can't build a signer
+
+const app = createApp({user})
 ```
 
-**Session utilities**:
+`User` wraps a signer and pubkey:
+
+- `User.fromSigner(signer)` / `User.fromSession(session)`
+- `User.require(app)` — the signed-in user or **throws**; use on paths that require login
+- `user.sign(event)`, `user.wrapSigner(fn)`
+
+Persist the `Session`, not the `User` — rebuild the user on startup and construct the app with it.
+
+## Publishing
+
+Two layers, and you usually want the first.
+
+### Commands
+
+A `Command` owns a rendered event plus the relays routing resolved for it:
 
 ```typescript
-addSession(session: Session): void        // add and activate
-dropSession(pubkey: string): void         // remove and clean up signer
-getSession(pubkey: string): Session | undefined
-updateSession(pubkey, fn): void
-clearSessions(): void
-nip46Perms: string                        // default NIP-46 permission string
+import {Domain, publish} from "@welshman/app"
+import {Note} from "@welshman/domain"
+
+const writer = app.use(Domain).writer(Note).setContent("hello")
+const command = await app.use(Domain).command(writer)
+
+command.publish()                 // to the resolved relays
+command.publishToRelays(urls)     // to specific relays
+command.publishAsRelay(url)       // signed by the relay itself (NIP-86)
 ```
 
-**Gift wrap (NIP-59)**:
+Plugin mutators already return a `Command`, so `.then(publish)` is the common shape:
 
 ```typescript
-shouldUnwrap: Writable<boolean>           // must be true to process incoming wraps
-wrapManager: WrapManager                  // tracks wrap↔rumor mappings
-unwrapAndStore(wrap: SignedEvent): Promise<void>
+await app.use(FollowLists).follow(["p", pubkey]).then(publish)
+await app.use(RelayLists).addWriteUrl(url).then(publish)
 ```
 
-### Publishing — Thunks
+Free-function forms exist for pipelines: `publish`, `publishToRelays(urls)`,
+`publishAsRelay(url)`, `signAsRelay(url)`.
 
-| Export | Description |
-|---|---|
-| `publishThunk(options: ThunkOptions): Thunk` | Create, enqueue, and optimistically publish an event |
-| `Thunk` | Class representing a single in-flight publish |
-| `MergedThunk` | Aggregates multiple `Thunk`s (used by `sendWrapped`) |
-| `thunks` | `Writable<Thunk[]>` — all active thunks |
-| `abortThunk(thunk)` | Abort all constituent thunks |
-| `retryThunk(thunk)` | Re-publish with original options |
-| `mergeThunks(thunks[])` | Combine into a `MergedThunk` |
+### Thunks
 
-**Thunk status helpers**:
+`app.use(Thunks).publish({event, relays, delay})` publishes optimistically: the event lands in the
+local repository immediately, so the UI updates before the network settles. The returned `Thunk`
+is a store you can render:
 
 ```typescript
-thunkIsComplete(thunk): boolean
-getThunkError(thunk): string | undefined
-getThunkUrlsWithStatus(statuses, thunk): string[]
-getCompleteThunkUrls(thunk): string[]
-getFailedThunkUrls(thunk): string[]
-waitForThunkError(thunk): Promise<string>
-waitForThunkCompletion(thunk): Promise<void>
+const thunk = app.use(Thunks).publish({event, relays})
+
+thunk.getUrlsWithStatus(PublishStatus.Success)
+thunk.getFailedUrls()
+thunk.isComplete()
+await thunk.waitForError()        // "" when everything succeeded
+await thunk.waitForCompletion()
 ```
 
-`ThunkOptions`:
+`app.use(Thunks).history` is a writable of every thunk this app has published — useful for a
+"sending" indicator or deciding which relays the user has actually written to.
+
+## Requests
+
 ```typescript
-type ThunkOptions = {
-  event: EventTemplate   // unsigned — will be signed lazily
-  relays: string[]
-  recipient?: string     // if set, event is NIP-59 gift-wrapped
-  delay?: number         // ms to wait before sending (abort window)
-  pow?: number           // proof-of-work difficulty target
-  timeout?: number       // ms per relay before marking as timed out
-  // PublishOptions callbacks: onSuccess, onFailure, onPending, onTimeout, onAborted, onComplete
+const network = app.use(Network)
+
+network.load({relays, filters})            // batched, deduped, shared loader
+network.request({relays, filters, onEvent})
+network.publish({event, relays})
+network.loadUsingOutbox(pubkey, filter)     // newest matching event from the author's write relays
+network.loadAllUsingOutbox(pubkey, filter)  // every matching event
+```
+
+Prefer a plugin's `one(key)` / `load(key)` when one exists — they handle outbox routing and
+caching for you. The bare `load`/`request`/`publish` from `@welshman/net` need an explicit
+`context`; `Network` supplies `app.netContext`.
+
+## Relay selection
+
+Routing is the `RelaySelection` DSL from `@welshman/util`, resolved by `app.use(Router)`:
+
+```typescript
+import {outbox, inbox, seen, userOutbox, indexers, relay, relays} from "@welshman/util"
+
+const scenario = await app.use(Router).resolve([userOutbox(), outbox(pubkey)])
+const urls = scenario.getUrls()
+
+// single best relay for a route
+const hint = await app.use(Router).resolver.relay([outbox(event.pubkey)])
+```
+
+Selections are weighted (`outbox(pubkey, 2)`), and resolution is **async** — it may need to load
+the target's relay list first.
+
+## App policies
+
+An `AppPolicy` is `(app) => Unsubscriber`, applied once at construction and torn down by
+`cleanup()`. Policies own everything that subscribes or wires components together, keeping the
+data classes free of side effects.
+
+Built-ins: `appPolicyIngest`, `appPolicyRelayStats`, `appPolicyWraps`, `appPolicyCacheDecrypt`,
+`appPolicyLogSignerMethods`, plus auth: `appPolicyAuthNever`, `appPolicyAuthAlways`,
+`appPolicyAuthUnlessBlocked`, and `makeAppPolicyAuth(shouldAuth)` for a custom predicate.
+
+```typescript
+const app = createApp({
+  user,
+  policies: [...defaultAppPolicies, appPolicyAuthUnlessBlocked, myPolicy],
+})
+
+const myPolicy: AppPolicy = app => {
+  const unsubscribe = on(app.repository, "update", handleUpdate)
+
+  return unsubscribe
 }
 ```
 
-### Commands (Higher-level Thunk Factories)
+**Ordering gotcha:** policies run in the `App` constructor. If a policy module imports something
+that transitively imports your app module, construct the app lazily (on first access) so every
+policy has registered by the time it's built.
 
-Most return a `Thunk` (or `Promise<Thunk>`). They automatically load the relevant user list before modifying it. Exception: `manageRelay` returns `Promise<Response>` (an HTTP response from the NIP-86 management endpoint), not a Thunk.
-
-| Export | Description |
-|---|---|
-| `setProfile(profile: Profile)` | Publish NIP-01 profile metadata |
-| `follow(tag: string[])` | Add to NIP-02 follow list |
-| `unfollow(value: string)` | Remove from follow list |
-| `mutePublicly(tag)` | Add to public mute list |
-| `mutePrivately(tag)` | Add to private (encrypted) mute list |
-| `unmute(value)` | Remove from mute list |
-| `setMutes({publicTags?, privateTags?})` | Replace entire mute list |
-| `pin(tag)` / `unpin(value)` | Manage pin list |
-| `addRelay(url, mode)` / `removeRelay(url, mode)` | NIP-65 relay list management |
-| `setRelays(tags)` / `setReadRelays(urls)` / `setWriteRelays(urls)` | Bulk relay list updates |
-| `addMessagingRelay(url)` / `removeMessagingRelay(url)` | NIP-17 messaging relay list |
-| `addBlockedRelay(url)` / `removeBlockedRelay(url)` | Blocked relay list |
-| `addSearchRelay(url)` / `removeSearchRelay(url)` | Search relay list |
-| `sendWrapped({event, recipients, ...options})` | NIP-59 gift-wrap to multiple recipients |
-| `manageRelay(url, request)` | NIP-86 relay management |
-| `createRoom` / `editRoom` / `deleteRoom` / `joinRoom` / `leaveRoom` | NIP-29 group room management |
-
-### Profiles
+## Web of trust
 
 ```typescript
-profilesByPubkey: Readable<Map<string, Profile>>
-profiles: Readable<Profile[]>
-getProfile(pubkey: string): Profile | undefined
-loadProfile(pubkey, relayHints?): Promise<void>
-forceLoadProfile(pubkey, relayHints?): Promise<void>
-deriveProfile(pubkey: string): Readable<Profile | undefined>  // auto-loads
-deriveProfileDisplay(pubkey: string): Readable<string>         // display name with fallback
-displayProfileByPubkey(pubkey: string): string                 // synchronous
+const wot = app.use(Wot)
+
+wot.follows(pubkey).get()
+wot.followers(pubkey).get()
+wot.network(pubkey).$              // follows-of-follows
+wot.followsWhoFollow(pubkey, target).$
+wot.wotScore(pubkey, target).$
 ```
 
-### Follow / Mute / Pin Lists
-
-Each list type follows the same pattern (`follow` shown, `mute` and `pin` are identical):
+## Feeds and sync
 
 ```typescript
-followListsByPubkey: Readable<Map<string, List>>
-followLists: Readable<List[]>
-getFollowList(pubkey): List | undefined
-loadFollowList(pubkey, relayHints?): Promise<void>
-forceLoadFollowList(pubkey, relayHints?): Promise<void>
-deriveFollowList(pubkey): Readable<List | undefined>
+app.use(Feeds).makeFeedController({feed, onEvent, ...})
+app.use(Feeds).getPubkeysForScope(scope)
+app.use(Feeds).forAuthor(pubkey).$
+
+app.use(Sync).pull({relays, filters})   // negentropy: fetch what we're missing
+app.use(Sync).push({relays, filters})   // publish what the relay is missing
 ```
 
-### Relay Lists
+## Using welshman stores outside Svelte
+
+Projections and plugin stores implement the Svelte store contract — `subscribe(cb) → unsubscribe`,
+firing synchronously with the current value — so they adapt to any reactive framework with a small
+hook. Only the `svelte/store` *types* are needed, not the runtime.
 
 ```typescript
-// NIP-65 relay lists
-relayListsByPubkey / relayLists / getRelayList / loadRelayList / deriveRelayList
+// React
+const useStore = <T>(store: Readable<T>): T => {
+  const [value, setValue] = useState<T>(() => get(store))
 
-// NIP-17 messaging relay lists
-messagingRelayListsByPubkey / messagingRelayLists / getMessagingRelayList / loadMessagingRelayList / deriveMessagingRelayList
-
-// Blocked relay lists
-blockedRelayListsByPubkey / getBlockedRelayList / loadBlockedRelayList / deriveBlockedRelayList
-
-// Search relay lists (internal only — not exported from @welshman/app)
-// Use userSearchRelayList / loadUserSearchRelayList / forceLoadUserSearchRelayList from user.ts instead
-```
-
-### Outbox Loading
-
-`makeOutboxLoader` creates a loader function for any event kind. It looks up the target pubkey's relay list (fetching it if needed), then fetches events from their write relays using the outbox model. This is the internal mechanism used by all built-in `loadX` helpers.
-
-```typescript
-import {makeOutboxLoader} from '@welshman/app'
-
-// Signature: makeOutboxLoader(kind, filter?, limit?)
-// Returns: (pubkey: string, relayHints?: string[]) => Promise<void>
-// Results are stored in repository — read via the derived store/getter, not the return value.
-
-// Loader for kind 1 notes (default limit = 1)
-const loadNote = makeOutboxLoader(1)
-await loadNote('target-pubkey')
-
-// With extra filter constraints
-const loadRecentNotes = makeOutboxLoader(1, {since: Math.floor(Date.now() / 1000) - 86400})
-await loadRecentNotes('target-pubkey')
-
-// Override the limit via the third positional argument (not inside the filter object)
-const loadMany = makeOutboxLoader(1, {}, 20)
-await loadMany('target-pubkey')
-
-// With relay hints to seed the lookup
-await loadNote('target-pubkey', ['wss://relay.damus.io/'])
-```
-
-**Relay URL helpers** (exported from index):
-
-```typescript
-getPubkeyRelays(pubkey: string, mode?: RelayMode): string[]
-derivePubkeyRelays(pubkey: string, mode?: RelayMode): Readable<string[]>
-```
-
-### User Data Stores (current session)
-
-These automatically derive from the active `pubkey` and trigger a load on first access:
-
-```typescript
-userProfile: Readable<Profile | undefined>
-userFollowList: Readable<List | undefined>
-userMuteList: Readable<List | undefined>
-userPinList: Readable<List | undefined>
-userRelayList: Readable<List | undefined>
-userMessagingRelayList: Readable<List | undefined>
-userSearchRelayList: Readable<List | undefined>
-userBlockedRelayList: Readable<List | undefined>
-userBlossomServerList: Readable<List | undefined>
-```
-
-Corresponding loaders (operate on the current session's pubkey):
-
-```typescript
-loadUserProfile(relays?)
-forceLoadUserProfile(relays?)
-loadUserFollowList / forceLoadUserFollowList
-loadUserMuteList / forceLoadUserMuteList
-loadUserPinList / forceLoadUserPinList
-loadUserRelayList / forceLoadUserRelayList
-loadUserMessagingRelayList / forceLoadUserMessagingRelayList
-// ...etc for each list type
-```
-
-### Router
-
-```typescript
-import {Router, routerContext, addMaximalFallbacks, addMinimalFallbacks} from '@welshman/router'
-
-// The index.ts wires up routerContext automatically:
-// routerContext.getUserPubkey, getPubkeyRelays, getRelayQuality, getDefaultRelays, etc.
-
-Router.get()                        // singleton with app-wired context
-Router.get().FromUser()             // relays to publish from the current user
-Router.get().ForPubkey(pubkey)      // relays to read a pubkey's events
-Router.get().Event(event)           // best relay for a specific event
-Router.get().Index()                // indexer/bootstrap relays
-Router.get().FromRelays(urls)       // relay set from explicit URLs
-  .policy(addMaximalFallbacks)      // add fallback relays
-  .limit(8)
-  .getUrls()                        // string[]
-  .getUrl()                         // string | undefined (first)
-```
-
-`routerContext` settings (configure before using router):
-
-```typescript
-import {routerContext} from '@welshman/router'  // from @welshman/router, not @welshman/app
-
-routerContext.getDefaultRelays = () => ["wss://relay.damus.io/", "wss://nos.lol/"]
-```
-
-### Tag Utilities
-
-```typescript
-tagPubkey(pubkey: string): string[]          // ["p", pubkey, relayHint, displayName]
-tagEvent(event, url?, mark?): string[][]     // e-tag (+ a-tag if replaceable)
-tagEventPubkeys(event): string[][]           // p-tags for all mentioned pubkeys (excl. self)
-tagEventForQuote(event, relay?): string[]    // q-tag
-tagEventForReply(event, relay?): string[][]  // full reply thread tags
-tagEventForComment(event, relay?): string[][]// NIP-22 comment tags
-tagEventForReaction(event, relay?): string[][]// reaction tags
-tagZapSplit(pubkey, split?): string[]        // zap tag
-```
-
-### Web of Trust (WoT)
-
-```typescript
-// Reactive stores
-followersByPubkey: Readable<Map<string, Set<string>>>
-mutersByPubkey: Readable<Map<string, Set<string>>>
-wotGraph: Writable<Map<string, number>>  // pubkey → score; rebuilt on follow/mute changes
-maxWot: Readable<number>
-
-// Synchronous getters
-getFollows(pubkey): string[]
-getMutes(pubkey): string[]
-getFollowers(pubkey): string[]
-getMuters(pubkey): string[]
-getNetwork(pubkey): string[]             // follows-of-follows (excludes direct follows)
-getFollowsWhoFollow(pubkey, target): string[]
-getFollowsWhoMute(pubkey, target): string[]
-getWotScore(pubkey, target): number      // follows-who-follow minus follows-who-mute
-
-// Per-user reactive score
-getUserWotScore(tpk: string): number
-deriveUserWotScore(tpk: string): Readable<number>
-```
-
-### Handles & Zappers
-
-```typescript
-handlesByNip05: Writable<Map<string, Handle>>
-deriveHandle(nip05: string): Readable<Handle | undefined>   // auto-loads
-loadHandle(nip05): Promise<void>
-
-zappersByLnurl: Writable<Map<string, Zapper>>
-deriveZapper(lnurl: string): Readable<Zapper | undefined>   // auto-loads
-loadZapper(lnurl): Promise<void>
-```
-
-### Feeds
-
-```typescript
-import {makeFeedController} from '@welshman/app'
-import {makeKindFeed} from '@welshman/feeds'
-
-// makeFeedController wraps FeedController with app-level scope/WoT helpers
-const ctrl = makeFeedController({
-  feed: makeKindFeed(NOTE),
-  useWindowing: true,
-  signal: abortController.signal,
-  onEvent: (e) => { /* handle event */ },
-  onExhausted: () => { /* no more events */ },
-})
-
-ctrl.load(100)
-abortController.abort()
-```
-
-WoT-scoped feed helpers (passed automatically to `FeedController`):
-
-```typescript
-getPubkeysForScope(scope: string): string[]   // Scope.Self|Follows|Network|Followers
-getPubkeysForWOTRange(min: number, max: number): string[]  // fractional of maxWot
-```
-
-### Sync (Negentropy)
-
-```typescript
-import {pull, push, hasNegentropy} from '@welshman/app'
-
-// pull/push use negentropy if the relay supports it, falling back to plain requests
-await pull({relays, filters})
-await push({relays, filters})
-hasNegentropy(url: string): boolean
-```
-
-### Application Context
-
-```typescript
-import {appContext} from '@welshman/app'
-
-appContext.dufflepudUrl = 'https://my-dufflepud.example.com'
-```
-
-[Dufflepud](https://github.com/coracle-social/dufflepud) is an optional proxy server for NIP-05 lookups, zapper resolution, relay metadata, and link previews. Not required but helps bypass CORS.
-
----
-
-## Common Patterns
-
-### Login and publish a note
-
-```typescript
-import {makeSecret} from '@welshman/util'
-import {loginWithNip07, publishThunk, signer} from '@welshman/app'
-import {Router} from '@welshman/router'
-import {NOTE, makeEvent} from '@welshman/util'
-import {Nip07Signer} from '@welshman/signer'
-
-// NIP-07 login
-const nip07 = new Nip07Signer()
-const pubkey = await nip07.getPubkey()
-loginWithNip07(pubkey)
-
-// Publish with optimistic local update and 3s undo window
-const thunk = publishThunk({
-  event: makeEvent(NOTE, {content: 'Hello Nostr!'}),
-  relays: Router.get().FromUser().getUrls(),
-  delay: 3000,
-})
-
-// Subscribe to per-relay status
-thunk.subscribe($thunk => {
-  for (const [url, result] of Object.entries($thunk.results)) {
-    console.log(url, result.status, result.detail)
-  }
-})
-
-// Soft-undo within delay window
-setTimeout(() => thunk.controller.abort(), 1000)
-
-// Wait for all relays to finish (thunk.complete is a Deferred<void>)
-await thunk.complete
-```
-
-### Derive a reactive profile
-
-```typescript
-import {deriveProfile, deriveProfileDisplay} from '@welshman/app'
-
-const targetPubkey = '97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322'
-
-// Reactive store — loads the profile in the background on first subscribe
-const profile = deriveProfile(targetPubkey)
-
-// Reactive display name with npub fallback
-const name = deriveProfileDisplay(targetPubkey)
-
-// In Svelte
-// $: displayName = $name
-```
-
-### Reply to an event
-
-```typescript
-import {publishThunk, tagEventForReply, tagPubkey, signer} from '@welshman/app'
-import {Router} from '@welshman/router'
-import {NOTE, makeEvent} from '@welshman/util'
-import type {TrustedEvent} from '@welshman/util'
-
-async function replyTo(parent: TrustedEvent, content: string) {
-  const tags = tagEventForReply(parent)
-
-  return publishThunk({
-    event: makeEvent(NOTE, {content, tags}),
-    relays: Router.get().PublishEvent(parent).getUrls(),
-  })
-}
-```
-
-### Send a NIP-59 gift-wrapped DM
-
-```typescript
-import {sendWrapped} from '@welshman/app'
-import {DIRECT_MESSAGE, makeEvent} from '@welshman/util'
-
-const mergedThunk = await sendWrapped({
-  event: makeEvent(DIRECT_MESSAGE, {content: 'secret message'}),
-  recipients: [recipientPubkey],
-})
-
-// Monitor combined status
-mergedThunk.subscribe($t => {
-  for (const [url, result] of Object.entries($t.results)) {
-    console.log(url, result.status)
-  }
-})
-```
-
-### Follow/unfollow
-
-```typescript
-import {follow, unfollow} from '@welshman/app'
-
-// tag format: ["p", pubkey] or ["p", pubkey, relayHint, petname]
-await follow(["p", "97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322"])
-await unfollow("97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322")
-```
-
-### Web of Trust filtering
-
-```typescript
-import {deriveUserWotScore, getWotScore, wotGraph, maxWot} from '@welshman/app'
-import {get} from 'svelte/store'
-
-// Filter a list of pubkeys to those with positive WoT score
-const $graph = get(wotGraph)
-const trusted = pubkeys.filter(pk => ($graph.get(pk) ?? 0) > 0)
-
-// Reactive score for a single user
-const score = deriveUserWotScore(somePubkey)
-
-// Normalize by max score (0–1 range)
-const $max = get(maxWot)
-const normalized = ($graph.get(somePubkey) ?? 0) / ($max || 1)
-```
-
-### Load a feed of notes
-
-```typescript
-import {makeFeedController, getPubkeysForScope} from '@welshman/app'
-import {makeKindFeed} from '@welshman/feeds'
-import {NOTE} from '@welshman/util'
-
-const abort = new AbortController()
-
-const ctrl = makeFeedController({
-  feed: makeKindFeed(NOTE),
-  useWindowing: true,
-  signal: abort.signal,
-  onEvent: event => console.log(event),
-  onExhausted: () => console.log('no more events'),
-})
-
-ctrl.load(50)
-
-// cleanup
-abort.abort()
-```
-
----
-
-## Integration Notes
-
-- `@welshman/app` **re-exports nothing** from `@welshman/net`, `@welshman/router`, etc. Import those directly when you need low-level primitives (`load`, `request`, `publish`, `Router` scenarios beyond `FromUser`).
-- The `index.ts` bootstrap code runs on import and automatically wires `routerContext` (pubkey relays, relay quality, default/indexer/search relays) and hooks `Pool` to store incoming events in `repository`. **Import `@welshman/app` early in your app entry point** so this runs before any requests. The canonical side-effect import pattern is:
-
-  ```typescript
-  // app entry point — must be first, before any @welshman/net or @welshman/router imports
-  import "@welshman/app"
-
-  // Then optionally override defaults
-  import {routerContext} from "@welshman/router"
-  routerContext.getDefaultRelays = () => ["wss://relay.damus.io/", "wss://nos.lol/"]
-  ```
-- `repository` and `tracker` are singletons shared across the whole app. All subscriptions made through `@welshman/net` that pass through the pool will populate `repository` automatically.
-- `Router` is imported from `@welshman/router` but `routerContext` is configured by `@welshman/app/index.ts`. Use `Router.get()` (not `new Router(...)`) to get the app-configured singleton.
-- `deriveProfile`, `deriveFollowList`, etc. use `makeLoadItem` under the hood: they fire a network request on first subscribe if data is not already in the repository, then resolve immediately on subsequent subscribes.
-- `userFollowList`, `userMuteList`, etc. are derived from `pubkey`. They automatically re-derive when the active session changes (multi-account support).
-
----
-
-## Using Welshman Stores Outside Svelte
-
-All welshman stores implement the Svelte store contract: a `subscribe(callback) → unsubscribe` method where the callback fires **synchronously** with the current value on first call, then again on every change. This makes them trivially adaptable to any reactive framework — no Svelte runtime required, only the type imports.
-
-### React
-
-```typescript
-import {useState, useEffect} from 'react'
-import type {Readable, Writable} from 'svelte/store'
-
-// Returns the current store value; re-renders when it changes.
-function useReadable<T>(store: Readable<T>): T {
-  const [value, setValue] = useState<T>(() => {
-    // subscribe fires synchronously — capture the initial value then unsub immediately
-    let initial!: T
-    store.subscribe(v => { initial = v })()
-    return initial
-  })
   useEffect(() => store.subscribe(setValue), [store])
+
   return value
 }
-
-// Returns [currentValue, setter] — setter calls store.set directly.
-function useWritable<T>(store: Writable<T>): [T, (value: T) => void] {
-  return [useReadable(store), store.set]
-}
 ```
 
-Usage:
+For a `Projection`, subscribe to `.$` and read `.get()` for a synchronous snapshot.
 
-```tsx
-import {userProfile, pubkey} from '@welshman/app'
+## Related skills
 
-function ProfileHeader() {
-  const profile = useReadable(userProfile)
-  const [currentPubkey, setPubkey] = useWritable(pubkey)
-
-  return <div>{profile?.name ?? currentPubkey}</div>
-}
-```
-
-### SolidJS
-
-```typescript
-import {createSignal, onCleanup} from 'solid-js'
-import type {Readable, Writable} from 'svelte/store'
-
-// Returns a SolidJS accessor (getter function); updates reactively.
-function useReadable<T>(store: Readable<T>): () => T {
-  let initial!: T
-  store.subscribe(v => { initial = v })()   // sync capture then unsubscribe
-
-  const [value, setValue] = createSignal<T>(initial)
-  onCleanup(store.subscribe(v => setValue(() => v)))
-  return value
-}
-
-// Returns [accessor, setter].
-function useWritable<T>(store: Writable<T>): [() => T, (value: T) => void] {
-  return [useReadable(store), store.set]
-}
-```
-
-Usage:
-
-```tsx
-import {userProfile} from '@welshman/app'
-
-function ProfileHeader() {
-  const profile = useReadable(userProfile)
-  return <div>{profile()?.name}</div>
-}
-```
-
-### Vue
-
-```typescript
-import {ref, onUnmounted} from 'vue'
-import type {Readable, Writable} from 'svelte/store'
-
-function useReadable<T>(store: Readable<T>) {
-  let initial!: T
-  store.subscribe(v => { initial = v })()
-
-  const value = ref<T>(initial)
-  const unsub = store.subscribe(v => { value.value = v as any })
-  onUnmounted(unsub)
-  return value  // use as a readonly ref
-}
-```
-
-### Notes
-
-- **No Svelte runtime needed.** Only `svelte/store` types are imported. The store objects themselves ship with `@welshman/app`.
-- **Welshman stores with `.get()`** (created via `withGetter`) can be read synchronously without subscribing — useful in event handlers and callbacks outside any reactive context. Most writable stores in `@welshman/app` expose `.get()`.
-- **`subscribe` always fires immediately.** Unlike many observable libraries, the initial emission is synchronous, so the `useState` / `createSignal` initial value is always populated on first render.
-
----
-
-## Gotchas & Tips
-
-- **Thunks sign lazily.** `publishThunk` returns synchronously and immediately writes an unsigned/hashed event to `repository` for optimistic UI. Actual signing happens in a background queue. Do not assume the event has an `id` suitable for embedding in other events until signing completes.
-- **`delay` is an undo window, not a debounce.** The thunk starts the delay timer immediately; if not aborted before `delay` ms, it signs and publishes. Calling `thunk.controller.abort()` after the delay has elapsed does nothing.
-- **`sendWrapped` uses `recipients`, not `pubkeys`.** The docs example uses `pubkeys` but the actual type is `recipients: string[]`.
-- **Gift wrap processing requires opt-in.** Set `shouldUnwrap.set(true)` to enable automatic NIP-59 unwrapping of incoming `kind:1059` events. Without this, wrapped events are silently discarded.
-- **`commands` force-load lists before modifying them.** `follow()`, `unfollow()`, etc. call `forceLoadUserFollowList` to ensure they have the latest list before adding/removing, preventing accidental list truncation. Do not call these in rapid succession without awaiting each one.
-- **WoT graph is rebuilt at most once per second** (throttled). Do not expect `wotGraph` to reflect a `follow()` call immediately; subscribe to the store instead.
-- **`routerContext.getDefaultRelays` is throttled** with a 200 ms window by default in `index.ts`. It returns up to the 5 highest-quality known relays. Override it before any relay connections if you want a fixed bootstrap list.
-- **Multiple sessions are supported.** Call `loginWith*` multiple times to add sessions. Switch the active session with `pubkey.set(otherPubkey)`. Remove a session with `dropSession(pubkey)` — this also cleans up the cached signer.
-- **Stores have `.get()` via `withGetter`.** `pubkey.get()`, `signer.get()`, `session.get()`, `signerLog.get()`, `shouldUnwrap.get()` all work without `get()` from `svelte/store`. Use this for synchronous reads outside of reactive contexts.
-- **`appContext.dufflepudUrl` must be set before first handle/zapper load.** There is no lazy re-fetch; set it at app startup.
+- `welshman-domain` — the readers/writers every plugin decodes events with
+- `welshman-net` — sockets, adapters, request/publish lifecycle, auth
+- `welshman-store` — the repository and the derive helpers plugins are built on
+- `welshman-signer` — signer implementations behind `User`
+- `welshman-util` — kinds, filters, tag specs, and the `RelaySelection` DSL
diff --git a/.agents/skills/welshman-domain/SKILL.md b/.agents/skills/welshman-domain/SKILL.md
new file mode 100644
index 00000000..4041bb34
--- /dev/null
+++ b/.agents/skills/welshman-domain/SKILL.md
@@ -0,0 +1,197 @@
+---
+name: welshman-domain
+description: "Use this skill when working with @welshman/domain: reading or writing a specific nostr event kind, parsing tags, building events to publish, or adding support for a new kind. Provides a typed Reader/Writer pair per kind so you never hand-parse tags."
+---
+
+# welshman/domain — Typed Readers and Writers per Kind
+
+`@welshman/domain` replaces ad-hoc tag digging. Every supported kind gets a **Reader** (typed
+accessors over an event) and a **Writer** (a builder that renders a new event), paired in a
+`KindFactory`.
+
+**The rule this package exists to enforce:** never reach into `event.tags` yourself. Use the
+reader's getter (`note.content()`, `roomMeta.name()`, `goal.amount()`). If a kind has no reader,
+use `tagValue`/`tagValues` from `@welshman/util` — not `tags.find(...)`.
+
+## Installation
+
+```bash
+npm i @welshman/domain
+```
+
+## The three pieces
+
+```typescript
+import {KindFactory} from "@welshman/domain"
+
+KindFactory        // the exported per-kind object, e.g. `Note`, `Profile`, `RoomMeta`
+  .configure(ctx)  // binds a resolver/signer -> ConfiguredKind
+  .reader(event)   // -> Reader instance (call .parse() before use)
+  .writer(reader?) // -> Writer, optionally seeded from an existing reader to edit it
+```
+
+You rarely call `configure` directly — the `Domain` plugin does it for you.
+
+## Usage through an app
+
+```typescript
+import {Domain} from "@welshman/app"
+import {Note, Profile} from "@welshman/domain"
+
+// Read: returns a parsed reader, ready to use
+const note = app.use(Domain).reader(Note)(event)
+
+note.content()      // typed accessors, no tag digging
+note.author()
+note.createdAt()
+
+// Write: build, then wrap in a Command to publish
+const writer = app.use(Domain).writer(Note).setContent("hello").addMention(pubkey)
+const command = await app.use(Domain).command(writer)
+
+await command.publish().waitForError()
+
+// Edit an existing event: seed the writer with its reader
+const profile = app.use(Domain).reader(Profile)(profileEvent)
+const edit = app.use(Domain).writer(Profile, profile).setName("new name")
+```
+
+## Sync vs async readers
+
+Some kinds decrypt on parse (encrypted lists, app data), so `parse()` is async for them:
+
+- `EventReader.parse(): this`
+- `AsyncEventReader.parse(): Promise<this>`
+
+`Parsed<R> = ReturnType<R["parse"]>` captures which one you get. `app.use(Domain).reader(F)`
+returns `Parsed<R>` — the reader itself for sync kinds, a promise for async ones. That's exactly
+what `EventToItem` accepts, so collections keep their synchronous path where the kind allows one.
+
+```typescript
+const note = app.use(Domain).reader(Note)(event)          // NoteReader
+const list = await app.use(Domain).reader(MuteList)(event) // MuteListReader (decrypts)
+```
+
+## Reader base API
+
+Every reader inherits from `BaseEventReader`:
+
+| Method | Returns |
+|---|---|
+| `id()` | event id |
+| `author()` | pubkey |
+| `content()` | content string |
+| `tags()` | raw tags (prefer a typed getter when one exists) |
+| `createdAt()` | timestamp |
+| `identifier()` | `d` tag |
+| `address()` | `kind:pubkey:d` |
+| `room()` | `h` tag |
+| `protect()` | whether the event carries `-` (NIP-70) |
+| `expiration()` | `expiration` tag as a number |
+| `emojis()` | parsed `emoji` tags |
+| `zapSplits()` | parsed `zap` tags |
+
+Kind-specific readers add their own on top — `RoomMetaReader.name()`, `ZapGoalReader.amount()`,
+`RelayMembersReader.isMember(pubkey)`, and so on.
+
+## Writer base API
+
+Writers are chainable and validate on render:
+
+```typescript
+writer
+  .setContent(content)
+  .addTags(...tags)
+  .dropTags(pred)              // also keepTags(pred)
+  .setIdentifier(d)            // defaults to a random id
+  .setRoom(url, h)             // NIP-29 `h` tag + forced relay
+  .setProtected(true)          // NIP-70 `-`
+  .setExpiration(ts)
+  .addMention(pubkey)
+  .addQuote(event)
+  .addZapSplit(pubkey, split)
+  .addEmoji(shortcode, url)
+  .forceRelays(...urls)        // bypass routing for relay-scoped kinds
+```
+
+`readonly requiresRelays` marks kinds that are meaningless without an explicit relay (NIP-29 room
+ops, relay membership). Subclasses override `validate()` to enforce kind-specific invariants —
+e.g. `RoomUpdatePins` throws without a room, `ZapGoal` requires an amount and at least one relay.
+
+## Display helpers
+
+A few kinds export display helpers alongside their reader:
+
+```typescript
+import {displayPubkey} from "@welshman/domain"
+
+profile.display("Anonymous")   // ProfileReader: name/display_name, or the fallback
+displayPubkey(pubkey)          // 'npub1abc...xyz'
+```
+
+## Adding a new kind
+
+1. Add the kind constant to `@welshman/util`'s `Kinds.ts`.
+2. Create `packages/domain/src/kinds/YourKind.ts` with a Reader, a Writer, and the factory:
+
+```typescript
+import {uniq, spec} from "@welshman/lib"
+import {YOUR_KIND, hexTags, tagValues} from "@welshman/util"
+import {EventReader} from "../core/EventReader.js"
+import {EventWriter} from "../core/EventWriter.js"
+import {KindFactory} from "../core/Kind.js"
+
+export class YourKindReader extends EventReader {
+  pubkeys() {
+    return uniq(tagValues(hexTags("p"), this.event.tags))
+  }
+}
+
+export class YourKindWriter extends EventWriter<YourKindReader> {
+  readonly requiresRelays = true
+
+  validate() {
+    super.validate()
+
+    if (!this.roomTag) throw new Error("YourKind requires a room")
+  }
+
+  setPubkeys(pubkeys: string[]) {
+    return this.dropTags(spec(["p"])).addTags(...uniq(pubkeys).map(pk => ["p", pk]))
+  }
+}
+
+export const YourKind = new KindFactory({
+  kind: YOUR_KIND,
+  reader: YourKindReader,
+  writer: YourKindWriter,
+})
+```
+
+3. Export it from `packages/domain/src/index.ts`.
+4. Add `packages/domain/__tests__/YourKind.test.ts` — every kind has one. Use the `read`, `write`,
+   and `buildTemplate` helpers from `./helpers.js`, and cover: reading represented tags,
+   round-tripping without duplicating tags, and any `validate()` rule.
+
+## Available kinds
+
+Profile, Note, Comment, Thread, Delete, Reaction, Report, Poll, PollResponse, Classified,
+TimeEvent, AppData, Handler, HandlerRecommendation, Feed, Pin, Pinboard.
+
+Lists: FollowList, MuteList, PinList, BookmarkList, TopicList, EmojiList, RelayList, RelaySet,
+SearchRelayList, MessagingRelayList, BlossomServerList, BlockedRelayList, CommunityList,
+FeedList, RoomList.
+
+Zaps: ZapRequest, ZapReceipt, ZapGoal.
+
+NIP-29 rooms: RoomMeta, RoomCreate, RoomEdit, RoomDelete, RoomJoin, RoomLeave, RoomAddMember,
+RoomRemoveMember, RoomMembers, RoomAdmins, RoomCreatePermission, RoomPins, RoomUpdatePins.
+
+Relay membership: RelayInvite, RelayJoin, RelayLeave, RelayAddMember, RelayRemoveMember,
+RelayMembers, RelayRole.
+
+## Related skills
+
+- `welshman-app` — the `Domain` plugin, `Command`, and the collections that decode events for you
+- `welshman-util` — kind constants, tag specs (`tagValue`, `hexTags`, `addressTags`), filters
+- `welshman-store` — indexing decoded readers into reactive collections
diff --git a/.agents/skills/welshman-editor/SKILL.md b/.agents/skills/welshman-editor/SKILL.md
index 35333e65..c1d571d6 100644
--- a/.agents/skills/welshman-editor/SKILL.md
+++ b/.agents/skills/welshman-editor/SKILL.md
@@ -138,8 +138,8 @@ import {get, writable} from "svelte/store"
 import {Node, Extension, mergeAttributes} from "@tiptap/core"
 import {Plugin, PluginKey} from "@tiptap/pm/state"
 import type {NodeViewRendererProps} from "@tiptap/core"
-import {Router} from "@welshman/router"
-import {createSearch, profiles, searchProfiles, deriveProfileDisplay} from "@welshman/app"
+import {Profiles, Router, createSearch} from "@welshman/app"
+import {outbox} from "@welshman/util"
 import {
   Editor, WelshmanExtension, MentionSuggestion, TippySuggestion, editorProps,
 } from "@welshman/editor"
@@ -323,8 +323,8 @@ const onSubmit = (editor: Editor) => {
 
 ## Integration Notes
 
-- **`@welshman/app`** — `profileSearch` and `deriveProfileDisplay` are the typical sources for mention autocomplete data and display names.
-- **`@welshman/router`** — `Router.get().FromPubkeys([pubkey]).getUrls()` provides the relay hints encoded into nprofile bech32 strings.
+- **`@welshman/app`** — `app.use(Profiles).profileSearch` and `app.use(Profiles).display(pubkey)` are the typical sources for mention autocomplete data and display names.
+- **`@welshman/app`** — relay hints for nprofile bech32 strings come from `app.use(Router).resolve([outbox(pubkey)])`.
 - **`@welshman/util`** — `fromNostrURI` is used internally by `EventNodeView` to strip the `nostr:` scheme before displaying.
 - **`nostr-editor`** — `WelshmanExtension` extends `NostrExtension` from this package. Storage at `editor.storage.nostr` (including `getEditorTags()`) is provided by `nostr-editor`, not welshman itself.
 - **`@tiptap/core`** — `Editor`, `NodeViewProps`, and all extension primitives come from Tiptap. Welshman does not re-export every Tiptap helper; import additional ones directly from `@tiptap/core` as needed.
diff --git a/.agents/skills/welshman-lib/SKILL.md b/.agents/skills/welshman-lib/SKILL.md
index 6e5c73ac..cc7f5800 100644
--- a/.agents/skills/welshman-lib/SKILL.md
+++ b/.agents/skills/welshman-lib/SKILL.md
@@ -387,9 +387,9 @@ const label = formatTimestampRelative(event.created_at) // "3 hours ago"
 
 ```typescript
 import { on } from '@welshman/lib'
-import { repository } from '@welshman/app'
 
-const unsub = on(repository, 'update', updates => {
+// Each App owns its repository.
+const unsub = on(app.repository, 'update', updates => {
   console.log('added', updates.flatMap(u => u.added).length, 'events')
 })
 
diff --git a/.agents/skills/welshman-net/SKILL.md b/.agents/skills/welshman-net/SKILL.md
index c33a70ac..abf1108e 100644
--- a/.agents/skills/welshman-net/SKILL.md
+++ b/.agents/skills/welshman-net/SKILL.md
@@ -5,7 +5,7 @@ description: "Use this skill when working with @welshman/net: relay connections,
 
 # welshman/net — Relay Network Layer
 
-`@welshman/net` is the core networking layer for welshman-based nostr apps. It manages WebSocket relay connections, subscriptions, event publishing, NIP-42 auth, and NIP-77 negentropy sync. It sits below `@welshman/app` (which provides higher-level reactive stores and routing) and depends on `@welshman/util` for event types and `@welshman/lib` for utilities.
+`@welshman/net` is the core networking layer for welshman-based nostr apps. It manages WebSocket relay connections, subscriptions, event publishing, NIP-42 auth, and NIP-77 negentropy sync. It sits below `@welshman/app` (which owns an `App` instance and its plugins) and depends on `@welshman/util` for event types and `@welshman/lib` for utilities.
 
 ## Installation
 
@@ -135,10 +135,10 @@ Emits `"update"` with `RepositoryUpdate` (`{ added: TrustedEvent[], removed: Set
 
 | Export | Description |
 |--------|-------------|
-| `netContext` | Global `NetContext` config object |
-| `NetContext` | `{ pool, repository, isEventValid, isEventDeleted, getAdapter? }` |
+| `NetContext` | `{ pool?, repository?, getAdapter? }` |
 
-Mutate `netContext` fields directly to change global defaults; pass `context` to individual calls to override per-request.
+Pass `context` to each `request`/`publish`/`load` call. An `App` from `@welshman/app` owns one per
+instance (`app.netContext`), and `app.use(Network)` supplies it for you.
 
 ### Negentropy / Diff (NIP-77)
 
@@ -366,7 +366,7 @@ repo.load(storedEvents)
 ### Startup: bulk-load Tracker state
 
 ```typescript
-import {tracker} from '@welshman/app'   // singleton wired to the pool and repository
+// `app.tracker` — wired to that app's pool and repository
 
 // Build the map from your stored relay<->event mappings
 const relaysById = new Map<string, Set<string>>()
@@ -384,7 +384,7 @@ tracker.load(relaysById)
 
 ```typescript
 import {on, batch} from '@welshman/lib'
-import {repository} from '@welshman/app'   // singleton; or Repository.get() standalone
+// `app.repository`, or `new Repository()` when using @welshman/net standalone
 import type {RepositoryUpdate} from '@welshman/net'
 import type {TrustedEvent} from '@welshman/util'
 
@@ -417,8 +417,8 @@ on(
 
 - **`@welshman/util`** — provides `TrustedEvent`, `SignedEvent`, `Filter`, `verifyEvent`, `matchFilters`, `getAddress`, etc. All event objects flowing through `@welshman/net` are `TrustedEvent` (already verified).
 - **`@welshman/lib`** — utility helpers (`Emitter`, `batcher`, `defer`, `on`, etc.) used internally; `Emitter` (from `@welshman/lib`) is the base class for `Tracker`, `Repository`, and `WrapManager`. `Socket`, `AuthState`, `AbstractAdapter`, and `Difference` extend node's built-in `EventEmitter` directly.
-- **`@welshman/app`** — wraps `@welshman/net` with reactive Svelte stores, a router, and higher-level helpers. Most app-level code should use `@welshman/app`; drop down to `@welshman/net` only for raw relay I/O or when building non-Svelte clients.
-- **`netContext`** — shared singleton used as the default by `request`, `requestOne`, and the repository. Override fields on `netContext` at startup, or pass a `context` object per-call to isolate behavior.
+- **`@welshman/app`** — wraps `@welshman/net` in an `App` instance whose plugins own routing, collections, and publishing. Most app-level code should go through `app.use(Network)`; drop down to `@welshman/net` only for raw relay I/O or when building without an `App`.
+- **`NetContext`** — passed explicitly per call. Each `App` owns its own pool and repository, which keeps one identity's data out of another's.
 
 ---
 
diff --git a/.agents/skills/welshman-router/SKILL.md b/.agents/skills/welshman-router/SKILL.md
deleted file mode 100644
index 8ff3b02a..00000000
--- a/.agents/skills/welshman-router/SKILL.md
+++ /dev/null
@@ -1,291 +0,0 @@
----
-name: welshman-router
-description: "Use this skill when working with @welshman/router: relay selection, routing strategies, scenario-based relay routing, or choosing which relays to use for reads/writes."
----
-
-# welshman/router — Relay Selection
-
-`@welshman/router` provides scenario-based relay selection for nostr clients. It answers the question "which relays should I use for this operation?" by scoring candidate relays based on pubkey relay lists, relay quality, and configurable fallback policies. It sits between `@welshman/util` (types/helpers) and `@welshman/net` (actual relay connections), and is wrapped by `@welshman/app` for full-stack usage.
-
-## Installation
-
-```bash
-npm install @welshman/router
-# or
-pnpm add @welshman/router
-yarn add @welshman/router
-```
-
-Peer dependencies: `@welshman/lib`, `@welshman/net`, `@welshman/util`.
-
-## Key Exports
-
-### Router (class)
-
-The main entry point. Use as a singleton via `Router.configure()` + `Router.get()`, or instantiate directly with options.
-
-| Method | Description |
-|--------|-------------|
-| `Router.configure(options)` | Merge options into the global `routerContext` |
-| `Router.get()` | Return a `Router` instance using the global context |
-| `new Router(options)` | Create a router that overrides specific options from the global context |
-
-**RouterOptions** (all optional):
-
-| Option | Signature | Description |
-|--------|-----------|-------------|
-| `getUserPubkey` | `() => string \| undefined` | Current user's pubkey |
-| `getPubkeyRelays` | `(pubkey, mode?) => string[]` | Relays for a pubkey; `mode` is `"read"`, `"write"`, or `"messaging"` |
-| `getDefaultRelays` | `() => string[]` | Fallback relays of last resort |
-| `getIndexerRelays` | `() => string[]` | Relays that index profiles and relay lists (NIP-65) |
-| `getSearchRelays` | `() => string[]` | Relays supporting NIP-50 search |
-| `getRelayQuality` | `(url) => number` | Quality score 0–1 for a relay (affects selection ranking) |
-| `getLimit` | `() => number` | Max relays returned by `getUrls()` (default: 3) |
-
-**Default behavior:** if `getPubkeyRelays` is not configured, the router falls back to querying the local `Repository` (from `@welshman/net`) for kind-10002 events.
-
-### Router Scenario Methods
-
-All return a `RouterScenario`. Naming convention: `For*` = relays to write to (so others can read), `From*` = relays to read from (author's outbox).
-
-| Method | Description |
-|--------|-------------|
-| `FromRelays(relays)` | Use an explicit list of relay URLs |
-| `ForUser()` | User's read relays (where others can send things to the user) |
-| `FromUser()` | User's write relays (user's outbox) |
-| `MessagesForUser()` | User's messaging relays (NIP-17 DMs) |
-| `ForPubkey(pubkey)` | A pubkey's read relays |
-| `FromPubkey(pubkey)` | A pubkey's write relays (outbox) |
-| `MessagesForPubkey(pubkey)` | A pubkey's messaging relays |
-| `ForPubkeys(pubkeys)` | Merged read relays for multiple pubkeys |
-| `FromPubkeys(pubkeys)` | Merged write relays for multiple pubkeys |
-| `MessagesForPubkeys(pubkeys)` | Merged messaging relays for multiple pubkeys |
-| `Event(event)` | Event author's write relays (where the event lives) |
-| `Replies(event)` | Event author's read relays (where replies should be sent) |
-| `PublishEvent(event)` | Author's outbox + mentioned pubkeys' read relays; hard-limits to 30 |
-| `Quote(event, id, hints)` | Best relays to find a quoted event; checks tag relay hints and author pubkey from tag |
-| `EventParents(event)` | Relays for fetching parent events (from ancestor tags + mentioned pubkeys) |
-| `EventRoots(event)` | Relays for fetching root events |
-| `Search()` | Search relays |
-| `Index()` | Indexer relays |
-| `Default()` | Default/fallback relays |
-| `merge(scenarios)` | Combine multiple scenarios into one |
-
-### RouterScenario (class)
-
-Immutable builder — every builder method returns a new instance. Terminal methods (`getUrls()`, `getUrl()`) return relay URLs, not instances.
-
-| Method | Description |
-|--------|-------------|
-| `getUrls()` | Execute selection; returns `string[]` |
-| `getUrl()` | Returns the first selected URL or `undefined` |
-| `limit(n)` | Override max relay count for this scenario |
-| `weight(scale)` | Multiply all selection weights by `scale` |
-| `policy(fn)` | Set fallback policy |
-| `allowLocal(bool)` | Allow `ws://localhost` / `ws://127.*` URLs (default: false) |
-| `allowOnion(bool)` | Allow `.onion` URLs (default: false) |
-| `allowInsecure(bool)` | Allow plain `ws://` non-onion URLs (default: false) |
-| `filter(fn)` | Filter the internal `Selection[]` |
-| `update(fn)` | Map over the internal `Selection[]` |
-
-### Fallback Policies
-
-Applied after relay scoring when not enough relays are found. Draw from `getDefaultRelays`.
-
-| Export | Behavior |
-|--------|----------|
-| `addNoFallbacks` | Never add fallbacks (default) |
-| `addMinimalFallbacks` | Add 1 fallback only if zero relays were selected |
-| `addMaximalFallbacks` | Fill remaining slots up to the limit |
-
-### Filter Selection
-
-| Export | Description |
-|--------|-------------|
-| `getFilterSelections(filters, rules?)` | Returns `RelaysAndFilters[]` — optimized relay+filter combos for a subscription |
-| `RelaysAndFilters` | `{ relays: string[], filters: Filter[] }` |
-| `defaultFilterSelectionRules` | The default ordered rule array |
-| `getFilterSelectionsForSearch` | Rule: search filters → search relays (weight 10) |
-| `getFilterSelectionsForWraps` | Rule: kind-1059 wraps without authors → user messaging relays |
-| `getFilterSelectionsForIndexedKinds` | Rule: kinds 0/3/10002/10050 → indexer relays |
-| `getFilterSelectionsForAuthors` | Rule: author filters → each author's outbox (split into up to 30 chunks) |
-| `getFilterSelectionsForUser` | Rule: low-weight (0.2) baseline that always fires for every filter → user's read relays. It is not conditional on other rules failing. |
-
-### Other Exports
-
-| Export | Description |
-|--------|-------------|
-| `INDEXED_KINDS` | `[PROFILE, RELAYS, MESSAGING_RELAYS, FOLLOWS]` — kinds routed to indexers |
-| `makeSelection(relays, weight?)` | Create a `Selection` object; validates and normalizes URLs |
-| `Selection` | `{ weight: number, relays: string[] }` |
-| `FallbackPolicy` | `(count: number, limit: number) => number` |
-| `routerContext` | The global mutable options object updated by `Router.configure()` |
-
-## Common Patterns
-
-### 1. Configure once at app startup
-
-`Router.get()` is the primary entry point — it returns a `Router` instance using the global `routerContext`. Call `Router.configure()` once at startup to set options, or assign directly to `routerContext` for individual overrides.
-
-```typescript
-import {Router} from '@welshman/router'
-
-Router.configure({
-  getUserPubkey: () => myStore.userPubkey,
-  getPubkeyRelays: (pubkey, mode) => myStore.getRelaysForPubkey(pubkey, mode),
-  getDefaultRelays: () => ['wss://relay.example.com/', 'wss://relay2.example.com/'],
-  getIndexerRelays: () => ['wss://indexer.example.com/', 'wss://indexer2.example.com/'],
-  getSearchRelays: () => ['wss://search.example.com/', 'wss://search2.example.com/'],
-  getRelayQuality: (url) => myStore.getRelayQuality(url),
-  getLimit: () => 5,
-})
-```
-
-When using `@welshman/app`, it pre-configures `Router` automatically. The two most common customization points when using `@welshman/app` are `getDefaultRelays` and `getIndexerRelays`, which you can assign directly on `routerContext`:
-
-```typescript
-import {routerContext} from '@welshman/router'
-
-routerContext.getDefaultRelays = () => [
-  'wss://relay.example.com/',
-  'wss://relay2.example.com/',
-]
-
-routerContext.getIndexerRelays = () => [
-  'wss://indexer.example.com/',
-  'wss://indexer2.example.com/',
-]
-```
-
-### 2. Fetch events from specific pubkeys
-
-```typescript
-import {Router} from '@welshman/router'
-
-const relays = Router.get().FromPubkeys(['pubkey1', 'pubkey2']).getUrls()
-// relays is string[] — pass to your subscription
-```
-
-### 3. Publish an event
-
-```typescript
-import {Router} from '@welshman/router'
-import type {TrustedEvent} from '@welshman/util'
-
-function getPublishRelays(event: TrustedEvent): string[] {
-  return Router.get().PublishEvent(event).getUrls()
-  // Automatically includes author's outbox + mentioned pubkeys' read relays
-  // Hard-limited to 30 relays for deliverability
-}
-```
-
-### 4. Find a quoted/referenced event with fallbacks
-
-```typescript
-import {Router, addMaximalFallbacks} from '@welshman/router'
-import type {TrustedEvent} from '@welshman/util'
-
-function getQuoteRelays(event: TrustedEvent, quotedId: string, hints: string[]) {
-  return Router.get()
-    .Quote(event, quotedId, hints)
-    .policy(addMaximalFallbacks)
-    .limit(8)
-    .getUrls()
-}
-```
-
-### 5. Common scenario cheat-sheet
-
-```typescript
-import {Router} from '@welshman/router'
-
-const router = Router.get()
-
-// Read relays for the current user (where others deliver events to you)
-router.ForUser().getUrls()
-
-// Write relays for the current user (your outbox)
-router.FromUser().getUrls()
-
-// Best relays to deliver an event to a pubkey (their inbox)
-router.ForPubkey('pubkey').getUrls()
-
-// Best relays to fetch events authored by a pubkey (their outbox)
-router.FromPubkey('pubkey').getUrls()
-
-// Indexer relays (profiles, relay lists)
-router.Index().getUrls()
-
-// Cap relay count for this scenario only
-router.ForPubkey('pubkey').limit(3).getUrls()
-
-// Merge multiple scenarios; relay URLs are deduplicated when getUrls() is called
-router.merge([
-  router.FromUser(),
-  router.Index(),
-]).getUrls()
-```
-
-### 6. Build subscriptions with getFilterSelections
-
-```typescript
-import {getFilterSelections} from '@welshman/router'
-import type {Filter} from '@welshman/util'
-
-const filters: Filter[] = [
-  {kinds: [1], authors: ['pubkey1', 'pubkey2']},
-  {kinds: [0], search: 'bitcoin'},
-]
-
-for (const {relays, filters} of getFilterSelections(filters)) {
-  // Open one subscription per relay group
-  myPool.subscribe(relays, filters)
-}
-```
-
-### 7. Use a custom filter routing rule
-
-```typescript
-import {
-  Router,
-  getFilterSelections,
-  defaultFilterSelectionRules,
-  type RelaysAndFilters,
-} from '@welshman/router'
-import type {Filter} from '@welshman/util'
-
-// Add a rule that sends kind-1 to a dedicated relay
-const myRule = (filter: Filter) => {
-  if (!filter.kinds?.includes(1)) return []
-  return [{filter, scenario: Router.get().FromRelays(['wss://notes.example.com/'])}]
-}
-
-const selections = getFilterSelections(filters, [myRule, ...defaultFilterSelectionRules])
-```
-
-## Integration Notes
-
-- **`@welshman/util`** — Router imports `TrustedEvent`, `Filter`, `RelayMode`, `PROFILE`, `RELAYS`, `MESSAGING_RELAYS`, `FOLLOWS`, `WRAP`, `normalizeRelayUrl`, and tag-parsing helpers. All relay URLs are normalized with `normalizeRelayUrl` and validated with `isRelayUrl` before use.
-- **`@welshman/net`** — The default `getPubkeyRelays` implementation queries `Repository.get()` (the in-memory event store from `@welshman/net`) for kind-10002 events. Override it if you maintain relay lists elsewhere.
-- **`@welshman/app`** — The app layer pre-configures `Router` using its own stores (relay lists, connection quality). If you use `@welshman/app`, call `Router.configure` only to override specific options; the app layer handles the rest.
-- **`@welshman/lib`** — Used internally for utilities (`sortBy`, `shuffle`, `uniq`, etc.); no direct integration needed.
-
-## Gotchas & Tips
-
-- **Relay list events must be in the Repository for pubkey routing to work.** The default `getPubkeyRelays` implementation reads kind-10002 (NIP-65) relay list events from the global in-memory `Repository`. If those events haven't been loaded — either from a local cache at startup or fetched from the network — the Router has no relay list data for that pubkey and silently falls back to default/indexer relays. When using `@welshman/app`, relay lists are fetched automatically as part of profile loading (`loadRelayList`, `makeOutboxLoader`). Without `@welshman/app`, you must fetch and load them yourself before calling pubkey-based scenarios.
-
-- **`For*` vs `From*`**: `ForPubkey` returns a pubkey's **read** relays (where you send things for that pubkey to receive); `FromPubkey` returns their **write** relays (their outbox, where their events live). Use `From*` to fetch events, `For*` to deliver events.
-
-- **Default limit is 3.** Set `getLimit` in `Router.configure` or call `.limit(n)` on a scenario if you need more. `PublishEvent` unconditionally overrides to 30.
-
-- **Scoring includes randomness.** `getUrls()` introduces `Math.random()` in the scoring formula so that lower-quality or less-popular relays get occasional selection. Results are not deterministic across calls.
-
-- **`addNoFallbacks` is the default policy.** If no relays are found for a scenario (e.g. no relay list for a pubkey) and you haven't set a policy, `getUrls()` returns `[]`. Use `addMinimalFallbacks` or `addMaximalFallbacks` when you need a result even for unknown pubkeys.
-
-- **Insecure `ws://` URLs are filtered by default.** Only onion addresses (`*.onion`) are exempt from the TLS requirement. Pass `.allowInsecure(true)` to a scenario if you need to support plain websocket relays (e.g. local dev).
-
-- **`getFilterSelections` uses `addMinimalFallbacks`.** Each resulting relay group will have at least one relay *if* `getDefaultRelays` is configured and returns relays. If `getDefaultRelays` is not configured or returns an empty array, the group may still be empty.
-
-- **`routerContext` is a shared mutable object.** `Router.configure()` mutates it in place with `Object.assign`. `new Router(options)` merges the supplied options *over* the global `routerContext` (via `mergeLeft`), so any options not provided in `options` still fall back to whatever is in `routerContext`. For true isolation (e.g. in tests), pass a complete options object or reset `routerContext` first.
-
-- **`Quote` reads relay hints from event tags.** It looks for a tag whose second element (`t[1]`) matches the quoted event ID, then extracts a relay hint from `t[2]` and an author pubkey from `t[3]`. Standard NIP-21/NIP-10 tag format.
diff --git a/.agents/skills/welshman-signer/SKILL.md b/.agents/skills/welshman-signer/SKILL.md
index dc23b739..498f8cdb 100644
--- a/.agents/skills/welshman-signer/SKILL.md
+++ b/.agents/skills/welshman-signer/SKILL.md
@@ -211,7 +211,7 @@ const plaintext = await signer.nip44.decrypt(theirPubkey, ciphertext)
 
 - **`@welshman/util`** supplies `makeEvent`, `makeSecret`, `StampedEvent`, `SignedEvent`, and nostr kind constants (`NOTE`, `DIRECT_MESSAGE`, etc.) used in all examples above.
 - **`@welshman/net`** and **`@welshman/app`** accept an `ISigner` wherever signing is needed (e.g. publishing events). Pass any concrete signer — they are interchangeable.
-- **`@welshman/app`** exposes a `signer` writable store (`import { signer } from '@welshman/app'`) that the rest of the app stack reads. Set it to your chosen `ISigner` after login.
+- **`@welshman/app`** wraps a signer in a `User` (`User.fromSigner(signer)` or `User.fromSession(session)`), passed to the app at construction: `createApp({user})`. Reach it again via `app.user?.signer`, or `User.require(app).signer` where a login is required.
 - `Nip59` wraps events with an ephemeral `Nip01Signer` by default (per the NIP-59 spec), so callers do not need to supply a wrapper unless they want a custom one.
 
 ## Gotchas & Tips
diff --git a/.agents/skills/welshman-store/SKILL.md b/.agents/skills/welshman-store/SKILL.md
index bf53dd72..9f9e63ed 100644
--- a/.agents/skills/welshman-store/SKILL.md
+++ b/.agents/skills/welshman-store/SKILL.md
@@ -140,15 +140,19 @@ notes.subscribe($notes => {
 ```typescript
 import { Repository } from "@welshman/net"
 import { deriveItemsByKey, deriveItems, makeDeriveItem } from "@welshman/store"
-import { readProfile, PROFILE, type PublishedProfile } from "@welshman/util"
+import { PROFILE } from "@welshman/util"
+import { Profile, type ProfileReader } from "@welshman/domain"
 
 const repository = new Repository()
 
-const profilesByPubkey = deriveItemsByKey<PublishedProfile>({
+// Decoding is @welshman/domain's job — configure the kind, then use its reader as eventToItem.
+const readProfile = Profile.configure({}).reader
+
+const profilesByPubkey = deriveItemsByKey<ProfileReader>({
   repository,
   filters: [{ kinds: [PROFILE] }],
-  eventToItem: event => readProfile(event),
-  getKey: profile => profile.event.pubkey,
+  eventToItem: event => readProfile(event).parse(),
+  getKey: profile => profile.author(),
 })
 
 // All profiles as array
@@ -159,7 +163,7 @@ const deriveProfile = makeDeriveItem(profilesByPubkey)
 const aliceProfile = deriveProfile("alice-pubkey-hex")
 
 aliceProfile.subscribe($profile => {
-  console.log($profile?.name)
+  console.log($profile?.display())
 })
 ```
 
@@ -227,7 +231,8 @@ This `getBookmark` function is the right shape to pass as `getItem` to `makeLoad
 ### 6. Full reactive item chain: deriveItemsByKey → deriveItems → getter → makeLoadItem → makeDeriveItem
 
 This is the canonical pattern for domain objects derived from repository events with
-on-demand network loading.
+on-demand network loading. `@welshman/app` packages it as `DerivedPlugin` — prefer subclassing
+that over hand-rolling the chain unless you need something it doesn't cover.
 
 ```typescript
 import {
@@ -237,10 +242,9 @@ import {
   makeLoadItem,
   makeDeriveItem,
 } from "@welshman/store"
-import { load } from "@welshman/net"
-import { repository } from "@welshman/app"
-import { Router } from "@welshman/router"
-import { getTagValue, getTagValues } from "@welshman/util"
+import { Network, Router } from "@welshman/app"
+import { outbox } from "@welshman/util"
+import { relayTags, tagSpec, tagValue, tagValues } from "@welshman/util"
 import type { TrustedEvent } from "@welshman/util"
 
 const BOOKMARK_KIND = 30003
@@ -254,14 +258,14 @@ type Bookmark = {
 
 const parseBookmark = (event: TrustedEvent): Bookmark => ({
   pubkey: event.pubkey,
-  title: getTagValue("title", event.tags) ?? "Untitled",
-  urls: getTagValues("r", event.tags),
+  title: tagValue(tagSpec("title"), event.tags) ?? "Untitled",
+  urls: tagValues(relayTags("r"), event.tags),
   event,
 })
 
 // Step 1: Reactive Map<pubkey, Bookmark> — live-updates from repository
 const bookmarksByPubkey = deriveItemsByKey<Bookmark>({
-  repository,
+  repository: app.repository,
   filters: [{ kinds: [BOOKMARK_KIND] }],
   getKey: b => b.pubkey,
   eventToItem: parseBookmark,
@@ -278,8 +282,10 @@ const getBookmark = (pubkey: string) => getBookmarksByPubkey().get(pubkey)
 //         re-fetches only after the timeout window (default: 3600 s)
 const loadBookmark = makeLoadItem<Bookmark>(
   async (pubkey: string) => {
-    await load({
-      relays: Router.get().ForPubkey(pubkey).getUrls(),
+    const scenario = await app.use(Router).resolve([outbox(pubkey)])
+
+    await app.use(Network).load({
+      relays: scenario.getUrls(),
       filters: [{ kinds: [BOOKMARK_KIND], authors: [pubkey], limit: 1 }],
     })
   },
@@ -298,7 +304,8 @@ aliceBookmark.subscribe($b => console.log($b?.title))
 ## Integration Notes
 
 - **`@welshman/net`** — provides `Repository` and `Tracker`. `Repository` is the event cache that feeds all store primitives in this package. Events flow from the network into the repository, which triggers store updates automatically.
-- **`@welshman/util`** — provides `TrustedEvent`, `Filter`, `readProfile`, `readList`, and other event-parsing helpers that feed into `deriveItemsByKey` / `deriveEventsById`.
+- **`@welshman/util`** — provides `TrustedEvent`, `Filter`, and the tag specs (`tagValue`, `hexTags`, …) used when decoding events.
+- **`@welshman/domain`** — the typed readers you normally pass as `eventToItem`, instead of writing a parser by hand.
 - **`@welshman/app`** — the high-level app layer re-exports and composes store utilities with pre-configured repositories, loaders, and context. If you are using `@welshman/app`, many of these stores are already wired up for you.
 - Stores in this package are **framework-agnostic** at runtime (plain Svelte stores), so they work in SvelteKit SSR as well as browser-only Svelte apps. The `synced` store's `localStorageProvider` is browser-only — guard it with `if (browser)` in SvelteKit.
 
diff --git a/.agents/skills/welshman-util/SKILL.md b/.agents/skills/welshman-util/SKILL.md
index f7e1adc4..ea2e723a 100644
--- a/.agents/skills/welshman-util/SKILL.md
+++ b/.agents/skills/welshman-util/SKILL.md
@@ -32,7 +32,6 @@ yarn add @welshman/util
 | `HashedEvent` | `OwnedEvent + id` |
 | `SignedEvent` | `HashedEvent + sig` |
 | `TrustedEvent` | `HashedEvent + optional sig` — most common in-app type |
-| `DecryptedEvent` | `TrustedEvent + plaintext` (for encrypted lists/events) |
 
 ### Event Utilities
 
@@ -49,9 +48,6 @@ yarn add @welshman/util
 | `isReplaceable(event)` | True for plain or parameterized replaceable |
 | `isPlainReplaceable(event)` | True for kinds 10000–19999 and metadata/contacts |
 | `isParameterizedReplaceable(event)` | True for kinds 30000–39999 |
-| `getAncestors(event)` | Returns `{ roots, replies, mentions }` for NIP-10 events (mentions may be empty `[]` but is always present); NIP-22/COMMENT path returns `{ roots, replies }` without mentions |
-| `getParentIdOrAddr(event)` | Immediate parent id or address |
-| `isChildOf(child, parent)` | Check if child replies to parent |
 
 ### Type Guards
 
@@ -274,24 +270,16 @@ isDVMKind(kind)                    // 5000–7000
 
 | Export | Description |
 |--------|-------------|
-| `getTags(types, tags)` | Get all tags matching one or more type strings |
-| `getTag(types, tags)` | Get first matching tag |
-| `getTagValues(types, tags)` | Get value (index 1) of all matching tags — types first, then the tags array |
-| `getTagValue(types, tags)` | Get value of first matching tag — types first, then the tags array |
-| `getEventTags(tags)` | `e` tags |
-| `getEventTagValues(tags)` | Values of `e` tags |
-| `getAddressTags(tags)` | `a` tags |
-| `getAddressTagValues(tags)` | Values of `a` tags |
-| `getPubkeyTags(tags)` | `p` tags |
-| `getPubkeyTagValues(tags)` | Values of `p` tags |
-| `getTopicTags(tags)` / `getTopicTagValues(tags)` | `t` (hashtag) tags |
-| `getRelayTags(tags)` / `getRelayTagValues(tags)` | `r` and `relay` tags |
-| `getKindTags(tags)` / `getKindTagValues(tags)` | `k` tags (returns `number[]`) |
-| `getGroupTags(tags)` / `getGroupTagValues(tags)` | group tags |
-| `getReplyTags(tags)` | `{ roots, replies, mentions }` — NIP-10 threading |
-| `getCommentTags(tags)` | `{ roots, replies }` — NIP-22 uppercase/lowercase tags |
-| `uniqTags(tags)` | Remove duplicate tags |
-| `tagsFromIMeta(imeta)` | Parse `imeta` tag into array of tag arrays |
+| `tagSpec(keys, matchValue?, normalize?)` | Build a spec: which tag keys, plus optional validation/normalization |
+| `hexTags(keys)` | Spec for 32-byte hex values (`e`, `p`, …) |
+| `addressTags(keys)` | Spec for `kind:pubkey:d` addresses (`a`, `A`) |
+| `kindTags(keys)` | Spec for kind numbers (`k`) |
+| `topicTags(keys)` | Spec for topics, normalized (`t`) |
+| `relayTags(keys)` | Spec for relay urls (`r`, `relay`) |
+| `tagValue(spec, tags)` | Value (index 1) of the first matching tag |
+| `tagValues(spec, tags)` | Values of all matching tags |
+| `matchTag(spec, tags)` / `matchTags(spec, tags)` | The matching tag(s) themselves |
+| `tagMatcher(spec)` | A `(tag) => boolean` predicate, for filtering in one pass |
 
 ### Filters
 
@@ -319,50 +307,12 @@ isDVMKind(kind)                    // 5000–7000
 | `Address.from(s, relays?)` | Parse from `kind:pubkey:identifier` string |
 | `Address.fromNaddr(naddr)` | Parse from NIP-19 naddr |
 | `Address.fromEvent(event, relays?)` | Create from addressable event |
-| `address.toString()` | Serialize to `kind:pubkey:identifier` |
-| `address.toNaddr()` | Serialize to NIP-19 naddr |
 | `getAddress(event)` | Convenience: get address string from event |
 
-### Profile
-
-| Export | Description |
-|--------|-------------|
-| `makeProfile(partial)` | Create a profile object |
-| `readProfile(event)` | Parse `PublishedProfile` from kind 0 event |
-| `createProfile(profile)` | Create kind 0 `EventTemplate` |
-| `editProfile(published)` | Update existing profile event |
-| `displayProfile(profile?, fallback?)` | Get best display name string |
-| `displayPubkey(pubkey)` | Shorten pubkey to `npub1abc...xyz` |
-| `profileHasName(profile?)` | Check if profile has a name field |
-
-Profile fields: `name`, `display_name`, `about`, `picture`, `banner`, `website`, `nip05`, `lud06`, `lud16`, `lnurl`
-
-### Lists (kind 10000+)
-
-| Export | Description |
-|--------|-------------|
-| `makeList(params)` | Create a new list |
-| `readList(event)` | Parse `PublishedList` from `DecryptedEvent` |
-| `getListTags(list)` | Combined public + private tags |
-| `addToListPublicly(list, ...tags)` | Returns `Encryptable` with tag added publicly |
-| `addToListPrivately(list, ...tags)` | Returns `Encryptable` with tag added privately |
-| `removeFromList(list, value)` | Returns `Encryptable` with tag removed |
-| `removeFromListByPredicate(list, pred)` | Returns `Encryptable` with matching tags removed |
-| `updateList(list, { publicTags?, privateTags? })` | Bulk update tags |
-
-### Encryptable
-
-| Export | Description |
-|--------|-------------|
-| `Encryptable<T>` | Wraps a partial event with plaintext updates; call `.reconcile(encrypt)` to produce encrypted event |
-| `asDecryptedEvent(event, plaintext?)` | Attach plaintext data to a `TrustedEvent` |
-
 ### Relay
 
 | Export | Description |
 |--------|-------------|
-| `RelayMode` | Enum: `Read`, `Write`, `Search`, `Blocked`, `Messaging` |
-| `RelayProfile` | NIP-11 relay info type |
 | `isRelayUrl(url)` | Validate relay URL |
 | `isShareableRelayUrl(url)` | True if valid relay URL and not a local address |
 | `isOnionUrl(url)` | Tor address check |
@@ -370,7 +320,6 @@ Profile fields: `name`, `display_name`, `about`, `picture`, `banner`, `website`,
 | `isIPAddress(url)` | IP address check |
 | `normalizeRelayUrl(url)` | Normalize to standard wss:// format |
 | `displayRelayUrl(url)` | Strip protocol and trailing slash |
-| `displayRelayProfile(profile?, fallback?)` | Get display name for relay |
 
 ### Zaps (NIP-57)
 
@@ -379,9 +328,6 @@ Profile fields: `name`, `display_name`, `about`, `picture`, `banner`, `website`,
 | `getLnUrl(address)` | Convert lightning address or URL to LNURL; returns `undefined` if invalid |
 | `getInvoiceAmount(bolt11)` | Extract millisatoshi amount from BOLT11 invoice |
 | `hrpToMillisat(hrpString)` | Convert human-readable BTC amount to millisats (`bigint`) |
-| `zapFromEvent(response, zapper)` | Validate zap receipt and return `Zap` or `undefined` |
-| `Zapper` type | `{ lnurl, pubkey?, callback?, minSendable?, maxSendable?, nostrPubkey?, allowsNostr? }` |
-| `Zap` type | `{ request: TrustedEvent, response: TrustedEvent, invoiceAmount: number }` |
 
 ### Wallet
 
@@ -502,29 +448,14 @@ Only do this for events you persisted yourself after they were validated. Never
 ### Working with tags
 
 ```typescript
-import {
-  getTagValue,
-  getTagValues,
-  getPubkeyTagValues,
-  getTopicTagValues,
-  getRelayTagValues,
-  getReplyTags,
-  uniqTags,
-} from '@welshman/util'
+import {tagValue, tagValues, hexTags, relayTags, tagSpec, topicTags} from '@welshman/util'
 
-// getTagValue and getTagValues: types argument FIRST, then the tags array
-const title  = getTagValue('title', event.tags)          // string | undefined
-const urls   = getTagValues('r', event.tags)             // string[]
-
-// Multiple types at once
-const ids    = getTagValues(['e', 'a'], event.tags)      // string[]
-
-const mentions = getPubkeyTagValues(event.tags)   // string[]
-const topics   = getTopicTagValues(event.tags)    // string[]
-const relays   = getRelayTagValues(event.tags)    // string[]
-
-// NIP-10 thread context
-const { roots, replies, mentions: threadMentions } = getReplyTags(event.tags)
+// Specs come first, then the tags array. The spec says which keys to match and how to
+// validate the value, so malformed tags are skipped rather than silently returned.
+const title = tagValue(tagSpec('title'), event.tags)        // string | undefined
+const urls  = tagValues(relayTags('r'), event.tags)         // string[], valid relay urls only
+const ids   = tagValues(hexTags(['e', 'a']), event.tags)    // string[], 32-byte hex only
+const topics = tagValues(topicTags('t'), event.tags)        // string[], normalized
 ```
 
 ### Matching and building filters
@@ -566,24 +497,11 @@ const parsed = Address.fromNaddr('naddr1...')
 const addressStr = getAddress(event)  // '30023:deadbeef:my-slug'
 ```
 
-### Profiles
-
-```typescript
-import { readProfile, displayProfile, displayPubkey, editProfile } from '@welshman/util'
-
-const profile = readProfile(kind0Event)
-console.log(displayProfile(profile, 'Anonymous'))  // name or fallback
-console.log(displayPubkey(pubkey))                 // 'npub1abc...xyz'
-
-// Update profile
-const updatedEvent = editProfile({ ...profile, name: 'New Name', about: 'Updated bio' })
-// sign and publish updatedEvent
-```
-
 ### Zap flow
 
 ```typescript
-import { getLnUrl, makeEvent, ZAP_REQUEST, zapFromEvent } from '@welshman/util'
+import { getLnUrl, makeEvent, ZAP_REQUEST } from '@welshman/util'
+import { Zappers } from '@welshman/app'
 
 // Step 1: resolve LNURL
 const lnurl = getLnUrl('satoshi@getalby.com')
@@ -604,7 +522,7 @@ const zapRequest = makeEvent(ZAP_REQUEST, {
 // Step 3: sign, send to LNURL callback, pay invoice...
 
 // Step 4: validate receipt (kind 9735)
-const zap = zapFromEvent(zapReceipt, { nostrPubkey: zapperPubkey, allowsNostr: true, lnurl })
+const zap = await app.use(Zappers).validateZapReceipt(zapReceipt, zappedEvent)
 if (zap) {
   console.log(`Received ${zap.invoiceAmount} msat`, zap.request.content)
 }
@@ -646,9 +564,9 @@ await fetch('https://api.example.com/upload', {
 
 - **`@welshman/net`** — uses `TrustedEvent`, `Filter`, `SignedEvent` from this package as the wire types for relay connections and subscriptions.
 - **`@welshman/store`** — provides Svelte stores over repositories built on `TrustedEvent`; relies on `isReplaceable`, `getAddress`, etc. for deduplication.
-- **`@welshman/app`** — high-level application layer; wraps net/store/router and uses profile, list, zap, and handler helpers from this package.
-- **`@welshman/router`** — uses `RelayMode` and relay URL helpers when computing relay selections.
-- **`@welshman/signer`** — produces `SignedEvent` objects that satisfy types defined here; the `Encrypt` function type used by `Encryptable` is typically provided by a signer.
+- **`@welshman/app`** — high-level application layer; wraps net/store/domain and resolves this package's `RelaySelection` DSL through `app.use(Router)`.
+- **`@welshman/domain`** — builds its typed readers on the tag specs (`tagValue`, `hexTags`, `addressTags`) defined here.
+- **`@welshman/signer`** — produces `SignedEvent` objects that satisfy types defined here, and supplies the encryption used when writing encrypted list kinds.
 
 ---
 
@@ -658,11 +576,9 @@ await fetch('https://api.example.com/upload', {
 
 - **Replaceable event identity**: Use `getIdOrAddress` rather than `event.id` when referencing events that may be addressable — the address string is stable across updates, the id is not.
 
-- **`getAncestors` handles two protocols**: Kind 1111 (comment/NIP-22) uses uppercase `E`/`A` for roots and lowercase for replies, returning `{ roots, replies }`. All other kinds use NIP-10 positional rules, returning `{ roots, replies, mentions }` where `mentions` is always present but may be an empty array. You do not need to branch on this; `getAncestors`, `getParentIdOrAddr`, and `isChildOf` handle it automatically.
 
-- **List mutations return `Encryptable`**: `addToListPrivately`, `removeFromList`, etc. do not return an event directly. Call `.reconcile(encryptFn)` on the result to get the final `EventTemplate` ready to sign.
 
-- **`zapFromEvent` returns `undefined` on any validation failure** including amount mismatch, wrong zapper pubkey, malformed invoice, or self-zap. Always check the result.
+- **`validateZapReceipt` returns `undefined` on any validation failure** including amount mismatch, wrong zapper pubkey, malformed invoice, or self-zap. Always check the result. For a reactive list of a parent's valid zaps, use `app.use(Zappers).validZapReceipts(receipts, parent)`, which re-validates as each recipient's zapper loads.
 
 - **`getLnUrl` handles three input forms**: bare lightning address (`user@domain`), full HTTPS URL, or already-encoded `lnurl1...`. Returns `undefined` for anything else.
 
diff --git a/.agents/skills/welshman/SKILL.md b/.agents/skills/welshman/SKILL.md
index 0cab4a8e..58394238 100644
--- a/.agents/skills/welshman/SKILL.md
+++ b/.agents/skills/welshman/SKILL.md
@@ -11,14 +11,14 @@ Welshman is a modular TypeScript nostr toolkit extracted from the [Coracle](http
 
 | Package | Description |
 |---|---|
-| `@welshman/util` | Core nostr types, event helpers, filters, and NIP implementations |
+| `@welshman/util` | Core nostr types, event helpers, filters, tag specs, NIPs, and the `RelaySelection` routing DSL |
 | `@welshman/lib` | General-purpose utilities: LRU cache, event emitter, deferred promises, task queue |
 | `@welshman/net` | Relay connections, request/publish lifecycle, and auth handling |
-| `@welshman/router` | Relay selection strategies for reads and writes |
+| `@welshman/domain` | A typed Reader/Writer pair per event kind, so you never hand-parse tags |
 | `@welshman/store` | Svelte stores and a Repository for indexing/querying nostr events client-side |
 | `@welshman/signer` | Signing and login methods: NIP-01 (privkey), NIP-07 (extension), NIP-46 (bunker), NIP-55 (app), NIP-59 (gift wrap) |
 | `@welshman/feeds` | Dynamic feed construction, filtering, and composition |
-| `@welshman/app` | High-level Svelte stores that compose net, router, store, signer, and feeds into a full application framework |
+| `@welshman/app` | The `App` instance and its plugin registry, composing net, store, domain, signer, and feeds into a full application framework |
 | `@welshman/content` | Parser and renderer for nostr note content (links, mentions, media, custom formatting) |
 | `@welshman/editor` | Batteries-included Svelte rich-text editor component with mention and embed support |
 
@@ -27,25 +27,43 @@ Welshman is a modular TypeScript nostr toolkit extracted from the [Coracle](http
 Packages are layered so lower-level ones have no welshman dependencies:
 
 - **Foundational** (no welshman deps): `@welshman/lib`, `@welshman/util`
-- **Mid-level** (depend only on foundational): `@welshman/net`, `@welshman/router`, `@welshman/store`, `@welshman/signer`
+- **Mid-level** (depend only on foundational): `@welshman/net`, `@welshman/store`, `@welshman/signer`, `@welshman/domain`
 - **Composing** (depend on mid-level + foundational): `@welshman/feeds`, `@welshman/app`
 - **UI-focused** (largely independent, UI rendering concerns): `@welshman/content`, `@welshman/editor`
 
-For deep-dives on any package, load the `welshman-<name>` skill (e.g. `welshman-net`, `welshman-app`, `welshman-signer`).
+For deep-dives on any package, load the `welshman-<name>` skill (e.g. `welshman-net`, `welshman-app`, `welshman-domain`).
 
-## Getting started
+## The App instance
 
-Install only what you need:
+Everything in the framework hangs off one `App`. An app owns the primitives a single identity
+needs — repository, socket pool, tracker, wrap manager — so data never bleeds across sessions.
 
-```bash
-# Full application framework (includes app, net, router, store, signer, feeds)
-npm i @welshman/app
+```typescript
+import {createApp, Network, Profiles, User} from "@welshman/app"
 
-# Or assemble manually for more control
-npm i @welshman/util @welshman/net @welshman/signer
+// `createApp` = `new App` plus the default policies (ingest, relay stats, gift-wrap unwrapping)
+const app = createApp({
+  user: await User.fromSigner(signer),   // omit for a signed-out app
+  config: {
+    getDefaultRelays: () => ["wss://relay.example.com"],
+    getIndexerRelays: () => ["wss://indexer.example.com"],
+  },
+})
+
+app.use(Profiles).load(pubkey)           // plugins are per-app singletons, constructed on demand
+app.use(Network).load({relays, filters})
 ```
 
-If you're building a conventional nostr web client, use `@welshman/app` for batteries-included functionality. For more advanced usage, use the lower-level modules without `app` for more control.
+Three rules follow from this design:
+
+1. **`app.use(Plugin)` is memoized and cheap** — call it inline rather than caching the result.
+2. **An app is scoped to one identity.** Logging in means building a *new* app and calling
+   `cleanup()` on the old one, not attaching a user to the existing one.
+3. **Side effects live in policies**, not in the data classes. An `AppPolicy` is
+   `(app) => Unsubscriber`, applied once at construction and torn down by `cleanup()`.
+
+Svelte apps typically wrap `app` in a store so plugin reads re-subscribe when login swaps the
+instance. That binding layer is app-specific and deliberately not part of welshman.
 
 ## Key nostr concepts
 
@@ -61,91 +79,67 @@ If you're building a conventional nostr web client, use `@welshman/app` for batt
 
 | Goal | Package(s) to use |
 |---|---|
-| Fetch notes from relays | `@welshman/net` (low-level) or `@welshman/app` (high-level) |
-| Select which relays to use | `@welshman/router` |
-| Sign and publish events | `@welshman/signer` + `@welshman/net` |
-| Build a feed UI | `@welshman/feeds` + `@welshman/app` |
+| Fetch notes from relays | `app.use(Network)`, or `@welshman/net` directly for low-level control |
+| Select which relays to use | `RelaySelection` helpers in `@welshman/util` + `app.use(Router)` |
+| Read or write a specific kind | `@welshman/domain` via `app.use(Domain)` |
+| Sign and publish events | `@welshman/signer` + `Command` from `@welshman/app` |
+| Build a feed UI | `@welshman/feeds` + `app.use(Feeds)` |
 | Parse note text and media | `@welshman/content` |
 | Embed a composer / editor | `@welshman/editor` |
-| Cache nostr events client-side | `@welshman/store` |
-| Core event/filter utilities | `@welshman/util` |
+| Cache nostr events client-side | `@welshman/store` + `app.repository` |
+| Core event/filter/tag utilities | `@welshman/util` |
 | Low-level helpers (LRU, emitter, utility functions) | `@welshman/lib` |
 
-### App Example
+## App example
 
 ```typescript
-import "@welshman/app" // side effects: wires pool → repository + tracker + router
+import {createApp, Domain, Profiles, User} from "@welshman/app"
+import {Note} from "@welshman/domain"
+import {Nip07Signer} from "@welshman/signer"
 
-import { openDB } from "idb"
-import { batch, on } from "@welshman/lib"
-import { verifiedSymbol } from "@welshman/util"
-import { repository, tracker, loginWithNip07, publishThunk, userProfile, loadUserProfile } from "@welshman/app"
-import { routerContext } from "@welshman/router"
-import { load } from "@welshman/net"
-import type { TrustedEvent } from "@welshman/util"
-import type { RepositoryUpdate } from "@welshman/net"
-
-// 1. Configure fallback relays
-routerContext.getDefaultRelays = () => ["wss://relay.example.com", "wss://relay2.example.com"]
-routerContext.getIndexerRelays = () => ["wss://indexer.example.com"]
-
-// 2. Open IndexedDB and hydrate the repository
-const db = await openDB("my-app", 1, {
-  upgrade(db) {
-    db.createObjectStore("events", { keyPath: "id" })
+// 1. Build an app for the signed-in user
+const signer = new Nip07Signer()
+const app = createApp({
+  user: await User.fromSigner(signer),
+  config: {
+    getDefaultRelays: () => ["wss://relay.example.com"],
+    getIndexerRelays: () => ["wss://indexer.example.com"],
   },
 })
 
-const stored: TrustedEvent[] = await db.getAll("events")
-for (const e of stored) e[verifiedSymbol] = true
-repository.load(stored)
+// 2. Read the user's profile (loads from their write relays if not cached)
+const profile = await app.use(Profiles).load(app.user!.pubkey)
 
-// Flush new events to IndexedDB
-on(repository, "update", batch(3000, async (updates: RepositoryUpdate[]) => {
-  const tx = db.transaction("events", "readwrite")
-  for (const { added, removed } of updates) {
-    for (const e of added) tx.store.put(e)
-    for (const id of removed) tx.store.delete(id)
-  }
-  await tx.done
-}))
+console.log("Hello,", profile?.display())
 
-// 3. Log in
-const pk = await window.nostr.getPublicKey()
-loginWithNip07(pk)
+// 3. Publish a note — build a writer, wrap it in a command, publish it
+const writer = app.use(Domain).writer(Note).setContent("Hello, Nostr!")
+const command = await app.use(Domain).command(writer)
 
-// 4. Load user's profile reactively (triggers network fetch if not cached)
-await loadUserProfile()
-
-userProfile.subscribe($profile => {
-  if ($profile) console.log("Hello,", $profile.name)
-})
-
-// 5. Publish a note
-import { makeEvent } from "@welshman/util"
-import { Router } from "@welshman/router"
-
-const thunk = publishThunk({
-  event: makeEvent(1, { content: "Hello, Nostr!", tags: [] }),
-  relays: Router.get().FromUser().getUrls(),
-})
-
-await thunk.complete
+await command.publish().waitForError()
 ```
 
-### Lower-level Example
+Publishing goes through a `Command`, which owns the rendered event and its resolved relays:
+`command.publish()`, `.publishToRelays(urls)`, or `.publishAsRelay(url)`. Plugin mutators
+(`app.use(FollowLists).follow(...)`, `app.use(Rooms).joinRoom(...)`) already return a `Command`,
+so `.then(publish)` is usually all you need.
+
+## Lower-level example
+
+The net layer takes an explicit context, so it can be used without an `App` at all.
 
 ```typescript
-import { AbstractAdapter, ClientMessage, NetContext, isClientEvent, netContext, publish, request } from '@welshman/net'
-import { call, sleep } from '@welshman/lib'
-import { Nip01Signer } from '@welshman/signer'
-import { makeEvent, NOTE } from '@welshman/util'
+import {AbstractAdapter, isClientEvent, publish, request} from "@welshman/net"
+import type {ClientMessage, NetContext} from "@welshman/net"
+import {call, sleep} from "@welshman/lib"
+import {Nip01Signer} from "@welshman/signer"
+import {makeEvent, NOTE} from "@welshman/util"
 
 const pingSigner = Nip01Signer.fromSecret(/* nostr hex secret key */)
 const pongSigner = Nip01Signer.fromSecret(/* nostr hex secret key */)
 const RELAY_URL = "bogus.relay"
 
-// Create an adapter for our relay url which just prints the content
+// An adapter for our relay url which just prints the content
 export class PrintAdapter extends AbstractAdapter {
   get sockets() { return [] }
   get urls() { return [] }
@@ -157,37 +151,32 @@ export class PrintAdapter extends AbstractAdapter {
   }
 }
 
-// Configure net context to use our custom adapter
-netContext.getAdapter = (url: string, context: NetContext) => {
-  if (url === RELAY_URL) {
-    return new PrintAdapter()
-  }
+// Context is passed explicitly. An `App` supplies its own via `app.netContext`; here we build one.
+const context: NetContext = {
+  getAdapter: (url: string) => (url === RELAY_URL ? new PrintAdapter() : undefined),
 }
 
-// Loop, sending off pings every so often
 call(async () => {
   while (true) {
     await sleep(1000)
 
-    const ping = await pingSigner.sign(
-      makeEvent(NOTE, {content: 'ping'})
-    )
+    const ping = await pingSigner.sign(makeEvent(NOTE, {content: "ping"}))
 
-    await publish({event: ping, relays: [RELAY_URL]})
+    await publish({event: ping, relays: [RELAY_URL], context})
   }
 })
 
-// Meanwhile, listen for pings and quote-note with a pong
 call(async () => {
   request({
     relays: [RELAY_URL],
     filters: [{kinds: [NOTE], authors: [await pingSigner.getPubkey()]}],
+    context,
     onEvent: async (ping, url) => {
       const pong = await pongSigner.sign(
-        makeEvent(NOTE, {content: 'pong', tags: [["q", ping.id, RELAY_URL, ping.pubkey]]})
+        makeEvent(NOTE, {content: "pong", tags: [["q", ping.id, RELAY_URL, ping.pubkey]]}),
       )
 
-      await publish({event: pong, relays: [RELAY_URL]})
+      await publish({event: pong, relays: [RELAY_URL], context})
     },
   })
 })
diff --git a/AGENTS.md b/AGENTS.md
index 0e0b4bb6..5a898701 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -45,8 +45,9 @@ Example:
 ```typescript
 import {derived} from "svelte/store"
 import {throttle} from "throttle-debounce"
+import {Profiles} from "@welshman/app"
 import {Dialog} from "$lib/components"
-import {repository} from "$app/core/state"
+import {app} from "@app/core"
 ```
 
 ## Cleanup Pass
@@ -67,9 +68,19 @@ Conventions below.
 **Core Principles:**
 
 - Use Svelte 4 **stores** for all state (NOT runes outside UI components)
-- Most global state flows through Welshman's `repository` (unidirectional)
-- Query state using `deriveEventsMapped` or `deriveProfile` etc
-- Update state by publishing events via `publishThunk`
+- Everything hangs off the single `App` instance in `app/core.ts`. There are no welshman globals —
+  reach features with `app.use(Plugin)`, which is memoized per app and cheap to call inline.
+- `app/core.ts` also exports `pubkey`, `signer`, `user` and `session` stores (all with `.get()`),
+  `login`, and `deriveUserItem(plugin)` for the current user's entry in a keyed collection.
+- Most global state flows through the app's `repository` (unidirectional)
+- Query state with a plugin's `one(key)` / `index` / `all`, or `deriveEventsById` /
+  `deriveItemsByKey` from `@welshman/store` against `app.repository`
+- Update state by building a domain writer and publishing the resulting `Command`
+
+**Projections:**
+
+A `Projection<T>` is `{get(): T, $: Readable<T>}` — bind `.$` in markup, call `.get()` in
+callbacks and hot paths.
 
 **Thunks:**
 
@@ -82,12 +93,12 @@ Conventions below.
 
 **Welshman Library Suite:**
 
-- `@welshman/app` - High-level state (pubkey, signer, repository, tracker)
-- `@welshman/net` - Network layer (Pool, Socket, load, pull, request)
-- `@welshman/store` - Svelte integration (deriveEventsMapped, etc.)
-- `@welshman/util` - Event utilities (kinds, tags, validation)
+- `@welshman/app` - The `App` instance and its plugins (Profiles, Rooms, Thunks, Router, …)
+- `@welshman/domain` - A typed Reader/Writer pair per event kind, plus `Relay` and `Zapper`
+- `@welshman/net` - Network layer (Pool, Socket, adapters, request/publish/pull)
+- `@welshman/store` - Svelte integration (deriveEventsById, deriveItemsByKey, etc.)
+- `@welshman/util` - Event utilities (kinds, tags, validation, the RelaySelection routing DSL)
 - `@welshman/signer` - Signing abstraction (NIP-01, NIP-07, NIP-46)
-- `@welshman/router` - Relay routing (inbox/outbox model)
 - `@welshman/editor` - Rich text editor with Nostr
 - `@welshman/content` - Content parsing
 - `@welshman/feeds` - Feed management
@@ -124,12 +135,13 @@ Conventions below.
 - Do not define svelte event handlers inline, instead name them and put them in the script section of templates
 - Write a `{#if}`/`{:else if}` chain rather than hoisting display strings into a lookup `Record` in the script section.
 - Avoid using `as`, except where necessary. Instead, annotate function parameters, and ensure upstream values are typed correctly.
-- To read a tag, use `getTagValue(tagName, event.tags)` (or `getTagValues` for all matches) rather than reaching into the tag array yourself — that means no `getTag(tagName, event.tags)?.[1] || ""` and no `event.tags.find(nthEq(0, tagName))?.[1]`. `getTagValue` is exactly the latter, so the replacement is behavior-preserving, `undefined` included. Reserve `nthEq` for cases with no `getTag*` equivalent, such as `partition(nthEq(0, "imeta"), tags)`.
-- Do not render a profile's `about` directly (e.g. `profile.about`); use the `ProfileAbout` component instead.
+- To read a tag, prefer the domain reader's getter (`note.content()`, `roomMeta.name()`) over touching tags at all. Where there's no reader, use `tagValue(spec, tags)` / `tagValues(spec, tags)` from `@welshman/util` rather than reaching into the tag array yourself — that means no `tags.find(nthEq(0, name))?.[1]`. Build the spec with the narrowest helper that fits: `hexTags("p")`, `relayTags(["r", "relay"])`, `addressTags("a")`, `kindTags("k")`, `topicTags("t")`, or plain `tagSpec("h")` when the value needs no validation. Reserve `nthEq` for cases with no spec equivalent, such as `partition(nthEq(0, "imeta"), tags)`.
+- Do not render a profile's `about` directly (e.g. `profile.about()`); use the `ProfileAbout` component instead.
 - Use `type Props` instead of interface when defining props for svelte components.
 - When a component's value/prop shape mirrors a subset of an existing type, derive it with `Pick`/`Partial` and `export` that type from the component's `<script module>` (e.g. a `Values` type) for callers to import, instead of re-enumerating its sub-properties.
 - Avoid pass-through functions except when the wrapper is part of an abstraction. `x => y()` is not ok, but `x => this.impl.y()` is ok, for example.
 - Use `call` from `@welshman/lib` instead of an IIFE: `const x = call(() => {...})`, not `const x = (() => {...})()`. It reads left-to-right and drops the wrapping parens and the leading-semicolon hazard. `call` ignores extra arguments, so it also works directly as a callback — `unsubscribers.forEach(call)`.
+- To match on field equality, use `spec` from `@welshman/lib` rather than an arrow comparing properties: `.filter(spec({shortcode}))`, not `.filter(emoji => emoji.shortcode === shortcode)`. It takes an object of key/value pairs and matches when every pair is equal, so it covers multi-key checks too (`spec({kind, pubkey})`), and it accepts an array for positional matching on tags (`spec(["p", pubkey])`). Keep an explicit arrow when the predicate isn't plain equality — ranges, negation, or a comparison joined with `&&`.
 - For durations and timestamps, use `@welshman/lib`'s time helpers and constants (`MINUTE`, `HOUR`, `DAY`, `WEEK`, `MONTH`, `YEAR`) rather than raw milliseconds: `int(5, MINUTE)` for a duration in seconds, `ago(5, MINUTE)` for a past timestamp, `now()` for the current one, and `ms()`/`ms(int(...))` only where a browser API needs milliseconds. So `checkedAt < ago(5, MINUTE)` instead of `checkedAt < Date.now() - 300_000`. Write these count-first (`int(3, MONTH)`, `ago(2, WEEK)`) — the declared parameter order is `(unit, count)`, but the product is the same either way and every call site in this repo reads count-first. Nostr timestamps are seconds, so prefer `now()` over `Date.now()` for anything stored on an event.
 - When declaring variables in a svelte component, the order should generally be: props, constants derived from props/state, functions declared with `const`, mutable variables declared with `let`, effects, onMount. This order may vary due to dependencies, but should generally be adhered to.
 
@@ -161,20 +173,23 @@ Conventions below.
 
 ### Loading Data from Network
 
-1. Use utilities from `app/core/requests.ts`
-2. Or create derived stores in `app/core/state.ts`
-3. Use `load`, `pull`, or `request` from `@welshman/net`
+1. Prefer a plugin's `one(key)` / `load(key)`, which handle outbox routing and caching
+2. For anything else use `app.use(Network).load/request` or `app.use(Sync).pull/push` — the bare
+   `load`/`request`/`publish` from `@welshman/net` throw without a context
 
 ### Publishing Events
 
-1. Create `make*` function to build event template
-2. Create `publish*` function using `publishThunk`
-3. Display thunk status to user (for cancel/error handling)
-4. These go in in `app/core/commands.ts`
+1. Build a writer: `app.use(Domain).writer(Kind, reader?)`, then chain its setters
+2. Wrap it: `const command = await app.use(Domain).command(writer)`
+3. Publish it: `command.publish()`, `.publishToRelays(urls)`, or `.publishAsRelay(url)`
+4. Display thunk status to user (for cancel/error handling)
+
+Plugin mutators (`app.use(FollowLists).follow(...)`, `app.use(Rooms).joinRoom(...)`, …) already
+return a `Command`, so `.then(publish)` is usually all you need.
 
 ### Managing Modals/Toasts
 
-- Import from `app/util/modal.ts` or `app/util/toast.ts`
+- Import from `app/modal.ts` or `app/toast.ts`
 - Pass component objects with parameters
 - Use `$state.snapshot` if calling component might unmount
 
diff --git a/android/app/src/main/java/social/flotilla/notifications/AndroidPushFallbackWorker.kt b/android/app/src/main/java/social/flotilla/notifications/AndroidPushFallbackWorker.kt
index 1aee3eff..119c01a3 100644
--- a/android/app/src/main/java/social/flotilla/notifications/AndroidPushFallbackWorker.kt
+++ b/android/app/src/main/java/social/flotilla/notifications/AndroidPushFallbackWorker.kt
@@ -134,8 +134,8 @@ class AndroidPushFallbackWorker(context: Context, params: WorkerParameters) : Wo
     val session = state.optJSONObject("session") ?: return SessionInfo("anonymous", "", JSONObject())
     return SessionInfo(
       session.optString("method", "anonymous"),
-      session.optString("pubkey", ""),
-      session,
+      state.optString("pubkey", ""),
+      session.optJSONObject("data") ?: JSONObject(),
     )
   }
 
@@ -537,7 +537,7 @@ class AndroidPushFallbackWorker(context: Context, params: WorkerParameters) : Wo
   private data class SessionInfo(
     val method: String,
     val pubkey: String,
-    val session: JSONObject,
+    val data: JSONObject,
   )
 
   private data class Subscription(
@@ -699,24 +699,23 @@ class AndroidPushFallbackWorker(context: Context, params: WorkerParameters) : Wo
     }
 
     private fun tryNip01Auth(webSocket: WebSocket, challenge: String): Boolean {
-      val secret = sessionInfo.session.optString("secret", "")
+      val secret = sessionInfo.data.optString("secret", "")
       if (secret.isEmpty()) return false
       val signed = signWithNip01Secret(secret, buildAuthEvent(challenge).toString(), sessionInfo.pubkey)
       return sendAuthMessage(webSocket, signed)
     }
 
     private fun tryNip55Auth(webSocket: WebSocket, challenge: String): Boolean {
-      val signerPackage = sessionInfo.session.optString("signer", "")
+      val signerPackage = sessionInfo.data.optString("signer", "")
       if (signerPackage.isEmpty()) return false
       val signed = signWithNip55ContentResolver(signerPackage, buildAuthEvent(challenge).toString(), sessionInfo.pubkey)
       return sendAuthMessage(webSocket, signed)
     }
 
     private fun tryNip46Auth(webSocket: WebSocket, challenge: String): Boolean {
-      val handler = sessionInfo.session.optJSONObject("handler") ?: return false
-      val clientSecret = sessionInfo.session.optString("secret", "")
-      val signerPubkey = handler.optString("pubkey", "")
-      val relays = handler.optJSONArray("relays")
+      val clientSecret = sessionInfo.data.optString("clientSecret", "")
+      val signerPubkey = sessionInfo.data.optString("signerPubkey", "")
+      val relays = sessionInfo.data.optJSONArray("relays")
 
       if (clientSecret.isEmpty() || signerPubkey.isEmpty() || relays == null || relays.length() == 0) return false
 
diff --git a/package.json b/package.json
index 7d9e0218..8db6574a 100644
--- a/package.json
+++ b/package.json
@@ -63,7 +63,7 @@
     "@getalby/sdk": "^5.1.2",
     "@hono/node-server": "^2.0.0",
     "@noble/curves": "^1.9.7",
-    "@pomade/core": "^0.3.1",
+    "@pomade/core": "^0.3.3",
     "@poppanator/sveltekit-svg": "^7.0.0",
     "@svelte-plugins/datepicker": "^1.0.11",
     "@sveltejs/adapter-static": "^3.0.10",
@@ -73,16 +73,16 @@
     "@types/throttle-debounce": "^5.0.2",
     "@vite-pwa/assets-generator": "^1.0.2",
     "@vite-pwa/sveltekit": "^1.1.0",
-    "@welshman/app": "^0.8.16",
-    "@welshman/content": "^0.8.16",
-    "@welshman/editor": "^0.8.16",
-    "@welshman/feeds": "^0.8.16",
-    "@welshman/lib": "^0.8.16",
-    "@welshman/net": "^0.8.16",
-    "@welshman/router": "^0.8.16",
-    "@welshman/signer": "^0.8.16",
-    "@welshman/store": "^0.8.16",
-    "@welshman/util": "^0.8.16",
+    "@welshman/app": "^0.9.0-pre2",
+    "@welshman/content": "^0.9.0-pre2",
+    "@welshman/domain": "^0.9.0-pre2",
+    "@welshman/editor": "^0.9.0-pre2",
+    "@welshman/feeds": "^0.9.0-pre2",
+    "@welshman/lib": "^0.9.0-pre2",
+    "@welshman/net": "^0.9.0-pre2",
+    "@welshman/signer": "^0.9.0-pre2",
+    "@welshman/store": "^0.9.0-pre2",
+    "@welshman/util": "^0.9.0-pre2",
     "cheerio": "^1.2.0",
     "compressorjs-next": "^1.1.2",
     "dotenv": "^16.6.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 111629b6..e0758c76 100644
Binary files a/pnpm-lock.yaml and b/pnpm-lock.yaml differ
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 0df7ebe8..3f0dddb1 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -11,9 +11,19 @@ minimumReleaseAgeExclude:
   - '@welshman/feeds'
   - '@welshman/lib'
   - '@welshman/net'
-  - '@welshman/router'
+  - '@welshman/domain'
   - '@welshman/signer'
   - '@welshman/store'
   - '@welshman/util'
 overrides:
+  '@welshman/app': link:../welshman/packages/app
+  '@welshman/content': link:../welshman/packages/content
+  '@welshman/domain': link:../welshman/packages/domain
+  '@welshman/editor': link:../welshman/packages/editor
+  '@welshman/feeds': link:../welshman/packages/feeds
+  '@welshman/lib': link:../welshman/packages/lib
+  '@welshman/net': link:../welshman/packages/net
+  '@welshman/signer': link:../welshman/packages/signer
+  '@welshman/store': link:../welshman/packages/store
+  '@welshman/util': link:../welshman/packages/util
   sharp: ^0.35.3
diff --git a/src/app/access.ts b/src/app/access.ts
index a8b24a84..361e1b23 100644
--- a/src/app/access.ts
+++ b/src/app/access.ts
@@ -1,27 +1,28 @@
-import {derived, get, writable, type Readable} from "svelte/store"
+import {derived, writable, type Readable} from "svelte/store"
 import {dissoc, fromPairs, last, poll, randomId, sleep, tryCatch} from "@welshman/lib"
-import {AuthStatus, Pool, request, SocketStatus} from "@welshman/net"
+import {AuthStatus, SocketStatus} from "@welshman/net"
+import type {Socket} from "@welshman/net"
 import {
   displayRelayUrl,
-  getTagValue,
   isRelayUrl,
   makeEvent,
   normalizeRelayUrl,
+  FOLLOWS,
+  MESSAGING_RELAYS,
+  PROFILE,
   RELAY_INVITE,
-  RELAY_JOIN,
-  RELAY_LEAVE,
-  ROOM_JOIN,
+  RELAYS,
 } from "@welshman/util"
-import {publishThunk, sign, waitForThunkError} from "@welshman/app"
+import {RelayInvite, RelayJoin, RelayLeave, RoomJoin} from "@welshman/domain"
+import {Sync, User, publish} from "@welshman/app"
 import {stripPrefix} from "@lib/util"
+import {app, command, network, reader, roomLists, thunks, writer} from "@app/core"
 import {PLATFORM_URL} from "@app/env"
-import {addSpace, userSpaceUrls} from "@app/groups"
 import {relaysMostlyRestricted} from "@app/policies"
-import {broadcastUserData} from "@app/profiles"
 import {Push} from "@app/push"
-import {syncApplicationData} from "@app/sync"
-import {notificationSettings, setSpaceNotifications} from "@app/settings"
 import {deriveSocket} from "@app/relays"
+import {notificationSettings, setSpaceNotifications} from "@app/settings"
+import {syncApplicationData} from "@app/sync"
 
 export const ROOM_CREATE_INVITE = 9009
 
@@ -32,11 +33,6 @@ export type InviteData = {
   code?: string
 }
 
-export type JoinRequestParams = {
-  url: string
-  claim: string
-}
-
 export const isNetworkAuthError = (error: string) => {
   const lower = error.toLowerCase()
 
@@ -104,32 +100,35 @@ export const deriveRelayAuthError = (url: string) =>
     }
   })
 
-export const makeJoinRequest = (params: JoinRequestParams) =>
-  makeEvent(RELAY_JOIN, {tags: [["claim", params.claim]]})
+export const publishJoinRequest = (url: string, claim = "") =>
+  command(writer(RelayJoin).forceRelays(url).setClaim(claim)).then(publish)
 
-export const publishJoinRequest = (params: JoinRequestParams) =>
-  publishThunk({event: makeJoinRequest(params), relays: [params.url]})
+export const publishLeaveRequest = (url: string) =>
+  command(writer(RelayLeave).forceRelays(url)).then(publish)
 
-export type LeaveRequestParams = {
-  url: string
+export const publishRoomJoinRequest = (url: string, h: string, code?: string) => {
+  const eventWriter = writer(RoomJoin).setRoom(url, h)
+
+  if (code) {
+    eventWriter.setClaim(code)
+  }
+
+  return command(eventWriter).then(publish)
 }
 
-export const publishLeaveRequest = (params: LeaveRequestParams) =>
-  publishThunk({event: makeEvent(RELAY_LEAVE), relays: [params.url]})
-
 export const publishRoomInvite = async (url: string, h: string) => {
   const code = randomId()
-  const error = await waitForThunkError(
-    publishThunk({
-      event: makeEvent(ROOM_CREATE_INVITE, {
-        tags: [
-          ["h", h],
-          ["code", code],
-        ],
-      }),
-      relays: [url],
-    }),
-  )
+  const event = makeEvent(ROOM_CREATE_INVITE, {
+    tags: [
+      ["h", h],
+      ["code", code],
+    ],
+  })
+
+  const error = await thunks
+    .get()
+    .publish({event, relays: [url]})
+    .waitForError()
 
   if (error) {
     return {error, code: undefined}
@@ -138,19 +137,6 @@ export const publishRoomInvite = async (url: string, h: string) => {
   return {error: undefined, code}
 }
 
-export const publishRoomJoinRequest = (url: string, h: string, code?: string) => {
-  const tags = [["h", h]]
-
-  if (code) {
-    tags.push(["code", code])
-  }
-
-  return publishThunk({
-    event: makeEvent(ROOM_JOIN, {tags}),
-    relays: [url],
-  })
-}
-
 const authTerminalStatuses = [
   AuthStatus.None,
   AuthStatus.Ok,
@@ -158,7 +144,7 @@ const authTerminalStatuses = [
   AuthStatus.DeniedSignature,
 ]
 
-const waitForAuth = async (socket: ReturnType<ReturnType<typeof Pool.get>["get"]>) => {
+const waitForAuth = async (socket: Socket) => {
   await poll({
     signal: AbortSignal.timeout(10_000),
     condition: () => authTerminalStatuses.includes(socket.auth.status),
@@ -180,7 +166,7 @@ const formatAuthError = (status: AuthStatus, details?: string) => {
 }
 
 export const attemptRelayAccess = async (url: string, claim = "") => {
-  const socket = Pool.get().get(url)
+  const socket = app.get().pool.get(url)
 
   socket.attemptToOpen()
 
@@ -199,7 +185,7 @@ export const attemptRelayAccess = async (url: string, claim = "") => {
   })
 
   for (let i = 0; i < 3 && !authTerminalStatuses.includes(socket.auth.status); i++) {
-    await socket.auth.retryAuth(sign)
+    await socket.auth.retryAuth(User.require(app.get()).sign)
     await waitForAuth(socket)
   }
 
@@ -207,7 +193,8 @@ export const attemptRelayAccess = async (url: string, claim = "") => {
     return formatAuthError(socket.auth.status, socket.auth.details)
   }
 
-  const error = await waitForThunkError(publishJoinRequest({url, claim}))
+  const thunk = await publishJoinRequest(url, claim)
+  const error = await thunk.waitForError()
 
   if (shouldIgnoreError(error)) return
 
@@ -292,10 +279,21 @@ export class Access {
 
   async completeJoin(notifications: boolean) {
     await this.configureNotifications(notifications)
-    await addSpace(this.url)
+    await roomLists.get().addRelay(this.url).then(publish)
     this.clearRestricted()
     syncApplicationData()
-    broadcastUserData([this.url])
+    app
+      .get()
+      .use(Sync)
+      .push({
+        relays: [this.url],
+        filters: [
+          {
+            kinds: [RELAYS, MESSAGING_RELAYS, FOLLOWS, PROFILE],
+            authors: [User.require(app.get()).pubkey],
+          },
+        ],
+      })
   }
 
   async joinSpace({
@@ -321,7 +319,8 @@ export class Access {
   async joinRoom(h: string, code?: string) {
     if (!code) return
 
-    const message = await waitForThunkError(publishRoomJoinRequest(this.url, h, code))
+    const thunk = await publishRoomJoinRequest(this.url, h, code)
+    const message = await thunk.waitForError()
 
     if (message && !message.startsWith("duplicate:")) {
       return message
@@ -329,11 +328,11 @@ export class Access {
   }
 
   async acceptInvite(data: InviteData, notifications: boolean) {
-    const alreadyInSpace = get(userSpaceUrls).includes(data.url)
+    const spaceUrls = roomLists.get().urls(User.require(app.get()).pubkey).get()
     const error = await this.joinSpace({
       claim: data.claim,
       notifications,
-      alreadyJoined: alreadyInSpace,
+      alreadyJoined: spaceUrls.includes(data.url),
     })
 
     if (error) {
@@ -351,7 +350,7 @@ export class Access {
     // A request that times out or hits a closed socket resolves with no events, so an
     // empty result is the only signal we get that the relay never answered.
     const [events, roomInviteResult] = await Promise.all([
-      request({
+      network.get().request({
         relays: [this.url],
         autoClose: true,
         signal: AbortSignal.timeout(10000),
@@ -362,7 +361,13 @@ export class Access {
       sleep(300),
     ])
 
-    this.claim.set(getTagValue("claim", events[0]?.tags || []) || "")
+    if (events[0]) {
+      const eventReader = reader(RelayInvite)
+      const invite = await eventReader(events[0])
+
+      this.claim.set(invite.claim() ?? "")
+    }
+
     this.claimFailed.set(events.length === 0)
 
     if (h) {
diff --git a/src/app/actionItems.ts b/src/app/actionItems.ts
index 418920b9..bd551bd4 100644
--- a/src/app/actionItems.ts
+++ b/src/app/actionItems.ts
@@ -1,3 +1,5 @@
+import {derived} from "svelte/store"
+import {first, groupBy, removeUndefined, spec} from "@welshman/lib"
 import {
   REPORT,
   ROOM_ADD_MEMBER,
@@ -5,28 +7,48 @@ import {
   ROOM_LEAVE,
   ROOM_MEMBERS,
   ROOM_REMOVE_MEMBER,
-  getPubkeyTagValues,
-  getTagValue,
+  hexTags,
+  sortEventsAsc,
   sortEventsDesc,
+  tagSpec,
+  tagValue,
+  tagValues,
 } from "@welshman/util"
 import type {TrustedEvent} from "@welshman/util"
-import {first, groupBy, removeUndefined} from "@welshman/lib"
-import {derived} from "svelte/store"
 import {deriveEventsForUrl} from "@app/repository"
-import {getRoomMembers} from "@app/members"
+
+// A room's membership replayed in order — each member list is a snapshot that resets
+// the set, with add/remove events applied on top.
+const getRoomMembers = (events: TrustedEvent[]) => {
+  const members = new Set<string>()
+
+  for (const event of sortEventsAsc(events)) {
+    const pubkeys = tagValues(hexTags("p"), event.tags)
+
+    if (event.kind === ROOM_MEMBERS) {
+      members.clear()
+      pubkeys.forEach(pubkey => members.add(pubkey))
+    } else if (event.kind === ROOM_ADD_MEMBER) {
+      pubkeys.forEach(pubkey => members.add(pubkey))
+    } else if (event.kind === ROOM_REMOVE_MEMBER) {
+      pubkeys.forEach(pubkey => members.delete(pubkey))
+    }
+  }
+
+  return members
+}
+
 // Action items (admin review queue)
 
 export const deriveSpaceActionItems = (url: string) =>
   derived(
     deriveEventsForUrl(url, [
-      {
-        kinds: [REPORT, ROOM_JOIN, ROOM_LEAVE, ROOM_MEMBERS, ROOM_ADD_MEMBER, ROOM_REMOVE_MEMBER],
-      },
+      {kinds: [REPORT, ROOM_JOIN, ROOM_LEAVE, ROOM_MEMBERS, ROOM_ADD_MEMBER, ROOM_REMOVE_MEMBER]},
     ]),
     $events => {
       const getRoomId = (e: TrustedEvent) =>
-        getTagValue(e.kind === ROOM_MEMBERS ? "d" : "h", e.tags)
-      const reports = $events.filter(e => e.kind === REPORT)
+        tagValue(tagSpec(e.kind === ROOM_MEMBERS ? "d" : "h"), e.tags)
+      const reports = $events.filter(spec({kind: REPORT}))
       const pendingJoins: TrustedEvent[] = []
 
       // Room-level join requests — most recent per pubkey+h
@@ -53,7 +75,7 @@ export const deriveSpaceActionItems = (url: string) =>
           }
         }
 
-        const roomMembers = new Set(getRoomMembers(url, h, roomMembershipEvents))
+        const roomMembers = getRoomMembers(roomMembershipEvents)
 
         pendingJoins.push(
           ...removeUndefined(
@@ -72,7 +94,7 @@ export const deriveSpaceActionItems = (url: string) =>
                   return true
                 }
 
-                return getPubkeyTagValues(event.tags).includes(pubkey)
+                return tagValues(hexTags("p"), event.tags).includes(pubkey)
               })
             ) {
               return false
diff --git a/src/app/call.ts b/src/app/call.ts
index af6aa6b3..e81c442e 100644
--- a/src/app/call.ts
+++ b/src/app/call.ts
@@ -16,15 +16,15 @@ import {
   type AudioCaptureOptions,
 } from "livekit-client"
 import {derived, get, writable} from "svelte/store"
-import {map, not, nthEq, reject, removeUndefined, uniqBy} from "@welshman/lib"
-import type {TrustedEvent} from "@welshman/util"
-import {makeHttpAuth, makeHttpAuthHeader, getTags} from "@welshman/util"
-import {signer} from "@welshman/app"
-import {load} from "@welshman/net"
+import {first, not, nthEq, reject, uniqBy} from "@welshman/lib"
+import {makeHttpAuth, makeHttpAuthHeader, sortEventsDesc, tagSpec, tagValues} from "@welshman/util"
+import {deriveDeduplicated} from "@welshman/store"
+import {makeRoomKey} from "@welshman/app"
+import type {Room} from "@welshman/app"
 import {getLivekitEndpoint} from "$lib/livekit"
 import {AbortError, TimeoutError, whenAborted, whenTimeout} from "$lib/util"
-import {deriveLatestEventForUrl} from "@app/repository"
-import {deriveRoom, makeRoomId, type Room} from "@app/groups"
+import {network, user} from "@app/core"
+import {deriveEventsForUrl} from "@app/repository"
 import {pushToast} from "@app/toast"
 
 export const LIVEKIT_PARTICIPANTS = 39004
@@ -135,7 +135,7 @@ export const joinVoiceRoom = async (
 ): Promise<void> => {
   abortJoinVoiceRoom()
 
-  callTargetRoom.set(get(deriveRoom(url, h)))
+  callTargetRoom.set({url, h, id: makeRoomKey(url, h)})
   callState.set(CallState.Joining)
 
   const controller = new AbortController()
@@ -384,7 +384,7 @@ export const toggleVideoPrimaryTile = (key: string) => {
 }
 
 export const loadCallParticipants = (url: string, h: string) =>
-  load({
+  network.get().load({
     relays: [url],
     filters: [{kinds: [LIVEKIT_PARTICIPANTS], "#d": [h]}],
   })
@@ -395,25 +395,22 @@ export const deriveCallParticipants = (url: string, h: string) =>
     [
       participantMediaState,
       callTargetRoom,
-      deriveLatestEventForUrl(url, [{kinds: [LIVEKIT_PARTICIPANTS], "#d": [h]}]),
+      deriveDeduplicated(
+        deriveEventsForUrl(url, [{kinds: [LIVEKIT_PARTICIPANTS], "#d": [h]}]),
+        events => first(sortEventsDesc(events)),
+      ),
     ],
     ([$participantMediaState, $callTargetRoom, $publishedParticipantList]) => {
-      const inCall = $participantMediaState.size > 0 && $callTargetRoom?.id === makeRoomId(url, h)
+      const inCall = $participantMediaState.size > 0 && $callTargetRoom?.id === makeRoomKey(url, h)
 
-      if (inCall) {
-        const participants = [...$participantMediaState.keys()].map(participantFromLiveKitIdentity)
-        return uniqBy((p: CallParticipant) => participantKey(p), participants)
-      } else {
-        const latestEvent = $publishedParticipantList as TrustedEvent | undefined
-        if (!latestEvent) return []
-        const participants = removeUndefined(
-          map(
-            (tag: string[]) => (tag[1] ? participantFromLiveKitIdentity(tag[1]) : undefined),
-            getTags("participant", latestEvent.tags),
-          ),
-        )
-        return uniqBy((p: CallParticipant) => participantKey(p), participants)
-      }
+      const identities = inCall
+        ? [...$participantMediaState.keys()]
+        : tagValues(tagSpec("participant"), $publishedParticipantList?.tags ?? [])
+
+      return uniqBy(
+        (p: CallParticipant) => participantKey(p),
+        identities.map(participantFromLiveKitIdentity),
+      )
     },
   )
 
@@ -527,18 +524,15 @@ const resyncAfterReconnect = (livekit: LiveKitRoom) => {
 
 const fetchLivekitToken = async (
   url: string,
-  groupId: string,
+  roomId: string,
   signal?: AbortSignal,
 ): Promise<{server_url: string; participant_token: string}> => {
-  const endpoint = getLivekitEndpoint(url, groupId)
-
-  const $signer = signer.get()
-  if (!$signer) throw new Error("No signer available")
+  const endpoint = getLivekitEndpoint(url, roomId)
 
   if (signal?.aborted) throw new DOMException("Aborted", "AbortError")
 
   const template = await makeHttpAuth(endpoint, "GET")
-  const signedEvent = await $signer.sign(template)
+  const signedEvent = await user.get().signer.sign(template)
   const authHeader = makeHttpAuthHeader(signedEvent)
 
   const response = await fetch(endpoint, {
diff --git a/src/app/chats.ts b/src/app/chats.ts
index bdb088cd..d0553697 100644
--- a/src/app/chats.ts
+++ b/src/app/chats.ts
@@ -1,12 +1,14 @@
-import {DELETE, PROFILE, getPubkeyTagValues} from "@welshman/util"
-import type {TrustedEvent} from "@welshman/util"
+import {derived, readable} from "svelte/store"
 import {append, call, on, reject, remove, sort, sortBy, spec, uniq, uniqBy} from "@welshman/lib"
 import type {Override} from "@welshman/lib"
-import {createSearch, displayProfileByPubkey, pubkey, repository} from "@welshman/app"
-import {derived, readable} from "svelte/store"
-import {DM_KINDS} from "@app/content"
+import {DELETE, PROFILE, hexTags, tagValues} from "@welshman/util"
+import type {TrustedEvent} from "@welshman/util"
 import type {RepositoryUpdate} from "@welshman/net"
 import {makeDeriveItem, throttled} from "@welshman/store"
+import {createSearch} from "@welshman/app"
+import {app, profiles, user} from "@app/core"
+import {DM_KINDS} from "@app/content"
+
 export type Chat = {
   id: string
   pubkeys: string[]
@@ -15,13 +17,13 @@ export type Chat = {
   search_text: string
 }
 
-export const getChatPubkeys = (pubkeys: string[]) => sort(uniq(append(pubkey.get()!, pubkeys)))
+export const getChatPubkeys = (pubkeys: string[]) => sort(uniq(append(user.get().pubkey, pubkeys)))
 
 export const getChatPubkeysFromEvent = (event: TrustedEvent) =>
-  getChatPubkeys(getPubkeyTagValues(event.tags).concat(event.pubkey))
+  getChatPubkeys(tagValues(hexTags("p"), event.tags).concat(event.pubkey))
 
 export const makeChatId = (pubkeys: string[]) => {
-  const userPubkey = pubkey.get()!
+  const userPubkey = user.get().pubkey
   const otherPubkeys = remove(userPubkey, uniq(pubkeys))
   const visiblePubkeys = otherPubkeys.length === 0 ? [userPubkey] : otherPubkeys
 
@@ -34,11 +36,13 @@ export const chatsById = call(() => {
   const chatsById = new Map<string, Chat>()
   const chatsByPubkey = new Map<string, string[]>()
 
+  const displayProfile = (pubkey: string) => profiles.get().display(pubkey).get()
+
   const addSearchText = (chat: Override<Chat, {search_text?: string}>) => {
     chat.search_text =
       chat.pubkeys.length === 1
-        ? displayProfileByPubkey(chat.pubkeys[0]) + " note to self"
-        : remove(pubkey.get()!, chat.pubkeys).map(displayProfileByPubkey).join(" ")
+        ? displayProfile(chat.pubkeys[0]) + " note to self"
+        : remove(user.get().pubkey, chat.pubkeys).map(displayProfile).join(" ")
 
     return chat as Chat
   }
@@ -91,7 +95,7 @@ export const chatsById = call(() => {
       let dirty = false
 
       for (const id of removed) {
-        const event = repository.getEvent(id)
+        const event = app.get().repository.getEvent(id)
 
         if (event && DM_KINDS.includes(event.kind)) {
           for (const chatId of chatsByPubkey.get(event.pubkey) || []) {
@@ -110,10 +114,10 @@ export const chatsById = call(() => {
       }
     }
 
-    addEvents(repository.query([{kinds: [...DM_KINDS, DELETE, PROFILE]}]))
+    addEvents(app.get().repository.query([{kinds: [...DM_KINDS, DELETE, PROFILE]}]))
 
     const unsubscribers = [
-      on(repository, "update", ({added, removed}: RepositoryUpdate) => {
+      on(app.get().repository, "update", ({added, removed}: RepositoryUpdate) => {
         // Do this async so that profiles are populated
         setTimeout(() => {
           addEvents(added)
diff --git a/src/app/comments.ts b/src/app/comments.ts
deleted file mode 100644
index b74fa5b1..00000000
--- a/src/app/comments.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import type {TrustedEvent} from "@welshman/util"
-import {COMMENT, makeEvent} from "@welshman/util"
-import {publishThunk, tagEventForComment} from "@welshman/app"
-
-export type CommentParams = {
-  event: TrustedEvent
-  content: string
-  tags?: string[][]
-  url?: string
-}
-
-export const makeComment = ({url, event, content, tags = []}: CommentParams) =>
-  makeEvent(COMMENT, {content, tags: [...tags, ...tagEventForComment(event, url)]})
-
-export const publishComment = ({relays, ...params}: CommentParams & {relays: string[]}) =>
-  publishThunk({event: makeComment({url: relays[0], ...params}), relays})
diff --git a/src/app/components/AppContainer.svelte b/src/app/components/AppContainer.svelte
index 6b2992cd..f9176376 100644
--- a/src/app/components/AppContainer.svelte
+++ b/src/app/components/AppContainer.svelte
@@ -1,13 +1,13 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
-  import {pubkey} from "@welshman/app"
   import Dialog from "@lib/components/Dialog.svelte"
   import Landing from "@app/components/Landing.svelte"
   import Toast from "@app/components/Toast.svelte"
   import PrimaryNav from "@app/components/PrimaryNav.svelte"
+  import {app} from "@app/core"
   import {modal} from "@app/modal"
 
-  interface Props {
+  type Props = {
     children: Snippet
   }
 
@@ -15,7 +15,7 @@
 </script>
 
 <div class="flex h-screen overflow-hidden">
-  {#if $pubkey}
+  {#if $app.user?.pubkey}
     <PrimaryNav>
       {@render children?.()}
     </PrimaryNav>
diff --git a/src/app/components/BoardMenu.svelte b/src/app/components/BoardMenu.svelte
index 7c4481a0..489ddf4f 100644
--- a/src/app/components/BoardMenu.svelte
+++ b/src/app/components/BoardMenu.svelte
@@ -1,17 +1,17 @@
 <script lang="ts">
   import {onMount} from "svelte"
+  import type {PinboardReader} from "@welshman/domain"
   import ShareCircle from "@assets/icons/share-circle.svg?dataurl"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import EventInfo from "@app/components/EventInfo.svelte"
-  import {type PublishedBoard} from "@app/pinboards"
   import {shareEventToChat} from "@app/share"
   import {pushModal} from "@app/modal"
 
   type Props = {
     url: string
-    board: PublishedBoard
+    board: PinboardReader
     onClick: () => void
   }
 
diff --git a/src/app/components/CalendarEventActions.svelte b/src/app/components/CalendarEventActions.svelte
index 15b02dbf..5d429b83 100644
--- a/src/app/components/CalendarEventActions.svelte
+++ b/src/app/components/CalendarEventActions.svelte
@@ -1,20 +1,18 @@
 <script lang="ts">
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {getTagValue, getAddress} from "@welshman/util"
-  import {pubkey} from "@welshman/app"
+  import {getAddress, tagSpec, tagValue} from "@welshman/util"
   import Pen2 from "@assets/icons/pen-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Link from "@lib/components/Link.svelte"
   import RoomName from "@app/components/RoomName.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
   import ThunkStatusOrDeleted from "@app/components/ThunkStatusOrDeleted.svelte"
   import EventActivity from "@app/components/EventActivity.svelte"
   import EventActions from "@app/components/EventActions.svelte"
   import CalendarEventEdit from "@app/components/CalendarEventEdit.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
+  import {user} from "@app/core"
   import {makeCalendarPath, makeSpacePath} from "@app/routes"
   import {pushModal} from "@app/modal"
 
@@ -27,17 +25,14 @@
 
   const {url, event, showRoom, showActivity}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
   const path = makeCalendarPath(url, getAddress(event))
-  const shouldProtect = canEnforceNip70(url)
 
   const editEvent = () => pushModal(CalendarEventEdit, {url, event})
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url, h})
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url, h})
 </script>
 
 <div class="flex grow flex-wrap justify-end gap-2">
@@ -53,7 +48,7 @@
   {/if}
   <EventActions {url} {event} noun="Event">
     {#snippet customActions()}
-      {#if event.pubkey === $pubkey}
+      {#if event.pubkey === $user.pubkey}
         <li>
           <Button onclick={editEvent}>
             <Icon size={4} icon={Pen2} />
diff --git a/src/app/components/CalendarEventCreate.svelte b/src/app/components/CalendarEventCreate.svelte
index 2c9a325b..9ffe8f33 100644
--- a/src/app/components/CalendarEventCreate.svelte
+++ b/src/app/components/CalendarEventCreate.svelte
@@ -17,7 +17,7 @@
   {#snippet header()}
     <ModalHeader>
       <ModalTitle>Create an Event</ModalTitle>
-      <ModalSubtitle>Invite other group members to events online or in real life.</ModalSubtitle>
+      <ModalSubtitle>Invite other room members to events online or in real life.</ModalSubtitle>
     </ModalHeader>
   {/snippet}
 </CalendarEventForm>
diff --git a/src/app/components/CalendarEventDate.svelte b/src/app/components/CalendarEventDate.svelte
index 8443ce88..7e3a6a99 100644
--- a/src/app/components/CalendarEventDate.svelte
+++ b/src/app/components/CalendarEventDate.svelte
@@ -1,17 +1,21 @@
 <script lang="ts">
-  import {fromPairs, LOCALE, secondsToDate} from "@welshman/lib"
+  import {LOCALE, secondsToDate} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
+  import {TimeEvent} from "@welshman/domain"
+  import {reader} from "@app/core"
 
   type Props = {
     event: TrustedEvent
   }
 
   const {event}: Props = $props()
-  const meta = $derived(fromPairs(event.tags) as Record<string, string>)
-  const start = $derived(parseInt(meta.start))
+
+  const timeEvent = reader(TimeEvent)(event)
+
+  const start = timeEvent.start()
 </script>
 
-{#if !isNaN(start)}
+{#if start}
   {@const startDate = secondsToDate(start)}
   <div
     class="hidden h-32 w-32 min-w-32 flex-col items-center justify-center gap-1 rounded-2xl bg-surface-more p-2 sm:flex">
diff --git a/src/app/components/CalendarEventEdit.svelte b/src/app/components/CalendarEventEdit.svelte
index 25dafbb3..21d68118 100644
--- a/src/app/components/CalendarEventEdit.svelte
+++ b/src/app/components/CalendarEventEdit.svelte
@@ -1,9 +1,10 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {TimeEvent} from "@welshman/domain"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
+  import {reader} from "@app/core"
   import CalendarEventForm from "@app/components/CalendarEventForm.svelte"
 
   type Props = {
@@ -13,21 +14,27 @@
 
   const {url, event}: Props = $props()
 
-  const initialValues = {
-    d: getTagValue("d", event.tags)!,
-    title: getTagValue("title", event.tags)!,
-    location: getTagValue("location", event.tags)!,
-    start: parseInt(getTagValue("start", event.tags)!),
-    end: parseInt(getTagValue("end", event.tags)!),
-    content: event.content,
-  }
+  const timeEvent = reader(TimeEvent)(event)
+
+  const initialValues = $derived(
+    timeEvent && {
+      d: timeEvent.identifier() ?? "",
+      title: timeEvent.title() ?? "",
+      location: timeEvent.location() ?? "",
+      start: timeEvent.start(),
+      end: timeEvent.end(),
+      content: timeEvent.content(),
+    },
+  )
 </script>
 
-<CalendarEventForm {url} {initialValues}>
-  {#snippet header()}
-    <ModalHeader>
-      <ModalTitle>Edit this Event</ModalTitle>
-      <ModalSubtitle>Invite other group members to events online or in real life.</ModalSubtitle>
-    </ModalHeader>
-  {/snippet}
-</CalendarEventForm>
+{#if initialValues}
+  <CalendarEventForm {url} {initialValues}>
+    {#snippet header()}
+      <ModalHeader>
+        <ModalTitle>Edit this Event</ModalTitle>
+        <ModalSubtitle>Invite other room members to events online or in real life.</ModalSubtitle>
+      </ModalHeader>
+    {/snippet}
+  </CalendarEventForm>
+{/if}
diff --git a/src/app/components/CalendarEventForm.svelte b/src/app/components/CalendarEventForm.svelte
index 089161a2..0fe81194 100644
--- a/src/app/components/CalendarEventForm.svelte
+++ b/src/app/components/CalendarEventForm.svelte
@@ -2,10 +2,9 @@
   import type {Snippet} from "svelte"
   import {writable} from "svelte/store"
   import {randomId} from "@welshman/lib"
-  import {makeEvent, EVENT_TIME} from "@welshman/util"
-  import {publishThunk, waitForThunkError} from "@welshman/app"
+  import {publish} from "@welshman/app"
+  import {TimeEvent} from "@welshman/domain"
   import {preventDefault} from "@lib/html"
-  import {daysBetween} from "@lib/util"
   import GallerySend from "@assets/icons/gallery-send.svg?dataurl"
   import MapPoint from "@assets/icons/map-point.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
@@ -18,11 +17,11 @@
   import ModalBody from "@lib/components/ModalBody.svelte"
   import DateTimeRangeInput from "@lib/components/DateTimeRangeInput.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
-  import {PROTECTED, publishRoomQuote} from "@app/groups"
+  import {publishRoomQuote} from "@app/rooms"
   import {makeEditor} from "@app/editor"
   import {DraftKey} from "@app/drafts"
   import {pushToast} from "@app/toast"
-  import {canEnforceNip70} from "@app/relays"
+  import {command, relays, writer} from "@app/core"
 
   type Values = {
     d: string
@@ -49,7 +48,7 @@
     initialValues = draftKey.get()
   }
 
-  const shouldProtect = canEnforceNip70(url)
+  const shouldProtect = $relays.hasNip(url, 70)
 
   const uploading = writable(false)
 
@@ -83,32 +82,29 @@
 
     const ed = await editor
     const content = ed.getText({blockSeparator: "\n"}).trim()
-    const tags = [
-      ["d", d],
-      ["title", title],
-      ["location", location],
-      ["start", start.toString()],
-      ["end", end.toString()],
-      ...daysBetween(start, end).map(D => ["D", D.toString()]),
-      ...ed.storage.nostr.getEditorTags(),
-    ]
 
     loading = true
 
     try {
       const protect = await shouldProtect
-
-      if (protect) {
-        tags.push(PROTECTED)
-      }
+      const eventWriter = writer(TimeEvent)
+        .setIdentifier(d)
+        .setTitle(title)
+        .setLocation(location)
+        .setStart(start)
+        .setEnd(end)
+        .setContent(content)
+        .setProtected(protect)
+        .addTags(...ed.storage.nostr.getEditorTags())
 
       if (h) {
-        tags.push(["h", h])
+        eventWriter.setRoom(url, h)
+      } else {
+        eventWriter.forceRelays(url)
       }
 
-      const event = makeEvent(EVENT_TIME, {content, tags})
-      const calendarThunk = publishThunk({event, relays: [url]})
-      const error = await waitForThunkError(calendarThunk)
+      const calendarThunk = await command(eventWriter).then(publish)
+      const error = await calendarThunk.waitForError()
 
       if (error) {
         return pushToast({theme: "error", message: error})
diff --git a/src/app/components/CalendarEventHeader.svelte b/src/app/components/CalendarEventHeader.svelte
index 764720f2..9d5b5208 100644
--- a/src/app/components/CalendarEventHeader.svelte
+++ b/src/app/components/CalendarEventHeader.svelte
@@ -1,30 +1,30 @@
 <script lang="ts">
-  import {
-    fromPairs,
-    formatTimestamp,
-    formatTimestampAsDate,
-    formatTimestampAsTime,
-  } from "@welshman/lib"
+  import {formatTimestamp, formatTimestampAsDate, formatTimestampAsTime} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
+  import {TimeEvent} from "@welshman/domain"
   import ClockCircle from "@assets/icons/clock-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
+  import {reader} from "@app/core"
 
   type Props = {
     event: TrustedEvent
   }
 
   const {event}: Props = $props()
-  const meta = $derived(fromPairs(event.tags) as Record<string, string>)
-  const start = $derived(parseInt(meta.start))
-  const end = $derived(parseInt(meta.end))
+
+  const timeEvent = reader(TimeEvent)(event)
+
+  // NIP-52 settled on `title`, but events from before that still carry `name`.
+  const title = $derived(timeEvent.title() ?? tagValue(tagSpec("name"), event.tags))
+  const start = timeEvent.start()
+  const end = timeEvent.end()
 </script>
 
 <div class="flex flex-col justify-between gap-1">
-  <p class="text-lg">{meta.title || meta.name}</p>
-  {#if !isNaN(start) && !isNaN(end)}
-    {@const startDateDisplay = formatTimestampAsDate(start)}
-    {@const endDateDisplay = formatTimestampAsDate(end)}
-    {@const isSingleDay = startDateDisplay === endDateDisplay}
+  <p class="text-lg">{title}</p>
+  {#if start && end}
+    {@const isSingleDay = formatTimestampAsDate(start) === formatTimestampAsDate(end)}
     <div class="flex flex-wrap gap-2 text-xs">
       <div class="flex items-center gap-2">
         <Icon icon={ClockCircle} size={4} />
diff --git a/src/app/components/CalendarEventItem.svelte b/src/app/components/CalendarEventItem.svelte
index ba2ccc9e..9afa25db 100644
--- a/src/app/components/CalendarEventItem.svelte
+++ b/src/app/components/CalendarEventItem.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue, getAddress} from "@welshman/util"
+  import {getAddress, tagValue, tagSpec} from "@welshman/util"
   import Link from "@lib/components/Link.svelte"
   import CalendarEventActions from "@app/components/CalendarEventActions.svelte"
   import CalendarEventHeader from "@app/components/CalendarEventHeader.svelte"
@@ -15,7 +15,7 @@
 
   const {url, event}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
 </script>
 
 <Link
diff --git a/src/app/components/CalendarEventMeta.svelte b/src/app/components/CalendarEventMeta.svelte
index 2669d123..afa315cc 100644
--- a/src/app/components/CalendarEventMeta.svelte
+++ b/src/app/components/CalendarEventMeta.svelte
@@ -1,9 +1,10 @@
 <script lang="ts">
-  import {fromPairs} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
+  import {TimeEvent} from "@welshman/domain"
   import UserCircle from "@assets/icons/user-circle.svg?dataurl"
   import MapPoint from "@assets/icons/map-point.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
+  import {reader} from "@app/core"
   import ProfileLink from "@app/components/ProfileLink.svelte"
 
   type Props = {
@@ -12,7 +13,10 @@
   }
 
   const {event, url}: Props = $props()
-  const meta = $derived(fromPairs(event.tags) as Record<string, string>)
+
+  const timeEvent = reader(TimeEvent)(event)
+
+  const location = timeEvent.location()
 </script>
 
 <div class="flex min-w-0 flex-col gap-1 text-sm opacity-75">
@@ -20,10 +24,10 @@
     <Icon icon={UserCircle} size={4} />
     Posted by <ProfileLink pubkey={event.pubkey} {url} />
   </span>
-  {#if meta.location}
+  {#if location}
     <span class="flex items-start gap-1">
       <Icon icon={MapPoint} class="mt-[2px]" size={4} />
-      <span class="wrap-break-word">{meta.location}</span>
+      <span class="wrap-break-word">{location}</span>
     </span>
   {/if}
 </div>
diff --git a/src/app/components/Chat.svelte b/src/app/components/Chat.svelte
index 9cadca0a..dc530074 100644
--- a/src/app/components/Chat.svelte
+++ b/src/app/components/Chat.svelte
@@ -18,22 +18,9 @@
     formatTimestampAsDate,
   } from "@welshman/lib"
   import type {TrustedEvent, EventTemplate, EventContent} from "@welshman/util"
+  import {makeEvent, DIRECT_MESSAGE, DIRECT_MESSAGE_FILE} from "@welshman/util"
   import {parse, isLink} from "@welshman/content"
-  import {
-    makeEvent,
-    tagsFromIMeta,
-    getTags,
-    DIRECT_MESSAGE,
-    DIRECT_MESSAGE_FILE,
-  } from "@welshman/util"
-  import {
-    pubkey,
-    tagPubkey,
-    sendWrapped,
-    mergeThunks,
-    loadMessagingRelayList,
-    messagingRelayListsByPubkey,
-  } from "@welshman/app"
+  import {MessagingRelayLists, Thunks} from "@welshman/app"
   import Danger from "@assets/icons/danger-triangle.svg?dataurl"
   import ArrowLeft from "@assets/icons/arrow-left.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -52,12 +39,12 @@
   import ChatComposeEdit from "@app/components/ChatComposeEdit.svelte"
   import ChatComposeParent from "@app/components/ChatComposeParent.svelte"
   import ThunkToast from "@app/components/ThunkToast.svelte"
+  import {app, deletes, user, wraps} from "@app/core"
   import {userSettingsValues} from "@app/settings"
   import {deriveChat, makeChatId} from "@app/chats"
   import {pushModal} from "@app/modal"
   import {DraftKey} from "@app/drafts"
-  import {makeDelete} from "@app/deletes"
-  import {prependParent} from "@app/groups"
+  import {prependParent} from "@app/rooms"
   import {pushToast} from "@app/toast"
 
   type Props = {
@@ -70,8 +57,9 @@
   const chatId = makeChatId(pubkeys)
   const chat = deriveChat(chatId)
   const draftKey = new DraftKey<{content?: string | object}>(`dm:${chatId}`)
-  const others = remove($pubkey!, pubkeys)
-  const missingRelayLists = $derived(others.filter(pk => !$messagingRelayListsByPubkey.has(pk)))
+  const others = remove($user.pubkey, pubkeys)
+  const messagingRelayLists = $app.use(MessagingRelayLists).index.$
+  const missingRelayLists = $derived(others.filter(pk => !$messagingRelayLists.has(pk)))
 
   const showMembers = () =>
     others.length === 1
@@ -95,28 +83,26 @@
 
   const onSubmit = async (params: EventContent) => {
     try {
-      const ptags = remove($pubkey!, pubkeys).map(tagPubkey)
+      const ptags = others.map(pk => ["p", pk])
 
       // Remove p tags since they result in forking the conversation
       params.tags = params.tags.filter(nthNe(0, "p"))
 
       // Add our reply quote to content
-      params = prependParent(parent, params)
+      params = await prependParent(parent, params)
 
       if (eventToEdit) {
         if (eventToEdit.content === params.content) {
           return
         }
 
-        await sendWrapped({
-          event: makeDelete({event: eventToEdit, protect: false}),
-          recipients: pubkeys,
-          pow: 16,
-        })
+        const command = await $deletes.deleteEvent(eventToEdit)
+
+        await $wraps.publish({event: command.event, recipients: pubkeys, pow: 16})
       }
 
       const [imetaTags, tags] = partition(nthEq(0, "imeta"), params.tags)
-      const imetas = getTags("imeta", imetaTags).map(tagsFromIMeta)
+      const imetas = imetaTags.map(tag => tag.slice(1).map(entry => entry.split(" ")))
       const templates: EventTemplate[] = []
       const buffer = []
 
@@ -141,11 +127,7 @@
 
         if (isLink(p) && imeta) {
           addTemplate(DIRECT_MESSAGE, buffer.splice(0).join(""), tags)
-          addTemplate(
-            DIRECT_MESSAGE_FILE,
-            p.value.url.toString(),
-            imeta.slice(1).filter(nthNe(0, "url")),
-          )
+          addTemplate(DIRECT_MESSAGE_FILE, p.value.url.toString(), imeta.filter(nthNe(0, "url")))
         } else {
           buffer.push(p.raw)
         }
@@ -157,7 +139,7 @@
       // Sleep 1 second between each one to make sure timestamps are distinct
       const thunks = await Promise.all(
         Array.from(enumerate(templates)).map(([i, event]) =>
-          sendWrapped({
+          $wraps.publish({
             event,
             recipients: pubkeys,
             delay: $userSettingsValues.send_delay + ms(i),
@@ -170,7 +152,7 @@
         timeout: 30_000,
         children: {
           component: ThunkToast,
-          props: {thunk: mergeThunks(thunks)},
+          props: {thunk: $app.use(Thunks).merge(thunks)},
         },
       })
     } finally {
@@ -185,7 +167,7 @@
   }
 
   const canEditEvent = (event: TrustedEvent) =>
-    event.pubkey === $pubkey &&
+    event.pubkey === $user.pubkey &&
     event.kind === DIRECT_MESSAGE &&
     event.created_at >= ago(500, MINUTE)
 
@@ -233,7 +215,7 @@
 
   onMount(() => {
     for (const pubkey of others) {
-      loadMessagingRelayList(pubkey)
+      $app.use(MessagingRelayLists).load(pubkey)
     }
   })
 
@@ -252,8 +234,8 @@
         <Button class="flex flex-col gap-1 sm:flex-row sm:gap-2" onclick={showMembers}>
           {#if others.length === 0}
             <div class="flex gap-2">
-              <ProfileCircle pubkey={$pubkey!} size={5} />
-              <ProfileName pubkey={$pubkey!} />
+              <ProfileCircle pubkey={$user.pubkey} size={5} />
+              <ProfileName pubkey={$user.pubkey} />
             </div>
           {:else if others.length === 1}
             <div class="flex gap-2">
@@ -294,7 +276,7 @@
           {#each missingRelayLists as pubkey (pubkey)}
             <ProfileLink {pubkey} />
           {/each}
-          to enable direct messaging by opening this conversation in their app.
+          to enable direct messaging by opening this conversation in their $app.
         </p>
       </div>
     </div>
diff --git a/src/app/components/ChatComposeParent.svelte b/src/app/components/ChatComposeParent.svelte
index 7d672460..a9f9ecff 100644
--- a/src/app/components/ChatComposeParent.svelte
+++ b/src/app/components/ChatComposeParent.svelte
@@ -1,28 +1,28 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {displayProfileByPubkey} from "@welshman/app"
   import {slide} from "@lib/transition"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import NoteContentMinimal from "@app/components/NoteContentMinimal.svelte"
+  import {profiles} from "@app/core"
 
-  const {
-    verb,
-    event,
-    clear,
-  }: {
+  type Props = {
     verb: string
     event: TrustedEvent
     clear: () => void
-  } = $props()
+  }
+
+  const {verb, event, clear}: Props = $props()
+
+  const display = $profiles.display(event.pubkey).$
 </script>
 
 <div
   class="bg-surface-more relative border-l-2 border-solid px-2 py-1 pr-8"
   style="border-color: var(--primary)"
   transition:slide>
-  <p class="text-primary text-xs">{verb} @{displayProfileByPubkey(event.pubkey)}</p>
+  <p class="text-primary text-xs">{verb} @{$display}</p>
   {#key event.id}
     <NoteContentMinimal trimParent {event} />
   {/key}
diff --git a/src/app/components/ChatEnable.svelte b/src/app/components/ChatEnable.svelte
index 23553879..ffcb2ee2 100644
--- a/src/app/components/ChatEnable.svelte
+++ b/src/app/components/ChatEnable.svelte
@@ -1,6 +1,4 @@
 <script lang="ts">
-  import {getRelaysFromList} from "@welshman/util"
-  import {waitForThunkError, setMessagingRelays, userRelayList, setRelays} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
@@ -12,6 +10,7 @@
   import ModalHeader from "@lib/components/ModalHeader.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import {deriveUserItem, messagingRelayLists, relayLists} from "@app/core"
   import {DEFAULT_RELAYS, DEFAULT_MESSAGING_RELAYS} from "@app/env"
   import {pushToast} from "@app/toast"
 
@@ -21,7 +20,7 @@
 
   const {next}: Props = $props()
 
-  let loading = $state(false)
+  const userRelayList = deriveUserItem($app => $relayLists)
 
   const back = () => history.back()
 
@@ -29,8 +28,14 @@
     loading = true
 
     try {
-      if (getRelaysFromList($userRelayList).length === 0) {
-        const error = await waitForThunkError(await setRelays(DEFAULT_RELAYS.map(r => ["r", r])))
+      const relayUrls = $userRelayList?.urls() ?? []
+
+      if (relayUrls.length === 0) {
+        const command = await $relayLists.update(writer =>
+          writer.setReadUrls(DEFAULT_RELAYS).setWriteUrls(DEFAULT_RELAYS),
+        )
+
+        const error = await command.publish().waitForError()
 
         if (error) {
           pushToast({theme: "error", message: error})
@@ -38,7 +43,8 @@
         }
       }
 
-      const error = await waitForThunkError(await setMessagingRelays(DEFAULT_MESSAGING_RELAYS))
+      const command = await $messagingRelayLists.setUrls(DEFAULT_MESSAGING_RELAYS)
+      const error = await command.publish().waitForError()
 
       if (error) {
         pushToast({theme: "error", message: error})
@@ -50,6 +56,8 @@
       loading = false
     }
   }
+
+  let loading = $state(false)
 </script>
 
 <Modal tag="form" onsubmit={preventDefault(enable)}>
diff --git a/src/app/components/ChatItem.svelte b/src/app/components/ChatItem.svelte
index 4bc2dc30..92911c7e 100644
--- a/src/app/components/ChatItem.svelte
+++ b/src/app/components/ChatItem.svelte
@@ -4,7 +4,6 @@
   import {page} from "$app/stores"
   import {remove, uniq, formatTimestamp} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {pubkey, loadMessagingRelayList} from "@welshman/app"
   import {fade} from "@lib/transition"
   import Button from "@lib/components/Button.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
@@ -12,6 +11,7 @@
   import ProfileCircles from "@app/components/ProfileCircles.svelte"
   import {makeChatPath, goToChat} from "@app/routes"
   import {notifications} from "@app/notifications"
+  import {messagingRelayLists, user} from "@app/core"
 
   interface Props {
     id: string
@@ -22,14 +22,14 @@
 
   const {...props}: Props = $props()
 
-  const others = uniq(remove($pubkey!, props.pubkeys))
+  const others = uniq(remove($user.pubkey, props.pubkeys))
   const active = $derived($page.params.chat === props.id)
   const path = makeChatPath(props.pubkeys)
   const openChat = () => goToChat(props.pubkeys)
 
   onMount(() => {
     for (const pk of others) {
-      loadMessagingRelayList(pk)
+      $messagingRelayLists.load(pk)
     }
   })
 </script>
@@ -46,7 +46,7 @@
       <div class="flex items-center justify-between gap-2">
         <div class="flex min-w-0 items-center gap-2">
           {#if others.length === 0}
-            <ProfileCircle pubkey={$pubkey!} size={5} />
+            <ProfileCircle pubkey={$user.pubkey} size={5} />
             Note to self
           {:else if others.length === 1}
             <ProfileCircle pubkey={others[0]} size={5} />
@@ -66,7 +66,7 @@
       </div>
       <p class="overflow-hidden text-ellipsis whitespace-nowrap text-sm">
         <span class="opacity-70">
-          {#if props.messages[0].pubkey === $pubkey}
+          {#if props.messages[0].pubkey === $user.pubkey}
             You:
           {/if}
         </span>
diff --git a/src/app/components/ChatMembers.svelte b/src/app/components/ChatMembers.svelte
index e956e0b7..cacbf1ac 100644
--- a/src/app/components/ChatMembers.svelte
+++ b/src/app/components/ChatMembers.svelte
@@ -7,7 +7,7 @@
   import ModalBody from "@lib/components/ModalBody.svelte"
   import Profile from "@app/components/Profile.svelte"
 
-  interface Props {
+  type Props = {
     pubkeys: string[]
   }
 
diff --git a/src/app/components/ChatMessage.svelte b/src/app/components/ChatMessage.svelte
index ce372e21..2e65e34f 100644
--- a/src/app/components/ChatMessage.svelte
+++ b/src/app/components/ChatMessage.svelte
@@ -3,7 +3,7 @@
   import {type Instance} from "tippy.js"
   import {hash, formatTimestampAsTime} from "@welshman/lib"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {thunks, mergeThunks, pubkey, deriveProfileDisplay, sendWrapped} from "@welshman/app"
+  import {Thunks} from "@welshman/app"
   import {isMobile} from "@lib/html"
   import MenuDots from "@assets/icons/menu-dots.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -11,15 +11,15 @@
   import Tippy from "@lib/components/Tippy.svelte"
   import TapTarget from "@lib/components/TapTarget.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
+  import {publishWrappedReaction, retractWrappedReaction} from "@app/reactions"
   import Content from "@app/components/Content.svelte"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
   import ThunkFailure from "@app/components/ThunkFailure.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
   import ChatMessageMenu from "@app/components/ChatMessageMenu.svelte"
   import ChatMessageMenuMobile from "@app/components/ChatMessageMenuMobile.svelte"
+  import {app, profiles, user} from "@app/core"
   import {colors} from "@app/theme"
-  import {makeDelete} from "@app/deletes"
-  import {makeReaction} from "@app/reactions"
   import {pushModal} from "@app/modal"
 
   interface Props {
@@ -33,23 +33,18 @@
 
   const {event, replyTo, canEdit, onEdit, pubkeys, showPubkey = false}: Props = $props()
 
-  const isOwn = event.pubkey === $pubkey
-  const profileDisplay = deriveProfileDisplay(event.pubkey)
-  const thunk = mergeThunks($thunks.filter(t => t.event.id === event.id))
+  const isOwn = event.pubkey === $user.pubkey
+  const profileDisplay = $profiles.display(event.pubkey).$
+  const thunks = $app.use(Thunks).history
+  const thunk = $app.use(Thunks).merge($thunks.filter(t => t.event.id === event.id))
   const [_, colorValue] = colors[hash(event.pubkey) % colors.length]
 
   const reply = () => replyTo(event)
   const edit = canEdit?.(event) ? () => onEdit?.(event) : undefined
 
-  const deleteReaction = (event: TrustedEvent) =>
-    sendWrapped({event: makeDelete({event, protect: false}), recipients: pubkeys, pow: 16})
+  const deleteReaction = (reaction: TrustedEvent) => retractWrappedReaction(reaction, pubkeys)
 
-  const createReaction = (template: EventContent) =>
-    sendWrapped({
-      event: makeReaction({event, protect: false, ...template}),
-      recipients: pubkeys,
-      pow: 16,
-    })
+  const createReaction = (values: EventContent) => publishWrappedReaction(event, values, pubkeys)
 
   const openProfile = () => pushModal(ProfileDetail, {pubkey: event.pubkey})
 
@@ -67,9 +62,7 @@
   let popoverIsVisible = $state(false)
 </script>
 
-{#if thunk}
-  <ThunkFailure showToastOnRetry {thunk} class="mt-1" />
-{/if}
+<ThunkFailure showToastOnRetry {thunk} class="mt-1" />
 <div
   data-event={event.id}
   class={cx("group flex items-center justify-end gap-1 px-2", {"flex-row-reverse": !isOwn})}>
diff --git a/src/app/components/ChatMessageEmojiButton.svelte b/src/app/components/ChatMessageEmojiButton.svelte
index 1f29f093..c490c48a 100644
--- a/src/app/components/ChatMessageEmojiButton.svelte
+++ b/src/app/components/ChatMessageEmojiButton.svelte
@@ -1,25 +1,23 @@
 <script lang="ts">
   import type {NativeEmoji} from "emoji-picker-element/shared"
   import type {TrustedEvent} from "@welshman/util"
-  import {sendWrapped} from "@welshman/app"
   import SmileCircle from "@assets/icons/smile-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import EmojiButton from "@lib/components/EmojiButton.svelte"
-  import {makeReaction} from "@app/reactions"
+  import {reactions, wraps} from "@app/core"
 
-  interface Props {
+  type Props = {
     event: TrustedEvent
     pubkeys: string[]
   }
 
   const {event, pubkeys}: Props = $props()
 
-  const onEmoji = (emoji: NativeEmoji) =>
-    sendWrapped({
-      event: makeReaction({event, content: emoji.unicode, protect: false}),
-      recipients: pubkeys,
-      pow: 16,
-    })
+  const onEmoji = async (emoji: NativeEmoji) => {
+    const reaction = await $reactions.react(event, emoji.unicode)
+
+    return $wraps.publish({event: reaction.event, recipients: pubkeys, pow: 16})
+  }
 </script>
 
 <EmojiButton {onEmoji} class="button button-neutral button-xs join-item">
diff --git a/src/app/components/ChatMessageMenuMobile.svelte b/src/app/components/ChatMessageMenuMobile.svelte
index f38c140f..83d5f1a2 100644
--- a/src/app/components/ChatMessageMenuMobile.svelte
+++ b/src/app/components/ChatMessageMenuMobile.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import type {NativeEmoji} from "emoji-picker-element/shared"
   import type {TrustedEvent} from "@welshman/util"
-  import {sendWrapped} from "@welshman/app"
   import SmileCircle from "@assets/icons/smile-circle.svg?dataurl"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
@@ -13,7 +12,7 @@
   import Button from "@lib/components/Button.svelte"
   import EmojiPicker from "@lib/components/EmojiPicker.svelte"
   import EventInfo from "@app/components/EventInfo.svelte"
-  import {makeReaction} from "@app/reactions"
+  import {reactions, wraps} from "@app/core"
   import {pushModal} from "@app/modal"
   import {clip} from "@app/toast"
 
@@ -26,14 +25,13 @@
 
   const {event, pubkeys, reply, edit}: Props = $props()
 
-  const onEmoji = ((event: TrustedEvent, pubkeys: string[], emoji: NativeEmoji) => {
+  const onEmoji = async (emoji: NativeEmoji) => {
     history.back()
-    sendWrapped({
-      event: makeReaction({event, content: emoji.unicode, protect: false}),
-      recipients: pubkeys,
-      pow: 16,
-    })
-  }).bind(undefined, event, pubkeys)
+
+    const reaction = await $reactions.react(event, emoji.unicode)
+
+    return $wraps.publish({event: reaction.event, recipients: pubkeys, pow: 16})
+  }
 
   const showEmojiPicker = () => pushModal(EmojiPicker, {onClick: onEmoji}, {replaceState: true})
 
diff --git a/src/app/components/ChatStart.svelte b/src/app/components/ChatStart.svelte
index b13b4625..0e9e50ea 100644
--- a/src/app/components/ChatStart.svelte
+++ b/src/app/components/ChatStart.svelte
@@ -2,7 +2,6 @@
   import {onMount} from "svelte"
   import {writable} from "svelte/store"
   import {uniq} from "@welshman/lib"
-  import {loadMessagingRelayList} from "@welshman/app"
   import {decodePubkey} from "@lib/util"
   import {preventDefault} from "@lib/html"
   import Field from "@lib/components/Field.svelte"
@@ -18,6 +17,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import ProfileMultiSelect from "@app/components/ProfileMultiSelect.svelte"
   import {goToChat} from "@app/routes"
+  import {messagingRelayLists} from "@app/core"
 
   const back = () => history.back()
 
@@ -33,7 +33,7 @@
   let pubkeys: string[] = $state([])
 
   $effect(() => {
-    pubkeys.forEach(pubkey => loadMessagingRelayList(pubkey))
+    pubkeys.forEach(pubkey => $messagingRelayLists.load(pubkey))
   })
 
   onMount(() => {
diff --git a/src/app/components/ClassifiedActions.svelte b/src/app/components/ClassifiedActions.svelte
index 34121ba4..b33a7ac4 100644
--- a/src/app/components/ClassifiedActions.svelte
+++ b/src/app/components/ClassifiedActions.svelte
@@ -1,27 +1,26 @@
 <script lang="ts">
   import {uniq} from "@welshman/lib"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {getTagValue, getTagValues, getAddress} from "@welshman/util"
-  import {pubkey} from "@welshman/app"
+  import {getAddress} from "@welshman/util"
+  import {Classified} from "@welshman/domain"
   import Pen2 from "@assets/icons/pen-2.svg?dataurl"
   import {normalizeTopic} from "@lib/util"
   import Link from "@lib/components/Link.svelte"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import RoomName from "@app/components/RoomName.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
   import ClassifiedStatus from "@app/components/ClassifiedStatus.svelte"
   import ThunkStatusOrDeleted from "@app/components/ThunkStatusOrDeleted.svelte"
   import EventActivity from "@app/components/EventActivity.svelte"
   import EventActions from "@app/components/EventActions.svelte"
   import ClassifiedEdit from "@app/components/ClassifiedEdit.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
+  import {reader, user} from "@app/core"
   import {makeClassifiedPath, makeSpacePath} from "@app/routes"
   import {pushModal} from "@app/modal"
 
-  interface Props {
+  type Props = {
     url: string
     event: TrustedEvent
     showRoom?: boolean
@@ -30,18 +29,17 @@
 
   const {url, event, showRoom, showActivity}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
-  const topics = getTagValues("t", event.tags)
+  const classified = reader(Classified)(event)
+
+  const h = classified.room()
+  const topics = classified.topics() ?? []
   const path = makeClassifiedPath(url, getAddress(event))
-  const shouldProtect = canEnforceNip70(url)
 
   const editClassified = () => pushModal(ClassifiedEdit, {url, event})
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url, h})
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url, h})
 </script>
 
 <div class="flex grow flex-wrap justify-end gap-2">
@@ -66,7 +64,7 @@
   {/if}
   <EventActions {url} {event} noun="Listing">
     {#snippet customActions()}
-      {#if event.pubkey === $pubkey}
+      {#if event.pubkey === $user.pubkey}
         <li>
           <Button onclick={editClassified}>
             <Icon size={4} icon={Pen2} />
diff --git a/src/app/components/ClassifiedEdit.svelte b/src/app/components/ClassifiedEdit.svelte
index 508b845a..714a8b9a 100644
--- a/src/app/components/ClassifiedEdit.svelte
+++ b/src/app/components/ClassifiedEdit.svelte
@@ -1,10 +1,10 @@
 <script lang="ts">
-  import {fromPairs} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {getTag, getTagValues} from "@welshman/util"
+  import {Classified} from "@welshman/domain"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
+  import {reader} from "@app/core"
   import ClassifiedForm from "@app/components/ClassifiedForm.svelte"
 
   type Props = {
@@ -14,19 +14,29 @@
 
   const {url, event}: Props = $props()
 
-  const {content} = event
-  const {d, title, status} = fromPairs(event.tags)
-  const [_, price = 0, currency = "SAT"] = getTag("price", event.tags) || []
-  const images = getTagValues("image", event.tags)
-  const topics = getTagValues("t", event.tags)
-  const initialValues = {d, title, status, content, price: Number(price), currency, images, topics}
+  const classified = reader(Classified)(event)
+
+  const initialValues = $derived(
+    classified && {
+      d: classified.identifier() ?? "",
+      title: classified.title() ?? "",
+      status: classified.status() ?? "",
+      content: classified.content(),
+      price: classified.price()?.amount ?? 0,
+      currency: classified.price()?.currency ?? "SAT",
+      images: classified.images(),
+      topics: classified.topics(),
+    },
+  )
 </script>
 
-<ClassifiedForm {url} {initialValues}>
-  {#snippet header()}
-    <ModalHeader>
-      <ModalTitle>Edit this Listing</ModalTitle>
-      <ModalSubtitle>Advertise a job, sale, or need.</ModalSubtitle>
-    </ModalHeader>
-  {/snippet}
-</ClassifiedForm>
+{#if initialValues}
+  <ClassifiedForm {url} {initialValues}>
+    {#snippet header()}
+      <ModalHeader>
+        <ModalTitle>Edit this Listing</ModalTitle>
+        <ModalSubtitle>Advertise a job, sale, or need.</ModalSubtitle>
+      </ModalHeader>
+    {/snippet}
+  </ClassifiedForm>
+{/if}
diff --git a/src/app/components/ClassifiedForm.svelte b/src/app/components/ClassifiedForm.svelte
index a36a7d58..a304383b 100644
--- a/src/app/components/ClassifiedForm.svelte
+++ b/src/app/components/ClassifiedForm.svelte
@@ -1,8 +1,8 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
   import {removeUndefined, randomId, uniq} from "@welshman/lib"
-  import {makeEvent, CLASSIFIED} from "@welshman/util"
-  import {publishThunk, waitForThunkError} from "@welshman/app"
+  import {publish} from "@welshman/app"
+  import {Classified} from "@welshman/domain"
   import {isMobile, preventDefault} from "@lib/html"
   import {normalizeTopic} from "@lib/util"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
@@ -17,11 +17,11 @@
   import CurrencyInput from "@app/components/CurrencyInput.svelte"
   import TopicMultiSelect from "@app/components/TopicMultiSelect.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
+  import {command, relays, writer} from "@app/core"
   import {pushToast} from "@app/toast"
-  import {PROTECTED, publishRoomQuote} from "@app/groups"
+  import {publishRoomQuote} from "@app/rooms"
   import {makeEditor} from "@app/editor"
   import {DraftKey} from "@app/drafts"
-  import {canEnforceNip70} from "@app/relays"
   import {compressFileForUpload, uploadFile} from "@app/uploads"
 
   type Values = {
@@ -51,8 +51,6 @@
     initialValues = draftKey.get()
   }
 
-  const shouldProtect = canEnforceNip70(url)
-
   const back = () => history.back()
 
   const submit = async () => {
@@ -76,32 +74,11 @@
         })
       }
 
-      const tags = [
-        ["d", d],
-        ["title", title],
-        ["summary", content],
-        ["price", String(price), currency],
-        ["status", status],
-        ...ed.storage.nostr.getEditorTags(),
-      ]
-
-      for (const topic of topics) {
-        tags.push(["t", topic])
-      }
-
-      const protect = await shouldProtect
-
-      if (protect) {
-        tags.push(PROTECTED)
-      }
-
-      if (h) {
-        tags.push(["h", h])
-      }
+      const imageUrls: string[] = []
 
       for (const image of images) {
         if (typeof image === "string") {
-          tags.push(["image", image])
+          imageUrls.push(image)
         } else {
           const {result, error} = await uploadFile(await compressFileForUpload(image), {url})
 
@@ -113,17 +90,33 @@
           }
 
           if (result) {
-            tags.push(["image", result.url])
+            imageUrls.push(result.url)
           }
         }
       }
 
-      const classifiedThunk = publishThunk({
-        relays: [url],
-        event: makeEvent(CLASSIFIED, {content, tags}),
-      })
+      const protect = await $relays.hasNip(url, 70)
 
-      const error = await waitForThunkError(classifiedThunk)
+      const eventWriter = writer(Classified)
+        .setIdentifier(d)
+        .setContent(content)
+        .setTitle(title)
+        .setSummary(content)
+        .setPrice(price, currency)
+        .setStatus(status)
+        .setTopics(topics)
+        .setImages(imageUrls)
+        .setProtected(protect)
+        .addTags(...ed.storage.nostr.getEditorTags())
+
+      if (h) {
+        eventWriter.setRoom(url, h)
+      } else {
+        eventWriter.forceRelays(url)
+      }
+
+      const classifiedThunk = await command(eventWriter).then(publish)
+      const error = await classifiedThunk.waitForError()
 
       if (error) {
         return pushToast({theme: "error", message: error})
diff --git a/src/app/components/ClassifiedItem.svelte b/src/app/components/ClassifiedItem.svelte
index 160d173b..d8fc854a 100644
--- a/src/app/components/ClassifiedItem.svelte
+++ b/src/app/components/ClassifiedItem.svelte
@@ -1,9 +1,11 @@
 <script lang="ts">
   import {formatTimestamp} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {getTag, getAddress, getTagValue, getTagValues} from "@welshman/util"
+  import {getAddress} from "@welshman/util"
+  import {Classified} from "@welshman/domain"
   import Link from "@lib/components/Link.svelte"
   import CurrencySymbol from "@lib/components/CurrencySymbol.svelte"
+  import {reader} from "@app/core"
   import ContentLinkBlock from "@app/components/ContentLinkBlock.svelte"
   import Content from "@app/components/Content.svelte"
   import ProfileLink from "@app/components/ProfileLink.svelte"
@@ -18,10 +20,12 @@
 
   const {url, event}: Props = $props()
 
-  const title = getTagValue("title", event.tags)
-  const h = getTagValue("h", event.tags)
-  const images = new Set(getTagValues("image", event.tags))
-  const [_, price = 0, currency = "SAT"] = getTag("price", event.tags) || []
+  const classified = reader(Classified)(event)
+
+  const title = classified.title()
+  const h = classified.room()
+  const images = new Set(classified.images())
+  const price = classified.price()
 </script>
 
 <Link
@@ -31,7 +35,7 @@
     <div class="flex w-full items-center justify-between gap-2">
       <p class="text-xl">
         {title} —
-        <CurrencySymbol code={currency} />{price}
+        <CurrencySymbol code={price?.currency ?? "SAT"} />{price?.amount ?? 0}
       </p>
       <p class="text-sm opacity-75">
         {formatTimestamp(event.created_at)}
diff --git a/src/app/components/ClassifiedStatus.svelte b/src/app/components/ClassifiedStatus.svelte
index 58e1ccb0..e81cea16 100644
--- a/src/app/components/ClassifiedStatus.svelte
+++ b/src/app/components/ClassifiedStatus.svelte
@@ -1,8 +1,9 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {Classified} from "@welshman/domain"
   import {ucFirst} from "@lib/util"
   import Badge from "@lib/components/Badge.svelte"
+  import {reader} from "@app/core"
 
   type Props = {
     event: TrustedEvent
@@ -10,7 +11,9 @@
 
   const {event}: Props = $props()
 
-  const status = getTagValue("status", event.tags)
+  const classified = reader(Classified)(event)
+
+  const status = classified.status()
 </script>
 
 {#if status}
diff --git a/src/app/components/CommentActions.svelte b/src/app/components/CommentActions.svelte
index 91759de2..4c379480 100644
--- a/src/app/components/CommentActions.svelte
+++ b/src/app/components/CommentActions.svelte
@@ -1,15 +1,14 @@
 <script lang="ts">
   import type {TrustedEvent, EventContent} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ThunkStatusOrDeleted from "@app/components/ThunkStatusOrDeleted.svelte"
   import EventActivity from "@app/components/EventActivity.svelte"
   import EventActions from "@app/components/EventActions.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
   import {makeSpacePath} from "@app/routes"
 
-  interface Props {
+  type Props = {
     url: string
     event: TrustedEvent
     segment: string
@@ -18,15 +17,13 @@
 
   const {url, event, segment, showActivity = false}: Props = $props()
 
-  const shouldProtect = canEnforceNip70(url)
+  const h = tagValue(tagSpec("h"), event.tags)
 
   const path = makeSpacePath(url, segment, event.id)
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url, h})
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url, h})
 </script>
 
 <div class="flex flex-wrap items-center justify-between gap-2">
diff --git a/src/app/components/Content.svelte b/src/app/components/Content.svelte
index 52d05903..2db4660b 100644
--- a/src/app/components/Content.svelte
+++ b/src/app/components/Content.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import {fromNostrURI, getTagValue} from "@welshman/util"
+  import {fromNostrURI, tagSpec, tagValue} from "@welshman/util"
   import {
     parse,
     truncate,
@@ -38,7 +38,7 @@
   import {entityLink} from "@app/env"
   import {userSettingsValues} from "@app/settings"
 
-  interface Props {
+  type Props = {
     event: any
     minLength?: number
     maxLength?: number
@@ -106,7 +106,7 @@
   const warning = $derived(
     warningDismissed
       ? undefined
-      : $userSettingsValues.hide_sensitive && getTagValue("content-warning", event.tags),
+      : $userSettingsValues.hide_sensitive && tagValue(tagSpec("content-warning"), event.tags),
   )
 
   const dropWhile = <T,>(f: (x: T) => boolean, xs: Iterable<T>) => {
diff --git a/src/app/components/ContentLinkBlock.svelte b/src/app/components/ContentLinkBlock.svelte
index 89da62cd..05f9d1b7 100644
--- a/src/app/components/ContentLinkBlock.svelte
+++ b/src/app/components/ContentLinkBlock.svelte
@@ -16,7 +16,7 @@
 
 <script lang="ts">
   import {call, ellipsize, displayUrl} from "@welshman/lib"
-  import {isRelayUrl, getTagValue} from "@welshman/util"
+  import {isRelayUrl, tagSpec, tagValue} from "@welshman/util"
   import {Capacitor} from "@capacitor/core"
   import {preventDefault, stopPropagation} from "@lib/html"
   import Link from "@lib/components/Link.svelte"
@@ -27,7 +27,7 @@
   import {pushModal} from "@app/modal"
   import {PLATFORM_URL, THUMBNAIL_URL} from "@app/env"
   import {IMAGE_CONTENT_TYPES, VIDEO_CONTENT_TYPES} from "@app/content"
-  import {isRoomId} from "@app/groups"
+  import {isRoomId} from "@app/rooms"
 
   const {value, event} = $props()
 
@@ -41,7 +41,7 @@
     return [url, true]
   })
 
-  const fileType = getTagValue("file-type", event.tags) || ""
+  const fileType = tagValue(tagSpec("file-type"), event.tags) || ""
 
   const getVideoPoster = (videoUrl: string): string | undefined => {
     if (Capacitor.getPlatform() === "android" && THUMBNAIL_URL) {
@@ -62,50 +62,48 @@
   <ContentLinkUrl {url} class="link-content whitespace-nowrap" />
 {:else}
   <Link {external} {href} class="my-2 block">
-    <div class="overflow-hidden rounded-2xl">
-      {#if url.match(/\.(mov|webm|mp4)$/) || VIDEO_CONTENT_TYPES.includes(fileType)}
-        <video
-          controls
-          src={url}
-          poster={getVideoPoster(url)}
-          preload="metadata"
-          class="max-h-96 rounded-2xl object-contain object-center">
-          <track kind="captions" />
-        </video>
-      {:else if url.match(/\.(jpe?g|png|gif|webp)$/) || IMAGE_CONTENT_TYPES.includes(fileType)}
-        <button type="button" onclick={stopPropagation(preventDefault(expand))}>
-          <ContentLinkBlockImage {value} {event} class="m-auto max-h-96 rounded-2xl" />
-        </button>
-      {:else}
-        {#await loadPreview(url)}
-          <div class="flex justify-center items-center my-12 w-full">
-            <Spinner />
+    {#if url.match(/\.(mov|webm|mp4)$/) || VIDEO_CONTENT_TYPES.includes(fileType)}
+      <video
+        controls
+        src={url}
+        poster={getVideoPoster(url)}
+        preload="metadata"
+        class="max-h-96 rounded-2xl object-contain object-center">
+        <track kind="captions" />
+      </video>
+    {:else if url.match(/\.(jpe?g|png|gif|webp)$/) || IMAGE_CONTENT_TYPES.includes(fileType)}
+      <button type="button" onclick={stopPropagation(preventDefault(expand))}>
+        <ContentLinkBlockImage {value} {event} class="m-auto max-h-96 rounded-2xl" />
+      </button>
+    {:else}
+      {#await loadPreview(url)}
+        <div class="flex justify-center items-center my-12 w-full">
+          <Spinner />
+        </div>
+      {:then preview}
+        <div
+          class="border border-solid flex max-w-xl flex-col overflow-hidden leading-normal rounded-2xl"
+          style="border-color: var(--line)">
+          {#if preview.image && !hideImage}
+            <img
+              alt=""
+              onerror={onError}
+              src={preview.image}
+              class="bg-surface max-h-72 object-contain object-center" />
+          {/if}
+          <div class="flex flex-col gap-2 p-4">
+            <strong class="overflow-hidden text-ellipsis whitespace-nowrap"
+              >{preview.title || displayUrl(url)}</strong>
+            <p>{ellipsize(preview.description, 140)}</p>
           </div>
-        {:then preview}
-          <div
-            class="border border-solid flex max-w-xl flex-col leading-normal rounded-2xl"
-            style="border-color: var(--line)">
-            {#if preview.image && !hideImage}
-              <img
-                alt=""
-                onerror={onError}
-                src={preview.image}
-                class="bg-surface max-h-72 rounded-t-2xl object-contain object-center" />
-            {/if}
-            <div class="flex flex-col gap-2 p-4">
-              <strong class="overflow-hidden text-ellipsis whitespace-nowrap"
-                >{preview.title || displayUrl(url)}</strong>
-              <p>{ellipsize(preview.description, 140)}</p>
-            </div>
-          </div>
-        {:catch}
-          <p
-            class="border border-solid p-12 text-center leading-normal"
-            style="border-color: var(--line)">
-            Unable to load a preview for {url}
-          </p>
-        {/await}
-      {/if}
-    </div>
+        </div>
+      {:catch}
+        <p
+          class="border border-solid p-12 text-center leading-normal rounded-2xl"
+          style="border-color: var(--line)">
+          Unable to load a preview for {url}
+        </p>
+      {/await}
+    {/if}
   </Link>
 {/if}
diff --git a/src/app/components/ContentLinkBlockImage.svelte b/src/app/components/ContentLinkBlockImage.svelte
index d0cac62c..2225c6ec 100644
--- a/src/app/components/ContentLinkBlockImage.svelte
+++ b/src/app/components/ContentLinkBlockImage.svelte
@@ -2,34 +2,35 @@
   import {onMount, onDestroy} from "svelte"
   import {displayUrl, once} from "@welshman/lib"
   import {
-    getTags,
     getBlob,
     decryptFile,
-    getTagValue,
-    tagsFromIMeta,
     makeBlossomAuthEvent,
+    matchTags,
+    tagSpec,
+    tagValue,
   } from "@welshman/util"
-  import {signer} from "@welshman/app"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
+  import {user} from "@app/core"
 
   const {value, event, ...props} = $props()
 
   const url = value.url.toString()
+  // An imeta tag packs its own tags into space-separated values, so unpack the one for this url.
   const meta =
-    getTags("imeta", event.tags)
-      .map(tagsFromIMeta)
-      .find(meta => getTagValue("url", meta) === url) || event.tags
+    matchTags(tagSpec("imeta"), event.tags)
+      .map(([, ...values]: string[]) => values.map(value => value.split(" ")))
+      .find(meta => tagValue(tagSpec("url"), meta) === url) || event.tags
 
   // Fallback to filename if hash was omitted from the message for interoperability
-  const hash = getTagValue("x", meta) || url.split(/[\/\.]/).slice(-2)[0]
-  const key = getTagValue("decryption-key", meta)
-  const nonce = getTagValue("decryption-nonce", meta)
-  const algorithm = getTagValue("encryption-algorithm", meta)
-  const mime = getTagValue("m", meta)
+  const hash = tagValue(tagSpec("x"), meta) || url.split(/[\/\.]/).slice(-2)[0]
+  const key = tagValue(tagSpec("decryption-key"), meta)
+  const nonce = tagValue(tagSpec("decryption-nonce"), meta)
+  const algorithm = tagValue(tagSpec("encryption-algorithm"), meta)
+  const mime = tagValue(tagSpec("m"), meta)
   const fileName =
-    getTagValue("filename", meta) ||
-    getTagValue("name", meta) ||
+    tagValue(tagSpec("filename"), meta) ||
+    tagValue(tagSpec("name"), meta) ||
     decodeURIComponent(new URL(url).pathname.split("/").filter(Boolean).at(-1) || "image")
 
   const revokeSrc = () => {
@@ -45,10 +46,10 @@
 
   const onError = once(async () => {
     // If the image failed to load, try authenticating
-    if (hash && $signer) {
+    if (hash) {
       const server = new URL(url).origin
       const template = makeBlossomAuthEvent({action: "get", server, hashes: [hash]})
-      const authEvent = await $signer.sign(template)
+      const authEvent = await $user.signer.sign(template)
       const res = await getBlob(server, hash, {authEvent})
 
       if (res.status === 200) {
diff --git a/src/app/components/ContentLinkInline.svelte b/src/app/components/ContentLinkInline.svelte
index ff2a661a..b8106c4b 100644
--- a/src/app/components/ContentLinkInline.svelte
+++ b/src/app/components/ContentLinkInline.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import {displayUrl} from "@welshman/lib"
-  import {getTagValue} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import {preventDefault, stopPropagation} from "@lib/html"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -12,7 +12,7 @@
   const {value, event} = $props()
 
   const url = value.url.toString()
-  const fileType = getTagValue("file-type", event.tags) || ""
+  const fileType = tagValue(tagSpec("file-type"), event.tags) || ""
 
   const expand = () => pushModal(ContentLinkDetail, {value, event}, {fullscreen: true})
 </script>
diff --git a/src/app/components/ContentLinkUrl.svelte b/src/app/components/ContentLinkUrl.svelte
index 71aedfaf..d3f01540 100644
--- a/src/app/components/ContentLinkUrl.svelte
+++ b/src/app/components/ContentLinkUrl.svelte
@@ -1,28 +1,28 @@
 <script lang="ts">
   import {call, displayUrl} from "@welshman/lib"
   import {displayRelayUrl, isRelayUrl, normalizeRelayUrl} from "@welshman/util"
+  import {splitRoomKey} from "@welshman/app"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Link from "@lib/components/Link.svelte"
   import RoomName from "@app/components/RoomName.svelte"
   import {PLATFORM_URL} from "@app/env"
-  import {isRoomId, splitRoomId} from "@app/groups"
+  import {isRoomId} from "@app/rooms"
   import {makeRoomPath, makeSpacePath} from "@app/routes"
 
-  const {
-    url,
-    class: className = "",
-  }: {
+  type Props = {
     url: string
     class?: string
-  } = $props()
+  }
+
+  const {url, class: className = ""}: Props = $props()
 
   const roomReference = call(() => {
     if (!isRoomId(url)) {
       return undefined
     }
 
-    const [roomUrl, h] = splitRoomId(url)
+    const [roomUrl, h] = splitRoomKey(url)
 
     if (!roomUrl || !h || !isRelayUrl(roomUrl)) {
       return undefined
diff --git a/src/app/components/ContentMention.svelte b/src/app/components/ContentMention.svelte
index 17512e77..9a2ecd6a 100644
--- a/src/app/components/ContentMention.svelte
+++ b/src/app/components/ContentMention.svelte
@@ -1,10 +1,9 @@
 <script lang="ts">
-  import {removeUndefined} from "@welshman/lib"
   import type {ProfilePointer} from "@welshman/content"
-  import {deriveProfileDisplay} from "@welshman/app"
   import Button from "@lib/components/Button.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
   import {pushModal} from "@app/modal"
+  import {profiles} from "@app/core"
 
   type Props = {
     value: ProfilePointer
@@ -13,7 +12,7 @@
 
   const {value, url}: Props = $props()
 
-  const display = deriveProfileDisplay(value.pubkey, removeUndefined([url]))
+  const display = $profiles.display(value.pubkey).$
 
   const openProfile = () => pushModal(ProfileDetail, {pubkey: value.pubkey, url})
 </script>
diff --git a/src/app/components/ContentMinimal.svelte b/src/app/components/ContentMinimal.svelte
index a97bbf74..5d934184 100644
--- a/src/app/components/ContentMinimal.svelte
+++ b/src/app/components/ContentMinimal.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import cx from "classnames"
-  import {fromNostrURI, getTagValue} from "@welshman/util"
+  import {fromNostrURI, tagValue, tagSpec} from "@welshman/util"
   import {
     parse,
     truncate,
@@ -71,7 +71,7 @@
   const warning = $derived(
     warningDismissed
       ? undefined
-      : $userSettingsValues.hide_sensitive && getTagValue("content-warning", event.tags),
+      : $userSettingsValues.hide_sensitive && tagValue(tagSpec("content-warning"), event.tags),
   )
 
   const dropWhile = <T,>(f: (x: T) => boolean, xs: Iterable<T>) => {
diff --git a/src/app/components/ContentQuote.svelte b/src/app/components/ContentQuote.svelte
index ef4d2985..b54c4954 100644
--- a/src/app/components/ContentQuote.svelte
+++ b/src/app/components/ContentQuote.svelte
@@ -1,13 +1,16 @@
 <script lang="ts">
   import * as nip19 from "nostr-tools/nip19"
-  import {Router} from "@welshman/router"
+  import {derived, writable} from "svelte/store"
+  import {removeUndefined} from "@welshman/lib"
+  import type {Maybe} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {Address, MESSAGE} from "@welshman/util"
+  import {Address, MESSAGE, eventOutbox, relays as relaySelections, seen} from "@welshman/util"
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import NoteCard from "@app/components/NoteCard.svelte"
   import NoteContent from "@app/components/NoteContent.svelte"
   import NoteContentMinimal from "@app/components/NoteContentMinimal.svelte"
+  import {router} from "@app/core"
   import {deriveEvent} from "@app/repository"
   import {entityLink} from "@app/env"
   import {goToEvent} from "@app/routes"
@@ -22,22 +25,37 @@
 
   const {id, identifier, kind, pubkey, relays = []} = value
   const idOrAddress = id || new Address(kind, pubkey, identifier).toString()
-  const mergedRelays = Router.get().Quote(event, idOrAddress, relays).getUrls()
+  const ref = {id, pubkey, kind, identifier, relays}
 
-  if (url) {
-    mergedRelays.push(url)
-  }
+  // Start with the hints we were handed, then widen to everything the router can work out:
+  // where the quoted event has been seen, its author's outbox, and — since whoever quoted it
+  // must have seen it — the relays the quoting event came from.
+  const mergedRelays = writable(removeUndefined([...relays, url]))
 
-  const quote = deriveEvent(idOrAddress, mergedRelays)
-  const entity = id
-    ? nip19.neventEncode({id, relays: mergedRelays})
-    : new Address(kind, pubkey, identifier, mergedRelays).toNaddr()
+  $router.resolver
+    .relays([
+      ...relaySelections(removeUndefined([url])),
+      seen(ref),
+      eventOutbox(ref),
+      seen(event, 0.5),
+    ])
+    .then(urls => mergedRelays.set(urls))
+
+  const quote = derived(mergedRelays, ($mergedRelays, set: (event: Maybe<TrustedEvent>) => void) =>
+    deriveEvent(idOrAddress, $mergedRelays).subscribe(set),
+  )
+
+  const entity = derived(mergedRelays, $mergedRelays =>
+    id
+      ? nip19.neventEncode({id, relays: $mergedRelays})
+      : new Address(kind, pubkey, identifier, $mergedRelays).toNaddr(),
+  )
 
   const onclick = () => {
     if ($quote) {
       goToEvent($quote)
     } else {
-      window.open(entityLink(entity))
+      window.open(entityLink($entity))
     }
   }
 </script>
diff --git a/src/app/components/CurrencyInput.svelte b/src/app/components/CurrencyInput.svelte
index 673f2fe1..0d6af28e 100644
--- a/src/app/components/CurrencyInput.svelte
+++ b/src/app/components/CurrencyInput.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+  import {spec} from "@welshman/lib"
   import cx from "classnames"
   import {writable} from "svelte/store"
   import type {Writable} from "svelte/store"
@@ -50,7 +51,7 @@
     }
   }
 
-  const currency = $derived(currencyOptions.find(c => c.code === value))
+  const currency = $derived(currencyOptions.find(spec({code: value})))
 
   let wrapper: Element | undefined = $state()
   let popover: Instance | undefined = $state()
diff --git a/src/app/components/EditFeaturedContent.svelte b/src/app/components/EditFeaturedContent.svelte
index e4e404af..a5215ffb 100644
--- a/src/app/components/EditFeaturedContent.svelte
+++ b/src/app/components/EditFeaturedContent.svelte
@@ -31,7 +31,8 @@
     loading = true
 
     try {
-      const error = await setFeaturedContent(url, content)
+      const thunk = await setFeaturedContent(url, content)
+      const error = await thunk.waitForError()
 
       if (error) {
         pushToast({theme: "error", message: error})
@@ -39,6 +40,9 @@
         pushToast({message: "Featured content updated!"})
         back()
       }
+    } catch (e) {
+      console.error(e)
+      pushToast({theme: "error", message: "Failed to update featured content."})
     } finally {
       loading = false
     }
diff --git a/src/app/components/EventActions.svelte b/src/app/components/EventActions.svelte
index 55ae0912..6f3bce2e 100644
--- a/src/app/components/EventActions.svelte
+++ b/src/app/components/EventActions.svelte
@@ -3,18 +3,18 @@
   import type {Instance} from "tippy.js"
   import type {NativeEmoji} from "emoji-picker-element/shared"
   import type {TrustedEvent} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import SmileCircle from "@assets/icons/smile-circle.svg?dataurl"
   import MenuDots from "@assets/icons/menu-dots.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Tippy from "@lib/components/Tippy.svelte"
   import Button from "@lib/components/Button.svelte"
-  import ZapButton from "@app/components/ZapButton.svelte"
   import EmojiButton from "@lib/components/EmojiButton.svelte"
+  import ZapButton from "@app/components/ZapButton.svelte"
   import EventMenu from "@app/components/EventMenu.svelte"
+  import {reactions, relays} from "@app/core"
   import {ENABLE_ZAPS} from "@app/env"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
 
   type Props = {
     url: string
@@ -26,20 +26,27 @@
 
   const {url, noun, event, hideZap, customActions}: Props = $props()
 
-  const shouldProtect = canEnforceNip70(url)
+  const shouldProtect = $relays.hasNip(url, 70)
 
   const showPopover = () => popover?.show()
 
   const hidePopover = () => popover?.hide()
 
-  const onEmoji = async (emoji: NativeEmoji) =>
-    publishReaction({
-      event,
-      content: emoji.unicode,
-      relays: [url],
-      protect: await shouldProtect,
+  const onEmoji = async (emoji: NativeEmoji) => {
+    const protect = await shouldProtect
+    const room = tagValue(tagSpec("h"), event.tags)
+
+    const command = await $reactions.react(event, emoji.unicode, writer => {
+      writer.setProtected(protect)
+
+      if (room) {
+        writer.setRoom(url, room)
+      }
     })
 
+    return command.publishToRelays([url])
+  }
+
   let popover: Instance | undefined = $state()
 </script>
 
diff --git a/src/app/components/EventActivity.svelte b/src/app/components/EventActivity.svelte
index 444d4176..44ebfea0 100644
--- a/src/app/components/EventActivity.svelte
+++ b/src/app/components/EventActivity.svelte
@@ -2,23 +2,22 @@
   import {onMount} from "svelte"
   import {max, gt, formatTimestampRelative} from "@welshman/lib"
   import {COMMENT} from "@welshman/util"
-  import {load} from "@welshman/net"
-  import {deriveArray, deriveEventsById} from "@welshman/store"
   import type {TrustedEvent} from "@welshman/util"
-  import {repository} from "@welshman/app"
-  import {deriveChecked} from "@app/notifications"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
+  import {deriveEvents} from "@app/repository"
+  import {network} from "@app/core"
+  import {deriveChecked} from "@app/notifications"
 
   const {url, path, event}: {url: string; path: string; event: TrustedEvent} = $props()
 
   const checked = deriveChecked(path)
   const filters = [{kinds: [COMMENT], "#E": [event.id]}]
-  const replies = deriveArray(deriveEventsById({repository, filters}))
+  const replies = deriveEvents(filters)
   const lastActive = $derived(max([...$replies, event].map(e => e.created_at)))
 
   onMount(() => {
-    load({relays: [url], filters})
+    $network.load({relays: [url], filters})
   })
 </script>
 
diff --git a/src/app/components/EventDeleteConfirm.svelte b/src/app/components/EventDeleteConfirm.svelte
index c2770f1e..8a8c945e 100644
--- a/src/app/components/EventDeleteConfirm.svelte
+++ b/src/app/components/EventDeleteConfirm.svelte
@@ -1,8 +1,7 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
   import Confirm from "@lib/components/Confirm.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {canEnforceNip70} from "@app/relays"
+  import {deletes, relays} from "@app/core"
   import {clearModals} from "@app/modal"
 
   type Props = {
@@ -12,10 +11,13 @@
 
   const {url, event}: Props = $props()
 
-  const shouldProtect = canEnforceNip70(url)
+  const shouldProtect = $relays.hasNip(url, 70)
 
   const confirm = async () => {
-    await publishDelete({event, relays: [url], protect: await shouldProtect})
+    const protect = await shouldProtect
+    const command = await $deletes.deleteEvent(event, writer => writer.setProtected(protect))
+
+    command.publishToRelays([url])
 
     clearModals()
   }
diff --git a/src/app/components/EventInfo.svelte b/src/app/components/EventInfo.svelte
index 2f15971e..2d50ce7c 100644
--- a/src/app/components/EventInfo.svelte
+++ b/src/app/components/EventInfo.svelte
@@ -1,10 +1,9 @@
 <script lang="ts">
+  import {onMount} from "svelte"
   import * as nip19 from "nostr-tools/nip19"
-  import {Router} from "@welshman/router"
   import {LOCALE, secondsToDate} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {displayRelayUrl, toNostrURI} from "@welshman/util"
-  import {tracker} from "@welshman/app"
+  import {displayRelayUrl, seen, toNostrURI} from "@welshman/util"
   import FileText from "@assets/icons/file-text.svg?dataurl"
   import Copy from "@assets/icons/copy.svg?dataurl"
   import UserCircle from "@assets/icons/user-circle.svg?dataurl"
@@ -18,6 +17,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
+  import {app, router} from "@app/core"
   import {clip} from "@app/toast"
 
   type Props = {
@@ -27,9 +27,7 @@
 
   const {url, event}: Props = $props()
 
-  const relays = url ? [url] : Router.get().Event(event).getUrls()
-  const nevent1 = toNostrURI(nip19.neventEncode({...event, relays}))
-  const seenOn = tracker.getRelays(event.id)
+  const seenOn = $app.tracker.getRelays(event.id)
   const npub1 = nip19.npubEncode(event.pubkey)
   const json = JSON.stringify(event, null, 2)
   const copyLink = () => clip(nevent1)
@@ -41,6 +39,14 @@
     dateStyle: "long",
     timeStyle: "long",
   })
+
+  let nevent1 = $state("")
+
+  onMount(async () => {
+    const relays = url ? [url] : await $router.resolver.relays([seen(event)])
+
+    nevent1 = toNostrURI(nip19.neventEncode({...event, relays}))
+  })
 </script>
 
 <Modal>
diff --git a/src/app/components/EventMenu.svelte b/src/app/components/EventMenu.svelte
index d235d236..38687b72 100644
--- a/src/app/components/EventMenu.svelte
+++ b/src/app/components/EventMenu.svelte
@@ -2,8 +2,7 @@
   import {onMount} from "svelte"
   import type {Snippet} from "svelte"
   import type {TrustedEvent} from "@welshman/util"
-  import {COMMENT, ManagementMethod} from "@welshman/util"
-  import {pubkey, repository, manageRelay} from "@welshman/app"
+  import {COMMENT} from "@welshman/util"
   import GalleryWide from "@assets/icons/gallery-wide.svg?dataurl"
   import ShareCircle from "@assets/icons/share-circle.svg?dataurl"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
@@ -17,9 +16,10 @@
   import EventDeleteConfirm from "@app/components/EventDeleteConfirm.svelte"
   import PinboardSelect from "@app/components/PinboardSelect.svelte"
   import {shareEventToChat} from "@app/share"
-  import {deriveUserIsSpaceAdmin} from "@app/members"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
+  import {app, relayManagement, user} from "@app/core"
 
   type Props = {
     url: string
@@ -49,16 +49,13 @@
       title: `Delete ${noun}`,
       message: `Are you sure you want to delete this ${noun.toLowerCase()} from the space?`,
       confirm: async () => {
-        const {error} = await manageRelay(url, {
-          method: ManagementMethod.BanEvent,
-          params: [event.id],
-        })
+        const {error} = await $relayManagement.forUrl(url).banEvent(event.id)
 
         if (error) {
           pushToast({theme: "error", message: error})
         } else {
           pushToast({message: "Event has successfully been deleted!"})
-          repository.removeEvent(event.id)
+          $app.repository.removeEvent(event.id)
           history.back()
         }
       },
@@ -93,7 +90,7 @@
     </Button>
   </li>
   {@render customActions?.()}
-  {#if event.pubkey === $pubkey}
+  {#if event.pubkey === $user.pubkey}
     <li>
       <Button onclick={showDelete} class="text-error">
         <Icon size={4} icon={TrashBin2} />
diff --git a/src/app/components/EventReply.svelte b/src/app/components/EventReply.svelte
index 9945b201..4539dfe0 100644
--- a/src/app/components/EventReply.svelte
+++ b/src/app/components/EventReply.svelte
@@ -2,6 +2,8 @@
   import {onMount} from "svelte"
   import {writable} from "svelte/store"
   import type {TrustedEvent} from "@welshman/util"
+  import {publishToRelays} from "@welshman/app"
+  import {Comment} from "@welshman/domain"
   import {isMobile, preventDefault} from "@lib/html"
   import {fly} from "@lib/transition"
   import Paperclip from "@assets/icons/paperclip-2.svg?dataurl"
@@ -10,12 +12,11 @@
   import Spinner from "@lib/components/Spinner.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
   import ChatComposeParent from "@app/components/ChatComposeParent.svelte"
-  import {publishComment} from "@app/comments"
-  import {canEnforceNip70} from "@app/relays"
-  import {PROTECTED, prependParent} from "@app/groups"
+  import {prependParent} from "@app/rooms"
   import {makeEditor} from "@app/editor"
   import {DraftKey} from "@app/drafts"
   import {pushToast} from "@app/toast"
+  import {command, relays, writer} from "@app/core"
 
   type Values = {
     content?: string | object
@@ -33,7 +34,6 @@
   const {url, event, parent, onClose, onClearParent, onSubmit}: Props = $props()
   const draftKey = new DraftKey<Values>(`reply:${event.id}:${parent?.id || ""}`)
   const initialValues = draftKey.get()
-  const shouldProtect = canEnforceNip70(url)
   const uploading = writable(false)
   const autofocus = !isMobile
 
@@ -46,10 +46,6 @@
     let content = ed.getText({blockSeparator: "\n"}).trim()
     let tags = ed.storage.nostr.getEditorTags()
 
-    if (await shouldProtect) {
-      tags.push(PROTECTED)
-    }
-
     if (!content) {
       return pushToast({
         theme: "error",
@@ -58,11 +54,20 @@
     }
 
     if (parent) {
-      ;({content, tags} = prependParent(parent, {content, tags}, url))
+      ;({content, tags} = await prependParent(parent, {content, tags}, url))
     }
 
+    const eventWriter = writer(Comment)
+      .setContent(content)
+      .addTags(...tags)
+      .setRootFromEvent(event)
+      .setParentFromEvent(event)
+      .setProtected(await $relays.hasNip(url, 70))
+
+    const thunk = await command(eventWriter).then(publishToRelays([url]))
+
     draftKey.clear()
-    onSubmit(publishComment({event, content, tags, relays: [url]}))
+    onSubmit(thunk)
   }
 
   let form: HTMLElement
diff --git a/src/app/components/EventShare.svelte b/src/app/components/EventShare.svelte
index 34b0a3a5..d1908b4e 100644
--- a/src/app/components/EventShare.svelte
+++ b/src/app/components/EventShare.svelte
@@ -14,10 +14,18 @@
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
   import RoomNameWithImage from "@app/components/RoomNameWithImage.svelte"
-  import {roomsByUrl} from "@app/groups"
   import {makeRoomPath} from "@app/routes"
+  import {rooms} from "@app/core"
 
-  const {url, noun, event}: {url: string; noun: string; event: TrustedEvent} = $props()
+  type Props = {
+    url: string
+    noun: string
+    event: TrustedEvent
+  }
+
+  const {url, noun, event}: Props = $props()
+
+  const spaceRooms = $rooms.forUrl(url).$
 
   const back = () => history.back()
 
@@ -40,14 +48,14 @@
       <ModalSubtitle>Which room would you like to share this event to?</ModalSubtitle>
     </ModalHeader>
     <div class="grid grid-cols-2 gap-2">
-      {#each $roomsByUrl.get(url) || [] as room (room.h)}
+      {#each $spaceRooms as room (room.h)}
         <Button
           type="button"
           class="flex justify-center button {selection === room.h
             ? 'button-primary'
             : 'button-neutral'}"
           onclick={() => toggleRoom(room.h)}>
-          <RoomNameWithImage {...room} />
+          <RoomNameWithImage {url} h={room.h} />
         </Button>
       {/each}
     </div>
diff --git a/src/app/components/GoalActions.svelte b/src/app/components/GoalActions.svelte
index 16169b3f..315ae032 100644
--- a/src/app/components/GoalActions.svelte
+++ b/src/app/components/GoalActions.svelte
@@ -1,15 +1,14 @@
 <script lang="ts">
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {ZapGoal} from "@welshman/domain"
   import Link from "@lib/components/Link.svelte"
+  import {reader} from "@app/core"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ThunkStatusOrDeleted from "@app/components/ThunkStatusOrDeleted.svelte"
   import EventActivity from "@app/components/EventActivity.svelte"
   import EventActions from "@app/components/EventActions.svelte"
   import RoomName from "@app/components/RoomName.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
   import {makeGoalPath, makeSpacePath} from "@app/routes"
 
   interface Props {
@@ -22,14 +21,13 @@
   const {url, event, showRoom, showActivity}: Props = $props()
 
   const path = makeGoalPath(url, event.id)
-  const h = getTagValue("h", event.tags)
-  const shouldProtect = canEnforceNip70(url)
+  const goal = reader(ZapGoal)(event)
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
+  const h = goal.room()
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url})
+
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url})
 </script>
 
 <div class="flex grow flex-wrap justify-end gap-2">
diff --git a/src/app/components/GoalCreate.svelte b/src/app/components/GoalCreate.svelte
index 5785bc69..909393a5 100644
--- a/src/app/components/GoalCreate.svelte
+++ b/src/app/components/GoalCreate.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {writable} from "svelte/store"
-  import {makeEvent, ZAP_GOAL} from "@welshman/util"
-  import {publishThunk, waitForThunkError} from "@welshman/app"
+  import {ZapGoal} from "@welshman/domain"
+  import {publish} from "@welshman/app"
   import {isMobile, preventDefault} from "@lib/html"
   import Paperclip from "@assets/icons/paperclip-2.svg?dataurl"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
@@ -18,11 +18,11 @@
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
+  import {command, relays, writer} from "@app/core"
   import {pushToast} from "@app/toast"
-  import {PROTECTED, publishRoomQuote} from "@app/groups"
+  import {publishRoomQuote} from "@app/rooms"
   import {makeEditor} from "@app/editor"
   import {DraftKey} from "@app/drafts"
-  import {canEnforceNip70} from "@app/relays"
 
   type Values = {
     title: string
@@ -45,7 +45,7 @@
     initialValues = draftKey.get()
   }
 
-  const shouldProtect = canEnforceNip70(url)
+  const shouldProtect = $relays.hasNip(url, 70)
 
   const uploading = writable(false)
 
@@ -73,32 +73,25 @@
       })
     }
 
-    const tags = [
-      ...ed.storage.nostr.getEditorTags(),
-      ["summary", content],
-      ["amount", String(amount)],
-      ["relays", url],
-    ]
-
     loading = true
 
     try {
       const protect = await shouldProtect
-
-      if (protect) {
-        tags.push(PROTECTED)
-      }
+      const eventWriter = writer(ZapGoal)
+        .setTitle(title)
+        .setSummary(content)
+        .setAmount(amount)
+        .setUrls([url])
+        .setProtected(protect)
+        .addTags(...ed.storage.nostr.getEditorTags())
+        .forceRelays(url)
 
       if (h) {
-        tags.push(["h", h])
+        eventWriter.setRoom(url, h)
       }
 
-      const goalThunk = publishThunk({
-        relays: [url],
-        event: makeEvent(ZAP_GOAL, {content: title, tags}),
-      })
-
-      const error = await waitForThunkError(goalThunk)
+      const goalThunk = await command(eventWriter).then(publish)
+      const error = await goalThunk.waitForError()
 
       if (error) {
         return pushToast({theme: "error", message: error})
diff --git a/src/app/components/GoalItem.svelte b/src/app/components/GoalItem.svelte
index e712b209..ba5bb8db 100644
--- a/src/app/components/GoalItem.svelte
+++ b/src/app/components/GoalItem.svelte
@@ -1,7 +1,8 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {ZapGoal} from "@welshman/domain"
   import Link from "@lib/components/Link.svelte"
+  import {reader} from "@app/core"
   import Content from "@app/components/Content.svelte"
   import ProfileLink from "@app/components/ProfileLink.svelte"
   import GoalActions from "@app/components/GoalActions.svelte"
@@ -16,14 +17,17 @@
 
   const {url, event}: Props = $props()
 
-  const summary = getTagValue("summary", event.tags)
-  const h = getTagValue("h", event.tags)
+  const goal = reader(ZapGoal)(event)
+
+  const title = goal.title()
+  const summary = goal.summary()
+  const h = goal.room()
 </script>
 
 <Link
   class="cv flex flex-col gap-2 card card-interactive w-full"
   href={makeGoalPath(url, event.id)}>
-  <p class="text-2xl">{event.content}</p>
+  <p class="text-2xl">{title}</p>
   <Content
     event={{content: summary, tags: event.tags}}
     {url}
diff --git a/src/app/components/GoalSummary.svelte b/src/app/components/GoalSummary.svelte
index 844c5f9d..3e696f38 100644
--- a/src/app/components/GoalSummary.svelte
+++ b/src/app/components/GoalSummary.svelte
@@ -1,12 +1,16 @@
 <script lang="ts">
+  import {derived} from "svelte/store"
   import {now, DAY, uniq, sum} from "@welshman/lib"
-  import type {Zap, TrustedEvent} from "@welshman/util"
-  import {getTagValue, fromMsats, ZAP_RESPONSE} from "@welshman/util"
-  import {deriveItemsByKey, deriveArray} from "@welshman/store"
-  import {repository, getValidZap} from "@welshman/app"
+  import type {TrustedEvent} from "@welshman/util"
+  import {fromMsats, ZAP_RECEIPT} from "@welshman/util"
+  import {ZapGoal} from "@welshman/domain"
+  import type {Zap} from "@welshman/domain"
+  import {Zappers} from "@welshman/app"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
+  import {deriveEvents} from "@app/repository"
   import ZapButton from "@app/components/ZapButton.svelte"
+  import {app, reader} from "@app/core"
 
   type Props = {
     url?: string
@@ -16,18 +20,23 @@
 
   const {url, event, ...props}: Props = $props()
 
-  const zaps = deriveArray(
-    deriveItemsByKey<Zap>({
-      repository,
-      getKey: zap => zap.response.id,
-      filters: [{kinds: [ZAP_RESPONSE], "#e": [event.id]}],
-      eventToItem: (response: TrustedEvent) => getValidZap(response, event),
-    }),
+  const receipts = deriveEvents([{kinds: [ZAP_RECEIPT], "#e": [event.id]}])
+
+  const zaps = derived<typeof receipts, Zap[]>(
+    receipts,
+    ($receipts, set) => $app.use(Zappers).validZapReceipts($receipts, event).$.subscribe(set),
+    [],
   )
 
-  const goalAmount = parseInt(getTagValue("amount", event.tags) || "0")
-  const zapAmount = $derived(fromMsats(sum($zaps.map(zap => zap.invoiceAmount))))
-  const contributorsCount = $derived(uniq($zaps.map(zap => zap.request.pubkey)).length)
+  const goal = reader(ZapGoal)(event)
+
+  const goalAmount = goal.amount() ?? 0
+  const closedAt = goal.closedAt()
+
+  // NIP-75: receipts published after closed_at don't count toward the goal.
+  const counted = $derived($zaps.filter(zap => !closedAt || zap.response.created_at <= closedAt))
+  const zapAmount = $derived(fromMsats(sum(counted.map(zap => zap.invoiceAmount))))
+  const contributorsCount = $derived(uniq(counted.map(zap => zap.request.pubkey)).length)
   const daysOld = Math.ceil((now() - event.created_at) / DAY)
 </script>
 
diff --git a/src/app/components/InfoKeys.svelte b/src/app/components/InfoKeys.svelte
index 0457accc..e550dd9b 100644
--- a/src/app/components/InfoKeys.svelte
+++ b/src/app/components/InfoKeys.svelte
@@ -1,5 +1,4 @@
 <script lang="ts">
-  import {session} from "@welshman/app"
   import Link from "@lib/components/Link.svelte"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
@@ -11,8 +10,10 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import KeyRecoveryRequest from "@app/components/KeyRecoveryRequest.svelte"
+  import {isPomadeSession} from "@app/pomade"
   import {PLATFORM_NAME} from "@app/env"
   import {pushModal} from "@app/modal"
+  import {session} from "@app/core"
 
   const back = () => history.back()
 
@@ -36,7 +37,7 @@
       <strong>public key</strong>, which acts as your user ID, and a
       <strong>private key</strong> which allows you to prove your identity.
     </p>
-    {#if $session?.email}
+    {#if isPomadeSession($session)}
       <p>
         It's very important to keep private keys safe, but this can sometimes be tricky, which is
         why {PLATFORM_NAME}
@@ -47,7 +48,7 @@
       <Button class="button button-primary" onclick={back}>Got it</Button>
     {/if}
   </ModalBody>
-  {#if $session?.email}
+  {#if isPomadeSession($session)}
     <ModalFooter>
       <Button class="button button-link" onclick={back}>
         <Icon icon={AltArrowLeft} />
diff --git a/src/app/components/InfoZapperError.svelte b/src/app/components/InfoZapperError.svelte
index e5f6c9d1..ca9a80a3 100644
--- a/src/app/components/InfoZapperError.svelte
+++ b/src/app/components/InfoZapperError.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import {deriveZapperForPubkey} from "@welshman/app"
+  import {Zappers} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -9,10 +9,15 @@
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
   import ProfileLink from "@app/components/ProfileLink.svelte"
+  import {app} from "@app/core"
 
-  const {pubkey} = $props()
+  type Props = {
+    pubkey: string
+  }
 
-  const zapper = deriveZapperForPubkey(pubkey)
+  const {pubkey}: Props = $props()
+
+  const zapper = $app.use(Zappers).forPubkey(pubkey).$
 
   const back = () => history.back()
 </script>
diff --git a/src/app/components/KeyRecoveryConfirm.svelte b/src/app/components/KeyRecoveryConfirm.svelte
index 29bba038..7d23d696 100644
--- a/src/app/components/KeyRecoveryConfirm.svelte
+++ b/src/app/components/KeyRecoveryConfirm.svelte
@@ -1,8 +1,6 @@
 <script lang="ts">
   import {Client} from "@pomade/core"
   import {getPubkey} from "@welshman/util"
-  import type {SessionPomade} from "@welshman/app"
-  import {session} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
@@ -19,6 +17,8 @@
   import KeyDownload from "@app/components/KeyDownload.svelte"
   import {pushToast} from "@app/toast"
   import {pushModal, clearModals} from "@app/modal"
+  import {session} from "@app/core"
+  import {requirePomadeSession} from "@app/pomade"
 
   type Props = {
     peersByPrefix: Map<string, string>
@@ -29,7 +29,7 @@
   const {
     email,
     clientOptions: {secret, peers},
-  } = $session as SessionPomade
+  } = requirePomadeSession($session).data
 
   const confirmRecovery = async () => {
     const request = await Client.recoverWithChallenge(email, peersByPrefix, otps)
diff --git a/src/app/components/KeyRecoveryRequest.svelte b/src/app/components/KeyRecoveryRequest.svelte
index c3abf6af..a829290f 100644
--- a/src/app/components/KeyRecoveryRequest.svelte
+++ b/src/app/components/KeyRecoveryRequest.svelte
@@ -1,7 +1,5 @@
 <script lang="ts">
   import {Client} from "@pomade/core"
-  import type {SessionPomade} from "@welshman/app"
-  import {session} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
@@ -15,12 +13,14 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import {pushModal} from "@app/modal"
+  import {session} from "@app/core"
+  import {requirePomadeSession} from "@app/pomade"
   import KeyRecoveryConfirm from "@app/components/KeyRecoveryConfirm.svelte"
 
   const {
     email,
     clientOptions: {peers},
-  } = $session as SessionPomade
+  } = requirePomadeSession($session).data
 
   const requestRecovery = async () => {
     const {peersByPrefix} = await Client.requestChallenge(email, peers)
diff --git a/src/app/components/LogIn.svelte b/src/app/components/LogIn.svelte
index 0429405c..19573b9f 100644
--- a/src/app/components/LogIn.svelte
+++ b/src/app/components/LogIn.svelte
@@ -3,7 +3,8 @@
   import {onMount} from "svelte"
   import {Capacitor} from "@capacitor/core"
   import {getNip07, getNip55, Nip55Signer} from "@welshman/signer"
-  import {addSession, type Session, makeNip07Session, makeNip55Session} from "@welshman/app"
+  import {nip07, nip55, toSession} from "@welshman/app"
+  import type {Session} from "@welshman/app"
   import Widget from "@assets/icons/widget-4.svg?dataurl"
   import Letter from "@assets/icons/letter.svg?dataurl"
   import Cpu from "@assets/icons/cpu-bolt.svg?dataurl"
@@ -24,6 +25,7 @@
   import {PLATFORM_NAME, POMADE_SIGNERS} from "@app/env"
   import {pushToast} from "@app/toast"
   import {setChecked} from "@app/notifications"
+  import {login} from "@app/core"
 
   let signers: any[] = $state([])
   let loading: string | undefined = $state()
@@ -35,7 +37,7 @@
   const signUp = () => pushModal(SignUp)
 
   const onSuccess = async (session: Session) => {
-    addSession(session)
+    await login(session)
     setChecked("*")
     clearModals()
   }
@@ -47,7 +49,7 @@
       const pubkey = await getNip07()?.getPublicKey()
 
       if (pubkey) {
-        await onSuccess(makeNip07Session(pubkey))
+        await onSuccess(toSession(nip07, {}))
       } else {
         pushToast({
           theme: "error",
@@ -59,15 +61,15 @@
     }
   }
 
-  const loginWithNip55 = async (app: any) => {
+  const loginWithNip55 = async (signerApp: any) => {
     loading = "nip55"
 
     try {
-      const signer = new Nip55Signer(app.packageName)
+      const signer = new Nip55Signer(signerApp.packageName)
       const pubkey = await signer.getPubkey()
 
       if (pubkey) {
-        await onSuccess(makeNip55Session(pubkey, app.packageName))
+        await onSuccess(toSession(nip55, {pubkey, signer: signerApp.packageName}))
       } else {
         pushToast({
           theme: "error",
@@ -112,14 +114,14 @@
         Log in with Extension
       </Button>
     {/if}
-    {#each signers as app}
-      <Button {disabled} class="button button-primary" onclick={() => loginWithNip55(app)}>
+    {#each signers as signerApp}
+      <Button {disabled} class="button button-primary" onclick={() => loginWithNip55(signerApp)}>
         {#if loading === "nip55"}
           <Spinner size="sm" class="mr-3" />
         {:else}
-          <img src={app.iconUrl} alt={app.name} width="20" height="20" />
+          <img src={signerApp.iconUrl} alt={signerApp.name} width="20" height="20" />
         {/if}
-        Log in with {app.name}
+        Log in with {signerApp.name}
       </Button>
     {/each}
     {#if hasPomade && !hasSigner}
diff --git a/src/app/components/LogInBunker.svelte b/src/app/components/LogInBunker.svelte
index 487592a7..92f84af7 100644
--- a/src/app/components/LogInBunker.svelte
+++ b/src/app/components/LogInBunker.svelte
@@ -5,7 +5,7 @@
   import type {Nip46ResponseWithResult} from "@welshman/signer"
   import {Nip46Broker} from "@welshman/signer"
   import {makeSecret} from "@welshman/util"
-  import {loginWithNip01, loginWithNip46} from "@welshman/app"
+  import {nip01, nip46, toSession} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -20,6 +20,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import BunkerConnect from "@app/components/BunkerConnect.svelte"
   import BunkerUrl from "@app/components/BunkerUrl.svelte"
+  import {login} from "@app/core"
   import {Nip46Controller} from "@app/nip46"
   import {clearModals} from "@app/modal"
   import {setChecked} from "@app/notifications"
@@ -36,16 +37,16 @@
 
   const controller = new Nip46Controller({
     onNostrConnect: async (response: Nip46ResponseWithResult) => {
-      const pubkey = await controller.broker.getPublicKey()
-
       // Use the broker's current relays rather than the ones we started with, since
       // the signer may have asked us to switch relays during the connection handshake.
-      loginWithNip46(
-        pubkey,
-        controller.clientSecret,
-        response.event.pubkey,
-        controller.broker.params.relays,
+      await login(
+        toSession(nip46, {
+          clientSecret: controller.clientSecret,
+          signerPubkey: response.event.pubkey,
+          relays: controller.broker.params.relays,
+        }),
       )
+
       setChecked("*")
       clearModals()
     },
@@ -86,7 +87,7 @@
         controller.stop()
 
         // connect() may have switched relays, so persist the broker's current relays.
-        loginWithNip46(pubkey, clientSecret, signerPubkey, broker.params.relays)
+        await login(toSession(nip46, {clientSecret, signerPubkey, relays: broker.params.relays}))
         setChecked("*")
       } else {
         return pushToast({
@@ -128,7 +129,7 @@
   $effect(() => {
     // For testing and for play store reviewers
     if ($bunker === "reviewkey") {
-      loginWithNip01(makeSecret())
+      login(toSession(nip01, {secret: makeSecret()}))
     }
   })
 
diff --git a/src/app/components/LogInEmail.svelte b/src/app/components/LogInEmail.svelte
index ad8da6e8..6cbddfbf 100644
--- a/src/app/components/LogInEmail.svelte
+++ b/src/app/components/LogInEmail.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
-  import {uniq} from "@welshman/lib"
   import {Client} from "@pomade/core"
+  import {uniq} from "@welshman/lib"
   import {preventDefault} from "@lib/html"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -24,7 +24,7 @@
   import {setChecked} from "@app/notifications"
   import {pushToast} from "@app/toast"
 
-  interface Props {
+  type Props = {
     email?: string
   }
 
@@ -56,7 +56,7 @@
         const {clientOptions, ...res} = await Client.selectLogin(clientSecret, client, peers)
 
         if (res.ok && clientOptions) {
-          loginWithPomade(clientOptions, email)
+          await loginWithPomade(clientOptions, email)
           deleteDeactivatedPomadeSessions()
           setChecked("*")
           clearModals()
diff --git a/src/app/components/LogInKey.svelte b/src/app/components/LogInKey.svelte
index 6cfe1207..4a90ad91 100644
--- a/src/app/components/LogInKey.svelte
+++ b/src/app/components/LogInKey.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
-  import {bytesToHex} from "@welshman/lib"
-  import {loginWithNip01} from "@welshman/app"
   import {decrypt} from "nostr-tools/nip49"
+  import {bytesToHex} from "@welshman/lib"
+  import {nip01, toSession} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import {nsecDecode} from "@lib/util"
   import Spinner from "@lib/components/Spinner.svelte"
@@ -19,6 +19,7 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import {login} from "@app/core"
   import {clearModals} from "@app/modal"
   import {setChecked} from "@app/notifications"
   import {pushToast} from "@app/toast"
@@ -56,7 +57,7 @@
         })
       }
 
-      loginWithNip01(secret)
+      await login(toSession(nip01, {secret}))
       setChecked("*")
       clearModals()
     } catch (e) {
diff --git a/src/app/components/LogInSelect.svelte b/src/app/components/LogInSelect.svelte
index ae310179..b8401922 100644
--- a/src/app/components/LogInSelect.svelte
+++ b/src/app/components/LogInSelect.svelte
@@ -38,7 +38,7 @@
       const {clientOptions, ...res} = await Client.selectLogin(clientSecret, client, peers)
 
       if (res.ok && clientOptions) {
-        loginWithPomade(clientOptions, email)
+        await loginWithPomade(clientOptions, email)
         deleteDeactivatedPomadeSessions()
         setChecked("*")
         clearModals()
diff --git a/src/app/components/MenuSettings.svelte b/src/app/components/MenuSettings.svelte
index 8fc3e2d3..3469263b 100644
--- a/src/app/components/MenuSettings.svelte
+++ b/src/app/components/MenuSettings.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
   import {Capacitor} from "@capacitor/core"
-  import {pubkey} from "@welshman/app"
   import ServerPath from "@assets/icons/server-path.svg?dataurl"
   import RemoteControlMinimalistic from "@assets/icons/remote-controller-minimalistic.svg?dataurl"
   import GalleryMinimalistic from "@assets/icons/gallery-minimalistic.svg?dataurl"
@@ -14,6 +13,7 @@
   import ModalBody from "@lib/components/ModalBody.svelte"
   import Profile from "@app/components/Profile.svelte"
   import LogOut from "@app/components/LogOut.svelte"
+  import {user} from "@app/core"
   import {pushModal} from "@app/modal"
   import {theme} from "@app/theme"
 
@@ -24,11 +24,9 @@
 <Modal>
   <ModalBody>
     <div class="flex flex-col gap-8 items-center py-12 max-w-[16rem] m-auto w-full">
-      {#if $pubkey}
-        <Link replaceState href="/settings/profile">
-          <Profile inert pubkey={$pubkey} />
-        </Link>
-      {/if}
+      <Link replaceState href="/settings/profile">
+        <Profile inert pubkey={$user.pubkey} />
+      </Link>
       <div class="grid grid-cols-3 gap-3 w-full">
         <Link
           replaceState
diff --git a/src/app/components/NoteCard.svelte b/src/app/components/NoteCard.svelte
index 67bd6827..8d2e59db 100644
--- a/src/app/components/NoteCard.svelte
+++ b/src/app/components/NoteCard.svelte
@@ -11,14 +11,7 @@
   import {goToEvent} from "@app/routes"
   import {isEventMuted} from "@app/social"
 
-  const {
-    event,
-    children,
-    minimal = false,
-    hideProfile = false,
-    url,
-    ...restProps
-  }: {
+  type Props = {
     event: TrustedEvent
     children?: Snippet
     minimal?: boolean
@@ -26,12 +19,16 @@
     url?: string
     class?: string
     style?: string
-  } = $props()
+  }
+
+  const {event, children, minimal = false, hideProfile = false, url, ...restProps}: Props = $props()
 
   const ignoreMute = () => {
     muted = false
   }
 
+  const goToNote = () => goToEvent(event)
+
   let muted = $state($isEventMuted(event))
 </script>
 
@@ -55,7 +52,7 @@
       {/if}
       <Button
         class={cx("text-sm opacity-75 @max-sm:hidden", {"text-xs": minimal})}
-        onclick={() => goToEvent(event)}>
+        onclick={goToNote}>
         {formatTimestamp(event.created_at)}
       </Button>
     </div>
diff --git a/src/app/components/NoteContent.svelte b/src/app/components/NoteContent.svelte
index 5c8a0f6e..406e40b8 100644
--- a/src/app/components/NoteContent.svelte
+++ b/src/app/components/NoteContent.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {EVENT_TIME, ZAP_GOAL, THREAD, CLASSIFIED, POLL} from "@welshman/util"
+  import {EVENT_TIME, ZAP_GOAL, THREAD, CLASSIFIED, POLL, PIN, PINBOARD} from "@welshman/util"
   import NoteContentEventTime from "@app/components/NoteContentEventTime.svelte"
   import NoteContentThread from "@app/components/NoteContentThread.svelte"
   import NoteContentClassified from "@app/components/NoteContentClassified.svelte"
@@ -9,7 +9,6 @@
   import NoteContentPin from "@app/components/NoteContentPin.svelte"
   import NoteContentBoard from "@app/components/NoteContentBoard.svelte"
   import Content from "@app/components/Content.svelte"
-  import {PIN, BOARD} from "@app/pinboards"
 
   const props: ComponentProps<typeof Content> = $props()
 </script>
@@ -27,7 +26,7 @@
     <NoteContentPoll {...props} />
   {:else if props.event.kind === PIN}
     <NoteContentPin {...props} />
-  {:else if props.event.kind === BOARD}
+  {:else if props.event.kind === PINBOARD}
     <NoteContentBoard {...props} />
   {:else}
     <Content {...props} />
diff --git a/src/app/components/NoteContentBoard.svelte b/src/app/components/NoteContentBoard.svelte
index 22664ac7..9f09287d 100644
--- a/src/app/components/NoteContentBoard.svelte
+++ b/src/app/components/NoteContentBoard.svelte
@@ -1,16 +1,17 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
+  import {Pinboard} from "@welshman/domain"
   import Content from "@app/components/Content.svelte"
-  import {readBoard} from "@app/pinboards"
+  import {reader} from "@app/core"
 
   const props: ComponentProps<typeof Content> = $props()
 
-  const board = readBoard(props.event)
+  const board = reader(Pinboard)(props.event)
 </script>
 
 <div class="flex flex-col">
-  <strong class="text-lg">{board.title || "Untitled shelf"}</strong>
-  {#if board.description}
-    <span class="text-sm opacity-70">{board.description}</span>
+  <strong class="text-lg">{board?.title() || "Untitled shelf"}</strong>
+  {#if board?.description()}
+    <span class="text-sm opacity-70">{board.description()}</span>
   {/if}
 </div>
diff --git a/src/app/components/NoteContentClassified.svelte b/src/app/components/NoteContentClassified.svelte
index 78423b2f..fa13293a 100644
--- a/src/app/components/NoteContentClassified.svelte
+++ b/src/app/components/NoteContentClassified.svelte
@@ -1,22 +1,25 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {getTag, getTagValue, getTagValues} from "@welshman/util"
+  import {Classified} from "@welshman/domain"
   import CurrencySymbol from "@lib/components/CurrencySymbol.svelte"
+  import {reader} from "@app/core"
   import Content from "@app/components/Content.svelte"
   import ContentLinkBlock from "@app/components/ContentLinkBlock.svelte"
 
   const props: ComponentProps<typeof Content> = $props()
 
-  const title = getTagValue("title", props.event.tags)
-  const images = getTagValues("image", props.event.tags)
-  const [_, price = 0, currency = "SAT"] = getTag("price", props.event.tags) || []
+  const classified = reader(Classified)(props.event)
+
+  const title = classified.title()
+  const images = classified.images() ?? []
+  const price = classified.price()
 </script>
 
 <div class="flex flex-col gap-2">
   {#if title}
     <p class="text-xl">
       {title} —
-      <CurrencySymbol code={currency} />{price}
+      <CurrencySymbol code={price?.currency ?? "SAT"} />{price?.amount ?? 0}
     </p>
   {/if}
   {#if props.event.content}
diff --git a/src/app/components/NoteContentGoal.svelte b/src/app/components/NoteContentGoal.svelte
index cf0b52ca..795642a5 100644
--- a/src/app/components/NoteContentGoal.svelte
+++ b/src/app/components/NoteContentGoal.svelte
@@ -1,17 +1,20 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {getTagValue} from "@welshman/util"
+  import {ZapGoal} from "@welshman/domain"
+  import {reader} from "@app/core"
   import Content from "@app/components/Content.svelte"
   import GoalSummary from "@app/components/GoalSummary.svelte"
 
   const props: ComponentProps<typeof Content> = $props()
 
-  const content = getTagValue("summary", props.event.tags)
-  const fakeEvent = {content, tags: props.event.tags}
+  const goal = reader(ZapGoal)(props.event)
+
+  const title = goal.title()
+  const summaryEvent = $derived({content: goal.summary(), tags: props.event.tags})
 </script>
 
 <div class="flex flex-col gap-2">
-  <p class="text-2xl">{props.event.content}</p>
-  <Content {...props} event={fakeEvent} expandMode="inline" minLength={50} maxLength={300} />
+  <p class="text-2xl">{title}</p>
+  <Content {...props} event={summaryEvent} expandMode="inline" minLength={50} maxLength={300} />
   <GoalSummary url={props.url} event={props.event} />
 </div>
diff --git a/src/app/components/NoteContentMinimalClassified.svelte b/src/app/components/NoteContentMinimalClassified.svelte
index d0aa1208..f99b3c72 100644
--- a/src/app/components/NoteContentMinimalClassified.svelte
+++ b/src/app/components/NoteContentMinimalClassified.svelte
@@ -1,11 +1,14 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {getTagValue} from "@welshman/util"
+  import {Classified} from "@welshman/domain"
+  import {reader} from "@app/core"
   import ContentMinimal from "@app/components/ContentMinimal.svelte"
 
   const props: ComponentProps<typeof ContentMinimal> = $props()
 
-  const title = getTagValue("title", props.event.tags)
+  const classified = reader(Classified)(props.event)
+
+  const title = classified.title()
 </script>
 
 {#if title}
diff --git a/src/app/components/NoteContentMinimalGoal.svelte b/src/app/components/NoteContentMinimalGoal.svelte
index af9679d9..2579a384 100644
--- a/src/app/components/NoteContentMinimalGoal.svelte
+++ b/src/app/components/NoteContentMinimalGoal.svelte
@@ -1,37 +1,43 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
+  import {derived} from "svelte/store"
   import {sum} from "@welshman/lib"
-  import type {Zap, TrustedEvent} from "@welshman/util"
-  import {getTagValue, fromMsats, ZAP_RESPONSE} from "@welshman/util"
-  import {deriveItemsByKey, deriveArray} from "@welshman/store"
-  import {repository, getValidZap} from "@welshman/app"
+  import {ZAP_RECEIPT, fromMsats} from "@welshman/util"
+  import {ZapGoal} from "@welshman/domain"
+  import type {Zap} from "@welshman/domain"
+  import {Zappers} from "@welshman/app"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import ContentMinimal from "@app/components/ContentMinimal.svelte"
+  import {app, reader} from "@app/core"
+  import {deriveEvents} from "@app/repository"
 
   const props: ComponentProps<typeof ContentMinimal> = $props()
 
-  const content = getTagValue("summary", props.event.tags)
-  const fakeEvent = {content, tags: props.event.tags}
+  const goal = reader(ZapGoal)(props.event)
 
-  const zaps = deriveArray(
-    deriveItemsByKey<Zap>({
-      repository,
-      getKey: zap => zap.response.id,
-      filters: [{kinds: [ZAP_RESPONSE], "#e": [props.event.id]}],
-      eventToItem: (response: TrustedEvent) => getValidZap(response, props.event),
-    }),
+  const title = goal.title()
+  const summaryEvent = $derived({content: goal.summary(), tags: props.event.tags})
+
+  const receipts = deriveEvents([{kinds: [ZAP_RECEIPT], "#e": [props.event.id]}])
+
+  const zaps = derived<typeof receipts, Zap[]>(
+    receipts,
+    ($receipts, set) => $app.use(Zappers).validZapReceipts($receipts, props.event).$.subscribe(set),
+    [],
   )
 
-  const goalAmount = parseInt(getTagValue("amount", props.event.tags) || "0")
-  const zapAmount = $derived(fromMsats(sum($zaps.map(zap => zap.invoiceAmount))))
+  const goalAmount = goal.amount() ?? 0
+  const closedAt = goal.closedAt()
+  const counted = $derived($zaps.filter(zap => !closedAt || zap.response.created_at <= closedAt))
+  const zapAmount = $derived(fromMsats(sum(counted.map(zap => zap.invoiceAmount))))
 </script>
 
 <div class="flex justify-between">
-  <span class="text-sm">{props.event.content}</span>
+  <span class="text-sm">{title}</span>
   <div class="flex items-center gap-1">
     <Icon icon={Bolt} size={4} />
     {zapAmount}/{goalAmount} sats funded
   </div>
 </div>
-<ContentMinimal {...props} event={fakeEvent} />
+<ContentMinimal {...props} event={summaryEvent} />
diff --git a/src/app/components/NoteContentMinimalPoll.svelte b/src/app/components/NoteContentMinimalPoll.svelte
index 6e357296..7de6b942 100644
--- a/src/app/components/NoteContentMinimalPoll.svelte
+++ b/src/app/components/NoteContentMinimalPoll.svelte
@@ -1,19 +1,19 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {derived} from "svelte/store"
   import {POLL_RESPONSE} from "@welshman/util"
+  import {Poll} from "@welshman/domain"
   import ContentMinimal from "@app/components/ContentMinimal.svelte"
+  import {reader} from "@app/core"
   import {deriveEvents} from "@app/repository"
-  import {getPollResults} from "@app/polls"
 
   const props: ComponentProps<typeof ContentMinimal> = $props()
 
   const responses = deriveEvents([{kinds: [POLL_RESPONSE], "#e": [props.event.id]}])
 
-  const results = derived(responses, $responses => getPollResults(props.event, $responses))
+  const voters = $derived(reader(Poll)(props.event).results($responses).voters)
 </script>
 
 <div class="flex flex-col gap-0">
   <ContentMinimal {...props} />
-  <span class="text-xs opacity-50">{$results.voters} voter{$results.voters === 1 ? "" : "s"}</span>
+  <span class="text-xs opacity-50">{voters} voter{voters === 1 ? "" : "s"}</span>
 </div>
diff --git a/src/app/components/NoteContentMinimalThread.svelte b/src/app/components/NoteContentMinimalThread.svelte
index d0aa1208..554ef6e9 100644
--- a/src/app/components/NoteContentMinimalThread.svelte
+++ b/src/app/components/NoteContentMinimalThread.svelte
@@ -1,11 +1,11 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {getTagValue} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import ContentMinimal from "@app/components/ContentMinimal.svelte"
 
   const props: ComponentProps<typeof ContentMinimal> = $props()
 
-  const title = getTagValue("title", props.event.tags)
+  const title = tagValue(tagSpec("title"), props.event.tags)
 </script>
 
 {#if title}
diff --git a/src/app/components/NoteContentPin.svelte b/src/app/components/NoteContentPin.svelte
index a6e82f41..f176b117 100644
--- a/src/app/components/NoteContentPin.svelte
+++ b/src/app/components/NoteContentPin.svelte
@@ -1,52 +1,42 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import * as nip19 from "nostr-tools/nip19"
-  import {Address} from "@welshman/util"
+  import {Pin} from "@welshman/domain"
   import Badge from "@lib/components/Badge.svelte"
   import Content from "@app/components/Content.svelte"
   import PinContentEvent from "@app/components/PinContentEvent.svelte"
-  import {readPin} from "@app/pinboards"
+  import {reader} from "@app/core"
+  import {pinToReference} from "@app/pinboards"
 
   const props: ComponentProps<typeof Content> = $props()
 
-  const pin = readPin(props.event)
-
-  // Encode nostr references as nostr: entities (i tags are already urls) so
-  // Content parses them into rich embeds rather than rendering raw ids/coords.
-  const content = $derived.by(() => {
-    const [type, data = ""] = pin.value
-
-    if (type === "e") return "nostr:" + nip19.neventEncode({id: data})
-
-    if (type === "p") return "nostr:" + nip19.nprofileEncode({pubkey: data})
-
-    if (type === "a") {
-      const {kind, pubkey, identifier} = Address.from(data)
-
-      return "nostr:" + nip19.naddrEncode({kind, pubkey, identifier})
-    }
-
-    return data
-  })
+  const loadPin = reader(Pin)(props.event)
 </script>
 
-<div class="flex h-full flex-col gap-2">
-  {#if pin.title}
-    <strong class="truncate min-w-0">{pin.title}</strong>
-  {/if}
-  {#if pin.description}
-    <Content event={{content: pin.description, tags: []}} />
-  {/if}
-  {#if pin.value[0] === "e" || pin.value[0] === "a"}
-    <PinContentEvent value={pin.value[1]} relays={pin.value[2] ? [pin.value[2]] : []} />
-  {:else}
-    <Content event={{content, tags: []}} />
-  {/if}
-  {#if pin.topics.length > 0}
-    <div class="mt-auto flex flex-wrap gap-1">
-      {#each pin.topics as topic (topic)}
-        <Badge>#{topic}</Badge>
-      {/each}
-    </div>
-  {/if}
-</div>
+{#await loadPin then pin}
+  {@const reference = pin.reference()}
+  <div class="flex h-full flex-col gap-2">
+    {#if pin.title()}
+      <strong class="truncate min-w-0">{pin.title()}</strong>
+    {/if}
+    {#if pin.content()}
+      <Content event={{content: pin.content(), tags: []}} />
+    {/if}
+    {#if reference?.type === "event"}
+      <PinContentEvent value={reference.id} relays={reference.relay ? [reference.relay] : []} />
+    {:else if reference?.type === "address"}
+      <PinContentEvent
+        value={reference.address}
+        relays={reference.relay ? [reference.relay] : []} />
+    {:else}
+      <!-- External references are urls or bech32 entities, both of which Content parses. -->
+      <Content event={{content: pinToReference(pin), tags: []}} />
+    {/if}
+    {#if pin.topics().length > 0}
+      <div class="mt-auto flex flex-wrap gap-1">
+        {#each pin.topics() as topic (topic)}
+          <Badge>#{topic}</Badge>
+        {/each}
+      </div>
+    {/if}
+  </div>
+{/await}
diff --git a/src/app/components/NoteContentThread.svelte b/src/app/components/NoteContentThread.svelte
index ca6ec43b..939c5390 100644
--- a/src/app/components/NoteContentThread.svelte
+++ b/src/app/components/NoteContentThread.svelte
@@ -1,11 +1,11 @@
 <script lang="ts">
   import type {ComponentProps} from "svelte"
-  import {getTagValue} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Content from "@app/components/Content.svelte"
 
   const props: ComponentProps<typeof Content> = $props()
 
-  const title = getTagValue("title", props.event.tags)
+  const title = tagValue(tagSpec("title"), props.event.tags)
 </script>
 
 <div class="flex flex-col gap-2">
diff --git a/src/app/components/NoteItem.svelte b/src/app/components/NoteItem.svelte
index e98c2c4d..dc80d5d3 100644
--- a/src/app/components/NoteItem.svelte
+++ b/src/app/components/NoteItem.svelte
@@ -2,16 +2,15 @@
   import type {Snippet} from "svelte"
   import type {NativeEmoji} from "emoji-picker-element/shared"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {Router} from "@welshman/router"
+  import {seen} from "@welshman/util"
   import SmileCircle from "@assets/icons/smile-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import EmojiButton from "@lib/components/EmojiButton.svelte"
   import NoteContent from "@app/components/NoteContent.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import NoteCard from "@app/components/NoteCard.svelte"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
+  import {router} from "@app/core"
 
   type Props = {
     event: TrustedEvent
@@ -21,23 +20,15 @@
 
   const {url, event, children}: Props = $props()
 
-  const relays = url ? [url] : Router.get().Event(event).getUrls()
+  const getRelays = () => (url ? [url] : $router.resolver.relays([seen(event)]))
 
-  const shouldProtect = url ? canEnforceNip70(url) : false
+  const deleteReaction = async (reaction: TrustedEvent) =>
+    retractReaction(reaction, {url, urls: await getRelays()})
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays, event, protect: await shouldProtect})
+  const createReaction = async (values: EventContent) =>
+    publishReaction(event, values, {url, urls: await getRelays()})
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays, protect: await shouldProtect})
-
-  const onEmoji = async (emoji: NativeEmoji) =>
-    publishReaction({
-      event,
-      relays,
-      content: emoji.unicode,
-      protect: await shouldProtect,
-    })
+  const onEmoji = (emoji: NativeEmoji) => createReaction({content: emoji.unicode, tags: []})
 </script>
 
 <NoteCard {event} {url} class="cv card card-interactive">
diff --git a/src/app/components/PasswordReset.svelte b/src/app/components/PasswordReset.svelte
index 3f06e3b3..1224febc 100644
--- a/src/app/components/PasswordReset.svelte
+++ b/src/app/components/PasswordReset.svelte
@@ -1,7 +1,5 @@
 <script lang="ts">
   import {Client} from "@pomade/core"
-  import type {SessionPomade} from "@welshman/app"
-  import {session} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
@@ -16,6 +14,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import StringMultiInput from "@lib/components/StringMultiInput.svelte"
   import PasswordResetConfirm from "@app/components/PasswordResetConfirm.svelte"
+  import {session} from "@app/core"
   import {pushToast} from "@app/toast"
   import {pushModal} from "@app/modal"
   import {getPomadeClient} from "@app/pomade"
@@ -26,7 +25,7 @@
 
   const {peersByPrefix}: Props = $props()
 
-  const {email} = $session as SessionPomade
+  const {email} = $session?.data as {email: string}
 
   const confirmRecovery = async () => {
     const request = await Client.recoverWithChallenge(email, peersByPrefix, otps)
diff --git a/src/app/components/PasswordResetConfirm.svelte b/src/app/components/PasswordResetConfirm.svelte
index 6f77b47e..58775351 100644
--- a/src/app/components/PasswordResetConfirm.svelte
+++ b/src/app/components/PasswordResetConfirm.svelte
@@ -1,7 +1,5 @@
 <script lang="ts">
   import {Client} from "@pomade/core"
-  import {session} from "@welshman/app"
-  import type {SessionPomade} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import Key from "@assets/icons/key.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
@@ -19,6 +17,8 @@
   import {loginWithPomade, deleteCurrentPomadeSession} from "@app/pomade"
   import {clearModals} from "@app/modal"
   import {pushToast} from "@app/toast"
+  import {session} from "@app/core"
+  import {requirePomadeSession} from "@app/pomade"
 
   type Props = {
     userSecret: string
@@ -26,7 +26,7 @@
 
   const {userSecret}: Props = $props()
 
-  const {email} = $session as SessionPomade
+  const {email} = requirePomadeSession($session).data
 
   const back = () => history.back()
 
diff --git a/src/app/components/PinAdd.svelte b/src/app/components/PinAdd.svelte
index d89c0903..7813bab7 100644
--- a/src/app/components/PinAdd.svelte
+++ b/src/app/components/PinAdd.svelte
@@ -1,6 +1,9 @@
 <script lang="ts">
+  import {Pin} from "@welshman/domain"
+  import {publishAsRelay} from "@welshman/app"
   import PinForm, {type PinFormValues} from "@app/components/PinForm.svelte"
-  import {createPin, referenceToPin} from "@app/pinboards"
+  import {command, writer} from "@app/core"
+  import {setPinReference} from "@app/pinboards"
 
   type Props = {
     url: string
@@ -11,11 +14,17 @@
   const {url, address, reference}: Props = $props()
 
   const submit = async ({title, topics, value, content}: PinFormValues) => {
-    const params = referenceToPin(value)
+    const eventWriter = writer(Pin).setIdentifier().addBoard(address)
 
-    if (!params) return "Please enter a valid URL or nostr link."
+    if (!setPinReference(eventWriter, value)) {
+      return "Please enter a valid URL or nostr link."
+    }
 
-    return createPin(url, {...params, boards: [address], title, topics, description: content})
+    eventWriter.setTitle(title).setTopics(topics).setContent(content)
+
+    const thunk = await command(eventWriter).then(publishAsRelay(url))
+
+    return thunk.waitForError()
   }
 </script>
 
diff --git a/src/app/components/PinEdit.svelte b/src/app/components/PinEdit.svelte
index a3c17e5f..5822de3d 100644
--- a/src/app/components/PinEdit.svelte
+++ b/src/app/components/PinEdit.svelte
@@ -1,28 +1,30 @@
 <script lang="ts">
+  import {Pin} from "@welshman/domain"
+  import {publishAsRelay} from "@welshman/app"
+  import type {PinReader} from "@welshman/domain"
   import PinForm, {type PinFormValues} from "@app/components/PinForm.svelte"
-  import {createPin, referenceToPin, pinToReference, type PublishedPin} from "@app/pinboards"
+  import {command, writer} from "@app/core"
+  import {pinToReference, setPinReference} from "@app/pinboards"
 
   type Props = {
     url: string
-    pin: PublishedPin
+    pin: PinReader
   }
 
   const {url, pin}: Props = $props()
 
   const submit = async ({title, topics, value, content}: PinFormValues) => {
-    const params = referenceToPin(value)
+    const eventWriter = writer(Pin, pin)
 
-    if (!params) return "Please enter a valid URL or nostr link."
+    if (!setPinReference(eventWriter, value)) {
+      return "Please enter a valid URL or nostr link."
+    }
 
-    // Reuse the pin's identifier and boards so its addressable event is replaced.
-    return createPin(url, {
-      ...params,
-      identifier: pin.identifier,
-      boards: pin.boards,
-      title,
-      topics,
-      description: content,
-    })
+    eventWriter.setTitle(title).setTopics(topics).setContent(content)
+
+    const thunk = await command(eventWriter).then(publishAsRelay(url))
+
+    return thunk.waitForError()
   }
 </script>
 
@@ -32,9 +34,9 @@
   action="Save changes"
   successMessage="Link updated!"
   values={{
-    title: pin.title,
-    topics: pin.topics,
+    title: pin.title(),
+    topics: pin.topics(),
     value: pinToReference(pin),
-    content: pin.description,
+    content: pin.content(),
   }}
   {submit} />
diff --git a/src/app/components/PinItem.svelte b/src/app/components/PinItem.svelte
index cce58999..87e575c0 100644
--- a/src/app/components/PinItem.svelte
+++ b/src/app/components/PinItem.svelte
@@ -2,16 +2,17 @@
   import * as nip19 from "nostr-tools/nip19"
   import {removeUndefined} from "@welshman/lib"
   import {Address} from "@welshman/util"
+  import type {PinReader} from "@welshman/domain"
   import Badge from "@lib/components/Badge.svelte"
   import MenuButton from "@lib/components/MenuButton.svelte"
   import Content from "@app/components/Content.svelte"
   import PinContentEvent from "@app/components/PinContentEvent.svelte"
   import PinMenu from "@app/components/PinMenu.svelte"
-  import {type PublishedPin} from "@app/pinboards"
+  import {pinToReference} from "@app/pinboards"
 
   type Props = {
     url: string
-    pin: PublishedPin
+    pin: PinReader
     minimal?: boolean
     class?: string
   }
@@ -20,20 +21,20 @@
 
   // Encode nostr references as nostr: entities (i tags are already urls) so
   // Content parses them into rich embeds rather than rendering raw ids/coords.
+  const reference = $derived(pin.reference())
+
   const content = $derived.by(() => {
-    const [type, data = ""] = pin.value
+    if (reference?.type === "event") {
+      return "nostr:" + nip19.neventEncode({id: reference.id, relays: [url]})
+    }
 
-    if (type === "e") return "nostr:" + nip19.neventEncode({id: data, relays: [url]})
-
-    if (type === "p") return "nostr:" + nip19.nprofileEncode({pubkey: data, relays: [url]})
-
-    if (type === "a") {
-      const {kind, pubkey, identifier} = Address.from(data)
+    if (reference?.type === "address") {
+      const {kind, pubkey, identifier} = Address.from(reference.address)
 
       return "nostr:" + nip19.naddrEncode({kind, pubkey, identifier, relays: [url]})
     }
 
-    return data
+    return pinToReference(pin)
   })
 </script>
 
@@ -48,20 +49,23 @@
         componentProps={{url, pin}} />
     </div>
   {/if}
-  {#if pin.title}
-    <strong class="truncate min-w-0 pr-8">{pin.title}</strong>
+  {#if pin.title()}
+    <strong class="truncate min-w-0 pr-8">{pin.title()}</strong>
   {/if}
-  {#if pin.description}
-    <Content event={{content: pin.description, tags: []}} {url} />
+  {#if pin.content()}
+    <Content event={{content: pin.content(), tags: []}} {url} />
   {/if}
-  {#if pin.value[0] === "e" || pin.value[0] === "a"}
-    <PinContentEvent {url} value={pin.value[1]} relays={removeUndefined([pin.value[2], url])} />
+  {#if reference?.type === "event" || reference?.type === "address"}
+    <PinContentEvent
+      {url}
+      value={reference.type === "event" ? reference.id : reference.address}
+      relays={removeUndefined([reference.relay, url])} />
   {:else}
     <Content event={{content, tags: []}} {url} />
   {/if}
-  {#if !minimal && pin.topics.length > 0}
+  {#if !minimal && pin.topics().length > 0}
     <div class="mt-auto flex flex-wrap gap-1">
-      {#each pin.topics as topic (topic)}
+      {#each pin.topics() as topic (topic)}
         <Badge>#{topic}</Badge>
       {/each}
     </div>
diff --git a/src/app/components/PinMenu.svelte b/src/app/components/PinMenu.svelte
index 9798a867..bfa69ea3 100644
--- a/src/app/components/PinMenu.svelte
+++ b/src/app/components/PinMenu.svelte
@@ -1,30 +1,31 @@
 <script lang="ts">
   import {onMount} from "svelte"
+  import type {PinReader} from "@welshman/domain"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import TrashBin from "@assets/icons/trash-bin-2.svg?dataurl"
   import ShareCircle from "@assets/icons/share-circle.svg?dataurl"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
+  import {errorMessage} from "@lib/util"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Confirm from "@lib/components/Confirm.svelte"
   import EventInfo from "@app/components/EventInfo.svelte"
   import PinEdit from "@app/components/PinEdit.svelte"
-  import {deriveSupportedMethods} from "@app/relays"
-  import {deletePin, type PublishedPin} from "@app/pinboards"
+  import {deletes} from "@app/core"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {shareEventToChat} from "@app/share"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
 
   type Props = {
     url: string
-    pin: PublishedPin
+    pin: PinReader
     onClick: () => void
   }
 
   const {url, pin, onClick}: Props = $props()
 
-  const supportedMethods = deriveSupportedMethods(url)
-  const canManage = $derived($supportedMethods.some(m => (m as string) === "signevent"))
+  const canManage = deriveUserIsSpaceAdmin(url)
 
   const showInfo = () => pushModal(EventInfo, {url, event: pin.event})
 
@@ -32,19 +33,27 @@
 
   const edit = () => pushModal(PinEdit, {url, pin})
 
+  const deletePin = async () => {
+    try {
+      const command = await $deletes.deleteEvent(pin.event)
+      const error = await command.publishAsRelay(url).then(thunk => thunk.waitForError())
+
+      if (error) {
+        pushToast({theme: "error", message: error})
+      } else {
+        pushToast({message: "Link deleted!"})
+      }
+    } catch (e) {
+      console.error(e)
+      pushToast({theme: "error", message: errorMessage(e)})
+    }
+  }
+
   const confirmDelete = () =>
     pushModal(Confirm, {
       title: "Delete Link",
       message: "Delete this link?",
-      confirm: async () => {
-        const error = await deletePin(url, pin.id)
-
-        if (error) {
-          pushToast({theme: "error", message: error})
-        } else {
-          pushToast({message: "Link deleted!"})
-        }
-      },
+      confirm: deletePin,
     })
 
   let ul: Element
@@ -67,7 +76,7 @@
       Share to chat
     </Button>
   </li>
-  {#if canManage}
+  {#if $canManage}
     <li>
       <Button onclick={edit}>
         <Icon icon={Pen} />
diff --git a/src/app/components/PinboardEdit.svelte b/src/app/components/PinboardEdit.svelte
index e233c752..c0f9ead6 100644
--- a/src/app/components/PinboardEdit.svelte
+++ b/src/app/components/PinboardEdit.svelte
@@ -1,4 +1,9 @@
 <script lang="ts">
+  import {goto} from "$app/navigation"
+  import {getAddress} from "@welshman/util"
+  import {publishAsRelay} from "@welshman/app"
+  import {Pinboard} from "@welshman/domain"
+  import type {PinboardReader} from "@welshman/domain"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -10,23 +15,17 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {goto} from "$app/navigation"
   import RelayName from "@app/components/RelayName.svelte"
-  import {editBoard, type Board} from "@app/pinboards"
+  import {command, writer} from "@app/core"
   import {makeLibraryPath} from "@app/routes"
   import {pushToast} from "@app/toast"
 
   type Props = {
     url: string
-    board: Board
-    isNew?: boolean
+    board?: PinboardReader
   }
 
-  const {url, board, isNew = false}: Props = $props()
-
-  let title = $state(board.title)
-  let description = $state(board.description)
-  let loading = $state(false)
+  const {url, board}: Props = $props()
 
   const back = () => history.back()
 
@@ -34,30 +33,41 @@
     loading = true
 
     try {
-      const error = await editBoard(url, {...board, title, description})
+      const eventWriter = writer(Pinboard, board).setTitle(title).setDescription(description)
+
+      if (!board) {
+        eventWriter.setIdentifier()
+      }
+
+      const thunk = await command(eventWriter).then(publishAsRelay(url))
+      const error = await thunk.waitForError()
 
       if (error) {
         pushToast({theme: "error", message: error})
+      } else if (board) {
+        pushToast({message: "Shelf updated!"})
+        back()
       } else {
-        pushToast({message: isNew ? "Shelf created!" : "Shelf updated!"})
-
-        // Navigate to a freshly created board; otherwise just close the modal.
-        if (isNew) {
-          goto(makeLibraryPath(url, board.address))
-        } else {
-          back()
-        }
+        pushToast({message: "Shelf created!"})
+        goto(makeLibraryPath(url, getAddress(thunk.event)))
       }
+    } catch (e) {
+      console.error(e)
+      pushToast({theme: "error", message: "This space refused to save the shelf."})
     } finally {
       loading = false
     }
   }
+
+  let title = $state(board?.title() ?? "")
+  let description = $state(board?.description() ?? "")
+  let loading = $state(false)
 </script>
 
 <Modal>
   <ModalBody>
     <ModalHeader>
-      <ModalTitle>{isNew ? "Create Shelf" : "Edit Shelf"}</ModalTitle>
+      <ModalTitle>{board ? "Edit Shelf" : "Create Shelf"}</ModalTitle>
       <ModalSubtitle>on <RelayName {url} class="text-primary" /></ModalSubtitle>
     </ModalHeader>
     <Field>
diff --git a/src/app/components/PinboardItem.svelte b/src/app/components/PinboardItem.svelte
index 0f1052b9..aa84961d 100644
--- a/src/app/components/PinboardItem.svelte
+++ b/src/app/components/PinboardItem.svelte
@@ -1,22 +1,24 @@
 <script lang="ts">
+  import {Pins} from "@welshman/app"
+  import type {PinboardReader} from "@welshman/domain"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Link from "@lib/components/Link.svelte"
   import MenuButton from "@lib/components/MenuButton.svelte"
   import PinItem from "@app/components/PinItem.svelte"
   import BoardMenu from "@app/components/BoardMenu.svelte"
-  import {derivePins, type PublishedBoard} from "@app/pinboards"
+  import {app} from "@app/core"
   import {makeLibraryPath} from "@app/routes"
 
   type Props = {
     url: string
-    board: PublishedBoard
+    board: PinboardReader
   }
 
   const {url, board}: Props = $props()
 
-  const pins = derivePins(url, board.address)
-  const detailPath = makeLibraryPath(url, board.address)
+  const pins = $app.use(Pins).forBoard(board.address()).$
+  const detailPath = makeLibraryPath(url, board.address())
 </script>
 
 <div class="card relative flex flex-col gap-2">
@@ -29,12 +31,12 @@
       componentProps={{url, board}} />
   </div>
   <div class="flex flex-col pr-8">
-    <strong class="text-lg">{board.title || "Untitled shelf"}</strong>
-    {#if board.description}
-      <span class="text-sm opacity-70">{board.description}</span>
+    <strong class="text-lg">{board.title() || "Untitled shelf"}</strong>
+    {#if board.description()}
+      <span class="text-sm opacity-70">{board.description()}</span>
     {/if}
   </div>
-  {#each $pins.slice(0, 1) as pin (pin.id)}
+  {#each $pins.slice(0, 1) as pin (pin.id())}
     <PinItem minimal {url} {pin} />
   {/each}
   <Link href={detailPath} class="button button-primary">
diff --git a/src/app/components/PinboardSelect.svelte b/src/app/components/PinboardSelect.svelte
index d13e6ea2..90ed42d9 100644
--- a/src/app/components/PinboardSelect.svelte
+++ b/src/app/components/PinboardSelect.svelte
@@ -1,5 +1,7 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
+  import type {PinboardReader} from "@welshman/domain"
+  import {Pinboards} from "@welshman/app"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -11,7 +13,8 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import RelayName from "@app/components/RelayName.svelte"
   import PinAdd from "@app/components/PinAdd.svelte"
-  import {deriveBoards, eventToReference, type PublishedBoard} from "@app/pinboards"
+  import {app, relays} from "@app/core"
+  import {eventToReference} from "@app/pinboards"
   import {makeSpacePath} from "@app/routes"
   import {pushModal} from "@app/modal"
 
@@ -22,11 +25,14 @@
 
   const {url, event}: Props = $props()
 
-  const boards = deriveBoards(url)
+  const relay = $relays.one(url)
+
+  const boards = $derived($app.use(Pinboards).forAuthor($relay?.self ?? "").$)
+
   const reference = eventToReference(event)
 
-  const selectBoard = (board: PublishedBoard) =>
-    pushModal(PinAdd, {url, address: board.address, reference})
+  const selectBoard = (board: PinboardReader) =>
+    pushModal(PinAdd, {url, address: board.address(), reference})
 </script>
 
 <Modal class="flex flex-col gap-2">
@@ -43,14 +49,14 @@
         </Link>
       </div>
     {:else}
-      {#each $boards as board (board.address)}
+      {#each $boards as board (board.address())}
         <Button
           class="card card-sm card-interactive flex flex-row items-center justify-between gap-3"
           onclick={() => selectBoard(board)}>
           <span class="flex min-w-0 flex-col">
-            <strong class="truncate min-w-0">{board.title || "Untitled shelf"}</strong>
-            {#if board.description}
-              <span class="truncate min-w-0 text-sm opacity-70">{board.description}</span>
+            <strong class="truncate min-w-0">{board.title() || "Untitled shelf"}</strong>
+            {#if board.description()}
+              <span class="truncate min-w-0 text-sm opacity-70">{board.description()}</span>
             {/if}
           </span>
           <Icon size={4} icon={AltArrowRight} class="shrink-0" />
diff --git a/src/app/components/PollActions.svelte b/src/app/components/PollActions.svelte
index bf154b22..c2458912 100644
--- a/src/app/components/PollActions.svelte
+++ b/src/app/components/PollActions.svelte
@@ -1,15 +1,13 @@
 <script lang="ts">
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Link from "@lib/components/Link.svelte"
   import RoomName from "@app/components/RoomName.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
   import ThunkStatusOrDeleted from "@app/components/ThunkStatusOrDeleted.svelte"
   import EventActivity from "@app/components/EventActivity.svelte"
   import EventActions from "@app/components/EventActions.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
   import {makePollPath, makeSpacePath} from "@app/routes"
 
   type Props = {
@@ -21,15 +19,12 @@
 
   const {url, event, showRoom, showActivity}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
   const path = makePollPath(url, event.id)
-  const shouldProtect = canEnforceNip70(url)
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url, h})
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url, h})
 </script>
 
 <div class="flex grow flex-wrap justify-end gap-2">
diff --git a/src/app/components/PollCreate.svelte b/src/app/components/PollCreate.svelte
index a056f2dd..430dee9c 100644
--- a/src/app/components/PollCreate.svelte
+++ b/src/app/components/PollCreate.svelte
@@ -1,7 +1,8 @@
 <script lang="ts">
-  import {insertAt, now, randomId, removeAt, removeUndefined} from "@welshman/lib"
-  import {makeEvent, POLL} from "@welshman/util"
-  import {publishThunk, waitForThunkError} from "@welshman/app"
+  import {insertAt, now, randomId, removeAt, removeUndefined, spec} from "@welshman/lib"
+  import {publish} from "@welshman/app"
+  import {Poll} from "@welshman/domain"
+  import type {PollType} from "@welshman/domain"
   import {isMobile, preventDefault} from "@lib/html"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import HamburgerMenu from "@assets/icons/hamburger-menu.svg?dataurl"
@@ -19,11 +20,10 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
+  import {command, relays, writer} from "@app/core"
   import {pushToast} from "@app/toast"
-  import {PROTECTED, publishRoomQuote} from "@app/groups"
-  import {canEnforceNip70} from "@app/relays"
+  import {publishRoomQuote} from "@app/rooms"
   import {DraftKey} from "@app/drafts"
-  import type {PollType} from "@app/polls"
 
   type Option = {
     id: string
@@ -47,8 +47,6 @@
   const draftKey = new DraftKey<Values>(`poll:${url}:${h ?? ""}`)
   const initialValues = draftKey.get()
 
-  const shouldProtect = canEnforceNip70(url)
-
   const back = () => history.back()
 
   const addOption = () => {
@@ -68,8 +66,8 @@
       return
     }
 
-    const sourceIndex = options.findIndex(option => option.id === draggedOptionId)
-    const targetIndex = options.findIndex(option => option.id === targetId)
+    const sourceIndex = options.findIndex(spec({id: draggedOptionId}))
+    const targetIndex = options.findIndex(spec({id: targetId}))
 
     if (sourceIndex === -1 || targetIndex === -1 || sourceIndex === targetIndex) {
       return
@@ -119,35 +117,32 @@
       return pushToast({theme: "error", message: "End time must be in the future."})
     }
 
-    const tags: string[][] = [
-      ...nonEmptyOptions.map(option => ["option", randomId(), option]),
-      ["polltype", pollType],
-      ["relay", url],
-    ]
-
-    if (endsAt) {
-      tags.push(["endsAt", String(endsAt)])
-    }
-
-    if (h) {
-      tags.push(["h", h])
-    }
-
     loading = true
 
     try {
-      const protect = await shouldProtect
+      const protect = await $relays.hasNip(url, 70)
+      const eventWriter = writer(Poll)
+        .setTitle(title.trim())
+        .setPollType(pollType)
+        .setUrls([url])
+        .setProtected(protect)
 
-      if (protect) {
-        tags.push(PROTECTED)
+      for (const option of nonEmptyOptions) {
+        eventWriter.addOption(option)
       }
 
-      const pollThunk = publishThunk({
-        relays: [url],
-        event: makeEvent(POLL, {content: title.trim(), tags}),
-      })
+      if (endsAt) {
+        eventWriter.setEndsAt(endsAt)
+      }
 
-      const error = await waitForThunkError(pollThunk)
+      if (h) {
+        eventWriter.setRoom(url, h)
+      } else {
+        eventWriter.forceRelays(url)
+      }
+
+      const pollThunk = await command(eventWriter).then(publish)
+      const error = await pollThunk.waitForError()
 
       if (error) {
         return pushToast({theme: "error", message: error})
diff --git a/src/app/components/PollItem.svelte b/src/app/components/PollItem.svelte
index 42135a08..91cdcdda 100644
--- a/src/app/components/PollItem.svelte
+++ b/src/app/components/PollItem.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Link from "@lib/components/Link.svelte"
   import NoteContent from "@app/components/NoteContent.svelte"
   import PollActions from "@app/components/PollActions.svelte"
@@ -15,7 +15,7 @@
 
   const {url, event}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
 </script>
 
 <Link
diff --git a/src/app/components/PollOption.svelte b/src/app/components/PollOption.svelte
index 388d931c..80fb9d9e 100644
--- a/src/app/components/PollOption.svelte
+++ b/src/app/components/PollOption.svelte
@@ -1,9 +1,10 @@
 <script lang="ts">
   import {tweened} from "svelte/motion"
   import type {TrustedEvent} from "@welshman/util"
-  import {noop} from "@welshman/lib"
+  import {noop, spec} from "@welshman/lib"
+  import {Poll} from "@welshman/domain"
   import {stopPropagation} from "@lib/html"
-  import {getPollType, isPollClosed} from "@app/polls"
+  import {reader} from "@app/core"
 
   type Props = {
     event: TrustedEvent
@@ -17,8 +18,9 @@
   const {event, option, results, selectedIds, setSingleChoice, toggleMultipleChoice}: Props =
     $props()
 
-  const pollType = getPollType(event)
-  const closed = isPollClosed(event)
+  const poll = reader(Poll)(event)
+  const pollType = poll.pollType()
+  const closed = poll.isClosed()
 
   const selected = $derived(
     pollType === "singlechoice" ? selectedIds[0] === option.id : selectedIds.includes(option.id),
@@ -26,7 +28,7 @@
   const onselect = () =>
     pollType === "singlechoice" ? setSingleChoice(option.id) : toggleMultipleChoice(option.id)
 
-  const votes = $derived(results.options.find(r => r.id === option.id)?.votes || 0)
+  const votes = $derived(results.options.find(spec({id: option.id}))?.votes || 0)
   const maxVotes = $derived(Math.max(...results.options.map(r => r.votes), 1))
 
   const tweenedVotes = tweened(votes, {duration: 300})
diff --git a/src/app/components/PollVotes.svelte b/src/app/components/PollVotes.svelte
index 04fbbb40..f335797e 100644
--- a/src/app/components/PollVotes.svelte
+++ b/src/app/components/PollVotes.svelte
@@ -1,20 +1,13 @@
 <script lang="ts">
   import {onDestroy} from "svelte"
-  import type {TrustedEvent} from "@welshman/util"
-  import {POLL_RESPONSE} from "@welshman/util"
-  import {pubkey, publishThunk, abortThunk} from "@welshman/app"
   import {formatTimestampRelative} from "@welshman/lib"
-  import {deriveEvents} from "@app/repository"
-  import {makePollResponse} from "@app/polls"
+  import type {TrustedEvent} from "@welshman/util"
+  import {POLL_RESPONSE, tagSpec, tagValues} from "@welshman/util"
+  import {Poll, PollResponse} from "@welshman/domain"
+  import type {Thunk} from "@welshman/app"
   import PollOption from "@app/components/PollOption.svelte"
-  import {
-    getPollEndsAt,
-    getPollOptions,
-    getPollResponseSelections,
-    getPollResults,
-    getPollType,
-    isPollClosed,
-  } from "@app/polls"
+  import {command, reader, thunks, user, writer} from "@app/core"
+  import {deriveEvents} from "@app/repository"
 
   type Props = {
     url: string
@@ -25,20 +18,14 @@
 
   const responses = deriveEvents([{kinds: [POLL_RESPONSE], "#e": [event.id]}])
 
-  const pollType = getPollType(event)
-  const options = getPollOptions(event)
-  const closed = isPollClosed(event)
-  const endsAt = getPollEndsAt(event)
-
   const getOwnResponse = (responses: TrustedEvent[]) => {
     let latest: TrustedEvent | undefined
 
     for (const response of responses) {
-      if (response.pubkey !== $pubkey) {
-        continue
-      }
-
-      if (!latest || response.created_at > latest.created_at) {
+      if (
+        response.pubkey === $user.pubkey &&
+        (!latest || response.created_at > latest.created_at)
+      ) {
         latest = response
       }
     }
@@ -46,29 +33,31 @@
     return latest
   }
 
-  const publishSelection = (selection: string[]) => {
-    if (activeThunk) {
-      abortThunk(activeThunk)
-    }
+  const publishSelection = async (selection: string[]) => {
+    activeThunk?.abort()
+    activeThunk = undefined
 
-    if (selection.length === 0) {
-      activeThunk = undefined
-      return
-    }
+    if (selection.length > 0) {
+      const eventWriter = writer(PollResponse).forceRelays(url).setPollId(event.id)
 
-    activeThunk = publishThunk({
-      relays: [url],
-      event: makePollResponse({event, selectedIds: selection}),
-      delay: pollType === "multiplechoice" ? 1000 : undefined,
-    })
+      for (const id of selection) {
+        eventWriter.addSelection(id)
+      }
+
+      const responseCommand = await command(eventWriter)
+
+      // Give the user time to check more boxes before the vote actually goes out.
+      activeThunk = $thunks.publish({
+        event: responseCommand.event,
+        relays: responseCommand.relays,
+        delay: pollType === "multiplechoice" ? 1000 : undefined,
+      })
+    }
   }
 
   const publishCurrentSelection = () =>
     publishSelection(pollType === "singlechoice" ? selectedIds.slice(0, 1) : selectedIds)
 
-  const results = $derived(getPollResults(event, $responses))
-  const ownResponse = $derived(getOwnResponse($responses))
-
   const setSingleChoice = (id: string) => {
     selectedIds = [id]
     publishCurrentSelection()
@@ -82,37 +71,51 @@
     publishCurrentSelection()
   }
 
+  const poll = reader(Poll)(event)
   let selectedIds = $state<string[]>([])
-  let activeThunk: ReturnType<typeof publishThunk> | undefined
+  let activeThunk: Thunk | undefined
+
+  const pollType = poll.pollType()
+  const results = $derived(poll.results($responses))
+  const ownResponse = $derived(getOwnResponse($responses))
 
   $effect(() => {
     if (ownResponse) {
-      selectedIds = getPollResponseSelections(ownResponse, pollType)
+      const selections = tagValues(tagSpec("response"), ownResponse.tags)
+
+      selectedIds = pollType === "singlechoice" ? selections.slice(0, 1) : selections
     }
   })
 
   onDestroy(() => {
-    if (activeThunk) {
-      abortThunk(activeThunk)
-    }
+    activeThunk?.abort()
   })
 </script>
 
-<div class="flex flex-col gap-2">
-  {#each options as option (option.id)}
-    <PollOption {event} {option} {results} {selectedIds} {setSingleChoice} {toggleMultipleChoice} />
-  {/each}
-  <div class="flex flex-wrap items-center justify-between gap-2">
-    <div class="text-sm opacity-75">
-      {pollType === "multiplechoice" ? "Multiple choice" : "Single choice"}
-      {#if endsAt}
-        {#if closed}
-          • Ended {formatTimestampRelative(endsAt)}
-        {:else}
-          • Ends {formatTimestampRelative(endsAt)}
+{#if poll && results}
+  {@const endsAt = poll.endsAt()}
+  <div class="flex flex-col gap-2">
+    {#each poll.options() as option (option.id)}
+      <PollOption
+        {event}
+        {option}
+        {results}
+        {selectedIds}
+        {setSingleChoice}
+        {toggleMultipleChoice} />
+    {/each}
+    <div class="flex flex-wrap items-center justify-between gap-2">
+      <div class="text-sm opacity-75">
+        {pollType === "multiplechoice" ? "Multiple choice" : "Single choice"}
+        {#if endsAt}
+          {#if poll.isClosed()}
+            • Ended {formatTimestampRelative(endsAt)}
+          {:else}
+            • Ends {formatTimestampRelative(endsAt)}
+          {/if}
         {/if}
-      {/if}
+      </div>
+      <div class="text-sm opacity-75">{results.voters} vote{results.voters === 1 ? "" : "s"}</div>
     </div>
-    <div class="text-sm opacity-75">{results.voters} vote{results.voters === 1 ? "" : "s"}</div>
   </div>
-</div>
+{/if}
diff --git a/src/app/components/PomadeSessions.svelte b/src/app/components/PomadeSessions.svelte
index ebf6bd6a..dfb564f0 100644
--- a/src/app/components/PomadeSessions.svelte
+++ b/src/app/components/PomadeSessions.svelte
@@ -1,36 +1,21 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {Client} from "@pomade/core"
-  import {session, isPomadeSession} from "@welshman/app"
   import MenuButton from "@lib/components/MenuButton.svelte"
   import Badge from "@lib/components/Badge.svelte"
   import PomadeSessionMenu from "@app/components/PomadeSessionMenu.svelte"
   import {pushToast} from "@app/toast"
-  import {loadOtherPomadeSessions} from "@app/pomade"
+  import {deletePomadeSession, loadOtherPomadeSessions} from "@app/pomade"
   import type {PomadeSessionWithPeers} from "@app/pomade"
 
   let sessions = $state<PomadeSessionWithPeers[]>([])
 
   const deleteSession = async (sessionItem: PomadeSessionWithPeers) => {
-    if (!isPomadeSession($session)) return
-
     try {
-      const client = new Client($session.clientOptions)
-      const result = await client.deleteSession(sessionItem.client, sessionItem.peers)
+      await deletePomadeSession(sessionItem.client, sessionItem.peers)
 
-      if (result.ok) {
-        pushToast({
-          message: "Session deleted successfully",
-        })
+      pushToast({message: "Session deleted successfully"})
 
-        // Remove from local list
-        sessions = sessions.filter(s => s.client !== sessionItem.client)
-      } else {
-        pushToast({
-          theme: "error",
-          message: "Failed to delete session",
-        })
-      }
+      sessions = sessions.filter(s => s.client !== sessionItem.client)
     } catch (e) {
       console.error(e)
       pushToast({
diff --git a/src/app/components/PrimaryNav.svelte b/src/app/components/PrimaryNav.svelte
index cb1b12f7..30c70077 100644
--- a/src/app/components/PrimaryNav.svelte
+++ b/src/app/components/PrimaryNav.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
   import cx from "classnames"
-  import {userProfile} from "@welshman/app"
   import Letter from "@assets/icons/letter.svg?dataurl"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
   import Widget from "@assets/icons/widget-4.svg?dataurl"
@@ -9,15 +8,16 @@
   import Settings from "@assets/icons/settings.svg?dataurl"
   import ImageIcon from "@lib/components/ImageIcon.svelte"
   import Divider from "@lib/components/Divider.svelte"
-  import MenuSettings from "@app/components/MenuSettings.svelte"
   import PrimaryNavItem from "@lib/components/PrimaryNavItem.svelte"
+  import MenuSettings from "@app/components/MenuSettings.svelte"
   import PrimaryNavItemSpace from "@app/components/PrimaryNavItemSpace.svelte"
   import PrimaryNavSpaces from "@app/components/PrimaryNavSpaces.svelte"
-  import {userSpaceUrls} from "@app/groups"
+  import {userSpaceUrls} from "@app/rooms"
   import {PLATFORM_RELAYS} from "@app/env"
   import {pushModal} from "@app/modal"
   import {notifications} from "@app/notifications"
   import {goToChat, makeSpacePath} from "@app/routes"
+  import {deriveUserItem, profiles} from "@app/core"
 
   type Props = {
     children?: Snippet
@@ -25,6 +25,8 @@
 
   const {children}: Props = $props()
 
+  const userProfile = deriveUserItem($app => $profiles)
+
   const chatHandler = () => goToChat()
 
   const showSettingsMenu = () => pushModal(MenuSettings)
@@ -41,8 +43,8 @@
   {/if}
   <div class="flex flex-col items-center">
     <PrimaryNavItem title="Settings" href="/settings/profile" prefix="/settings">
-      {#if $userProfile?.picture}
-        <ImageIcon alt="Settings" src={$userProfile?.picture} class="rounded-full" size={10} />
+      {#if $userProfile?.picture()}
+        <ImageIcon alt="Settings" src={$userProfile.picture()!} class="rounded-full" size={10} />
       {:else}
         <ImageIcon alt="Settings" src={UserRounded} class="rounded-full" size={8} />
       {/if}
@@ -85,8 +87,8 @@
       {/if}
     </div>
     <PrimaryNavItem onclick={showSettingsMenu}>
-      {#if $userProfile?.picture}
-        <ImageIcon alt="Settings" src={$userProfile?.picture} size={10} class="rounded-full" />
+      {#if $userProfile?.picture()}
+        <ImageIcon alt="Settings" src={$userProfile.picture()!} size={10} class="rounded-full" />
       {:else}
         <ImageIcon alt="Settings" src={Settings} size={8} class="rounded-full" />
       {/if}
diff --git a/src/app/components/PrimaryNavItemSpace.svelte b/src/app/components/PrimaryNavItemSpace.svelte
index f6d33606..9cca2c04 100644
--- a/src/app/components/PrimaryNavItemSpace.svelte
+++ b/src/app/components/PrimaryNavItemSpace.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
-  import {deriveRelayDisplay} from "@welshman/app"
   import PrimaryNavItem from "@lib/components/PrimaryNavItem.svelte"
   import RelayIcon from "@app/components/RelayIcon.svelte"
+  import {relays} from "@app/core"
   import {makeSpacePath, goToSpace} from "@app/routes"
   import {notifications} from "@app/notifications"
 
@@ -16,7 +16,7 @@
 
   const path = makeSpacePath(url)
 
-  const display = $derived(deriveRelayDisplay(url))
+  const display = $relays.display(url).$
 </script>
 
 <PrimaryNavItem
diff --git a/src/app/components/PrimaryNavSpaces.svelte b/src/app/components/PrimaryNavSpaces.svelte
index 978fb437..89ac0961 100644
--- a/src/app/components/PrimaryNavSpaces.svelte
+++ b/src/app/components/PrimaryNavSpaces.svelte
@@ -7,7 +7,7 @@
   import PrimaryNavItem from "@lib/components/PrimaryNavItem.svelte"
   import PrimaryNavItemSpace from "@app/components/PrimaryNavItemSpace.svelte"
   import PrimaryNavSpacesOverflow from "@app/components/PrimaryNavSpacesOverflow.svelte"
-  import {userSpaceUrls} from "@app/groups"
+  import {userSpaceUrls} from "@app/rooms"
   import {PLATFORM_RELAYS, PLATFORM_LOGO} from "@app/env"
   import {notifications} from "@app/notifications"
 
diff --git a/src/app/components/Profile.svelte b/src/app/components/Profile.svelte
index 8c7077bd..d266f788 100644
--- a/src/app/components/Profile.svelte
+++ b/src/app/components/Profile.svelte
@@ -1,16 +1,16 @@
 <script lang="ts">
   import * as nip19 from "nostr-tools/nip19"
-  import {removeUndefined} from "@welshman/lib"
-  import {displayPubkey} from "@welshman/util"
-  import {deriveHandleForPubkey, displayHandle, deriveProfileDisplay} from "@welshman/app"
+  import {displayHandle} from "@welshman/util"
+  import {displayPubkey} from "@welshman/domain"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
+  import Copy from "@assets/icons/copy.svg?dataurl"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import WotScore from "@app/components/WotScore.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
   import {pushModal} from "@app/modal"
   import {clip} from "@app/toast"
-  import Copy from "@assets/icons/copy.svg?dataurl"
+  import {handles, profiles} from "@app/core"
 
   type Props = {
     pubkey: string
@@ -22,9 +22,8 @@
 
   const {pubkey, url, showPubkey, inert, avatarSize = 10}: Props = $props()
 
-  const relays = removeUndefined([url])
-  const profileDisplay = deriveProfileDisplay(pubkey, relays)
-  const handle = deriveHandleForPubkey(pubkey)
+  const profileDisplay = $profiles.display(pubkey).$
+  const handle = $handles.forPubkey(pubkey).$
 
   const openProfile = () => {
     pushModal(ProfileDetail, {pubkey, url})
diff --git a/src/app/components/ProfileAbout.svelte b/src/app/components/ProfileAbout.svelte
index 525b770e..b8d8bef7 100644
--- a/src/app/components/ProfileAbout.svelte
+++ b/src/app/components/ProfileAbout.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {removeUndefined} from "@welshman/lib"
-  import {deriveProfile} from "@welshman/app"
   import ContentMinimal from "@app/components/ContentMinimal.svelte"
+  import {profiles} from "@app/core"
 
   export type Props = {
     pubkey: string
@@ -11,9 +11,9 @@
 
   const {pubkey, url, singleLine}: Props = $props()
 
-  const profile = deriveProfile(pubkey, removeUndefined([url]))
+  const profile = $profiles.one(pubkey, removeUndefined([url]))
 </script>
 
 {#if $profile}
-  <ContentMinimal event={{content: $profile.about || "", tags: []}} {singleLine} />
+  <ContentMinimal event={{content: $profile.about() || "", tags: []}} {singleLine} />
 {/if}
diff --git a/src/app/components/ProfileBadges.svelte b/src/app/components/ProfileBadges.svelte
index 6c3c2c8d..45cac751 100644
--- a/src/app/components/ProfileBadges.svelte
+++ b/src/app/components/ProfileBadges.svelte
@@ -1,15 +1,11 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {load} from "@welshman/net"
-  import {Router} from "@welshman/router"
-  import type {Filter} from "@welshman/util"
-  import {deriveEventsDesc, deriveEventsById} from "@welshman/store"
   import {formatTimestampRelative} from "@welshman/lib"
-  import {NOTE, ROOMS, COMMENT, MESSAGE} from "@welshman/util"
-  import {repository, loadRelayList} from "@welshman/app"
+  import {NOTE, ROOMS, COMMENT, MESSAGE, outbox} from "@welshman/util"
   import Button from "@lib/components/Button.svelte"
   import ProfileSpaces from "@app/components/ProfileSpaces.svelte"
-  import {deriveGroupList, getSpaceUrlsFromGroupList} from "@app/groups"
+  import {network, relayLists, roomLists, router} from "@app/core"
+  import {deriveEvents} from "@app/repository"
   import {goToEvent} from "@app/routes"
   import {pushModal} from "@app/modal"
 
@@ -19,24 +15,24 @@
   }
 
   const {pubkey, url}: Props = $props()
-  const filters: Filter[] = [{authors: [pubkey], limit: 1}]
-  const events = deriveEventsDesc(deriveEventsById({repository, filters}))
-  const groupList = deriveGroupList(pubkey)
-  const spaceUrls = $derived(getSpaceUrlsFromGroupList($groupList))
+
+  const events = deriveEvents([{authors: [pubkey], limit: 1}])
+
+  const spaceUrls = $roomLists.urls(pubkey).$
 
   const viewEvent = () => goToEvent($events[0]!)
 
   const openSpaces = () => pushModal(ProfileSpaces, {pubkey, url})
 
   onMount(async () => {
-    await loadRelayList(pubkey)
+    await $relayLists.load(pubkey)
 
-    load({
+    $network.load({
       filters: [
         {authors: [pubkey], kinds: [ROOMS]},
         {authors: [pubkey], limit: 1, kinds: [NOTE, COMMENT, MESSAGE]},
       ],
-      relays: Router.get().FromPubkeys([pubkey]).getUrls(),
+      relays: await $router.resolver.relays([outbox(pubkey)]),
     })
   })
 </script>
@@ -47,10 +43,10 @@
       Last active {formatTimestampRelative($events[0].created_at)}
     </Button>
   {/if}
-  {#if spaceUrls.length > 0}
+  {#if $spaceUrls.length > 0}
     <Button onclick={openSpaces} class="badge badge-neutral">
-      {spaceUrls.length}
-      {spaceUrls.length === 1 ? "space" : "spaces"}
+      {$spaceUrls.length}
+      {$spaceUrls.length === 1 ? "space" : "spaces"}
     </Button>
   {/if}
 </div>
diff --git a/src/app/components/ProfileCircle.svelte b/src/app/components/ProfileCircle.svelte
index d1f7f56f..94377701 100644
--- a/src/app/components/ProfileCircle.svelte
+++ b/src/app/components/ProfileCircle.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
   import cx from "classnames"
   import {removeUndefined} from "@welshman/lib"
-  import {deriveProfile} from "@welshman/app"
   import UserRounded from "@assets/icons/user-rounded.svg?dataurl"
   import ImageIcon from "@lib/components/ImageIcon.svelte"
+  import {profiles} from "@app/core"
 
   type Props = {
     pubkey?: string
@@ -15,7 +15,7 @@
 
   const {pubkey, url, size = 7, style = undefined, ...props}: Props = $props()
 
-  const profile = deriveProfile(pubkey, removeUndefined([url]))
+  const profile = $profiles.one(pubkey, removeUndefined([url]))
 </script>
 
 <ImageIcon
@@ -23,4 +23,4 @@
   {style}
   alt=""
   class={cx(props.class, "rounded-full")}
-  src={$profile?.picture || UserRounded} />
+  src={$profile?.picture() || UserRounded} />
diff --git a/src/app/components/ProfileCircles.svelte b/src/app/components/ProfileCircles.svelte
index bab5c875..49a5799b 100644
--- a/src/app/components/ProfileCircles.svelte
+++ b/src/app/components/ProfileCircles.svelte
@@ -1,8 +1,8 @@
 <script lang="ts">
   import cx from "classnames"
-  import {loadProfile} from "@welshman/app"
   import {isMobile} from "@lib/html"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
+  import {profiles} from "@app/core"
 
   type Props = {
     pubkeys: string[]
@@ -24,7 +24,7 @@
 
   $effect(() => {
     for (const pk of pubkeys) {
-      loadProfile(pk)
+      $profiles.load(pk)
     }
   })
 
diff --git a/src/app/components/ProfileDelete.svelte b/src/app/components/ProfileDelete.svelte
index 065b19fd..4efa397a 100644
--- a/src/app/components/ProfileDelete.svelte
+++ b/src/app/components/ProfileDelete.svelte
@@ -1,15 +1,7 @@
 <script lang="ts">
   import {chunk, sleep, uniq} from "@welshman/lib"
-  import {
-    makeEvent,
-    createProfile,
-    PROFILE,
-    DELETE,
-    isReplaceable,
-    getAddress,
-    RelayMode,
-  } from "@welshman/util"
-  import {pubkey, publishThunk, repository, derivePubkeyRelays} from "@welshman/app"
+  import {makeEvent, DELETE, isReplaceable, getAddress} from "@welshman/util"
+  import {Profile} from "@welshman/domain"
   import {preventDefault} from "@lib/html"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
@@ -23,15 +15,16 @@
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
   import {INDEXER_RELAYS, PLATFORM_NAME} from "@app/env"
-  import {userSpaceUrls} from "@app/groups"
+  import {userSpaceUrls} from "@app/rooms"
   import {pushToast} from "@app/toast"
   import {logout} from "@app/session"
+  import {app, relayLists, thunks, user, writer} from "@app/core"
 
   let progress: number | undefined = $state(undefined)
   let confirmText = $state("")
 
   const CONFIRM_TEXT = "permanently delete my nostr account"
-  const userWriteRelays = derivePubkeyRelays($pubkey!, RelayMode.Write)
+  const userWriteRelays = $relayLists.writeUrls($user.pubkey).$
   const confirmOk = $derived(confirmText.toLowerCase().trim() === CONFIRM_TEXT)
   const showProgress = $derived(progress !== undefined)
 
@@ -43,8 +36,8 @@
       })
     }
 
-    const chunks = chunk(500, repository.query([{authors: [$pubkey!]}]))
-    const profileEvent = makeEvent(PROFILE, createProfile({name: "[deleted]"}))
+    const chunks = chunk(500, $app.repository.query([{authors: [$user.pubkey]}]))
+    const profileEvent = await writer(Profile).setName("[deleted]").renderTemplate()
     const vanishEvent = makeEvent(62, {tags: [["relay", "ALL_RELAYS"]]})
     const denominator = chunks.length + 2
     const relays = uniq([...INDEXER_RELAYS, ...$userWriteRelays, ...$userSpaceUrls])
@@ -58,12 +51,12 @@
     }
 
     // First, blank out their profile in case relays don't support deletion by address
-    await publishThunk({relays, event: profileEvent})
+    await $thunks.publish({relays, event: profileEvent})
 
     await incrementProgress()
 
     // Next, send a "right to vanish" event to all relays
-    await publishThunk({relays, event: vanishEvent})
+    await $thunks.publish({relays, event: vanishEvent})
 
     await incrementProgress()
 
@@ -79,7 +72,7 @@
         }
       }
 
-      await publishThunk({relays, event: makeEvent(DELETE, {tags})})
+      await $thunks.publish({relays, event: makeEvent(DELETE, {tags})})
 
       await incrementProgress()
     }
diff --git a/src/app/components/ProfileDetail.svelte b/src/app/components/ProfileDetail.svelte
index 80c3f763..2a0fdcdd 100644
--- a/src/app/components/ProfileDetail.svelte
+++ b/src/app/components/ProfileDetail.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {onMount} from "svelte"
   import {goto} from "$app/navigation"
-  import {displayProfileByPubkey, loadMessagingRelayList} from "@welshman/app"
+  import {spec} from "@welshman/lib"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import UserCircle from "@assets/icons/user-circle.svg?dataurl"
   import MinusCircle from "@assets/icons/minus-circle.svg?dataurl"
@@ -17,13 +17,8 @@
   import ProfileAbout from "@app/components/ProfileAbout.svelte"
   import ProfileBadges from "@app/components/ProfileBadges.svelte"
   import ProfileMenu from "@app/components/ProfileMenu.svelte"
-  import {
-    deriveUserIsSpaceAdmin,
-    deriveSpaceBannedPubkeyItems,
-    removeSpaceMembers,
-    addSpaceMembers,
-    banSpaceMembers,
-  } from "@app/members"
+  import {messagingRelayLists, profiles, relayManagement} from "@app/core"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
   import {makeProfilePath} from "@app/routes"
@@ -37,54 +32,57 @@
 
   const userIsAdmin = deriveUserIsSpaceAdmin(url)
 
-  const bannedPubkeys = url ? deriveSpaceBannedPubkeyItems(url) : undefined
-
-  const isBanned = $derived($bannedPubkeys?.some(item => item.pubkey === pubkey) ?? false)
-
   const back = () => history.back()
 
   const viewProfile = () => goto(makeProfilePath(pubkey), {replaceState: true})
 
+  const report = (error: string | undefined, message: string) => {
+    if (error) {
+      pushToast({theme: "error", message: error})
+    } else {
+      pushToast({message})
+      back()
+    }
+  }
+
   const banMember = () =>
     pushModal(Confirm, {
       title: "Ban User",
-      message: `Are you sure you want to ban @${displayProfileByPubkey(pubkey)} from the space?`,
+      message: `Are you sure you want to ban @${$profiles.display(pubkey).get()} from the space?`,
       confirm: async () => {
-        const error = await banSpaceMembers(url!, [pubkey])
+        const {error} = await $relayManagement.forUrl(url!).banPubkey(pubkey)
 
-        if (error) {
-          pushToast({theme: "error", message: error})
-        } else {
-          pushToast({message: "User has successfully been banned!"})
-          back()
-        }
+        report(error, "User has successfully been banned!")
       },
     })
 
   const removeMember = async () => {
-    const error = await removeSpaceMembers(url!, [pubkey])
+    const {error} = await $relayManagement.forUrl(url!).unallowPubkey(pubkey)
 
-    if (error) {
-      pushToast({theme: "error", message: error})
-    } else {
-      pushToast({message: "User has successfully been removed!"})
-      back()
-    }
+    report(error, "User has successfully been removed!")
   }
 
   const restoreMember = async () => {
-    const error = await addSpaceMembers(url!, [pubkey])
+    const {error} = await $relayManagement.forUrl(url!).allowPubkey(pubkey)
 
-    if (error) {
-      pushToast({theme: "error", message: error})
-    } else {
-      pushToast({message: "User has successfully been restored!"})
-      back()
-    }
+    report(error, "User has successfully been restored!")
   }
 
+  let isBanned = $state(false)
+
+  $effect(() => {
+    if (url && $userIsAdmin) {
+      $relayManagement
+        .forUrl(url)
+        .listBannedPubkeys()
+        .then(({result = []}) => {
+          isBanned = result.some(spec({pubkey}))
+        })
+    }
+  })
+
   onMount(() => {
-    loadMessagingRelayList(pubkey)
+    $messagingRelayLists.load(pubkey)
   })
 </script>
 
diff --git a/src/app/components/ProfileEdit.svelte b/src/app/components/ProfileEdit.svelte
index 07c23819..bfceff9d 100644
--- a/src/app/components/ProfileEdit.svelte
+++ b/src/app/components/ProfileEdit.svelte
@@ -1,27 +1,25 @@
 <script lang="ts">
-  import type {Profile} from "@welshman/util"
-  import {makeProfile} from "@welshman/util"
-  import {pubkey, profilesByPubkey, waitForThunkError} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import {errorMessage} from "@lib/util"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import ProfileEditForm from "@app/components/ProfileEditForm.svelte"
+  import type {Values} from "@app/components/ProfileEditForm.svelte"
   import {clearModals} from "@app/modal"
   import {pushToast} from "@app/toast"
-  import {updateProfile} from "@app/profiles"
+  import {profiles, user} from "@app/core"
 
-  const profile = $profilesByPubkey.get($pubkey!) || makeProfile()
-  const initialValues = {profile}
+  const initialValues = {profile: {...$profiles.get($user.pubkey)?.values}}
 
   const back = () => history.back()
 
-  const onsubmit = async ({profile}: {profile: Profile}) => {
+  const onsubmit = async ({profile}: Values) => {
     loading = true
 
     try {
-      const error = await waitForThunkError(updateProfile({profile}))
+      const command = await $profiles.update(writer => writer.update(profile))
+      const error = await command.publish().waitForError()
 
       if (error) {
         pushToast({
diff --git a/src/app/components/ProfileEditForm.svelte b/src/app/components/ProfileEditForm.svelte
index f00023c3..09117a42 100644
--- a/src/app/components/ProfileEditForm.svelte
+++ b/src/app/components/ProfileEditForm.svelte
@@ -1,6 +1,22 @@
+<script module lang="ts">
+  export type ProfileValues = {
+    name?: string
+    about?: string
+    picture?: string
+    banner?: string
+    website?: string
+    nip05?: string
+    lud06?: string
+    lud16?: string
+  }
+
+  export type Values = {
+    profile: ProfileValues
+  }
+</script>
+
 <script lang="ts">
   import type {Snippet} from "svelte"
-  import type {Profile} from "@welshman/util"
   import {preventDefault} from "@lib/html"
   import UserCircle from "@assets/icons/user-circle.svg?dataurl"
   import MapPoint from "@assets/icons/map-point.svg?dataurl"
@@ -15,10 +31,6 @@
   import InfoHandle from "@app/components/InfoHandle.svelte"
   import {pushModal} from "@app/modal"
 
-  type Values = {
-    profile: Profile
-  }
-
   type Props = {
     initialValues: Values
     onsubmit: (values: Values) => void
diff --git a/src/app/components/ProfileFeed.svelte b/src/app/components/ProfileFeed.svelte
index 3555ccc4..836052dc 100644
--- a/src/app/components/ProfileFeed.svelte
+++ b/src/app/components/ProfileFeed.svelte
@@ -2,24 +2,26 @@
   import {onMount} from "svelte"
   import {sortBy, uniqBy} from "@welshman/lib"
   import {feedFromFilter, makeIntersectionFeed, makeRelayFeed} from "@welshman/feeds"
-  import {NOTE, getReplyTags} from "@welshman/util"
+  import {NOTE} from "@welshman/util"
   import type {TrustedEvent} from "@welshman/util"
-  import {makeFeedController} from "@welshman/app"
+  import {getReplyTags} from "@welshman/domain"
+  import {Feeds} from "@welshman/app"
   import {createScroller} from "@lib/html"
   import {fly} from "@lib/transition"
   import Spinner from "@lib/components/Spinner.svelte"
   import NoteItem from "@app/components/NoteItem.svelte"
+  import {app} from "@app/core"
 
-  interface Props {
-    url: any
-    pubkey: any
+  type Props = {
+    url: string
+    pubkey: string
     events?: TrustedEvent[]
     hideLoading?: boolean
   }
 
   let {url, pubkey, events = $bindable([]), hideLoading = false}: Props = $props()
 
-  const ctrl = makeFeedController({
+  const ctrl = $app.use(Feeds).makeFeedController({
     useWindowing: true,
     feed: makeIntersectionFeed(
       makeRelayFeed(url),
diff --git a/src/app/components/ProfileInfo.svelte b/src/app/components/ProfileInfo.svelte
index 8b326d06..21db813a 100644
--- a/src/app/components/ProfileInfo.svelte
+++ b/src/app/components/ProfileInfo.svelte
@@ -1,10 +1,9 @@
 <script lang="ts">
   import * as nip19 from "nostr-tools/nip19"
-  import {Router} from "@welshman/router"
+  import {onMount} from "svelte"
   import {call, LOCALE, secondsToDate} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {displayRelayUrl, toNostrURI} from "@welshman/util"
-  import {tracker} from "@welshman/app"
+  import {displayRelayUrl, outbox, toNostrURI} from "@welshman/util"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Copy from "@assets/icons/copy.svg?dataurl"
   import UserId from "@assets/icons/user-id.svg?dataurl"
@@ -18,6 +17,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
+  import {app, router} from "@app/core"
   import {clip} from "@app/toast"
 
   type Props = {
@@ -27,10 +27,8 @@
 
   const {url, event}: Props = $props()
 
-  const relays = url ? [url] : Router.get().FromPubkeys([event.pubkey]).getUrls()
-  const nprofile1 = toNostrURI(nip19.nprofileEncode({pubkey: event.pubkey, relays}))
   const npub1 = nip19.npubEncode(event.pubkey)
-  const seenOn = tracker.getRelays(event.id)
+  const seenOn = $app.tracker.getRelays(event.id)
   const json = call(() => {
     try {
       return JSON.stringify(JSON.parse(event.content), null, 2)
@@ -47,6 +45,14 @@
     dateStyle: "long",
     timeStyle: "long",
   })
+
+  let nprofile1 = $state("")
+
+  onMount(async () => {
+    const relays = url ? [url] : await $router.resolver.relays([outbox(event.pubkey)])
+
+    nprofile1 = toNostrURI(nip19.nprofileEncode({pubkey: event.pubkey, relays}))
+  })
 </script>
 
 <Modal>
@@ -98,9 +104,9 @@
         {/snippet}
         {#snippet input()}
           <div class="flex flex-wrap gap-2">
-            {#each seenOn as url, i (url)}
+            {#each seenOn as seenUrl (seenUrl)}
               <Badge class="bg-surface flex gap-1">
-                {displayRelayUrl(url)}
+                {displayRelayUrl(seenUrl)}
               </Badge>
             {/each}
           </div>
diff --git a/src/app/components/ProfileLatest.svelte b/src/app/components/ProfileLatest.svelte
index 94c568df..0e42c9f6 100644
--- a/src/app/components/ProfileLatest.svelte
+++ b/src/app/components/ProfileLatest.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
-  import {load} from "@welshman/net"
   import {NOTE} from "@welshman/util"
   import Spinner from "@lib/components/Spinner.svelte"
   import NoteItem from "@app/components/NoteItem.svelte"
+  import {network} from "@app/core"
 
   interface Props {
     url: string
@@ -14,7 +14,7 @@
 
   const {url, pubkey, limit = 1, fallback}: Props = $props()
 
-  const events = load({
+  const events = $network.load({
     relays: [url],
     filters: [{authors: [pubkey], kinds: [NOTE], limit}],
   })
diff --git a/src/app/components/ProfileList.svelte b/src/app/components/ProfileList.svelte
index f1fe3258..3a56e743 100644
--- a/src/app/components/ProfileList.svelte
+++ b/src/app/components/ProfileList.svelte
@@ -8,14 +8,14 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import Profile from "@app/components/Profile.svelte"
 
-  interface Props {
-    title: any
-    pubkeys: any
+  type Props = {
+    title: string
+    pubkeys: string[]
     subtitle?: string
     url?: string
   }
 
-  const {subtitle = "", pubkeys, url, ...restProps}: Props = $props()
+  const {title, subtitle = "", pubkeys, url}: Props = $props()
 
   const back = () => history.back()
 </script>
@@ -23,7 +23,7 @@
 <Modal>
   <ModalBody>
     <ModalHeader>
-      <ModalTitle>{restProps.title}</ModalTitle>
+      <ModalTitle>{title}</ModalTitle>
       <ModalSubtitle>{subtitle}</ModalSubtitle>
     </ModalHeader>
     {#each pubkeys as pubkey (pubkey)}
diff --git a/src/app/components/ProfileMenuList.svelte b/src/app/components/ProfileMenuList.svelte
index 11f0cf97..a099281f 100644
--- a/src/app/components/ProfileMenuList.svelte
+++ b/src/app/components/ProfileMenuList.svelte
@@ -1,13 +1,13 @@
 <script lang="ts">
   import {onMount} from "svelte"
   import type {Snippet} from "svelte"
-  import {deriveProfile} from "@welshman/app"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
   import ShareCircle from "@assets/icons/share-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import ProfileInfo from "@app/components/ProfileInfo.svelte"
   import ProfileQrCode from "@app/components/ProfileQrCode.svelte"
+  import {profiles} from "@app/core"
   import {pushModal} from "@app/modal"
 
   type Props = {
@@ -19,7 +19,7 @@
 
   const {pubkey, url, onClick, customActions}: Props = $props()
 
-  const profile = deriveProfile(pubkey)
+  const profile = $profiles.one(pubkey)
 
   const showInfo = () => pushModal(ProfileInfo, {event: $profile!.event, url})
 
diff --git a/src/app/components/ProfileMultiSelect.svelte b/src/app/components/ProfileMultiSelect.svelte
index 469fc678..2a74bcf0 100644
--- a/src/app/components/ProfileMultiSelect.svelte
+++ b/src/app/components/ProfileMultiSelect.svelte
@@ -3,7 +3,6 @@
   import type {Writable} from "svelte/store"
   import {type Instance} from "tippy.js"
   import {append, remove, uniq} from "@welshman/lib"
-  import {profileSearch} from "@welshman/app"
   import {decodePubkey} from "@lib/util"
   import Suggestions from "@lib/components/Suggestions.svelte"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
@@ -15,9 +14,10 @@
   import ProfileSuggestion from "@app/editor/ProfileSuggestion.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
+  import {profiles} from "@app/core"
   import {pushModal} from "@app/modal"
 
-  interface Props {
+  type Props = {
     value: string[]
     autofocus?: boolean
     term?: Writable<string>
@@ -25,6 +25,8 @@
 
   let {value = $bindable(), term = writable(""), autofocus = false}: Props = $props()
 
+  const profileSearch = $profiles.profileSearch
+
   const search = (term: string) => $profileSearch.searchValues(term)
 
   const selectPubkey = (pubkey: string) => {
diff --git a/src/app/components/ProfileName.svelte b/src/app/components/ProfileName.svelte
index 075c779a..2e602e98 100644
--- a/src/app/components/ProfileName.svelte
+++ b/src/app/components/ProfileName.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import {removeUndefined} from "@welshman/lib"
-  import {deriveProfileDisplay} from "@welshman/app"
+  import {profiles} from "@app/core"
 
   type Props = {
     pubkey: string
@@ -9,7 +9,7 @@
 
   const {pubkey, url}: Props = $props()
 
-  const profileDisplay = deriveProfileDisplay(pubkey, removeUndefined([url]))
+  const profileDisplay = $profiles.display(pubkey, removeUndefined([url])).$
 </script>
 
 {$profileDisplay}
diff --git a/src/app/components/ProfilePage.svelte b/src/app/components/ProfilePage.svelte
index 2b308846..ab0fcfa1 100644
--- a/src/app/components/ProfilePage.svelte
+++ b/src/app/components/ProfilePage.svelte
@@ -1,17 +1,7 @@
 <script lang="ts">
   import * as nip19 from "nostr-tools/nip19"
-  import {displayPubkey} from "@welshman/util"
-  import {
-    pubkey,
-    followLists,
-    deriveProfile,
-    deriveProfileDisplay,
-    getFollows,
-    follow,
-    unfollow,
-    tagPubkey,
-    loadRelayList,
-  } from "@welshman/app"
+  import {publish} from "@welshman/app"
+  import {displayPubkey} from "@welshman/domain"
   import Copy from "@assets/icons/copy.svg?dataurl"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Letter from "@assets/icons/letter-opened.svg?dataurl"
@@ -30,11 +20,11 @@
   import ProfileEdit from "@app/components/ProfileEdit.svelte"
   import ProfileMenu from "@app/components/ProfileMenu.svelte"
   import WotScore from "@app/components/WotScore.svelte"
-  import {updateProfile} from "@app/profiles"
   import {compressFileForUpload, uploadFile} from "@app/uploads"
   import {pushModal} from "@app/modal"
   import {clip, pushToast} from "@app/toast"
   import {goToChat} from "@app/routes"
+  import {followLists, profiles, relayLists, user} from "@app/core"
 
   type Props = {
     pubkey: string
@@ -42,19 +32,16 @@
 
   const {pubkey: target}: Props = $props()
 
-  const profile = deriveProfile(target)
-  const profileDisplay = deriveProfileDisplay(target)
-  const isSelf = $derived($pubkey === target)
-  const isFollowing = $derived.by(() => {
-    void $followLists
-
-    return $pubkey ? getFollows($pubkey).includes(target) : false
-  })
-  const website = $derived($profile?.website?.replace(/^https?:\/\//, ""))
+  const profile = $profiles.one(target)
+  const profileDisplay = $profiles.display(target).$
+  const isSelf = $derived($user.pubkey === target)
+  const follows = $derived($followLists.one($user.pubkey))
+  const isFollowing = $derived(($follows?.pubkeys() ?? []).includes(target))
+  const website = $derived($profile?.website()?.replace(/^https?:\/\//, ""))
   const websiteHref = $derived(
-    $profile?.website?.match(/^https?:\/\//)
-      ? $profile.website
-      : `https://${$profile?.website || ""}`,
+    website && $profile?.website()?.match(/^https?:\/\//)
+      ? $profile.website()!
+      : `https://${website || ""}`,
   )
 
   let bannerLoading = $state(false)
@@ -67,12 +54,12 @@
   const openChat = () => goToChat([target])
 
   const toggleFollow = async () => {
-    if (!$pubkey || isSelf) return
+    if (isSelf) return
 
     if (isFollowing) {
-      await unfollow(target)
+      await $followLists.unfollow(target).then(publish)
     } else {
-      await follow(tagPubkey(target))
+      await $followLists.follow(["p", target]).then(publish)
     }
   }
 
@@ -92,7 +79,10 @@
       const {result} = await uploadFile(await compressFileForUpload(file))
 
       if (result?.url) {
-        await updateProfile({profile: {...$profile, banner: result.url}})
+        const command = await $profiles.update(w => w.setBanner(result.url))
+
+        await command.publish().waitForCompletion()
+
         pushToast({message: "Banner updated."})
       }
     } finally {
@@ -105,8 +95,8 @@
   <div class="flex flex-col gap-3 xl:flex-row xl:items-start">
     <div class="min-w-0 flex-1 overflow-hidden border-line bg-surface md:rounded-3xl md:border">
       <div class="relative overflow-hidden border-b border-line bg-surface-more">
-        {#if $profile?.banner}
-          <img src={$profile.banner} alt="" class="h-28 w-full object-cover sm:h-32 md:h-40" />
+        {#if $profile?.banner()}
+          <img src={$profile.banner()} alt="" class="h-28 w-full object-cover sm:h-32 md:h-40" />
         {:else}
           <div class="h-28 w-full bg-linear-to-br from-surface-more to-surface sm:h-32 md:h-40">
           </div>
@@ -159,7 +149,7 @@
                         <Icon icon={PenNewSquare} size={4} />
                         Edit profile
                       </Button>
-                    {:else if $pubkey}
+                    {:else}
                       <Button
                         class="button button-neutral flex-1 sm:button-sm sm:flex-none"
                         onclick={toggleFollow}>
@@ -200,7 +190,7 @@
                 </Link>
               {/if}
 
-              {#if $profile?.about}
+              {#if $profile?.about()}
                 <ProfileAbout pubkey={target} />
               {/if}
             </div>
@@ -214,7 +204,7 @@
             <ProfileTrust pubkey={target} {isSelf} />
             <ProfileSharedSpaces pubkey={target} {isSelf} />
           </div>
-          {#await loadRelayList(target)}
+          {#await $relayLists.load(target)}
             <p class="my-12 flex items-center justify-center gap-2">
               <Spinner loading />
               Loading notes...
diff --git a/src/app/components/ProfilePageNotes.svelte b/src/app/components/ProfilePageNotes.svelte
index 45106bee..a0277900 100644
--- a/src/app/components/ProfilePageNotes.svelte
+++ b/src/app/components/ProfilePageNotes.svelte
@@ -3,14 +3,14 @@
   import {derived, writable} from "svelte/store"
   import type {Writable} from "svelte/store"
   import {sortBy, uniqBy, now} from "@welshman/lib"
-  import {NOTE, getReplyTags, getListTags, getEventTagValues} from "@welshman/util"
+  import {NOTE, outbox} from "@welshman/util"
   import type {TrustedEvent} from "@welshman/util"
-  import {derivePinList} from "@welshman/app"
-  import {Router} from "@welshman/router"
-  import {load} from "@welshman/net"
+  import {getReplyTags} from "@welshman/domain"
+  import {PinLists} from "@welshman/app"
   import {fly} from "@lib/transition"
   import Spinner from "@lib/components/Spinner.svelte"
   import NoteItem from "@app/components/NoteItem.svelte"
+  import {app, network, router} from "@app/core"
   import {makeFeed} from "@app/feeds"
 
   type Props = {
@@ -19,19 +19,21 @@
 
   const {pubkey}: Props = $props()
 
-  const pinList = derivePinList(pubkey)
-  const pinnedIds = derived(pinList, $pinList => getEventTagValues(getListTags($pinList)))
+  const relays = $router.resolver.relays([outbox(pubkey)])
+  const pinnedIds = derived($app.use(PinLists).one(pubkey), $pinList => $pinList?.ids() ?? [])
 
   $effect(() => {
     if ($pinnedIds.length > 0) {
       const controller = new AbortController()
 
-      load({
-        relays: Router.get().FromPubkeys([pubkey]).getUrls(),
-        filters: [{ids: $pinnedIds}],
-        signal: controller.signal,
-        onEvent: e => events.update($events => uniqBy(e => e.id, $events.concat(e))),
-      })
+      relays.then($relays =>
+        $network.load({
+          relays: $relays,
+          filters: [{ids: $pinnedIds}],
+          signal: controller.signal,
+          onEvent: e => events.update($events => uniqBy(e => e.id, $events.concat(e))),
+        }),
+      )
 
       return () => controller.abort()
     }
@@ -49,18 +51,23 @@
   )
 
   onMount(() => {
-    const feed = makeFeed({
-      relays: Router.get().FromPubkeys([pubkey]).getUrls(),
-      element: element!,
-      filters: [{kinds: [NOTE], authors: [pubkey]}],
-      onBackwardExhausted: () => {
-        exhausted = true
-      },
+    let cleanup: (() => void) | undefined
+
+    relays.then($relays => {
+      const feed = makeFeed({
+        relays: $relays,
+        element: element!,
+        filters: [{kinds: [NOTE], authors: [pubkey]}],
+        onBackwardExhausted: () => {
+          exhausted = true
+        },
+      })
+
+      events = feed.events
+      cleanup = feed.cleanup
     })
 
-    events = feed.events
-
-    return () => feed.cleanup()
+    return () => cleanup?.()
   })
 </script>
 
diff --git a/src/app/components/ProfileSharedSpaces.svelte b/src/app/components/ProfileSharedSpaces.svelte
index d6e29bb0..5b5ce938 100644
--- a/src/app/components/ProfileSharedSpaces.svelte
+++ b/src/app/components/ProfileSharedSpaces.svelte
@@ -6,12 +6,8 @@
   import Link from "@lib/components/Link.svelte"
   import RelayIcon from "@app/components/RelayIcon.svelte"
   import RelayName from "@app/components/RelayName.svelte"
-  import {
-    groupListPubkeysByUrl,
-    userSpaceUrls,
-    deriveGroupList,
-    getSpaceUrlsFromGroupList,
-  } from "@app/groups"
+  import {userSpaceUrls} from "@app/rooms"
+  import {roomLists} from "@app/core"
   import {makeSpacePath} from "@app/routes"
 
   type Props = {
@@ -22,8 +18,8 @@
 
   const {pubkey, isSelf = false, ...props}: Props = $props()
 
-  const groupList = deriveGroupList(pubkey)
-  const spaceUrls = $derived(getSpaceUrlsFromGroupList($groupList))
+  const roomList = $roomLists.one(pubkey)
+  const spaceUrls = $derived($roomList?.urls() ?? [])
 </script>
 
 <div class={cx("card card-sm flex flex-col gap-3 sm:gap-4", props.class)}>
@@ -37,7 +33,7 @@
   {#if spaceUrls.length > 0}
     <div class="flex flex-col gap-2 border-t border-line pt-4">
       {#each spaceUrls as url (url)}
-        {@const count = $groupListPubkeysByUrl.get(url)?.size || 0}
+        {@const count = $roomLists.pubkeysForUrl(url).get().length}
         {@const isMember = !isSelf && $userSpaceUrls.includes(url)}
         <Link
           href={makeSpacePath(url)}
diff --git a/src/app/components/ProfileSpaces.svelte b/src/app/components/ProfileSpaces.svelte
index 936f1f26..9e816ef3 100644
--- a/src/app/components/ProfileSpaces.svelte
+++ b/src/app/components/ProfileSpaces.svelte
@@ -7,8 +7,8 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import RelayIcon from "@app/components/RelayIcon.svelte"
   import RelayName from "@app/components/RelayName.svelte"
+  import {roomLists} from "@app/core"
   import {makeSpacePath} from "@app/routes"
-  import {deriveGroupList, getSpaceUrlsFromGroupList} from "@app/groups"
 
   type Props = {
     pubkey: string
@@ -16,14 +16,13 @@
 
   const {pubkey}: Props = $props()
 
-  const groupList = deriveGroupList(pubkey)
-  const spaceUrls = $derived(getSpaceUrlsFromGroupList($groupList))
+  const spaceUrls = $roomLists.urls(pubkey).$
 
   const back = () => history.back()
 </script>
 
 <div class="flex flex-col gap-2">
-  {#each spaceUrls as url (url)}
+  {#each $spaceUrls as url (url)}
     <div class="card flex flex-row items-center gap-2">
       <div class="shrink-0">
         <RelayIcon {url} size={12} />
diff --git a/src/app/components/ProfileTrust.svelte b/src/app/components/ProfileTrust.svelte
index ac3cb6df..e5506ada 100644
--- a/src/app/components/ProfileTrust.svelte
+++ b/src/app/components/ProfileTrust.svelte
@@ -1,19 +1,10 @@
 <script lang="ts">
+  import {readable} from "svelte/store"
   import {clamp} from "@welshman/lib"
-  import {
-    pubkey,
-    followLists,
-    deriveUserWotScore,
-    deriveProfileDisplay,
-    deriveFollowList,
-    followersByPubkey,
-    loadFollowList,
-    getFollowsWhoFollow,
-    getFollowers,
-  } from "@welshman/app"
   import Shield from "@assets/icons/shield-minimalistic.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import ProfileCircles from "@app/components/ProfileCircles.svelte"
+  import {followLists, profiles, user, wot} from "@app/core"
 
   type Props = {
     pubkey: string
@@ -22,41 +13,20 @@
 
   const {pubkey: target, isSelf = false}: Props = $props()
 
-  const score = deriveUserWotScore(target)
-  const profileDisplay = deriveProfileDisplay(target)
-  const targetFollowList = deriveFollowList(target)
+  const profileDisplay = $profiles.display(target).$
+  const followers = $wot.followers(target).$
 
-  $effect(() => {
-    if (isSelf) return
+  const score = $derived($wot.wotScore($user.pubkey, target).$)
 
-    loadFollowList(target)
+  const followsWhoFollow = $derived(
+    !isSelf && $user.pubkey
+      ? $wot.followsWhoFollow($user.pubkey, target).$
+      : readable<string[]>([]),
+  )
 
-    const viewer = $pubkey
+  const followerCount = $derived($followers.length)
 
-    if (viewer) {
-      loadFollowList(viewer)
-    }
-  })
-
-  const followerCount = $derived.by(() => {
-    void $followersByPubkey
-
-    return getFollowers(target).length
-  })
-
-  const followsWhoFollow = $derived.by(() => {
-    if (isSelf) return []
-
-    const viewer = $pubkey
-    void $followLists
-    void $targetFollowList
-
-    if (!viewer) return []
-
-    return getFollowsWhoFollow(viewer, target)
-  })
-
-  const networkFollowCount = $derived(isSelf ? followerCount : followsWhoFollow.length)
+  const networkFollowCount = $derived(isSelf ? followerCount : $followsWhoFollow.length)
 
   const displayScore = $derived(isSelf ? followerCount : Math.round(clamp([0, 100], $score)))
   const progress = $derived(isSelf ? undefined : displayScore)
@@ -68,13 +38,6 @@
       return `Followed by ${followerCount}+ people in your network.`
     }
 
-    if (!$pubkey) {
-      if (displayScore >= 50) return "This user is highly trusted."
-      if (displayScore >= 10) return "This user has some trust."
-
-      return "This user is not well known."
-    }
-
     if (networkFollowCount > 0) {
       return `Followed by ${networkFollowCount}+ people in your network.`
     }
@@ -84,6 +47,13 @@
 
     return "This user is not well known in your network."
   })
+
+  $effect(() => {
+    if (!isSelf) {
+      $followLists.load(target)
+      $followLists.load($user.pubkey)
+    }
+  })
 </script>
 
 <div class="card card-sm flex flex-col gap-3 sm:gap-4">
@@ -107,13 +77,13 @@
     {/if}
     <p class="text-sm opacity-75">{trustMessage}</p>
   </div>
-  {#if followsWhoFollow.length > 0}
+  {#if $followsWhoFollow.length > 0}
     <div class="flex flex-col gap-2 border-t border-line pt-4">
       <p class="text-sm font-medium">People who follow {$profileDisplay}</p>
-      <ProfileCircles pubkeys={followsWhoFollow} limit={5} />
+      <ProfileCircles pubkeys={$followsWhoFollow} limit={5} />
       <p class="text-sm opacity-75">
-        {followsWhoFollow.length}
-        {followsWhoFollow.length === 1 ? "person" : "people"} you follow also follow
+        {$followsWhoFollow.length}
+        {$followsWhoFollow.length === 1 ? "person" : "people"} you follow also follow
         {$profileDisplay}.
       </p>
     </div>
diff --git a/src/app/components/Reaction.svelte b/src/app/components/Reaction.svelte
index 55b9d522..f57b10c6 100644
--- a/src/app/components/Reaction.svelte
+++ b/src/app/components/Reaction.svelte
@@ -1,11 +1,16 @@
 <script lang="ts">
+  import type {TrustedEvent} from "@welshman/util"
   import {parse, isEmoji, renderAsHtml} from "@welshman/content"
   import Heart from "@assets/icons/heart-angle.svg?dataurl"
   import ThumbsDown from "@assets/icons/dislike.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import ContentEmoji from "@app/components/ContentEmoji.svelte"
 
-  export let event
+  type Props = {
+    event: TrustedEvent
+  }
+
+  const {event}: Props = $props()
 </script>
 
 {#if event.content === "+" || event.content === ""}
diff --git a/src/app/components/ReactionSummary.svelte b/src/app/components/ReactionSummary.svelte
index 484caec9..86090edd 100644
--- a/src/app/components/ReactionSummary.svelte
+++ b/src/app/components/ReactionSummary.svelte
@@ -1,34 +1,47 @@
 <script lang="ts">
   import cx from "classnames"
   import {onMount} from "svelte"
+  import {derived} from "svelte/store"
   import type {Snippet} from "svelte"
-  import {groupBy, map, sum, uniq, uniqBy, batch, displayList} from "@welshman/lib"
+  import {
+    batch,
+    call,
+    displayList,
+    groupBy,
+    map,
+    removeUndefined,
+    spec,
+    sum,
+    uniq,
+    uniqBy,
+  } from "@welshman/lib"
   import {
     REPORT,
     REACTION,
-    ZAP_RESPONSE,
+    ZAP_RECEIPT,
     getReplyFilters,
-    getEmojiTags,
-    getEmojiTag,
     fromMsats,
-    getTag,
+    matchTag,
+    tagSpec,
+    userInbox,
     DELETE,
   } from "@welshman/util"
-  import type {TrustedEvent, EventContent, Zap} from "@welshman/util"
-  import {deriveArray, deriveEventsById, deriveItemsByKey} from "@welshman/store"
-  import {load} from "@welshman/net"
-  import {Router} from "@welshman/router"
-  import {pubkey, repository, getValidZap, displayProfileByPubkey} from "@welshman/app"
+  import type {TrustedEvent, EventContent} from "@welshman/util"
+  import {getEmojis} from "@welshman/domain"
+  import type {Zap} from "@welshman/domain"
+  import {Zappers} from "@welshman/app"
   import {isMobile, stopPropagation} from "@lib/html"
   import Danger from "@assets/icons/danger-triangle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
+  import {deriveEvents} from "@app/repository"
   import Reaction from "@app/components/Reaction.svelte"
   import ReportDetails from "@app/components/ReportDetails.svelte"
   import ProfileList from "@app/components/ProfileList.svelte"
   import ZapModal from "@app/components/Zap.svelte"
   import {REACTION_KINDS} from "@app/content"
-  import {deriveUserIsSpaceAdmin} from "@app/members"
+  import {app, network, profiles, router, user} from "@app/core"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {pushModal} from "@app/modal"
 
   interface Props {
@@ -55,44 +68,40 @@
 
   const eventIds = innerEvent ? [event.id, innerEvent.id] : [event.id]
 
-  const reports = deriveArray(
-    deriveEventsById({repository, filters: [{kinds: [REPORT], "#e": [event.id]}]}),
-  )
+  const reports = deriveEvents([{kinds: [REPORT], "#e": [event.id]}])
 
-  const reactions = deriveArray(
-    deriveEventsById({repository, filters: [{kinds: [REACTION], "#e": eventIds}]}),
-  )
+  const reactions = deriveEvents([{kinds: [REACTION], "#e": eventIds}])
 
-  const zaps = deriveArray(
-    deriveItemsByKey<Zap>({
-      repository,
-      getKey: zap => zap.response.id,
-      filters: [{kinds: [ZAP_RESPONSE], "#e": eventIds}],
-      eventToItem: (response: TrustedEvent) => {
-        const zap = getValidZap(response, event)
+  const receipts = deriveEvents([{kinds: [ZAP_RECEIPT], "#e": eventIds}])
 
-        if (zap) {
-          return zap
-        }
-
-        if (innerEvent) {
-          return getValidZap(response, innerEvent)
-        }
-      },
-    }),
+  // A receipt can be a zap of either the event or the one it wraps
+  const zaps = derived<typeof receipts, Zap[]>(
+    receipts,
+    ($receipts, set) =>
+      derived(
+        removeUndefined([event, innerEvent]).map(
+          parent => $app.use(Zappers).validZapReceipts($receipts, parent).$,
+        ),
+        (zapsByParent: Zap[][]) => uniqBy(zap => zap.response.id, zapsByParent.flat()),
+      ).subscribe(set),
+    [],
   )
 
   const toggleReaction = (events: TrustedEvent[]) => {
-    const reaction = events.find(e => e.pubkey === $pubkey)
+    const reaction = events.find(spec({pubkey: $user.pubkey}))
 
     if (reaction) {
       deleteReaction(reaction)
     } else {
       const [event] = events
 
+      const shortcode = event.content.replace(/:/g, "")
+
       createReaction({
         content: event.content,
-        tags: getEmojiTags(event.content.replace(/:/g, ""), event.tags),
+        tags: getEmojis(event)
+          .filter(spec({shortcode}))
+          .map(emoji => ["emoji", emoji.shortcode, emoji.url]),
       })
     }
   }
@@ -121,9 +130,16 @@
 
   const onReportClick = () => pushModal(ReportDetails, {url, event})
 
-  const reportReasons = $derived(uniq(map(e => getTag("e", e.tags)?.[2], $reports.values())))
+  const reportReasons = $derived(
+    uniq(map(e => matchTag(tagSpec("e"), e.tags)?.[2], $reports.values())),
+  )
 
-  const getReactionKey = (e: TrustedEvent) => getEmojiTag(e.content, e.tags)?.join("") || e.content
+  const getReactionKey = (e: TrustedEvent) => {
+    const shortcode = e.content.replace(/:/g, "")
+    const emoji = getEmojis(e).find(spec({shortcode}))
+
+    return emoji ? `emoji${emoji.shortcode}${emoji.url}` : e.content
+  }
 
   const groupedReactions = $derived(
     groupBy(
@@ -136,21 +152,24 @@
 
   onMount(() => {
     const controller = new AbortController()
-    const relays = url ? [url] : Router.get().ForUser().getUrls()
 
-    if (relays.length > 0) {
-      load({
-        relays,
-        signal: controller.signal,
-        filters: getReplyFilters([event], {kinds: REACTION_KINDS}),
-        onEvent: batch(300, (events: TrustedEvent[]) => {
-          load({
-            relays,
-            filters: getReplyFilters(events, {kinds: [DELETE]}),
-          })
-        }),
-      })
-    }
+    call(async () => {
+      const relays = url ? [url] : await $router.resolver.relays([userInbox()])
+
+      if (relays.length > 0) {
+        $network.load({
+          relays,
+          signal: controller.signal,
+          filters: getReplyFilters([event], {kinds: REACTION_KINDS}),
+          onEvent: batch(300, (events: TrustedEvent[]) => {
+            $network.load({
+              relays,
+              filters: getReplyFilters(events, {kinds: [DELETE]}),
+            })
+          }),
+        })
+      }
+    })
 
     return () => {
       controller.abort()
@@ -177,8 +196,8 @@
     {#each groupedZaps.entries() as [key, zaps]}
       {@const amount = fromMsats(sum(zaps.map(zap => zap.invoiceAmount)))}
       {@const pubkeys = uniq(zaps.map(zap => zap.request.pubkey))}
-      {@const isOwn = $pubkey && pubkeys.includes($pubkey)}
-      {@const info = displayList(pubkeys.map(pubkey => displayProfileByPubkey(pubkey)))}
+      {@const isOwn = pubkeys.includes($user.pubkey)}
+      {@const info = displayList(pubkeys.map(pubkey => $profiles.display(pubkey).get()))}
       {@const tooltip = `${info} zapped`}
       {@const onZapClickHandler = () => onZapClick(pubkeys, tooltip)}
       <Button
@@ -199,8 +218,8 @@
     {/each}
     {#each groupedReactions.entries() as [key, events]}
       {@const pubkeys = events.map(e => e.pubkey)}
-      {@const isOwn = $pubkey && pubkeys.includes($pubkey)}
-      {@const info = displayList(pubkeys.map(pubkey => displayProfileByPubkey(pubkey)))}
+      {@const isOwn = pubkeys.includes($user.pubkey)}
+      {@const info = displayList(pubkeys.map(pubkey => $profiles.display(pubkey).get()))}
       {@const tooltip = `${info} reacted`}
       {@const onClick = () => onReactionClick(events, pubkeys, info)}
       <Button
diff --git a/src/app/components/RecentConversation.svelte b/src/app/components/RecentConversation.svelte
index 19e7cae7..25fd2ef3 100644
--- a/src/app/components/RecentConversation.svelte
+++ b/src/app/components/RecentConversation.svelte
@@ -2,7 +2,7 @@
   import {goto} from "$app/navigation"
   import {formatTimestamp} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {tagValue, tagSpec} from "@welshman/util"
   import ChatRoundDots from "@assets/icons/chat-round-dots.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -20,7 +20,7 @@
 
   const {url, event, count}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
 
   const onClick = () => goto(h ? makeRoomPath(url, h) : makeSpaceChatPath(url))
 </script>
diff --git a/src/app/components/RelayAdd.svelte b/src/app/components/RelayAdd.svelte
index 02b0a3af..26a47714 100644
--- a/src/app/components/RelayAdd.svelte
+++ b/src/app/components/RelayAdd.svelte
@@ -5,7 +5,7 @@
   import {tryCatch} from "@welshman/lib"
   import {isShareableRelayUrl, isIPAddress, normalizeRelayUrl} from "@welshman/util"
   import type {Thunk} from "@welshman/app"
-  import {waitForThunkError, relaySearch} from "@welshman/app"
+  import {Relays} from "@welshman/app"
   import {createScroller} from "@lib/html"
   import {errorMessage} from "@lib/util"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
@@ -18,6 +18,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import RelayItem from "@app/components/RelayItem.svelte"
   import {pushToast} from "@app/toast"
+  import {app} from "@app/core"
 
   interface Props {
     relays: Readable<string[]>
@@ -35,7 +36,8 @@
     loading.add(url)
 
     try {
-      const error = await waitForThunkError(await addRelay(url))
+      const thunk = await addRelay(url)
+      const error = await thunk.waitForError()
 
       if (error) {
         pushToast({
@@ -53,11 +55,12 @@
   let element: Element | undefined = $state()
 
   const loading = $state(new SvelteSet<string>())
+  const relaySearch = $app.use(Relays).relaySearch
 
   const searchResults = $derived(
     $relaySearch
       .searchValues(term)
-      .filter(url => {
+      .filter((url: string) => {
         if (matchRelay?.(url) === false) return false
         if ($relays.includes(url)) return false
         if (isIPAddress(url)) return false
diff --git a/src/app/components/RelayDescription.svelte b/src/app/components/RelayDescription.svelte
index 82d4789a..1639f8a2 100644
--- a/src/app/components/RelayDescription.svelte
+++ b/src/app/components/RelayDescription.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
-  import {deriveRelay} from "@welshman/app"
   import Content from "@app/components/Content.svelte"
+  import {relays} from "@app/core"
 
   type Props = {
     url: string
@@ -8,7 +8,7 @@
 
   const {url}: Props = $props()
 
-  const relay = deriveRelay(url)
+  const relay = $relays.one(url)
 </script>
 
 {#if $relay?.description}
diff --git a/src/app/components/RelayIcon.svelte b/src/app/components/RelayIcon.svelte
index 630921cf..fcdefced 100644
--- a/src/app/components/RelayIcon.svelte
+++ b/src/app/components/RelayIcon.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
-  import {deriveRelay} from "@welshman/app"
   import RemoteControllerMinimalistic from "@assets/icons/remote-controller-minimalistic.svg?dataurl"
   import ImageIcon from "@lib/components/ImageIcon.svelte"
+  import {relays} from "@app/core"
 
   type Props = {
     url: string
@@ -11,7 +11,7 @@
 
   const {url, size = 7, ...props}: Props = $props()
 
-  const relay = deriveRelay(url)
+  const relay = $relays.one(url)
 </script>
 
 {#if $relay?.icon}
diff --git a/src/app/components/RelayItem.svelte b/src/app/components/RelayItem.svelte
index 4d8ecc95..c1692f42 100644
--- a/src/app/components/RelayItem.svelte
+++ b/src/app/components/RelayItem.svelte
@@ -1,17 +1,18 @@
 <script lang="ts">
+  import {displayUrl} from "@welshman/lib"
+  import {displayRelayUrl} from "@welshman/util"
+  import {RelayStats} from "@welshman/app"
   import Server from "@assets/icons/server.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Card from "@lib/components/Card.svelte"
   import Link from "@lib/components/Link.svelte"
   import ContentMinimal from "@app/components/ContentMinimal.svelte"
-  import {displayUrl} from "@welshman/lib"
-  import {displayRelayUrl} from "@welshman/util"
-  import {deriveRelay, deriveRelayStats} from "@welshman/app"
+  import {app, relays} from "@app/core"
 
   const {url, children} = $props()
 
-  const relay = deriveRelay(url)
-  const relayStats = deriveRelayStats(url)
+  const relay = $relays.one(url)
+  const relayStats = $app.use(RelayStats).one(url)
   const connections = $derived($relayStats?.open_count || 0)
 </script>
 
diff --git a/src/app/components/RelayList.svelte b/src/app/components/RelayList.svelte
index b1d90b3a..59e7dfc6 100644
--- a/src/app/components/RelayList.svelte
+++ b/src/app/components/RelayList.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import type {Readable} from "svelte/store"
   import {SvelteSet} from "svelte/reactivity"
-  import {waitForThunkError} from "@welshman/app"
   import type {Thunk} from "@welshman/app"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
@@ -19,7 +18,7 @@
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
 
-  interface Props {
+  type Props = {
     title: string
     subtitle: string
     relays: Readable<string[]>
@@ -38,7 +37,8 @@
     loading.add(url)
 
     try {
-      const error = await waitForThunkError(await removeRelay(url))
+      const thunk = await removeRelay(url)
+      const error = await thunk.waitForError()
 
       if (error) {
         pushToast({
diff --git a/src/app/components/RelayName.svelte b/src/app/components/RelayName.svelte
index f8cc0c6c..00cc2fde 100644
--- a/src/app/components/RelayName.svelte
+++ b/src/app/components/RelayName.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import {deriveRelayDisplay} from "@welshman/app"
+  import {relays} from "@app/core"
 
   type Props = {
     url: string
@@ -8,7 +8,7 @@
 
   const {url, ...props}: Props = $props()
 
-  const display = $derived(deriveRelayDisplay(url))
+  const display = $derived($relays.display(url).$)
 </script>
 
 <span class={props.class}>
diff --git a/src/app/components/RelaySettingsHealthCheck.svelte b/src/app/components/RelaySettingsHealthCheck.svelte
index f80b8d4b..627e03b3 100644
--- a/src/app/components/RelaySettingsHealthCheck.svelte
+++ b/src/app/components/RelaySettingsHealthCheck.svelte
@@ -4,7 +4,7 @@
   import Button from "@lib/components/Button.svelte"
   import Card from "@lib/components/Card.svelte"
   import type {HealthCheck} from "@app/healthChecks"
-  import {applyHealthCheck} from "@app/healthChecks"
+  import {healthChecks} from "@app/healthChecks"
 
   type Props = {
     healthCheck: HealthCheck
@@ -12,7 +12,7 @@
 
   const {healthCheck}: Props = $props()
 
-  const apply = () => applyHealthCheck(healthCheck)
+  const apply = () => $healthChecks.apply(healthCheck)
 </script>
 
 <Card sm class="bg-surface flex justify-between">
diff --git a/src/app/components/RelaySettingsHealthChecks.svelte b/src/app/components/RelaySettingsHealthChecks.svelte
index 912ba9cf..5e2e2e3c 100644
--- a/src/app/components/RelaySettingsHealthChecks.svelte
+++ b/src/app/components/RelaySettingsHealthChecks.svelte
@@ -7,11 +7,13 @@
   import Button from "@lib/components/Button.svelte"
   import RelaySettingsHealthCheck from "@app/components/RelaySettingsHealthCheck.svelte"
   import {PLATFORM_NAME} from "@app/env"
-  import {pendingHealthChecks, applyHealthCheck} from "@app/healthChecks"
+  import {healthChecks} from "@app/healthChecks"
+
+  const pending = $healthChecks.pending.$
 
   const applyAll = () => {
-    for (const healthCheck of $pendingHealthChecks) {
-      applyHealthCheck(healthCheck)
+    for (const healthCheck of $pending) {
+      $healthChecks.apply(healthCheck)
     }
   }
 </script>
@@ -23,18 +25,18 @@
       Health Check
     </strong>
     <span class="flex items-center gap-2 text-sm">
-      <Icon icon={$pendingHealthChecks.length === 0 ? CheckCircle : DangerTriangle} />
-      {$pendingHealthChecks.length} Issue{$pendingHealthChecks.length === 1 ? "" : "s"} Detected
+      <Icon icon={$pending.length === 0 ? CheckCircle : DangerTriangle} />
+      {$pending.length} Issue{$pending.length === 1 ? "" : "s"} Detected
     </span>
   </div>
   <p>
     {PLATFORM_NAME} actively checks your connection to the network in the background to discover relays
     that are offline, that you don't have access to, or are otherwise causing trouble.
   </p>
-  {#each $pendingHealthChecks as healthCheck}
+  {#each $pending as healthCheck}
     <RelaySettingsHealthCheck {healthCheck} />
   {/each}
-  {#if $pendingHealthChecks.length > 0}
+  {#if $pending.length > 0}
     <Button class="button button-primary" onclick={applyAll}>
       <Icon icon={Stars} />
       Apply All Recommendations
diff --git a/src/app/components/RelaySummary.svelte b/src/app/components/RelaySummary.svelte
index 7930cefa..0ed417b0 100644
--- a/src/app/components/RelaySummary.svelte
+++ b/src/app/components/RelaySummary.svelte
@@ -1,13 +1,13 @@
 <script lang="ts">
   import {remove} from "@welshman/lib"
-  import {pubkey} from "@welshman/app"
   import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import RelayName from "@app/components/RelayName.svelte"
   import RelayIcon from "@app/components/RelayIcon.svelte"
   import RelayDescription from "@app/components/RelayDescription.svelte"
   import ProfileCircles from "@app/components/ProfileCircles.svelte"
-  import {deriveGroupListPubkeys, deriveUserRooms} from "@app/groups"
+  import {roomLists, user} from "@app/core"
+  import {deriveUserRooms} from "@app/rooms"
 
   type Props = {
     url: string
@@ -16,8 +16,8 @@
 
   const {url, hideFavorites}: Props = $props()
   const rooms = deriveUserRooms(url)
-  const favorited = deriveGroupListPubkeys(url)
-  const favoritedPubkeys = $derived(remove($pubkey!, Array.from($favorited)))
+  const favorited = $roomLists.pubkeysForUrl(url).$
+  const favoritedPubkeys = $derived(remove($user.pubkey, $favorited))
 </script>
 
 <div class="flex flex-col gap-4 text-left">
diff --git a/src/app/components/Report.svelte b/src/app/components/Report.svelte
index 724c6f83..e6ff6983 100644
--- a/src/app/components/Report.svelte
+++ b/src/app/components/Report.svelte
@@ -1,4 +1,6 @@
 <script lang="ts">
+  import {Report} from "@welshman/domain"
+  import {publishToRelays} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -12,8 +14,8 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
+  import {command, writer} from "@app/core"
   import {pushToast} from "@app/toast"
-  import {publishReport} from "@app/reports"
 
   const {url, event} = $props()
 
@@ -29,7 +31,13 @@
 
     loading = true
 
-    await publishReport({event, reason: reason.toLowerCase(), content, relays: [url]})
+    const eventWriter = writer(Report)
+      .setPubkey(event.pubkey)
+      .setEventId(event.id)
+      .setReason(reason.toLowerCase())
+      .setContent(content)
+
+    await command(eventWriter).then(publishToRelays([url]))
 
     loading = false
     history.back()
diff --git a/src/app/components/ReportDetails.svelte b/src/app/components/ReportDetails.svelte
index df88cb88..f84f6653 100644
--- a/src/app/components/ReportDetails.svelte
+++ b/src/app/components/ReportDetails.svelte
@@ -1,8 +1,6 @@
 <script lang="ts">
   import {REPORT} from "@welshman/util"
   import type {TrustedEvent} from "@welshman/util"
-  import {deriveEventsById} from "@welshman/store"
-  import {repository} from "@welshman/app"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
@@ -10,6 +8,7 @@
   import ModalBody from "@lib/components/ModalBody.svelte"
   import Button from "@lib/components/Button.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import {deriveEventsById} from "@app/repository"
   import ReportItem from "@app/components/ReportItem.svelte"
 
   type Props = {
@@ -19,10 +18,7 @@
 
   const {url, event}: Props = $props()
 
-  const reports = deriveEventsById({
-    repository,
-    filters: [{kinds: [REPORT], "#e": [event.id]}],
-  })
+  const reports = deriveEventsById([{kinds: [REPORT], "#e": [event.id]}])
 
   const back = () => history.back()
 
diff --git a/src/app/components/ReportItem.svelte b/src/app/components/ReportItem.svelte
index 0918b556..4758d57b 100644
--- a/src/app/components/ReportItem.svelte
+++ b/src/app/components/ReportItem.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import {formatTimestamp} from "@welshman/lib"
-  import {getTag, getIdFilters} from "@welshman/util"
+  import {getIdFilters, matchTag, tagSpec} from "@welshman/util"
   import {load, LOCAL_RELAY_URL} from "@welshman/net"
   import type {TrustedEvent} from "@welshman/util"
   import Card from "@lib/components/Card.svelte"
@@ -21,8 +21,8 @@
 
   const {url, event, onResolved}: Props = $props()
 
-  const etag = getTag("e", event.tags)
-  const ptag = getTag("p", event.tags)
+  const etag = matchTag(tagSpec("e"), event.tags)
+  const ptag = matchTag(tagSpec("p"), event.tags)
   const reason = etag?.[2] || ptag?.[2]
 
   const onClick = (e: Event, event: TrustedEvent) => {
diff --git a/src/app/components/ReportMenuList.svelte b/src/app/components/ReportMenuList.svelte
index e0d97d6d..994f00fe 100644
--- a/src/app/components/ReportMenuList.svelte
+++ b/src/app/components/ReportMenuList.svelte
@@ -1,8 +1,7 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {getTag, ManagementMethod} from "@welshman/util"
+  import {matchTag, tagSpec} from "@welshman/util"
   import type {TrustedEvent} from "@welshman/util"
-  import {pubkey, manageRelay, repository, displayProfileByPubkey} from "@welshman/app"
   import InboxOut from "@assets/icons/inbox-out.svg?dataurl"
   import MinusCircle from "@assets/icons/minus-circle.svg?dataurl"
   import TrashBin2 from "@assets/icons/trash-bin-2.svg?dataurl"
@@ -10,9 +9,8 @@
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Confirm from "@lib/components/Confirm.svelte"
-  import {deriveUserIsSpaceAdmin, banSpaceMembers} from "@app/members"
-  import {publishDelete} from "@app/deletes"
-  import {canEnforceNip70} from "@app/relays"
+  import {app, deletes, profiles, relayManagement, relays, user} from "@app/core"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {pushToast} from "@app/toast"
   import {pushModal} from "@app/modal"
 
@@ -25,27 +23,26 @@
 
   const {url, event, onResolved, onClick}: Props = $props()
 
-  const shouldProtect = canEnforceNip70(url)
   const userIsAdmin = deriveUserIsSpaceAdmin(url)
-  const etag = getTag("e", event.tags)
-  const ptag = getTag("p", event.tags)
+  const etag = matchTag(tagSpec("e"), event.tags)
+  const ptag = matchTag(tagSpec("p"), event.tags)
 
   const deleteReport = async () => {
-    publishDelete({event, relays: [url], protect: await shouldProtect})
+    const protect = await $relays.hasNip(url, 70)
+    const command = await $deletes.deleteEvent(event, w => w.setProtected(protect))
+
+    command.publishToRelays([url])
     onResolved?.()
   }
 
   const dismissReport = async () => {
-    const {error} = await manageRelay(url, {
-      method: ManagementMethod.BanEvent,
-      params: [event.id, "Dismissed by admin"],
-    })
+    const {error} = await $relayManagement.forUrl(url).banEvent(event.id, "Dismissed by admin")
 
     if (error) {
       pushToast({theme: "error", message: error})
     } else {
       pushToast({message: "Content has successfully been deleted!"})
-      repository.removeEvent(event.id)
+      $app.repository.removeEvent(event.id)
       onResolved?.()
     }
   }
@@ -57,17 +54,14 @@
       title: `Remove Content`,
       message: `Are you sure you want to delete this content from the space?`,
       confirm: async () => {
-        const {error} = await manageRelay(url, {
-          method: ManagementMethod.BanEvent,
-          params: [id, reason],
-        })
+        const {error} = await $relayManagement.forUrl(url).banEvent(id, reason)
 
         if (error) {
           pushToast({theme: "error", message: error})
         } else {
           pushToast({message: "Content has successfully been deleted!"})
-          repository.removeEvent(event.id)
-          repository.removeEvent(id)
+          $app.repository.removeEvent(event.id)
+          $app.repository.removeEvent(id)
           history.back()
           setTimeout(() => onResolved?.())
         }
@@ -76,19 +70,19 @@
   }
 
   const banMember = () => {
-    const [_, pubkey, reason = ""] = ptag!
+    const [_, reported, reason = ""] = ptag!
 
     pushModal(Confirm, {
       title: "Ban User",
-      message: `Are you sure you want to ban @${displayProfileByPubkey(pubkey)} from the space?`,
+      message: `Are you sure you want to ban @${$profiles.display(reported).get()} from the space?`,
       confirm: async () => {
-        const error = await banSpaceMembers(url, [pubkey], reason)
+        const {error} = await $relayManagement.forUrl(url).banPubkey(reported, reason)
 
         if (error) {
           pushToast({theme: "error", message: error})
         } else {
           pushToast({message: "User has successfully been banned!"})
-          repository.removeEvent(event.id)
+          $app.repository.removeEvent(event.id)
           history.back()
           setTimeout(() => onResolved?.())
         }
@@ -104,7 +98,7 @@
 </script>
 
 <ul class="menu whitespace-nowrap rounded-2xl bg-surface p-2" bind:this={ul}>
-  {#if event.pubkey === $pubkey}
+  {#if event.pubkey === $user.pubkey}
     <li>
       <Button onclick={deleteReport}>
         <Icon icon={Close} />
diff --git a/src/app/components/RoleAddMembers.svelte b/src/app/components/RoleAddMembers.svelte
index 53fc53b3..ab9e98a8 100644
--- a/src/app/components/RoleAddMembers.svelte
+++ b/src/app/components/RoleAddMembers.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+  import type {RelayRoleReader} from "@welshman/domain"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -11,12 +12,12 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import ProfileMultiSelect from "@app/components/ProfileMultiSelect.svelte"
-  import {addSpaceMembers, assignRole, type SpaceRole} from "@app/members"
+  import {relayManagement, relayMemberLists} from "@app/core"
   import {pushToast} from "@app/toast"
 
-  interface Props {
+  type Props = {
     url: string
-    role: SpaceRole
+    role: RelayRoleReader
   }
 
   const {url, role}: Props = $props()
@@ -30,16 +31,21 @@
     loading = true
 
     try {
-      // Ensure they're space members first, then assign the role
-      const memberError = await addSpaceMembers(url, pubkeys)
-
-      if (memberError) {
-        pushToast({theme: "error", message: memberError})
-        return
-      }
+      const members = $relayMemberLists.get(url)
+      const management = $relayManagement.forUrl(url)
 
       for (const pubkey of pubkeys) {
-        const error = await assignRole(url, pubkey, role.id)
+        // Ensure they're space members first, then assign the role
+        if (!members?.isMember(pubkey)) {
+          const {error} = await management.allowPubkey(pubkey)
+
+          if (error) {
+            pushToast({theme: "error", message: error})
+            return
+          }
+        }
+
+        const {error} = await management.assignRole(pubkey, role.identifier()!)
 
         if (error) {
           pushToast({theme: "error", message: error})
@@ -58,7 +64,7 @@
 <Modal>
   <ModalBody>
     <ModalHeader>
-      <ModalTitle>Add to {role.label || "Role"}</ModalTitle>
+      <ModalTitle>Add to {role.label() || "Role"}</ModalTitle>
       <ModalSubtitle>Assign members to this role</ModalSubtitle>
     </ModalHeader>
     <Field>
diff --git a/src/app/components/RoleBadge.svelte b/src/app/components/RoleBadge.svelte
index 40462a72..9427393f 100644
--- a/src/app/components/RoleBadge.svelte
+++ b/src/app/components/RoleBadge.svelte
@@ -1,9 +1,10 @@
 <script lang="ts">
   import cx from "classnames"
-  import {roleColor, type SpaceRole} from "@app/members"
+  import type {RelayRoleReader} from "@welshman/domain"
+  import {roleColor} from "@app/roles"
 
   type Props = {
-    role: SpaceRole
+    role: RelayRoleReader
     size?: "sm" | "md"
   }
 
@@ -12,7 +13,7 @@
 
 <span
   class={cx("role-badge", size === "md" && "role-badge--md")}
-  style="--role-color: {roleColor(role.color)}">
+  style="--role-color: {roleColor(role.color() ?? 0)}">
   <span class="role-badge__dot" aria-hidden="true"></span>
-  {role.label || "Untitled Role"}
+  {role.label() || "Untitled Role"}
 </span>
diff --git a/src/app/components/RoleCreate.svelte b/src/app/components/RoleCreate.svelte
index bc1afa71..2c7d4dc3 100644
--- a/src/app/components/RoleCreate.svelte
+++ b/src/app/components/RoleCreate.svelte
@@ -7,7 +7,7 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import RelayName from "@app/components/RelayName.svelte"
   import RoleForm, {type Values} from "@app/components/RoleForm.svelte"
-  import {createRole} from "@app/members"
+  import {relayManagement} from "@app/core"
   import {pushToast} from "@app/toast"
 
   type Props = {
@@ -24,7 +24,9 @@
     loading = true
 
     try {
-      const error = await createRole(url, randomId(), label, description, color, 1)
+      const {error} = await $relayManagement
+        .forUrl(url)
+        .createRole(randomId(), label, description, String(color), 1)
 
       if (error) {
         pushToast({theme: "error", message: error})
diff --git a/src/app/components/RoleEdit.svelte b/src/app/components/RoleEdit.svelte
index d32b99a9..a117605d 100644
--- a/src/app/components/RoleEdit.svelte
+++ b/src/app/components/RoleEdit.svelte
@@ -1,4 +1,6 @@
 <script lang="ts">
+  import type {RelayRoleReader} from "@welshman/domain"
+  import {makeRelayRoleKey} from "@welshman/app"
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
@@ -6,29 +8,41 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import RelayName from "@app/components/RelayName.svelte"
   import RoleForm, {type Values} from "@app/components/RoleForm.svelte"
-  import {editRole, type SpaceRole} from "@app/members"
+  import {relayManagement, relayRoles} from "@app/core"
   import {pushToast} from "@app/toast"
 
   type Props = {
     url: string
-    role: SpaceRole
+    role: RelayRoleReader
   }
 
   const {url, role}: Props = $props()
 
-  const back = () => history.back()
+  const id = role.identifier() ?? ""
 
-  let loading = $state(false)
+  const initialValues = {
+    label: role.label() ?? "",
+    description: role.description() ?? "",
+    color: role.color(),
+  }
+
+  const back = () => history.back()
 
   const onSubmit = async ({label, description, color}: Values) => {
     loading = true
 
     try {
-      const error = await editRole(url, role.id, label, description, color, role.order)
+      const {error} = await $relayManagement
+        .forUrl(url)
+        .editRole(id, label, description, String(color), role.order())
 
       if (error) {
         pushToast({theme: "error", message: error})
       } else {
+        // Pull the relay's freshly-signed role event so the UI reflects the change
+        // immediately, rather than waiting for the live subscription to catch up.
+        await $relayRoles.forceLoad(makeRelayRoleKey(url, id))
+
         pushToast({message: "Role updated!"})
         back()
       }
@@ -36,6 +50,8 @@
       loading = false
     }
   }
+
+  let loading = $state(false)
 </script>
 
 <Modal>
@@ -44,6 +60,6 @@
       <ModalTitle>Edit Role</ModalTitle>
       <ModalSubtitle>in <RelayName {url} class="text-primary" /></ModalSubtitle>
     </ModalHeader>
-    <RoleForm {loading} {onSubmit} initialValues={role} />
+    <RoleForm {loading} {onSubmit} {initialValues} />
   </ModalBody>
 </Modal>
diff --git a/src/app/components/RoleForm.svelte b/src/app/components/RoleForm.svelte
index 65caaea3..64ca82b1 100644
--- a/src/app/components/RoleForm.svelte
+++ b/src/app/components/RoleForm.svelte
@@ -1,7 +1,9 @@
 <script module lang="ts">
-  import type {SpaceRole} from "@app/members"
-
-  export type Values = Pick<SpaceRole, "label" | "description" | "color">
+  export type Values = {
+    label: string
+    description: string
+    color: number
+  }
 </script>
 
 <script lang="ts">
@@ -11,7 +13,7 @@
   import Icon from "@lib/components/Icon.svelte"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {roleColor} from "@app/members"
+  import {roleColor} from "@app/roles"
 
   type Props = {
     initialValues?: Partial<Values>
diff --git a/src/app/components/RoleItem.svelte b/src/app/components/RoleItem.svelte
index 60127c14..4c319282 100644
--- a/src/app/components/RoleItem.svelte
+++ b/src/app/components/RoleItem.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
+  import type {RelayRoleReader} from "@welshman/domain"
   import RoleBadge from "@app/components/RoleBadge.svelte"
-  import type {SpaceRole} from "@app/members"
 
   interface Props {
-    role: SpaceRole
+    role: RelayRoleReader
   }
 
   const {role}: Props = $props()
@@ -11,7 +11,7 @@
 
 <div class="flex min-w-0 flex-col gap-2 justify-between">
   <RoleBadge {role} size="md" />
-  {#if role.description}
-    <p class="text-sm opacity-70">{role.description}</p>
+  {#if role.description()}
+    <p class="text-sm opacity-70">{role.description()}</p>
   {/if}
 </div>
diff --git a/src/app/components/RoomAccess.svelte b/src/app/components/RoomAccess.svelte
index 3ea0d340..64881988 100644
--- a/src/app/components/RoomAccess.svelte
+++ b/src/app/components/RoomAccess.svelte
@@ -4,31 +4,31 @@
   import Microphone from "@assets/icons/microphone.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
-  import {deriveRoom} from "@app/groups"
+  import {rooms} from "@app/core"
 
-  interface Props {
-    h: any
-    url: any
+  type Props = {
+    h: string
+    url: string
   }
 
   const {url, h}: Props = $props()
 
-  const room = deriveRoom(url, h)
+  const room = $rooms.forRoom(url, h)
 </script>
 
-{#if $room.isHidden}
+{#if $room?.meta?.isHidden()}
   <Button
     class="button button-neutral button-sm tip tip-left"
     data-tip="This room is not visible to non-members.">
     <Icon size={4} icon={EyeClosed} />
   </Button>
-{:else if $room.isPrivate}
+{:else if $room?.meta?.isPrivate()}
   <Button
     class="button button-neutral button-sm tip tip-left"
     data-tip="Only members can view messages.">
     <Icon size={4} icon={Lock} />
   </Button>
-{:else if $room.isRestricted}
+{:else if $room?.meta?.isRestricted()}
   <Button
     class="button button-neutral button-sm tip tip-left"
     data-tip="Only members can send messages.">
diff --git a/src/app/components/RoomChat.svelte b/src/app/components/RoomChat.svelte
index a8d49490..67ece432 100644
--- a/src/app/components/RoomChat.svelte
+++ b/src/app/components/RoomChat.svelte
@@ -5,14 +5,14 @@
   import {goto} from "$app/navigation"
   import type {Readable} from "svelte/store"
   import {debounce} from "throttle-debounce"
-  import {pubkey, publishThunk, waitForThunkError, joinRoom, leaveRoom} from "@welshman/app"
+  import cx from "classnames"
   import {now, ifLet, int, formatTimestampAsDate, ago, MINUTE} from "@welshman/lib"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {makeEvent, makeRoomMeta, MESSAGE, RELAY_ADD_MEMBER, ROOM_ADD_MEMBER} from "@welshman/util"
+  import {makeEvent, MESSAGE, RELAY_ADD_MEMBER, ROOM_ADD_MEMBER} from "@welshman/util"
+  import {publish} from "@welshman/app"
   import AltArrowDown from "@assets/icons/alt-arrow-down.svg?dataurl"
   import ClockCircle from "@assets/icons/clock-circle.svg?dataurl"
   import Login2 from "@assets/icons/login-3.svg?dataurl"
-  import cx from "classnames"
   import {fade, fly} from "@lib/transition"
   import {popKey} from "@lib/implicit"
   import Button from "@lib/components/Button.svelte"
@@ -28,6 +28,7 @@
   import ThunkToast from "@app/components/ThunkToast.svelte"
   import VideoCallContent from "@app/components/VideoCallContent.svelte"
   import VoiceWidget from "@app/components/VoiceWidget.svelte"
+  import {deletes, relays, rooms, thunks, user} from "@app/core"
   import {publishRoomJoinRequest} from "@app/access"
   import {
     CallState,
@@ -37,10 +38,14 @@
     videoCallLayout,
     videoTileCount,
   } from "@app/call"
-  import {publishDelete} from "@app/deletes"
-  import {prependParent, deriveRoom, getRoomType, PROTECTED, RoomType} from "@app/groups"
-  import {deriveUserRoomMembershipStatus, MembershipStatus} from "@app/members"
-  import {canEnforceNip70} from "@app/relays"
+  import {
+    PROTECTED,
+    RoomType,
+    deriveUserRoomMembershipStatus,
+    MembershipStatus,
+    getRoomType,
+    prependParent,
+  } from "@app/rooms"
   import {userSettingsValues} from "@app/settings"
   import {makeFeed} from "@app/feeds"
   import {checked, deferredRoomPath, setChecked} from "@app/notifications"
@@ -54,7 +59,7 @@
 
   const {url, h}: Props = $props()
 
-  const room = h ? deriveRoom(url, h) : readable(undefined)
+  const room = h ? $rooms.forRoom(url, h) : readable(undefined)
   const addMemberKind = h ? ROOM_ADD_MEMBER : RELAY_ADD_MEMBER
   const isVoiceRoom = $derived($room && getRoomType($room) === RoomType.Voice)
 
@@ -110,7 +115,7 @@
     prevVideoTileCount = n
   })
 
-  const shouldProtect = canEnforceNip70(url)
+  const shouldProtect = $relays.hasNip(url, 70)
   const membershipStatus = h
     ? deriveUserRoomMembershipStatus(url, h)
     : readable(MembershipStatus.Granted)
@@ -122,11 +127,11 @@
       joining = true
 
       try {
-        const message = await waitForThunkError(
-          inviteCode
-            ? publishRoomJoinRequest(url, h, inviteCode)
-            : joinRoom(url, makeRoomMeta({h})),
-        )
+        const thunk = await (inviteCode
+          ? publishRoomJoinRequest(url, h, inviteCode)
+          : $rooms.joinRoom(url, {h}).then(publish))
+
+        const message = await thunk.waitForError()
 
         if (message && !message.startsWith("duplicate:")) {
           return pushToast({theme: "error", message})
@@ -144,7 +149,8 @@
     if (h) {
       leaving = true
       try {
-        const message = await waitForThunkError(leaveRoom(url, makeRoomMeta({h})))
+        const thunk = await $rooms.leaveRoom(url, {h}).then(publish)
+        const message = await thunk.waitForError()
 
         if (message && !message.startsWith("duplicate:")) {
           pushToast({theme: "error", message})
@@ -182,7 +188,9 @@
         tags.push(["h", h])
       }
 
-      if (await shouldProtect) {
+      const protect = await shouldProtect
+
+      if (protect) {
         tags.push(PROTECTED)
       }
 
@@ -196,22 +204,23 @@
 
         // Delete previous message, to be republished with same timestamp
         template.created_at = eventToEdit.created_at
-        publishDelete({
-          relays: [url],
-          event: $state.snapshot(eventToEdit),
-          protect: await shouldProtect,
-        })
+
+        const command = await $deletes.deleteEvent($state.snapshot(eventToEdit), w =>
+          w.setProtected(protect),
+        )
+
+        command.publishToRelays([url])
       }
 
       if (share) {
-        template = prependParent(share, template, url)
+        template = await prependParent(share, template, url)
       }
 
       if (parent) {
-        template = prependParent(parent, template, url)
+        template = await prependParent(parent, template, url)
       }
 
-      const thunk = publishThunk({
+      const thunk = $thunks.publish({
         relays: [url],
         event: makeEvent(MESSAGE, template),
         delay: $userSettingsValues.send_delay,
@@ -295,7 +304,7 @@
   const onVisibilityChange = () => {
     if (document.hidden) {
       lastVisibleAt = now()
-    } else if ($events.some(e => e.pubkey !== $pubkey && e.created_at > lastVisibleAt)) {
+    } else if ($events.some(e => e.pubkey !== $user.pubkey && e.created_at > lastVisibleAt)) {
       newMessagesAfter = lastVisibleAt
       newMessagesBefore = now()
       newMessagesSeen = false
@@ -338,7 +347,7 @@
     let newMessagesSeen = false
 
     if (events) {
-      const lastUserEvent = $events.findLast(e => e.pubkey === $pubkey)
+      const lastUserEvent = $events.findLast(e => e.pubkey === $user.pubkey)
 
       // Adjust the boundary to account for messages that came from a different device
       const adjustedAfter =
@@ -356,7 +365,7 @@
         if (
           !newMessagesSeen &&
           adjustedAfter &&
-          event.pubkey !== $pubkey &&
+          event.pubkey !== $user.pubkey &&
           event.created_at > adjustedAfter &&
           event.created_at < newMessagesBefore
         ) {
@@ -428,7 +437,7 @@
   }
 
   const canEditEvent = (event: TrustedEvent) =>
-    event.pubkey === $pubkey && event.created_at >= ago(5, MINUTE)
+    event.pubkey === $user.pubkey && event.created_at >= ago(5, MINUTE)
 
   const onEditEvent = (event: TrustedEvent) => {
     clearParent()
@@ -484,7 +493,7 @@
         "room__content scroll-container",
         showMobileVideoPanel ? "hidden md:flex md:flex-col-reverse" : "flex",
       )}>
-      {#if $room?.isPrivate && $membershipStatus !== MembershipStatus.Granted}
+      {#if $room?.meta?.isPrivate() && $membershipStatus !== MembershipStatus.Granted}
         <div class="py-20">
           <div class="card flex flex-col gap-8 m-auto max-w-md items-center text-center">
             <p class="opacity-75">You aren't currently a member of this room.</p>
@@ -560,9 +569,9 @@
         showMobileVideoPanel && "max-md:hidden",
       )}>
       <div class="room__compose-inner min-w-0 flex-1">
-        {#if $room?.isPrivate && $membershipStatus !== MembershipStatus.Granted}
+        {#if $room?.meta?.isPrivate() && $membershipStatus !== MembershipStatus.Granted}
           <!-- pass -->
-        {:else if $room?.isRestricted && $membershipStatus !== MembershipStatus.Granted}
+        {:else if $room?.meta?.isRestricted() && $membershipStatus !== MembershipStatus.Granted}
           <div class="card m-4 flex flex-row items-center justify-between px-4 py-3">
             <p class="opacity-75">Only members are allowed to post to this room.</p>
             {#if $membershipStatus === MembershipStatus.Pending}
diff --git a/src/app/components/RoomComposeParent.svelte b/src/app/components/RoomComposeParent.svelte
index 5d968eb5..45a4667e 100644
--- a/src/app/components/RoomComposeParent.svelte
+++ b/src/app/components/RoomComposeParent.svelte
@@ -1,28 +1,28 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {displayProfileByPubkey} from "@welshman/app"
   import {slide} from "@lib/transition"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import NoteContentMinimal from "@app/components/NoteContentMinimal.svelte"
+  import {profiles} from "@app/core"
 
-  const {
-    verb,
-    event,
-    clear,
-  }: {
+  type Props = {
     verb: string
     event: TrustedEvent
     clear: () => void
-  } = $props()
+  }
+
+  const {verb, event, clear}: Props = $props()
+
+  const display = $profiles.display(event.pubkey).$
 </script>
 
 <div
   class="relative border-l-2 border-solid bg-surface-more px-2 py-1 pr-8"
   style="border-color: var(--primary)"
   transition:slide>
-  <p class="text-xs text-primary">{verb} @{displayProfileByPubkey(event.pubkey)}</p>
+  <p class="text-xs text-primary">{verb} @{$display}</p>
   {#key event.id}
     <NoteContentMinimal trimParent {event} />
   {/key}
diff --git a/src/app/components/RoomCreate.svelte b/src/app/components/RoomCreate.svelte
index bd87ec9e..2a50146c 100644
--- a/src/app/components/RoomCreate.svelte
+++ b/src/app/components/RoomCreate.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {goto} from "$app/navigation"
-  import type {RoomMeta} from "@welshman/util"
   import {displayRelayUrl} from "@welshman/util"
+  import type {RoomMeta} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import Spinner from "@lib/components/Spinner.svelte"
@@ -14,7 +14,11 @@
   import RoomForm from "@app/components/RoomForm.svelte"
   import {makeSpacePath} from "@app/routes"
 
-  const {url} = $props()
+  type Props = {
+    url: string
+  }
+
+  const {url}: Props = $props()
 
   const back = () => history.back()
 
diff --git a/src/app/components/RoomDetail.svelte b/src/app/components/RoomDetail.svelte
index 4e74a804..fe65ddbf 100644
--- a/src/app/components/RoomDetail.svelte
+++ b/src/app/components/RoomDetail.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
   import {displayRelayUrl} from "@welshman/util"
+  import {publish} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import EyeClosed from "@assets/icons/eye-closed.svg?dataurl"
@@ -22,8 +23,8 @@
   import RoomInvite from "@app/components/RoomInvite.svelte"
   import RoomName from "@app/components/RoomName.svelte"
   import RoomImage from "@app/components/RoomImage.svelte"
-  import {deriveRoom, deriveUserRooms, addRoom, removeRoom} from "@app/groups"
-  import {deriveRoomMembers, deriveUserIsRoomAdmin} from "@app/members"
+  import {roomLists, rooms} from "@app/core"
+  import {deriveRoomMembers, deriveUserIsRoomAdmin, deriveUserRooms} from "@app/rooms"
   import {deriveShouldNotify, toggleRoomNotifications} from "@app/settings"
   import {pushModal} from "@app/modal"
 
@@ -34,11 +35,12 @@
 
   const {url, h}: Props = $props()
 
-  const room = deriveRoom(url, h)
+  const room = $rooms.forRoom(url, h)
   const members = deriveRoomMembers(url, h)
   const userRooms = deriveUserRooms(url)
   const userIsAdmin = deriveUserIsRoomAdmin(url, h)
 
+  const meta = $derived($room?.meta)
   const isFavorite = $derived($userRooms.includes(h))
   const shouldNotify = deriveShouldNotify(url, h)
 
@@ -50,9 +52,9 @@
 
   const toggleFavorite = () => {
     if (isFavorite) {
-      removeRoom(url, h)
+      $roomLists.removeRoom(h, url).then(publish)
     } else {
-      addRoom(url, h)
+      $roomLists.addRoom(h, url).then(publish)
     }
   }
 
@@ -75,41 +77,41 @@
       </div>
       <MenuButton component={RoomDetailMenu} componentProps={{url, h}} />
     </div>
-    {#if $room?.about}
-      <p>{$room.about}</p>
+    {#if meta?.about()}
+      <p>{meta.about()}</p>
     {/if}
     <div class="flex flex-col gap-2 card card-sm">
       <strong class="text-lg">Room Permissions</strong>
       <div class="flex gap-2 flex-wrap">
-        {#if $room?.isRestricted}
+        {#if meta?.isRestricted()}
           <Tooltip content="Only members can send messages.">
             <Button class="button button-neutral button-xs button-pill flex gap-2 items-center">
               <Icon size={4} icon={Microphone} /> Restricted
             </Button>
           </Tooltip>
         {/if}
-        {#if $room?.isPrivate}
+        {#if meta?.isPrivate()}
           <Tooltip content="Only members can view messages.">
             <Button class="button button-neutral button-xs button-pill flex gap-2 items-center">
               <Icon size={4} icon={Lock} /> Private
             </Button>
           </Tooltip>
         {/if}
-        {#if $room?.isHidden}
+        {#if meta?.isHidden()}
           <Tooltip content="This room is not visible to non-members.">
             <Button class="button button-neutral button-xs button-pill flex gap-2 items-center">
               <Icon size={4} icon={EyeClosed} /> Hidden
             </Button>
           </Tooltip>
         {/if}
-        {#if $room?.isClosed}
+        {#if meta?.isClosed()}
           <Tooltip content="Requests to join this room will be ignored.">
             <Button class="button button-neutral button-xs button-pill flex gap-2 items-center">
               <Icon size={4} icon={MinusCircle} /> Closed
             </Button>
           </Tooltip>
         {/if}
-        {#if !$room?.isRestricted && !$room?.isPrivate && !$room?.isHidden && !$room?.isClosed}
+        {#if !meta?.isRestricted() && !meta?.isPrivate() && !meta?.isHidden() && !meta?.isClosed()}
           <Tooltip content="This room has no additional access controls.">
             <Button class="button button-neutral button-xs button-pill flex gap-2 items-center">
               <Icon size={4} icon={Eye} /> Public
diff --git a/src/app/components/RoomDetailMenu.svelte b/src/app/components/RoomDetailMenu.svelte
index 94525796..a8625657 100644
--- a/src/app/components/RoomDetailMenu.svelte
+++ b/src/app/components/RoomDetailMenu.svelte
@@ -1,10 +1,8 @@
 <script lang="ts">
   import {onMount} from "svelte"
   import {goto} from "$app/navigation"
-  import type {RoomMeta} from "@welshman/util"
-  import {makeRoomMeta} from "@welshman/util"
-  import type {Thunk} from "@welshman/app"
-  import {deleteRoom, waitForThunkError, repository, joinRoom, leaveRoom} from "@welshman/app"
+  import type {Command} from "@welshman/app"
+  import {publish} from "@welshman/app"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import TrashBin2 from "@assets/icons/trash-bin-2.svg?dataurl"
   import Login3 from "@assets/icons/login-3.svg?dataurl"
@@ -14,12 +12,8 @@
   import Spinner from "@lib/components/Spinner.svelte"
   import Confirm from "@lib/components/Confirm.svelte"
   import RoomEdit from "@app/components/RoomEdit.svelte"
-  import {deriveRoom, removeRoom} from "@app/groups"
-  import {
-    deriveUserIsRoomAdmin,
-    deriveUserRoomMembershipStatus,
-    MembershipStatus,
-  } from "@app/members"
+  import {app, roomLists, rooms} from "@app/core"
+  import {deriveUserIsRoomAdmin, deriveUserRoomMembershipStatus, MembershipStatus} from "@app/rooms"
   import {makeSpacePath} from "@app/routes"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
@@ -32,17 +26,17 @@
 
   const {url, h, onClick}: Props = $props()
 
-  const room = deriveRoom(url, h)
   const userIsAdmin = deriveUserIsRoomAdmin(url, h)
   const membershipStatus = deriveUserRoomMembershipStatus(url, h)
 
   const startEdit = () => pushModal(RoomEdit, {url, h})
 
-  const handleLoading = async (f: (url: string, room: RoomMeta) => Thunk) => {
+  const handleLoading = async (buildCommand: () => Promise<Command>) => {
     loading = true
 
     try {
-      const message = await waitForThunkError(f(url, makeRoomMeta({h})))
+      const command = await buildCommand()
+      const message = await command.publish().waitForError()
 
       if (message && !message.startsWith("duplicate:")) {
         pushToast({theme: "error", message})
@@ -52,9 +46,9 @@
     }
   }
 
-  const join = () => handleLoading(joinRoom)
+  const join = () => handleLoading(() => $rooms.joinRoom(url, {h}))
 
-  const leave = () => handleLoading(leaveRoom)
+  const leave = () => handleLoading(() => $rooms.leaveRoom(url, {h}))
 
   const startDelete = () =>
     pushModal(Confirm, {
@@ -62,14 +56,15 @@
       message:
         "This room will no longer be accessible to space members, and all messages posted to it will be deleted.",
       confirm: async () => {
-        const thunk = deleteRoom(url, $room)
-        const message = await waitForThunkError(thunk)
+        const command = await $rooms.deleteRoom(url, {h})
+        const thunk = command.publish()
+        const message = await thunk.waitForError()
 
         if (message) {
-          repository.removeEvent(thunk.event.id)
+          $app.repository.removeEvent(thunk.event.id)
           pushToast({theme: "error", message})
         } else {
-          await removeRoom(url, h)
+          await $roomLists.removeRoom(h, url).then(publish)
           goto(makeSpacePath(url))
         }
       },
diff --git a/src/app/components/RoomEdit.svelte b/src/app/components/RoomEdit.svelte
index 19db4765..f39fd8b1 100644
--- a/src/app/components/RoomEdit.svelte
+++ b/src/app/components/RoomEdit.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {goto} from "$app/navigation"
-  import type {RoomMeta} from "@welshman/util"
   import {displayRelayUrl} from "@welshman/util"
+  import type {RoomMeta} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -11,7 +11,7 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import RoomForm from "@app/components/RoomForm.svelte"
-  import {deriveRoom} from "@app/groups"
+  import {rooms} from "@app/core"
   import {makeSpacePath} from "@app/routes"
 
   type Props = {
@@ -21,14 +21,28 @@
 
   const {url, h}: Props = $props()
 
-  const room = deriveRoom(url, h)
+  const room = $rooms.forRoom(url, h)
+  const meta = $derived($room?.meta)
+
+  const initialValues: RoomMeta = $derived({
+    h,
+    name: meta?.name(),
+    about: meta?.about(),
+    picture: meta?.picture(),
+    pictureMeta: meta?.pictureMeta(),
+    isClosed: meta?.isClosed(),
+    isHidden: meta?.isHidden(),
+    isPrivate: meta?.isPrivate(),
+    isRestricted: meta?.isRestricted(),
+    livekit: meta?.hasLivekit(),
+  })
 
   const back = () => history.back()
 
-  const onsubmit = (room: RoomMeta) => goto(makeSpacePath(url, h))
+  const onsubmit = () => goto(makeSpacePath(url, h))
 </script>
 
-<RoomForm {url} {onsubmit} initialValues={$room}>
+<RoomForm {url} {onsubmit} {initialValues}>
   {#snippet header()}
     <ModalHeader>
       <ModalTitle>Edit a Room</ModalTitle>
diff --git a/src/app/components/RoomForm.svelte b/src/app/components/RoomForm.svelte
index e3f76f6d..12f54ca8 100644
--- a/src/app/components/RoomForm.svelte
+++ b/src/app/components/RoomForm.svelte
@@ -1,8 +1,7 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
-  import type {RoomMeta} from "@welshman/util"
-  import {makeRoomMeta} from "@welshman/util"
-  import {waitForThunkError, createRoom, editRoom, joinRoom} from "@welshman/app"
+  import {randomId} from "@welshman/lib"
+  import type {RoomMeta} from "@welshman/app"
   import Hashtag from "@assets/icons/hashtag.svg?dataurl"
   import Volume from "@assets/icons/volume.svg?dataurl"
   import {preventDefault} from "@lib/html"
@@ -12,10 +11,11 @@
   import IconInput from "@lib/components/IconInput.svelte"
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
+  import {rooms} from "@app/core"
   import {pushToast} from "@app/toast"
   import {compressFileForUpload, uploadFileOrFallback} from "@app/uploads"
   import {deriveHasLivekit} from "@app/relays"
-  import {getRoomType, RoomType} from "@app/groups"
+  import {RoomType} from "@app/rooms"
 
   type Props = {
     url: string
@@ -25,7 +25,7 @@
     initialValues?: RoomMeta
   }
 
-  const {url, header, footer, onsubmit, initialValues = makeRoomMeta()}: Props = $props()
+  const {url, header, footer, onsubmit, initialValues = {h: randomId()}}: Props = $props()
 
   const values = $state(initialValues)
   const relayHasLivekit = deriveHasLivekit(url)
@@ -53,19 +53,22 @@
       room.picture = result.url
     }
 
-    const createMessage = await waitForThunkError(createRoom(url, room))
+    const createCommand = await $rooms.createRoom(url, room)
+    const createMessage = await createCommand.publish().waitForError()
 
     if (createMessage && !createMessage.includes("already")) {
       return pushToast({theme: "error", message: createMessage})
     }
 
-    const editMessage = await waitForThunkError(editRoom(url, room))
+    const editCommand = await $rooms.editRoom(url, room)
+    const editMessage = await editCommand.publish().waitForError()
 
     if (editMessage) {
       return pushToast({theme: "error", message: editMessage})
     }
 
-    const joinMessage = await waitForThunkError(joinRoom(url, room))
+    const joinCommand = await $rooms.joinRoom(url, room)
+    const joinMessage = await joinCommand.publish().waitForError()
 
     if (joinMessage && !joinMessage.includes("already")) {
       return pushToast({theme: "error", message: joinMessage})
@@ -87,7 +90,7 @@
   let loading = $state(false)
   let imageFile = $state<File | undefined>()
   let imagePreview = $state(initialValues.picture)
-  let roomType = $state(getRoomType(initialValues))
+  let roomType = $state(initialValues.livekit ? RoomType.Voice : RoomType.Text)
 </script>
 
 <Modal tag="form" onsubmit={preventDefault(trySubmit)}>
diff --git a/src/app/components/RoomImage.svelte b/src/app/components/RoomImage.svelte
index 5cbbd524..1c1a973b 100644
--- a/src/app/components/RoomImage.svelte
+++ b/src/app/components/RoomImage.svelte
@@ -3,7 +3,7 @@
   import Volume from "@assets/icons/volume.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import ImageIcon from "@lib/components/ImageIcon.svelte"
-  import {deriveRoom} from "@app/groups"
+  import {rooms} from "@app/core"
 
   interface Props {
     h: string
@@ -14,20 +14,21 @@
 
   const {url, h, size = 5, fallbackIcon = Hashtag}: Props = $props()
 
-  const room = deriveRoom(url, h)
-  const isVoiceRoom = $derived($room.livekit)
+  const room = $rooms.forRoom(url, h)
+  const picture = $derived($room?.meta?.picture())
+  const isVoiceRoom = $derived($room?.meta?.hasLivekit())
 </script>
 
 {#if isVoiceRoom}
   <div class="flex shrink-0 items-center gap-1.5">
     <Icon size={size + 1} icon={Volume} />
-    {#if $room.picture}
+    {#if picture}
       <span class="text-base">/</span>
-      <ImageIcon src={$room.picture} {size} alt="" class="rounded-xl" />
+      <ImageIcon src={picture} {size} alt="" class="rounded-xl" />
     {/if}
   </div>
-{:else if $room.picture}
-  <ImageIcon src={$room.picture} {size} alt="" class="rounded-xl" />
+{:else if picture}
+  <ImageIcon src={picture} {size} alt="" class="rounded-xl" />
 {:else}
   <Icon icon={fallbackIcon} {size} />
 {/if}
diff --git a/src/app/components/RoomItem.svelte b/src/app/components/RoomItem.svelte
index d30cc366..3d341309 100644
--- a/src/app/components/RoomItem.svelte
+++ b/src/app/components/RoomItem.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import cx from "classnames"
-  import {readable} from "svelte/store"
+  import {get, readable} from "svelte/store"
   import {
     hash,
     gte,
@@ -10,14 +10,7 @@
     formatTimestampAsDate,
   } from "@welshman/lib"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {MESSAGE, COMMENT, getTag} from "@welshman/util"
-  import {
-    thunks,
-    pubkey,
-    mergeThunks,
-    deriveProfileDisplay,
-    displayProfileByPubkey,
-  } from "@welshman/app"
+  import {MESSAGE, COMMENT, matchTag, tagSpec, tagValue} from "@welshman/util"
   import {isMobile} from "@lib/html"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
@@ -27,6 +20,7 @@
   import Link from "@lib/components/Link.svelte"
   import Button from "@lib/components/Button.svelte"
   import ThunkFailure from "@app/components/ThunkFailure.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
@@ -35,16 +29,14 @@
   import RoomItemMenuButton from "@app/components/RoomItemMenuButton.svelte"
   import RoomItemMenuMobile from "@app/components/RoomItemMenuMobile.svelte"
   import RoomItemContent from "@app/components/RoomItemContent.svelte"
+  import {profiles, thunks, user} from "@app/core"
   import {colors} from "@app/theme"
   import {ENABLE_ZAPS} from "@app/env"
-  import {deriveEventsForUrl, deriveEvent} from "@app/repository"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
+  import {deriveEvent, deriveEventsForUrl} from "@app/repository"
   import {getRoomItemPath} from "@app/routes"
   import {pushModal} from "@app/modal"
 
-  interface Props {
+  type Props = {
     url: string
     event: TrustedEvent
     replyTo?: (event: TrustedEvent) => void
@@ -56,13 +48,13 @@
   const {url, event, replyTo = undefined, showPubkey = false, canEdit, onEdit}: Props = $props()
 
   const path = getRoomItemPath(url, event)
-  const shouldProtect = canEnforceNip70(url)
+  const h = tagValue(tagSpec("h"), event.tags)
   const today = formatTimestampAsDate(now())
-  const profileDisplay = deriveProfileDisplay(event.pubkey, [url])
-  const thunk = mergeThunks($thunks.filter(t => t.event.id === event.id))
+  const profileDisplay = $profiles.display(event.pubkey, [url]).$
+  const thunk = $thunks.merge(get($thunks.history).filter(t => t.event.id === event.id))
   const [_, colorValue] = colors[hash(event.pubkey) % colors.length]
 
-  const qTag = getTag("q", event.tags)
+  const qTag = matchTag(tagSpec("q"), event.tags)
   const isQuoteOnly = Boolean(
     gte(qTag?.length, 2) && event.content.trim().match(/^nostr:n(event|addr)1\w+\s*$/),
   )
@@ -78,11 +70,9 @@
 
   const openProfile = () => pushModal(ProfileDetail, {pubkey: event.pubkey, url})
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url, h})
 
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url, h})
 </script>
 
 <TapTarget
@@ -138,8 +128,8 @@
       innerEvent={$innerEvent} />
     {#if path && $innerComments.length > 0}
       {@const pubkeys = $innerComments.map(e => e.pubkey)}
-      {@const isOwn = $pubkey && pubkeys.includes($pubkey)}
-      {@const info = displayList(pubkeys.map(pubkey => displayProfileByPubkey(pubkey)))}
+      {@const isOwn = pubkeys.includes($user.pubkey)}
+      {@const info = displayList(pubkeys.map(pk => $profiles.display(pk).get()))}
       {@const tooltip = `${info} commented`}
       <div data-tip={tooltip} class="tip tip-right flex">
         <Link
diff --git a/src/app/components/RoomItemAddMember.svelte b/src/app/components/RoomItemAddMember.svelte
index 8fe4dd6b..aaf3f159 100644
--- a/src/app/components/RoomItemAddMember.svelte
+++ b/src/app/components/RoomItemAddMember.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getPubkeyTagValues} from "@welshman/util"
+  import {tagValues, hexTags} from "@welshman/util"
   import ProfileLink from "@app/components/ProfileLink.svelte"
 
   type Props = {
@@ -11,7 +11,7 @@
   const {url, event}: Props = $props()
 </script>
 
-{#each getPubkeyTagValues(event.tags) as pubkey}
+{#each tagValues(hexTags("p"), event.tags) as pubkey}
   <div class="py-1 text-center text-xs opacity-75">
     <ProfileLink unstyled class="text-primary" {url} {pubkey} /> joined the room
   </div>
diff --git a/src/app/components/RoomItemEmojiButton.svelte b/src/app/components/RoomItemEmojiButton.svelte
index d243dd73..9524af3c 100644
--- a/src/app/components/RoomItemEmojiButton.svelte
+++ b/src/app/components/RoomItemEmojiButton.svelte
@@ -1,22 +1,35 @@
 <script lang="ts">
   import type {NativeEmoji} from "emoji-picker-element/shared"
+  import type {TrustedEvent} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import EmojiButton from "@lib/components/EmojiButton.svelte"
   import SmileCircle from "@assets/icons/smile-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
+  import {reactions, relays} from "@app/core"
 
-  const {url, event} = $props()
+  type Props = {
+    url: string
+    event: TrustedEvent
+  }
 
-  const shouldProtect = canEnforceNip70(url)
+  const {url, event}: Props = $props()
 
-  const onEmoji = async (emoji: NativeEmoji) =>
-    publishReaction({
-      event,
-      relays: [url],
-      content: emoji.unicode,
-      protect: await shouldProtect,
+  const shouldProtect = $relays.hasNip(url, 70)
+
+  const onEmoji = async (emoji: NativeEmoji) => {
+    const protect = await shouldProtect
+    const room = tagValue(tagSpec("h"), event.tags)
+
+    const command = await $reactions.react(event, emoji.unicode, writer => {
+      writer.setProtected(protect)
+
+      if (room) {
+        writer.setRoom(url, room)
+      }
     })
+
+    return command.publishToRelays([url])
+  }
 </script>
 
 <EmojiButton
diff --git a/src/app/components/RoomItemMenu.svelte b/src/app/components/RoomItemMenu.svelte
index 62d80079..49cc2b63 100644
--- a/src/app/components/RoomItemMenu.svelte
+++ b/src/app/components/RoomItemMenu.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {ManagementMethod, getTagValue} from "@welshman/util"
-  import {pubkey, manageRelay, repository} from "@welshman/app"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
   import GalleryWide from "@assets/icons/gallery-wide.svg?dataurl"
   import TrashBin2 from "@assets/icons/trash-bin-2.svg?dataurl"
@@ -14,9 +13,9 @@
   import Report from "@app/components/Report.svelte"
   import PinboardSelect from "@app/components/PinboardSelect.svelte"
   import EventDeleteConfirm from "@app/components/EventDeleteConfirm.svelte"
-  import {ROOM} from "@app/groups"
-  import {deriveUserIsRoomAdmin, deriveUserIsSpaceAdmin} from "@app/members"
-  import {deriveRoomPinIds, pinRoomMessage, unpinRoomMessage} from "@app/pins"
+  import {app, relayManagement, roomPinLists, user} from "@app/core"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
+  import {ROOM, deriveUserIsRoomAdmin} from "@app/rooms"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
 
@@ -28,8 +27,8 @@
 
   const {url, event, onClick}: Props = $props()
 
-  const h = getTagValue(ROOM, event.tags) ?? ""
-  const pinIds = deriveRoomPinIds(url, h)
+  const h = tagValue(tagSpec(ROOM), event.tags) ?? ""
+  const pinIds = $roomPinLists.pins(url, h).$
   const userIsAdmin = deriveUserIsSpaceAdmin(url)
   const userIsRoomAdmin = deriveUserIsRoomAdmin(url, h)
   const isPinned = $derived($pinIds.includes(event.id))
@@ -59,16 +58,13 @@
       title: `Delete Message`,
       message: `Are you sure you want to delete this message from the space?`,
       confirm: async () => {
-        const {error} = await manageRelay(url, {
-          method: ManagementMethod.BanEvent,
-          params: [event.id],
-        })
+        const {error} = await $relayManagement.forUrl(url).banEvent(event.id)
 
         if (error) {
           pushToast({theme: "error", message: error})
         } else {
           pushToast({message: "Event has successfully been deleted!"})
-          repository.removeEvent(event.id)
+          $app.repository.removeEvent(event.id)
           history.back()
         }
       },
@@ -79,9 +75,9 @@
 
     if (!h) return
 
-    const error = isPinned
-      ? await unpinRoomMessage(url, h, event.id, $pinIds)
-      : await pinRoomMessage(url, h, event.id, $pinIds)
+    const pins = isPinned ? $pinIds.filter(pin => pin !== event.id) : [...$pinIds, event.id]
+    const command = await $roomPinLists.setPins(url, h, pins)
+    const error = await command.publishToRelays([url]).waitForError()
 
     if (error) {
       pushToast({theme: "error", message: error})
@@ -112,7 +108,7 @@
       </Button>
     </li>
   {/if}
-  {#if event.pubkey === $pubkey}
+  {#if event.pubkey === $user.pubkey}
     <li>
       <Button onclick={showDelete} class="text-error">
         <Icon size={4} icon={TrashBin2} />
diff --git a/src/app/components/RoomItemMenuMobile.svelte b/src/app/components/RoomItemMenuMobile.svelte
index 454c6e65..3fd34f9e 100644
--- a/src/app/components/RoomItemMenuMobile.svelte
+++ b/src/app/components/RoomItemMenuMobile.svelte
@@ -1,8 +1,7 @@
 <script lang="ts">
   import type {NativeEmoji} from "emoji-picker-element/shared"
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
-  import {pubkey} from "@welshman/app"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
@@ -19,12 +18,9 @@
   import ZapButton from "@app/components/ZapButton.svelte"
   import EventInfo from "@app/components/EventInfo.svelte"
   import EventDeleteConfirm from "@app/components/EventDeleteConfirm.svelte"
-  import {ROOM} from "@app/groups"
-  import {deriveUserIsRoomAdmin} from "@app/members"
-  import {deriveRoomPinIds, pinRoomMessage, unpinRoomMessage} from "@app/pins"
+  import {reactions, relays, roomPinLists, user} from "@app/core"
+  import {ROOM, deriveUserIsRoomAdmin} from "@app/rooms"
   import {ENABLE_ZAPS} from "@app/env"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
   import {getRoomItemPath} from "@app/routes"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
@@ -37,23 +33,20 @@
 
   const {url, event, reply}: Props = $props()
 
-  const h = getTagValue(ROOM, event.tags) ?? ""
+  const h = tagValue(tagSpec(ROOM), event.tags) ?? ""
   const path = getRoomItemPath(url, event)
-  const pinIds = deriveRoomPinIds(url, h)
+  const pinIds = $roomPinLists.pins(url, h).$
   const userIsRoomAdmin = deriveUserIsRoomAdmin(url, h)
   const isPinned = $derived($pinIds.includes(event.id))
 
-  const shouldProtect = canEnforceNip70(url)
-
-  const onEmoji = (async (event: TrustedEvent, url: string, emoji: NativeEmoji) => {
+  const onEmoji = async (emoji: NativeEmoji) => {
     history.back()
-    publishReaction({
-      event,
-      relays: [url],
-      content: emoji.unicode,
-      protect: await shouldProtect,
-    })
-  }).bind(undefined, event, url)
+
+    const protect = await $relays.hasNip(url, 70)
+    const command = await $reactions.react(event, emoji.unicode, w => w.setProtected(protect))
+
+    command.publishToRelays([url])
+  }
 
   const showEmojiPicker = () => pushModal(EmojiPicker, {onClick: onEmoji}, {replaceState: true})
 
@@ -71,9 +64,9 @@
 
     history.back()
 
-    const error = isPinned
-      ? await unpinRoomMessage(url, h, event.id, $pinIds)
-      : await pinRoomMessage(url, h, event.id, $pinIds)
+    const pins = isPinned ? $pinIds.filter(pin => pin !== event.id) : [...$pinIds, event.id]
+    const command = await $roomPinLists.setPins(url, h, pins)
+    const error = await command.publishToRelays([url]).waitForError()
 
     if (error) {
       pushToast({theme: "error", message: error})
@@ -86,7 +79,7 @@
 <Modal>
   <ModalBody>
     <div class="flex flex-col gap-2">
-      {#if event.pubkey === $pubkey}
+      {#if event.pubkey === $user.pubkey}
         <Button class="button button-neutral text-error" onclick={showDelete}>
           <Icon size={4} icon={TrashBin2} />
           Delete Message
diff --git a/src/app/components/RoomJoinItem.svelte b/src/app/components/RoomJoinItem.svelte
index d105503a..d7a35299 100644
--- a/src/app/components/RoomJoinItem.svelte
+++ b/src/app/components/RoomJoinItem.svelte
@@ -1,16 +1,15 @@
 <script lang="ts">
-  import {getTagValue, ManagementMethod} from "@welshman/util"
-  import type {TrustedEvent, PublishedRoomMeta} from "@welshman/util"
-  import {repository, manageRelay} from "@welshman/app"
+  import {tagSpec, tagValue} from "@welshman/util"
+  import type {TrustedEvent} from "@welshman/util"
   import Card from "@lib/components/Card.svelte"
   import Button from "@lib/components/Button.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
   import RoomName from "@app/components/RoomName.svelte"
+  import {app, relayManagement} from "@app/core"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
-  import {deriveRoom} from "@app/groups"
-  import {addRoomMembers} from "@app/members"
+  import {addRoomMembers} from "@app/rooms"
 
   type Props = {
     url: string
@@ -20,8 +19,7 @@
 
   const {url, event, onResolved}: Props = $props()
 
-  const h = getTagValue("h", event.tags) || ""
-  const room = deriveRoom(url, h)
+  const h = tagValue(tagSpec("h"), event.tags) || ""
 
   const showProfile = () => pushModal(ProfileDetail, {pubkey: event.pubkey, url})
 
@@ -29,16 +27,15 @@
     loading = true
 
     try {
-      const {error} = await manageRelay(url, {
-        method: ManagementMethod.BanEvent,
-        params: [event.id, "Join request dismissed"],
-      })
+      const {error} = await $relayManagement
+        .forUrl(url)
+        .banEvent(event.id, "Join request dismissed")
 
       if (error) {
         pushToast({theme: "error", message: error})
       } else {
         pushToast({message: "Join request has been dismissed."})
-        repository.removeEvent(event.id)
+        $app.repository.removeEvent(event.id)
         onResolved?.()
       }
     } finally {
@@ -50,7 +47,7 @@
     loading = true
 
     try {
-      const error = await addRoomMembers(url, $room as PublishedRoomMeta, [event.pubkey])
+      const error = await addRoomMembers(url, {h}, [event.pubkey])
 
       if (error) {
         pushToast({theme: "error", message: error})
diff --git a/src/app/components/RoomMemberMenu.svelte b/src/app/components/RoomMemberMenu.svelte
index 15818751..6a80deca 100644
--- a/src/app/components/RoomMemberMenu.svelte
+++ b/src/app/components/RoomMemberMenu.svelte
@@ -1,11 +1,10 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {waitForThunkError, removeRoomMember} from "@welshman/app"
   import MinusCircle from "@assets/icons/minus-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Confirm from "@lib/components/Confirm.svelte"
-  import {deriveRoom} from "@app/groups"
+  import {rooms} from "@app/core"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
 
@@ -18,14 +17,13 @@
 
   const {url, h, pubkey, onClick}: Props = $props()
 
-  const room = deriveRoom(url, h)
-
   const removeMember = () =>
     pushModal(Confirm, {
       title: "Remove Member",
       message: "Are you sure you want to remove this user from the room?",
       confirm: async () => {
-        const error = await waitForThunkError(removeRoomMember(url, $room, pubkey))
+        const command = await $rooms.removeMember(url, {h}, pubkey)
+        const error = await command.publish().waitForError()
 
         if (error) {
           pushToast({theme: "error", message: error})
diff --git a/src/app/components/RoomMembers.svelte b/src/app/components/RoomMembers.svelte
index 098216e8..b523924e 100644
--- a/src/app/components/RoomMembers.svelte
+++ b/src/app/components/RoomMembers.svelte
@@ -14,7 +14,7 @@
   import RoomName from "@app/components/RoomName.svelte"
   import RoomMembersAdd from "@app/components/RoomMembersAdd.svelte"
   import RoomMemberMenu from "@app/components/RoomMemberMenu.svelte"
-  import {deriveRoomMembers, deriveUserIsRoomAdmin} from "@app/members"
+  import {deriveRoomMembers, deriveUserIsRoomAdmin} from "@app/rooms"
   import {pushModal} from "@app/modal"
 
   interface Props {
diff --git a/src/app/components/RoomMembersAdd.svelte b/src/app/components/RoomMembersAdd.svelte
index acaddeee..113cbbb6 100644
--- a/src/app/components/RoomMembersAdd.svelte
+++ b/src/app/components/RoomMembersAdd.svelte
@@ -1,9 +1,7 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {setKey, popKey} from "@lib/implicit"
   import {sleep} from "@welshman/lib"
-  import {displayProfileByPubkey} from "@welshman/app"
-  import type {PublishedRoomMeta} from "@welshman/util"
+  import {setKey, popKey} from "@lib/implicit"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -18,20 +16,19 @@
   import Confirm from "@lib/components/Confirm.svelte"
   import RoomName from "@app/components/RoomName.svelte"
   import ProfileMultiSelect from "@app/components/ProfileMultiSelect.svelte"
+  import {profiles, relayMemberLists} from "@app/core"
   import {pushToast} from "@app/toast"
   import {pushModal} from "@app/modal"
-  import {deriveRoom} from "@app/groups"
-  import {deriveSpaceMembers, addRoomMembers} from "@app/members"
+  import {addRoomMembers} from "@app/rooms"
 
-  interface Props {
+  type Props = {
     url: string
     h: string
   }
 
   const {url, h}: Props = $props()
 
-  const room = deriveRoom(url, h)
-  const spaceMembers = deriveSpaceMembers(url)
+  const spaceMembers = $relayMemberLists.forUrl(url)
 
   const back = () => history.back()
 
@@ -42,7 +39,7 @@
       // Show loading for auto submit callback
       await sleep(500)
 
-      const error = await addRoomMembers(url, $room as PublishedRoomMeta, pubkeys)
+      const error = await addRoomMembers(url, {h}, pubkeys)
 
       if (error) {
         pushToast({theme: "error", message: error})
@@ -55,14 +52,12 @@
     }
   }
 
-  const onSubmit = async () => {
-    if (!$spaceMembers) {
-      addMembers()
-      return
-    }
-
+  const onSubmit = () => {
+    const members = $spaceMembers
     const pubkeysSnapshot = $state.snapshot(pubkeys)
-    const nonSpaceMembers = pubkeysSnapshot.filter(pubkey => !$spaceMembers.includes(pubkey))
+    const nonSpaceMembers = members
+      ? pubkeysSnapshot.filter(pubkey => !members.isMember(pubkey))
+      : []
 
     if (nonSpaceMembers.length > 0) {
       setKey("RoomMembersAdd.pubkeys", pubkeysSnapshot)
@@ -72,7 +67,7 @@
         subtitle: "Automatically add members to space",
         message:
           nonSpaceMembers.length === 1
-            ? `${displayProfileByPubkey(nonSpaceMembers[0])} is not a member of this space. Add them?`
+            ? `${$profiles.display(nonSpaceMembers[0]).get()} is not a member of this space. Add them?`
             : `${nonSpaceMembers.length} people are not members of this space. Add them?`,
         confirm: async () => {
           setKey("RoomMembersAdd.confirm", true)
diff --git a/src/app/components/RoomName.svelte b/src/app/components/RoomName.svelte
index 4e3ea185..a6621f0e 100644
--- a/src/app/components/RoomName.svelte
+++ b/src/app/components/RoomName.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import {deriveRoom} from "@app/groups"
+  import {rooms} from "@app/core"
 
   type Props = {
     url: string
@@ -9,9 +9,9 @@
 
   const {url, h, ...props}: Props = $props()
 
-  const room = deriveRoom(url, h)
+  const room = $rooms.forRoom(url, h)
 </script>
 
 <span class="truncate min-w-0 {props.class}">
-  {$room?.name || h}
+  {$room?.meta?.name() || h}
 </span>
diff --git a/src/app/components/RoomNameWithImage.svelte b/src/app/components/RoomNameWithImage.svelte
index f9b2478b..e0a457c5 100644
--- a/src/app/components/RoomNameWithImage.svelte
+++ b/src/app/components/RoomNameWithImage.svelte
@@ -2,7 +2,7 @@
   import RoomName from "@app/components/RoomName.svelte"
   import RoomImage from "@app/components/RoomImage.svelte"
 
-  interface Props {
+  type Props = {
     h: string
     url: string
     size?: number
diff --git a/src/app/components/RoomPinnedMessages.svelte b/src/app/components/RoomPinnedMessages.svelte
index cf49660d..868b910e 100644
--- a/src/app/components/RoomPinnedMessages.svelte
+++ b/src/app/components/RoomPinnedMessages.svelte
@@ -10,12 +10,7 @@
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import RoomItemContent from "@app/components/RoomItemContent.svelte"
   import RoomPinnedMessagesAll from "@app/components/RoomPinnedMessagesAll.svelte"
-  import {
-    deriveRoomPinIds,
-    deriveRoomPinnedEvents,
-    loadRoomPinList,
-    loadRoomPinnedMessages,
-  } from "@app/pins"
+  import {deriveRoomPinnedEvents} from "@app/roomPins"
   import {goToEvent} from "@app/routes"
   import {pushModal} from "@app/modal"
 
@@ -26,8 +21,7 @@
 
   const {url, h}: Props = $props()
 
-  const pinIds = deriveRoomPinIds(url, h)
-  const pinnedEvents = deriveRoomPinnedEvents(url, pinIds)
+  const pinnedEvents = deriveRoomPinnedEvents(url, h)
 
   let currentIndex = $state(0)
   let expanded = $state(false)
@@ -97,16 +91,6 @@
     reset(url, h)
   })
 
-  $effect(() => {
-    const ids = $pinIds
-    const controller = new AbortController()
-
-    loadRoomPinList(url, h, controller.signal)
-    loadRoomPinnedMessages(url, ids, controller.signal)
-
-    return () => controller.abort()
-  })
-
   $effect(() => {
     if (currentIndex >= $pinnedEvents.length) {
       currentIndex = 0
diff --git a/src/app/components/RoomPinnedMessagesAll.svelte b/src/app/components/RoomPinnedMessagesAll.svelte
index f16a2953..7f0cf641 100644
--- a/src/app/components/RoomPinnedMessagesAll.svelte
+++ b/src/app/components/RoomPinnedMessagesAll.svelte
@@ -10,18 +10,13 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import {roomPinLists} from "@app/core"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
   import RoomItemContent from "@app/components/RoomItemContent.svelte"
   import RoomName from "@app/components/RoomName.svelte"
-  import {deriveUserIsRoomAdmin} from "@app/members"
-  import {
-    deriveRoomPinIds,
-    deriveRoomPinnedEvents,
-    loadRoomPinList,
-    loadRoomPinnedMessages,
-    unpinRoomMessage,
-  } from "@app/pins"
+  import {deriveUserIsRoomAdmin} from "@app/rooms"
+  import {deriveRoomPinnedEvents} from "@app/roomPins"
   import {goToEvent} from "@app/routes"
   import {pushToast} from "@app/toast"
 
@@ -32,8 +27,8 @@
 
   const {url, h}: Props = $props()
 
-  const pinIds = deriveRoomPinIds(url, h)
-  const pinnedEvents = deriveRoomPinnedEvents(url, pinIds)
+  const pinIds = $roomPinLists.pins(url, h).$
+  const pinnedEvents = deriveRoomPinnedEvents(url, h)
   const userIsAdmin = deriveUserIsRoomAdmin(url, h)
 
   const back = () => history.back()
@@ -44,7 +39,12 @@
   }
 
   const unpin = async (event: TrustedEvent) => {
-    const error = await unpinRoomMessage(url, h, event.id, $pinIds)
+    const command = await $roomPinLists.setPins(
+      url,
+      h,
+      $pinIds.filter(pin => pin !== event.id),
+    )
+    const error = await command.publishToRelays([url]).waitForError()
 
     if (error) {
       pushToast({theme: "error", message: error})
@@ -52,16 +52,6 @@
       pushToast({message: "Message unpinned"})
     }
   }
-
-  $effect(() => {
-    const ids = $pinIds
-    const controller = new AbortController()
-
-    loadRoomPinList(url, h, controller.signal)
-    loadRoomPinnedMessages(url, ids, controller.signal)
-
-    return () => controller.abort()
-  })
 </script>
 
 <Modal>
diff --git a/src/app/components/RoomSearch.svelte b/src/app/components/RoomSearch.svelte
index 75cc6914..888e9f6f 100644
--- a/src/app/components/RoomSearch.svelte
+++ b/src/app/components/RoomSearch.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
   import {onMount, tick} from "svelte"
-  import {get} from "svelte/store"
   import {debounce} from "throttle-debounce"
   import {load} from "@welshman/net"
   import {groupBy, uniqBy, now, MINUTE, HOUR, DAY, WEEK} from "@welshman/lib"
@@ -19,7 +18,7 @@
   import NoteCard from "@app/components/NoteCard.svelte"
   import NoteContentMinimal from "@app/components/NoteContentMinimal.svelte"
   import {CONTENT_KINDS} from "@app/content"
-  import {deriveEventsForUrlDesc} from "@app/repository"
+  import {getEventsForUrl} from "@app/repository"
   import {popModal} from "@app/modal"
   import {goToEvent} from "@app/routes"
 
@@ -49,7 +48,7 @@
       search: searchTerm.trim(),
     }
 
-    results = get(deriveEventsForUrlDesc(url, [filter]))
+    results = sortEventsDesc(getEventsForUrl(url, [filter]))
 
     try {
       const events = await load({
diff --git a/src/app/components/SignUp.svelte b/src/app/components/SignUp.svelte
index 2d37d427..49097907 100644
--- a/src/app/components/SignUp.svelte
+++ b/src/app/components/SignUp.svelte
@@ -1,17 +1,9 @@
 <script lang="ts">
   import cx from "classnames"
   import type {ClientOptions} from "@pomade/core"
-  import type {Profile} from "@welshman/util"
-  import {
-    makeProfile,
-    makeSecret,
-    RELAYS,
-    PROFILE,
-    MESSAGING_RELAYS,
-    makeEvent,
-    createProfile,
-  } from "@welshman/util"
-  import {loginWithNip01, publishThunk, waitForThunkCompletion} from "@welshman/app"
+  import {makeSecret, RELAYS, MESSAGING_RELAYS, makeEvent} from "@welshman/util"
+  import {Profile} from "@welshman/domain"
+  import {Thunks, nip01, publish, toSession} from "@welshman/app"
   import Key from "@assets/icons/key-minimalistic.svg?dataurl"
   import Letter from "@assets/icons/letter.svg?dataurl"
   import {getKey, setKey} from "@lib/implicit"
@@ -23,6 +15,7 @@
   import SignUpKey from "@app/components/SignUpKey.svelte"
   import SignUpEmail from "@app/components/SignUpEmail.svelte"
   import SignUpProfile from "@app/components/SignUpProfile.svelte"
+  import type {ProfileValues} from "@app/components/ProfileEditForm.svelte"
   import SignUpComplete from "@app/components/SignUpComplete.svelte"
   import {attemptRelayAccess} from "@app/access"
   import {
@@ -34,18 +27,18 @@
     DEFAULT_SPACES,
   } from "@app/env"
   import {setChecked} from "@app/notifications"
-  import {setSpaces} from "@app/groups"
   import {loginWithPomade} from "@app/pomade"
   import {pushModal, clearModals} from "@app/modal"
+  import {app, domain, login, roomLists} from "@app/core"
 
   setKey("signup.email", "")
   setKey("signup.secret", makeSecret())
-  setKey("signup.profile", makeProfile())
+  setKey("signup.profile", {})
   setKey("signup.clientOptions", undefined)
 
   const hasPomade = POMADE_SIGNERS.length >= 3
 
-  const login = () => pushModal(LogIn)
+  const showLogIn = () => pushModal(LogIn)
 
   const completeSignup = async () => {
     // Join default spaces so the relay is warmed up before we publish below
@@ -53,23 +46,26 @@
 
     // Add default outbox/inbox/messaging relays, profile, spaces
     const thunks = await Promise.all([
-      publishThunk({
+      $app.use(Thunks).publish({
         event: makeEvent(RELAYS, {tags: DEFAULT_RELAYS.map(url => ["r", url])}),
         relays: [...INDEXER_RELAYS, ...DEFAULT_RELAYS, ...DEFAULT_SPACES],
       }),
-      publishThunk({
+      $app.use(Thunks).publish({
         event: makeEvent(MESSAGING_RELAYS, {tags: DEFAULT_MESSAGING_RELAYS.map(url => ["r", url])}),
         relays: [...DEFAULT_RELAYS, ...DEFAULT_SPACES],
       }),
-      publishThunk({
-        event: makeEvent(PROFILE, createProfile(getKey<Profile>("signup.profile")!)),
+      $app.use(Thunks).publish({
+        event: await $domain
+          .writer(Profile)
+          .update(getKey<ProfileValues>("signup.profile")!)
+          .renderTemplate(),
         relays: [...DEFAULT_RELAYS, ...DEFAULT_SPACES],
       }),
-      setSpaces(DEFAULT_SPACES),
+      $roomLists.setRelays(DEFAULT_SPACES).then(publish),
     ])
 
     // Wait for all the thunks to complete
-    await Promise.all(thunks.map(waitForThunkCompletion))
+    await Promise.all(thunks.map(thunk => thunk.waitForCompletion()))
 
     // Don't show any notifications for old content
     setChecked("*")
@@ -100,7 +96,7 @@
       finalize: async () => {
         const secret = getKey<string>("signup.secret")!
 
-        loginWithNip01(secret)
+        await login(toSession(nip01, {secret}))
         await completeSignup()
       },
     },
@@ -127,7 +123,7 @@
     </Button>
     <div class="text-sm">
       Already have an account?
-      <Button class="link" onclick={login}>Log in instead</Button>
+      <Button class="link" onclick={showLogIn}>Log in instead</Button>
     </div>
   </ModalBody>
 </Modal>
diff --git a/src/app/components/SignUpComplete.svelte b/src/app/components/SignUpComplete.svelte
index 9d63bd1d..a57e2f98 100644
--- a/src/app/components/SignUpComplete.svelte
+++ b/src/app/components/SignUpComplete.svelte
@@ -46,7 +46,7 @@
     </p>
     <p>
       From your dashboard, you can use invite links, discover community spaces, and keep up-to-date
-      on groups you've already joined. Click below to get started!
+      on spaces you've already joined. Click below to get started!
     </p>
   </ModalBody>
   {#if step && totalSteps}
diff --git a/src/app/components/SignUpProfile.svelte b/src/app/components/SignUpProfile.svelte
index bbb7630c..7a7bbb4b 100644
--- a/src/app/components/SignUpProfile.svelte
+++ b/src/app/components/SignUpProfile.svelte
@@ -1,11 +1,11 @@
 <script lang="ts">
-  import type {Profile} from "@welshman/util"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import {getKey, setKey} from "@lib/implicit"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import ProfileEditForm from "@app/components/ProfileEditForm.svelte"
+  import type {Values} from "@app/components/ProfileEditForm.svelte"
   import ProgressBar from "@app/components/ProgressBar.svelte"
 
   type Props = {
@@ -16,13 +16,13 @@
 
   const {next, step, totalSteps}: Props = $props()
 
-  const profile = getKey<Profile>("signup.profile")!
+  const profile = getKey<Values["profile"]>("signup.profile")!
 
   const initialValues = {profile}
 
   const back = () => history.back()
 
-  const onsubmit = ({profile}: {profile: Profile}) => {
+  const onsubmit = ({profile}: Values) => {
     setKey("signup.profile", profile)
     next()
   }
diff --git a/src/app/components/SignerStatus.svelte b/src/app/components/SignerStatus.svelte
index 654b96d6..c6c0f237 100644
--- a/src/app/components/SignerStatus.svelte
+++ b/src/app/components/SignerStatus.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
-  import {spec, avg} from "@welshman/lib"
-  import {session, SessionMethod, signerLog} from "@welshman/app"
+  import {avg, spec} from "@welshman/lib"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import Danger from "@assets/icons/danger-triangle.svg?dataurl"
   import ClockCircle from "@assets/icons/clock-circle.svg?dataurl"
@@ -9,17 +8,19 @@
   import Button from "@lib/components/Button.svelte"
   import LogOut from "@app/components/LogOut.svelte"
   import {pushModal} from "@app/modal"
+  import {session} from "@app/core"
+  import {signerRequests} from "@app/signer"
   import PomadeSessions from "@app/components/PomadeSessions.svelte"
 
-  const finished = $derived($signerLog.filter(x => x.finished_at))
-  const pending = $derived($signerLog.filter(x => !x.finished_at))
-  const failure = $derived(finished.filter(spec({ok: false})))
+  const finished = $derived($signerRequests.filter(request => request.finishedAt))
+  const pending = $derived($signerRequests.filter(request => !request.finishedAt))
   const success = $derived(finished.filter(spec({ok: true})))
+  const failure = $derived(finished.filter(spec({ok: false})))
   const cutoff = $derived(Date.now() - 10_000)
-  const recentCompleted = $derived($signerLog.filter(x => x.finished_at && x.finished_at > cutoff))
-  const recentAvg = $derived(avg(recentCompleted.map(x => x.finished_at! - x.started_at)))
-  const recentFailure = $derived(recentCompleted.filter(x => !x.ok))
-  const recentSuccess = $derived(recentCompleted.filter(x => x.ok))
+  const recentCompleted = $derived(finished.filter(request => request.finishedAt! > cutoff))
+  const recentAvg = $derived(avg(recentCompleted.map(r => r.finishedAt! - r.startedAt)))
+  const recentFailure = $derived(recentCompleted.filter(request => !request.ok))
+  const recentSuccess = $derived(recentCompleted.filter(request => request.ok))
   const isDisconnected = $derived(
     recentCompleted.length > 0 && recentFailure.length === recentCompleted.length,
   )
@@ -27,7 +28,7 @@
   const logout = () => pushModal(LogOut)
 </script>
 
-{#if $session && $session.method !== SessionMethod.Anonymous}
+{#if $session}
   <div class="card flex flex-col gap-4">
     <div class="flex flex-col gap-2">
       <div class="flex items-center justify-between">
@@ -49,17 +50,15 @@
       <div class="flex flex-col justify-between text-sm opacity-75 sm:flex-row">
         <p>
           Logged in with
-          {#if $session.method === SessionMethod.Nip01}
+          {#if $session.method === "nip01"}
             private key
-          {:else if $session.method === SessionMethod.Nip07}
+          {:else if $session.method === "nip07"}
             browser extension
-          {:else if $session.method === SessionMethod.Nip46}
+          {:else if $session.method === "nip46"}
             remote signer
-          {:else if $session.method === SessionMethod.Nip55}
-            {$session.signer}
-          {:else if $session.method === SessionMethod.Pubkey}
-            public key (readonly)
-          {:else if $session.method === SessionMethod.Pomade}
+          {:else if $session.method === "nip55"}
+            an external signer
+          {:else if $session.method === "pomade"}
             email and password
           {/if}
         </p>
diff --git a/src/app/components/SpaceAuthError.svelte b/src/app/components/SpaceAuthError.svelte
index 1f179989..bb10f8b9 100644
--- a/src/app/components/SpaceAuthError.svelte
+++ b/src/app/components/SpaceAuthError.svelte
@@ -2,6 +2,7 @@
   import {goto} from "$app/navigation"
   import {displayRelayUrl} from "@welshman/util"
   import {parse, renderAsHtml} from "@welshman/content"
+  import {publish} from "@welshman/app"
   import Button from "@lib/components/Button.svelte"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
@@ -16,11 +17,16 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import SpaceAccessRequest from "@app/components/SpaceAccessRequest.svelte"
   import {publishLeaveRequest} from "@app/access"
+  import {roomLists} from "@app/core"
   import {pushModal, clearModals} from "@app/modal"
-  import {removeSpace} from "@app/groups"
   import {removeTrustedRelay} from "@app/settings"
 
-  const {url, error} = $props()
+  type Props = {
+    url: string
+    error: string
+  }
+
+  const {url, error}: Props = $props()
 
   const back = () => goto("/home")
 
@@ -30,8 +36,8 @@
     loading = true
 
     try {
-      await removeSpace(url)
-      await publishLeaveRequest({url})
+      await $roomLists.removeRelay(url).then(publish)
+      await publishLeaveRequest(url)
       await removeTrustedRelay(url)
     } finally {
       loading = false
diff --git a/src/app/components/SpaceEdit.svelte b/src/app/components/SpaceEdit.svelte
index 516dbf5a..9a01cc73 100644
--- a/src/app/components/SpaceEdit.svelte
+++ b/src/app/components/SpaceEdit.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
-  import type {RelayProfile} from "@welshman/util"
-  import {displayRelayUrl, ManagementMethod} from "@welshman/util"
-  import {manageRelay, forceLoadRelay} from "@welshman/app"
+  import {displayRelayUrl} from "@welshman/util"
+  import type {RelayInfo} from "@welshman/domain"
   import Widget from "@assets/icons/widget-4.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import {preventDefault} from "@lib/html"
@@ -20,10 +19,11 @@
   import {pushToast} from "@app/toast"
   import {clearModals} from "@app/modal"
   import {compressFileForUpload, uploadFileOrFallback} from "@app/uploads"
+  import {relayManagement, relays} from "@app/core"
 
   type Props = {
     url: string
-    initialValues: Partial<RelayProfile>
+    initialValues: Partial<RelayInfo>
   }
 
   const {url, initialValues = {}}: Props = $props()
@@ -34,10 +34,7 @@
 
   const submit = async () => {
     if (values.name != initialValues.name) {
-      const res = await manageRelay(url, {
-        method: ManagementMethod.ChangeRelayName,
-        params: [values.name || ""],
-      })
+      const res = await $relayManagement.forUrl(url).changeRelayName(values.name || "")
 
       if (res.error) {
         return pushToast({theme: "error", message: res.error})
@@ -45,10 +42,9 @@
     }
 
     if (values.description != initialValues.description) {
-      const res = await manageRelay(url, {
-        method: ManagementMethod.ChangeRelayDescription,
-        params: [values.description || ""],
-      })
+      const res = await $relayManagement
+        .forUrl(url)
+        .changeRelayDescription(values.description || "")
 
       if (res.error) {
         return pushToast({theme: "error", message: res.error})
@@ -59,10 +55,7 @@
       const compressedFile = await compressFileForUpload(imageFile, {maxWidth: 128, maxHeight: 128})
       const result = await uploadFileOrFallback(compressedFile)
 
-      const res = await manageRelay(url, {
-        method: ManagementMethod.ChangeRelayIcon,
-        params: [result.url],
-      })
+      const res = await $relayManagement.forUrl(url).changeRelayIcon(result.url)
 
       if (res.error) {
         return pushToast({theme: "error", message: res.error})
@@ -70,7 +63,7 @@
     }
 
     pushToast({message: "Your changes have been saved!"})
-    forceLoadRelay(url)
+    $relays.forceLoad(url)
     clearModals()
   }
 
diff --git a/src/app/components/SpaceExit.svelte b/src/app/components/SpaceExit.svelte
index 5bd8ca89..7cf7c9f5 100644
--- a/src/app/components/SpaceExit.svelte
+++ b/src/app/components/SpaceExit.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
   import {goto} from "$app/navigation"
   import {displayRelayUrl} from "@welshman/util"
+  import {publish} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -12,7 +13,7 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import {publishLeaveRequest} from "@app/access"
-  import {removeSpace} from "@app/groups"
+  import {roomLists} from "@app/core"
   import {removeTrustedRelay} from "@app/settings"
 
   const {url} = $props()
@@ -23,8 +24,8 @@
     loading = true
 
     try {
-      await removeSpace(url)
-      await publishLeaveRequest({url})
+      await $roomLists.removeRelay(url).then(publish)
+      await publishLeaveRequest(url)
       await removeTrustedRelay(url)
     } finally {
       loading = false
diff --git a/src/app/components/SpaceFeaturedContent.svelte b/src/app/components/SpaceFeaturedContent.svelte
index 1bc18338..9e9b603c 100644
--- a/src/app/components/SpaceFeaturedContent.svelte
+++ b/src/app/components/SpaceFeaturedContent.svelte
@@ -8,7 +8,7 @@
   import EditFeaturedContent from "@app/components/EditFeaturedContent.svelte"
   import SpaceRecentSummary from "@app/components/SpaceRecentSummary.svelte"
   import {deriveFeaturedContent} from "@app/featured"
-  import {deriveSupportedMethods} from "@app/relays"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {pushModal} from "@app/modal"
 
   type Props = {
@@ -18,20 +18,19 @@
   const {url}: Props = $props()
 
   const content = deriveFeaturedContent(url)
-  const supportedMethods = deriveSupportedMethods(url)
-  const canEdit = $derived($supportedMethods.some(m => (m as string) === "signevent"))
+  const canEdit = deriveUserIsSpaceAdmin(url)
 
   const edit = () => pushModal(EditFeaturedContent, {url, initial: $content})
 </script>
 
-{#if $content.length > 0 || canEdit}
+{#if $content.length > 0 || $canEdit}
   <Card class="bg-surface flex flex-col gap-3 @container">
     <div class="flex items-center justify-between gap-2">
       <h3 class="flex items-center gap-2 text-lg font-bold">
         <Icon icon={Bookmark} />
         Featured
       </h3>
-      {#if canEdit}
+      {#if $canEdit}
         <Button class="button button-ghost button-sm button-square" onclick={edit}>
           <Icon icon={Pen} />
         </Button>
diff --git a/src/app/components/SpaceInvite.svelte b/src/app/components/SpaceInvite.svelte
index f69b6bb1..c8d6c85b 100644
--- a/src/app/components/SpaceInvite.svelte
+++ b/src/app/components/SpaceInvite.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {displayRelayUrl, ManagementMethod} from "@welshman/util"
   import {Share} from "@capacitor/share"
+  import {displayRelayUrl} from "@welshman/util"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Upload from "@assets/icons/upload.svg?dataurl"
   import Copy from "@assets/icons/copy.svg?dataurl"
@@ -18,19 +18,21 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import ProfileMultiSelect from "@app/components/ProfileMultiSelect.svelte"
+  import {deriveSpaceSupportedMethods} from "@app/management"
   import QRCode from "@app/components/QRCode.svelte"
-  import {clip, pushToast} from "@app/toast"
-  import {deriveSupportedMethods} from "@app/relays"
-  import {addSpaceMembers} from "@app/members"
   import {Access, makeInviteLink} from "@app/access"
+  import {relayManagement, relayMemberLists} from "@app/core"
+  import {clip, pushToast} from "@app/toast"
 
-  const {url} = $props()
+  type Props = {
+    url: string
+  }
+
+  const {url}: Props = $props()
 
   const access = new Access(url)
   const {claim, loading} = access
   const inviteStatus = access.createInviteStatus(false)
-  const supportedMethods = deriveSupportedMethods(url)
-  const canAddMembers = $derived($supportedMethods.includes(ManagementMethod.AllowPubkey))
 
   const back = () => history.back()
   const copyInvite = () => clip(invite)
@@ -45,19 +47,18 @@
     }
   }
 
-  let canShare = $state(false)
-  let invite = $state("")
-
-  let adding = $state(false)
-  let pubkeys: string[] = $state([])
-
   const addMembers = async () => {
-    if (pubkeys.length === 0) return
-
     adding = true
 
     try {
-      const error = await addSpaceMembers(url, pubkeys)
+      const members = $relayMemberLists.get(url)
+      const management = $relayManagement.forUrl(url)
+
+      const responses = await Promise.all(
+        pubkeys.filter(pk => !members?.isMember(pk)).map(pk => management.allowPubkey(pk)),
+      )
+
+      const error = responses.map(response => response.error).find(Boolean)
 
       if (error) {
         pushToast({theme: "error", message: error})
@@ -70,6 +71,16 @@
     }
   }
 
+  const supportedMethods = deriveSpaceSupportedMethods(url)
+
+  const canAddMembers = $derived($supportedMethods.includes("allowpubkey"))
+
+  let canShare = $state(false)
+  let invite = $state("")
+
+  let adding = $state(false)
+  let pubkeys: string[] = $state([])
+
   $effect(() => {
     invite = makeInviteLink({url, claim: $claim})
   })
diff --git a/src/app/components/SpaceMember.svelte b/src/app/components/SpaceMember.svelte
index d91ddf6f..88bb8374 100644
--- a/src/app/components/SpaceMember.svelte
+++ b/src/app/components/SpaceMember.svelte
@@ -1,29 +1,28 @@
 <script lang="ts">
-  import {ManagementMethod} from "@welshman/util"
-  import {displayProfileByPubkey} from "@welshman/app"
+  import type {RelayRoleReader} from "@welshman/domain"
   import MenuButton from "@lib/components/MenuButton.svelte"
   import Profile from "@app/components/Profile.svelte"
   import ProfileAbout from "@app/components/ProfileAbout.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
   import SpaceMemberMenu from "@app/components/SpaceMemberMenu.svelte"
   import RoleBadge from "@app/components/RoleBadge.svelte"
-  import {type SpaceRole} from "@app/members"
-  import {deriveSupportedMethods} from "@app/relays"
+  import {deriveSpaceSupportedMethods} from "@app/management"
   import {pushModal} from "@app/modal"
+  import {profiles} from "@app/core"
 
   interface Props {
     url: string
     pubkey: string
-    roles?: SpaceRole[]
+    roles?: RelayRoleReader[]
   }
 
   const {url, pubkey, roles = []}: Props = $props()
 
-  const supportedMethods = deriveSupportedMethods(url)
-  const canUnallow = $derived($supportedMethods.includes(ManagementMethod.UnallowPubkey))
-  const canBan = $derived($supportedMethods.includes(ManagementMethod.BanPubkey))
-  const canAssign = $derived($supportedMethods.some(m => (m as string) === "assignrole"))
-  const canUnassign = $derived($supportedMethods.some(m => (m as string) === "unassignrole"))
+  const supportedMethods = deriveSpaceSupportedMethods(url)
+  const canUnallow = $derived($supportedMethods.includes("unallowpubkey"))
+  const canBan = $derived($supportedMethods.includes("banpubkey"))
+  const canAssign = $derived($supportedMethods.includes("assignrole"))
+  const canUnassign = $derived($supportedMethods.includes("unassignrole"))
 
   const openProfile = () => pushModal(ProfileDetail, {pubkey, url})
 </script>
@@ -32,7 +31,7 @@
   <button
     type="button"
     class="absolute inset-0 cursor-pointer rounded-2xl"
-    aria-label="View {displayProfileByPubkey(pubkey)}'s profile"
+    aria-label="View {$profiles.display(pubkey).get()}'s profile"
     onclick={openProfile}>
   </button>
   <div class="pointer-events-none relative flex items-start justify-between gap-2">
@@ -40,7 +39,7 @@
       <Profile {pubkey} {url} inert />
       {#if roles.length > 0}
         <div class="flex flex-wrap gap-x-3 gap-y-1">
-          {#each roles as role (role.id)}
+          {#each roles as role (role.identifier())}
             <RoleBadge {role} />
           {/each}
         </div>
diff --git a/src/app/components/SpaceMemberBannedMenu.svelte b/src/app/components/SpaceMemberBannedMenu.svelte
index c21f5dec..f051e514 100644
--- a/src/app/components/SpaceMemberBannedMenu.svelte
+++ b/src/app/components/SpaceMemberBannedMenu.svelte
@@ -1,14 +1,12 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {ManagementMethod} from "@welshman/util"
-  import {manageRelay} from "@welshman/app"
   import Restart from "@assets/icons/restart.svg?dataurl"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
-  import {addSpaceMembers} from "@app/members"
-  import {deriveSupportedMethods} from "@app/relays"
+  import {deriveSpaceSupportedMethods} from "@app/management"
   import {pushToast} from "@app/toast"
+  import {relayManagement} from "@app/core"
 
   type Props = {
     url: string
@@ -18,17 +16,14 @@
 
   const {url, pubkey, onClick}: Props = $props()
 
-  const supportedMethods = deriveSupportedMethods(url)
-  const canUnban = $derived($supportedMethods.includes(ManagementMethod.UnbanPubkey))
-  const canRestore = $derived($supportedMethods.includes(ManagementMethod.AllowPubkey))
+  const supportedMethods = deriveSpaceSupportedMethods(url)
+  const canUnban = $derived($supportedMethods.includes("unbanpubkey"))
+  const canRestore = $derived($supportedMethods.includes("allowpubkey"))
 
   const back = () => history.back()
 
   const unbanMember = async () => {
-    const {error} = await manageRelay(url, {
-      method: ManagementMethod.UnbanPubkey,
-      params: [pubkey],
-    })
+    const {error} = await $relayManagement.forUrl(url).unbanPubkey(pubkey)
 
     if (error) {
       pushToast({theme: "error", message: error})
@@ -39,7 +34,7 @@
   }
 
   const restoreMember = async () => {
-    const error = await addSpaceMembers(url, [pubkey])
+    const {error} = await $relayManagement.forUrl(url).allowPubkey(pubkey)
 
     if (error) {
       pushToast({theme: "error", message: error})
diff --git a/src/app/components/SpaceMemberMenu.svelte b/src/app/components/SpaceMemberMenu.svelte
index c7297179..07623cc4 100644
--- a/src/app/components/SpaceMemberMenu.svelte
+++ b/src/app/components/SpaceMemberMenu.svelte
@@ -1,7 +1,5 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {ManagementMethod} from "@welshman/util"
-  import {displayProfileByPubkey} from "@welshman/app"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import UserMinus from "@assets/icons/user-minus.svg?dataurl"
   import MinusCircle from "@assets/icons/minus-circle.svg?dataurl"
@@ -9,8 +7,8 @@
   import Button from "@lib/components/Button.svelte"
   import Confirm from "@lib/components/Confirm.svelte"
   import SpaceMemberRoles from "@app/components/SpaceMemberRoles.svelte"
-  import {removeSpaceMembers, banSpaceMembers} from "@app/members"
-  import {deriveSupportedMethods} from "@app/relays"
+  import {profiles, relayManagement} from "@app/core"
+  import {deriveSpaceSupportedMethods} from "@app/management"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
 
@@ -22,11 +20,12 @@
 
   const {url, pubkey, onClick}: Props = $props()
 
-  const supportedMethods = deriveSupportedMethods(url)
-  const canUnallow = $derived($supportedMethods.includes(ManagementMethod.UnallowPubkey))
-  const canBan = $derived($supportedMethods.includes(ManagementMethod.BanPubkey))
-  const canAssign = $derived($supportedMethods.some(m => (m as string) === "assignrole"))
-  const canUnassign = $derived($supportedMethods.some(m => (m as string) === "unassignrole"))
+  const supportedMethods = deriveSpaceSupportedMethods(url)
+
+  const canUnallow = $derived($supportedMethods.includes("unallowpubkey"))
+  const canBan = $derived($supportedMethods.includes("banpubkey"))
+  const canAssign = $derived($supportedMethods.includes("assignrole"))
+  const canUnassign = $derived($supportedMethods.includes("unassignrole"))
 
   const back = () => history.back()
 
@@ -35,9 +34,9 @@
   const removeMember = () =>
     pushModal(Confirm, {
       title: "Remove Member",
-      message: `Remove @${displayProfileByPubkey(pubkey)} from the space?`,
+      message: `Remove @${$profiles.display(pubkey).get()} from the space?`,
       confirm: async () => {
-        const error = await removeSpaceMembers(url, [pubkey])
+        const {error} = await $relayManagement.forUrl(url).unallowPubkey(pubkey)
 
         if (error) {
           pushToast({theme: "error", message: error})
@@ -51,9 +50,9 @@
   const banMember = () =>
     pushModal(Confirm, {
       title: "Ban Member",
-      message: `Ban @${displayProfileByPubkey(pubkey)} from the space?`,
+      message: `Ban @${$profiles.display(pubkey).get()} from the space?`,
       confirm: async () => {
-        const error = await banSpaceMembers(url, [pubkey])
+        const {error} = await $relayManagement.forUrl(url).banPubkey(pubkey)
 
         if (error) {
           pushToast({theme: "error", message: error})
diff --git a/src/app/components/SpaceMemberRoles.svelte b/src/app/components/SpaceMemberRoles.svelte
index 4c77c1f4..9ca288c1 100644
--- a/src/app/components/SpaceMemberRoles.svelte
+++ b/src/app/components/SpaceMemberRoles.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
   import {get} from "svelte/store"
-  import {displayProfileByPubkey} from "@welshman/app"
+  import {sortBy} from "@welshman/lib"
+  import {RelayRoles} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Spinner from "@lib/components/Spinner.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -12,23 +13,24 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import RoleItem from "@app/components/RoleItem.svelte"
-  import {deriveSpaceRoles, deriveSpaceMemberRoles, assignRole, unassignRole} from "@app/members"
+  import {app, profiles, relayManagement} from "@app/core"
+  import {deriveSpaceMemberRoles} from "@app/roles"
   import {pushToast} from "@app/toast"
 
-  interface Props {
+  type Props = {
     url: string
     pubkey: string
   }
 
   const {url, pubkey}: Props = $props()
 
-  const roles = deriveSpaceRoles(url)
+  const relayRoles = $app.use(RelayRoles).forUrl(url).$
+  const roles = $derived(sortBy(role => [role.order(), role.label() ?? ""], $relayRoles))
+
+  const profileDisplay = $profiles.display(pubkey).$
   const memberRoles = deriveSpaceMemberRoles(url)
   const initial = new Set(get(memberRoles).get(pubkey) ?? [])
 
-  let selected = $state(new Set(initial))
-  let loading = $state(false)
-
   const back = () => history.back()
 
   const toggle = (id: string) => {
@@ -47,9 +49,11 @@
     loading = true
 
     try {
+      const management = $relayManagement.forUrl(url)
+
       for (const id of selected) {
         if (!initial.has(id)) {
-          const error = await assignRole(url, pubkey, id)
+          const {error} = await management.assignRole(pubkey, id)
 
           if (error) {
             pushToast({theme: "error", message: error})
@@ -60,7 +64,7 @@
 
       for (const id of initial) {
         if (!selected.has(id)) {
-          const error = await unassignRole(url, pubkey, id)
+          const {error} = await management.unassignRole(pubkey, id)
 
           if (error) {
             pushToast({theme: "error", message: error})
@@ -75,6 +79,9 @@
       loading = false
     }
   }
+
+  let selected = $state(new Set(initial))
+  let loading = $state(false)
 </script>
 
 <Modal>
@@ -82,21 +89,21 @@
     <ModalHeader>
       <ModalTitle>Edit Member</ModalTitle>
       <ModalSubtitle>
-        Manage roles for <span class="text-primary">@{displayProfileByPubkey(pubkey)}</span>
+        Manage roles for <span class="text-primary">@{$profileDisplay}</span>
       </ModalSubtitle>
     </ModalHeader>
-    {#if $roles.length === 0}
+    {#if roles.length === 0}
       <div class="card bg-surface p-4 text-sm opacity-70">This space has no roles yet.</div>
     {:else}
       <div class="flex flex-col gap-2">
-        {#each $roles as role (role.id)}
+        {#each roles as role (role.identifier())}
           <label class="card card-sm flex justify-between cursor-pointer gap-3">
             <RoleItem {role} />
             <input
               type="checkbox"
               class="checkbox"
-              checked={selected.has(role.id)}
-              onchange={() => toggle(role.id)} />
+              checked={selected.has(role.identifier() ?? "")}
+              onchange={() => toggle(role.identifier() ?? "")} />
           </label>
         {/each}
       </div>
diff --git a/src/app/components/SpaceMembersBanned.svelte b/src/app/components/SpaceMembersBanned.svelte
index 4cfff339..f2076f8d 100644
--- a/src/app/components/SpaceMembersBanned.svelte
+++ b/src/app/components/SpaceMembersBanned.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-  import {displayRelayUrl, ManagementMethod} from "@welshman/util"
+  import {displayRelayUrl} from "@welshman/util"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Button from "@lib/components/Button.svelte"
   import Icon from "@lib/components/Icon.svelte"
@@ -12,8 +12,7 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import Profile from "@app/components/Profile.svelte"
   import SpaceMemberBannedMenu from "@app/components/SpaceMemberBannedMenu.svelte"
-  import {deriveSpaceBannedPubkeyItems} from "@app/members"
-  import {deriveSupportedMethods} from "@app/relays"
+  import {deriveSpaceBannedPubkeyItems, deriveSpaceSupportedMethods} from "@app/management"
 
   interface Props {
     url: string
@@ -22,9 +21,9 @@
   const {url}: Props = $props()
 
   const bans = deriveSpaceBannedPubkeyItems(url)
-  const supportedMethods = deriveSupportedMethods(url)
-  const canUnban = $derived($supportedMethods.includes(ManagementMethod.UnbanPubkey))
-  const canRestore = $derived($supportedMethods.includes(ManagementMethod.AllowPubkey))
+  const supportedMethods = deriveSpaceSupportedMethods(url)
+  const canUnban = $derived($supportedMethods.includes("unbanpubkey"))
+  const canRestore = $derived($supportedMethods.includes("allowpubkey"))
 
   const back = () => history.back()
 </script>
diff --git a/src/app/components/SpaceMembersSummary.svelte b/src/app/components/SpaceMembersSummary.svelte
index 3104f432..92eadc9b 100644
--- a/src/app/components/SpaceMembersSummary.svelte
+++ b/src/app/components/SpaceMembersSummary.svelte
@@ -1,13 +1,12 @@
 <script lang="ts">
   import {derived} from "svelte/store"
-  import {RELAY_ADD_MEMBER, RELAY_JOIN, getPubkeyTagValues} from "@welshman/util"
-  import {deriveRelay} from "@welshman/app"
+  import {RELAY_ADD_MEMBER, RELAY_JOIN, hexTags, tagValues} from "@welshman/util"
   import UsersGroup from "@assets/icons/users-group-rounded.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Link from "@lib/components/Link.svelte"
   import Profile from "@app/components/Profile.svelte"
-  import {deriveSpaceMembers} from "@app/members"
+  import {relayMemberLists, relays} from "@app/core"
   import {deriveEventsForUrl} from "@app/repository"
   import {makeSpacePath} from "@app/routes"
 
@@ -17,8 +16,8 @@
 
   const {url}: Props = $props()
 
-  const relay = deriveRelay(url)
-  const members = deriveSpaceMembers(url)
+  const relay = $relays.one(url)
+  const members = $relayMemberLists.forUrl(url)
   const memberEvents = deriveEventsForUrl(url, [{kinds: [RELAY_ADD_MEMBER, RELAY_JOIN]}])
 
   const admins = $derived($relay?.pubkey ? [$relay.pubkey] : [])
@@ -33,14 +32,15 @@
       const joinedAt = new Map<string, number>()
 
       for (const event of $memberEvents) {
-        const pubkeys = event.kind === RELAY_JOIN ? [event.pubkey] : getPubkeyTagValues(event.tags)
+        const pubkeys =
+          event.kind === RELAY_JOIN ? [event.pubkey] : tagValues(hexTags("p"), event.tags)
 
         for (const pubkey of pubkeys) {
           joinedAt.set(pubkey, Math.max(joinedAt.get(pubkey) || 0, event.created_at))
         }
       }
 
-      return $members
+      return ($members?.pubkeys() ?? [])
         .filter(pubkey => !adminSet.has(pubkey))
         .sort((a, b) => (joinedAt.get(b) || 0) - (joinedAt.get(a) || 0))
         .slice(0, 5)
diff --git a/src/app/components/SpaceMenu.svelte b/src/app/components/SpaceMenu.svelte
index a2aaad65..3f1d9244 100644
--- a/src/app/components/SpaceMenu.svelte
+++ b/src/app/components/SpaceMenu.svelte
@@ -1,8 +1,16 @@
 <script lang="ts">
   import {derived} from "svelte/store"
   import cx from "classnames"
-  import {displayRelayUrl, EVENT_TIME, ZAP_GOAL, THREAD, CLASSIFIED, POLL} from "@welshman/util"
-  import {deriveRelay, createSearch, pubkey} from "@welshman/app"
+  import {
+    displayRelayUrl,
+    EVENT_TIME,
+    ZAP_GOAL,
+    THREAD,
+    CLASSIFIED,
+    PINBOARD,
+    POLL,
+  } from "@welshman/util"
+  import {createSearch} from "@welshman/app"
   import {fly} from "@lib/transition"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
   import AltArrowDown from "@assets/icons/alt-arrow-down.svg?dataurl"
@@ -44,19 +52,22 @@
   import SpaceMenuRoomItem from "@app/components/SpaceMenuRoomItem.svelte"
   import VoiceWidget from "@app/components/VoiceWidget.svelte"
   import SocketStatusIndicator from "@app/components/SocketStatusIndicator.svelte"
+  import {relays, user} from "@app/core"
   import {ENABLE_ZAPS} from "@app/env"
   import {CONTENT_KINDS} from "@app/content"
   import {deriveHostedRelay, HOSTING_ENABLED} from "@app/hosting"
-  import {deriveUserCanCreateRoom, deriveUserIsSpaceAdmin} from "@app/members"
   import {
-    deriveUserRooms,
+    deriveSpaceSupportedMethods,
+    deriveUserCanCreateRoom,
+    deriveUserIsSpaceAdmin,
+  } from "@app/management"
+  import {
     deriveOtherRooms,
     deriveOtherVoiceRooms,
-    userSpaceUrls,
+    deriveUserRooms,
     displayRoom,
-  } from "@app/groups"
-  import {hasNip29, deriveSupportedMethods} from "@app/relays"
-  import {BOARD} from "@app/pinboards"
+    userSpaceUrls,
+  } from "@app/rooms"
   import {deriveEventsForUrl} from "@app/repository"
   import {deriveSpaceActionItems} from "@app/actionItems"
   import {notificationSettings, deriveShouldNotify, setSpaceNotifications} from "@app/settings"
@@ -71,7 +82,7 @@
 
   const {url, mobile = false}: Props = $props()
 
-  const relay = deriveRelay(url)
+  const relay = $relays.one(url)
   const chatPath = makeSpacePath(url, "chat")
   const goalsPath = makeSpacePath(url, "goals")
   const threadsPath = makeSpacePath(url, "threads")
@@ -90,11 +101,10 @@
     $events => new Set($events.map(e => e.kind)),
   )
 
-  const boardEvents = deriveEventsForUrl(url, [{kinds: [BOARD]}])
-  const supportedMethods = deriveSupportedMethods(url)
-  const showLibrary = $derived(
-    $boardEvents.length > 0 || $supportedMethods.some(m => (m as string) === "signevent"),
-  )
+  const boardEvents = deriveEventsForUrl(url, [{kinds: [PINBOARD]}])
+  const hasNip29 = $derived($relay?.hasNip(29) ?? false)
+  const supportedMethods = deriveSpaceSupportedMethods(url)
+  const showLibrary = $derived($boardEvents.length > 0 || $supportedMethods.includes("signevent"))
 
   const roomSearch = derived(otherRooms, $otherRooms =>
     createSearch(
@@ -196,7 +206,7 @@
             </Button>
           </li>
         {/if}
-        {#if $relay?.pubkey && $relay.pubkey !== $pubkey}
+        {#if $relay?.pubkey && $relay.pubkey !== $user.pubkey}
           <li>
             <Button onclick={contactOwner}>
               <Icon icon={Letter} />
@@ -257,7 +267,7 @@
   <SecondaryNavItem href={makeSpacePath(url, "about")}>
     <Icon icon={Home} /> Space Details
   </SecondaryNavItem>
-  {#if hasNip29($relay)}
+  {#if hasNip29}
     <SecondaryNavItem href={makeSpacePath(url, "recent")}>
       <Icon icon={History} /> Recent Activity
     </SecondaryNavItem>
@@ -299,7 +309,7 @@
       <Icon icon={Revote} /> Polls
     </SecondaryNavItem>
   {/if}
-  {#if hasNip29($relay)}
+  {#if hasNip29}
     <SecondaryNavItem onclick={openSearch}>
       <Icon icon={Magnifier} /> Search
     </SecondaryNavItem>
@@ -307,7 +317,7 @@
 {/snippet}
 
 {#snippet spaceRooms()}
-  {#if hasNip29($relay)}
+  {#if hasNip29}
     {#if $userRooms.length > 0}
       {#if !mobile}
         <div class="h-2 shrink-0"></div>
@@ -376,7 +386,7 @@
           <SecondaryNavHeader>Space</SecondaryNavHeader>
           {@render spaceNavItems()}
         </div>
-        {#if hasNip29($relay) && ($userRooms.length > 0 || $otherRooms.length > 0 || $otherVoiceRooms.length > 0 || $canCreateRoom)}
+        {#if hasNip29 && ($userRooms.length > 0 || $otherRooms.length > 0 || $otherVoiceRooms.length > 0 || $canCreateRoom)}
           <div class="card space-menu__card flex flex-col gap-1">
             {@render spaceRooms()}
           </div>
diff --git a/src/app/components/SpaceMenuRoomItem.svelte b/src/app/components/SpaceMenuRoomItem.svelte
index 1800d124..70297125 100644
--- a/src/app/components/SpaceMenuRoomItem.svelte
+++ b/src/app/components/SpaceMenuRoomItem.svelte
@@ -5,7 +5,8 @@
   import SecondaryNavItem from "@lib/components/SecondaryNavItem.svelte"
   import RoomNameWithImage from "@app/components/RoomNameWithImage.svelte"
   import VoiceRoomItem from "@app/components/VoiceRoomItem.svelte"
-  import {deriveRoom, getRoomType, RoomType} from "@app/groups"
+  import {rooms} from "@app/core"
+  import {RoomType, getRoomType} from "@app/rooms"
   import {deriveShouldNotify} from "@app/settings"
   import {notifications} from "@app/notifications"
   import {makeRoomPath} from "@app/routes"
@@ -19,14 +20,14 @@
 
   const {url, h, replaceState = false, tooltip = true}: Props = $props()
 
-  const room = deriveRoom(url, h)
+  const room = $rooms.forRoom(url, h)
   const roomType = $derived(getRoomType($room))
   const path = makeRoomPath(url, h)
   const shouldNotifyForSpace = deriveShouldNotify(url)
   const shouldNotifyForRoom = deriveShouldNotify(url, h)
   const showDifferenceIcon = $derived($shouldNotifyForRoom !== $shouldNotifyForSpace)
   const notification = $derived($shouldNotifyForRoom ? $notifications.has(path) : false)
-  const roomName = $derived($room?.name || h)
+  const roomName = $derived($room?.meta?.name() || h)
 </script>
 
 {#if roomType === RoomType.Voice}
diff --git a/src/app/components/SpaceRedirect.svelte b/src/app/components/SpaceRedirect.svelte
index 827c0c70..a8141a1d 100644
--- a/src/app/components/SpaceRedirect.svelte
+++ b/src/app/components/SpaceRedirect.svelte
@@ -12,7 +12,7 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {moveSpace} from "@app/groups"
+  import {roomLists} from "@app/core"
   import {goToMovedSpace} from "@app/routes"
 
   type Props = {
@@ -28,7 +28,7 @@
     loading = true
 
     try {
-      await moveSpace(url, newUrl)
+      await $roomLists.migrateRelay(url, newUrl).then(command => command?.publish())
       await goToMovedSpace(url, newUrl)
     } finally {
       loading = false
diff --git a/src/app/components/SpaceRoleMenu.svelte b/src/app/components/SpaceRoleMenu.svelte
index ed445b11..2932b566 100644
--- a/src/app/components/SpaceRoleMenu.svelte
+++ b/src/app/components/SpaceRoleMenu.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
   import {onMount} from "svelte"
+  import type {RelayRoleReader} from "@welshman/domain"
   import AddCircle from "@assets/icons/add-circle.svg?dataurl"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import TrashBin from "@assets/icons/trash-bin-2.svg?dataurl"
@@ -8,13 +9,13 @@
   import Confirm from "@lib/components/Confirm.svelte"
   import RoleEdit from "@app/components/RoleEdit.svelte"
   import RoleAddMembers from "@app/components/RoleAddMembers.svelte"
-  import {deleteRole, type SpaceRole} from "@app/members"
+  import {relayManagement} from "@app/core"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
 
   type Props = {
     url: string
-    role: SpaceRole
+    role: RelayRoleReader
     onClick: () => void
   }
 
@@ -26,20 +27,22 @@
 
   const addMembers = () => pushModal(RoleAddMembers, {url, role})
 
+  const deleteRole = async () => {
+    const {error} = await $relayManagement.forUrl(url).deleteRole(role.identifier() ?? "")
+
+    if (error) {
+      pushToast({theme: "error", message: error})
+    } else {
+      pushToast({message: "Role deleted!"})
+      back()
+    }
+  }
+
   const confirmDelete = () =>
     pushModal(Confirm, {
       title: "Delete Role",
-      message: `Delete the "${role.label}" role? Members will keep their space membership.`,
-      confirm: async () => {
-        const error = await deleteRole(url, role.id)
-
-        if (error) {
-          pushToast({theme: "error", message: error})
-        } else {
-          pushToast({message: "Role deleted!"})
-          back()
-        }
-      },
+      message: `Delete the "${role.label()}" role? Members will keep their space membership.`,
+      confirm: deleteRole,
     })
 
   let ul: Element
diff --git a/src/app/components/SpaceRoles.svelte b/src/app/components/SpaceRoles.svelte
index eb1dd159..ea786721 100644
--- a/src/app/components/SpaceRoles.svelte
+++ b/src/app/components/SpaceRoles.svelte
@@ -1,4 +1,6 @@
 <script lang="ts">
+  import {sortBy} from "@welshman/lib"
+  import {RelayRoles} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AddCircle from "@assets/icons/add-circle.svg?dataurl"
   import Button from "@lib/components/Button.svelte"
@@ -14,16 +16,17 @@
   import RoleCreate from "@app/components/RoleCreate.svelte"
   import RoleItem from "@app/components/RoleItem.svelte"
   import SpaceRoleMenu from "@app/components/SpaceRoleMenu.svelte"
-  import {deriveSpaceRoles} from "@app/members"
+  import {app} from "@app/core"
   import {pushModal} from "@app/modal"
 
-  interface Props {
+  type Props = {
     url: string
   }
 
   const {url}: Props = $props()
 
-  const roles = deriveSpaceRoles(url)
+  const relayRoles = $app.use(RelayRoles).forUrl(url).$
+  const roles = $derived(sortBy(role => [role.order(), role.label() ?? ""], $relayRoles))
 
   const back = () => history.back()
 
@@ -36,13 +39,13 @@
       <ModalTitle>Manage Roles</ModalTitle>
       <ModalSubtitle>on <RelayName {url} class="text-primary" /></ModalSubtitle>
     </ModalHeader>
-    {#if $roles.length === 0}
+    {#if roles.length === 0}
       <div class="card bg-surface p-4 text-sm opacity-70">
         No roles yet. Create one to start organizing members.
       </div>
     {:else}
       <div class="flex flex-col gap-2">
-        {#each $roles as role (role.id)}
+        {#each roles as role (role.identifier())}
           <div class="card card-sm flex justify-between gap-2">
             <RoleItem {role} />
             <div class="shrink-0">
diff --git a/src/app/components/SpaceSearch.svelte b/src/app/components/SpaceSearch.svelte
index 7ac9f4d9..db435cd7 100644
--- a/src/app/components/SpaceSearch.svelte
+++ b/src/app/components/SpaceSearch.svelte
@@ -1,11 +1,10 @@
 <script lang="ts">
   import {onMount, tick} from "svelte"
-  import {get} from "svelte/store"
   import {debounce} from "throttle-debounce"
   import {load} from "@welshman/net"
   import {groupBy, uniqBy, now, MINUTE, HOUR, DAY, WEEK} from "@welshman/lib"
   import type {TrustedEvent, Filter} from "@welshman/util"
-  import {MESSAGE, getTagValue, sortEventsDesc, displayRelayUrl} from "@welshman/util"
+  import {MESSAGE, sortEventsDesc, displayRelayUrl, tagValue, tagSpec} from "@welshman/util"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
@@ -20,7 +19,7 @@
   import NoteCard from "@app/components/NoteCard.svelte"
   import NoteContentMinimal from "@app/components/NoteContentMinimal.svelte"
   import {CONTENT_KINDS} from "@app/content"
-  import {deriveEventsForUrlDesc} from "@app/repository"
+  import {getEventsForUrl} from "@app/repository"
   import {popModal} from "@app/modal"
   import {pushToast} from "@app/toast"
   import {goToEvent} from "@app/routes"
@@ -49,7 +48,7 @@
       search: searchTerm.trim(),
     }
 
-    results = get(deriveEventsForUrlDesc(url, [filter]))
+    results = sortEventsDesc(getEventsForUrl(url, [filter]))
 
     try {
       const events = await load({
@@ -159,7 +158,7 @@
           {/if}
         </p>
         {#each events as event (event.id)}
-          {@const h = getTagValue("h", event.tags)}
+          {@const h = tagValue(tagSpec("h"), event.tags)}
           <Button
             class="card card-sm card-interactive flex flex-col gap-2"
             onclick={() => onResultClick(event)}>
diff --git a/src/app/components/SpaceTrustRelay.svelte b/src/app/components/SpaceTrustRelay.svelte
index 4bb29c34..243564b4 100644
--- a/src/app/components/SpaceTrustRelay.svelte
+++ b/src/app/components/SpaceTrustRelay.svelte
@@ -2,6 +2,7 @@
   import {goto} from "$app/navigation"
   import {remove} from "@welshman/lib"
   import {displayRelayUrl} from "@welshman/util"
+  import {publish} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
@@ -16,9 +17,9 @@
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import InfoSignatures from "@app/components/InfoSignatures.svelte"
   import {relaysPendingTrust} from "@app/policies"
-  import {removeSpace} from "@app/groups"
   import {addTrustedRelay, removeTrustedRelay} from "@app/settings"
   import {pushModal} from "@app/modal"
+  import {roomLists} from "@app/core"
 
   type Props = {
     url: string
@@ -32,7 +33,7 @@
     loading = true
 
     try {
-      await removeSpace(url)
+      await $roomLists.removeRelay(url).then(publish)
       await removeTrustedRelay(url)
       goto("/home")
     } finally {
diff --git a/src/app/components/ThreadActions.svelte b/src/app/components/ThreadActions.svelte
index e4115191..94f2921a 100644
--- a/src/app/components/ThreadActions.svelte
+++ b/src/app/components/ThreadActions.svelte
@@ -1,15 +1,13 @@
 <script lang="ts">
+  import {tagSpec, tagValue} from "@welshman/util"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
   import Link from "@lib/components/Link.svelte"
   import RoomName from "@app/components/RoomName.svelte"
+  import {publishReaction, retractReaction} from "@app/reactions"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
   import ThunkStatusOrDeleted from "@app/components/ThunkStatusOrDeleted.svelte"
   import EventActivity from "@app/components/EventActivity.svelte"
   import EventActions from "@app/components/EventActions.svelte"
-  import {publishDelete} from "@app/deletes"
-  import {publishReaction} from "@app/reactions"
-  import {canEnforceNip70} from "@app/relays"
   import {makeThreadPath, makeSpacePath} from "@app/routes"
 
   interface Props {
@@ -21,15 +19,11 @@
 
   const {url, event, showRoom, showActivity}: Props = $props()
 
-  const h = getTagValue("h", event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
   const path = makeThreadPath(url, event.id)
-  const shouldProtect = canEnforceNip70(url)
+  const deleteReaction = (reaction: TrustedEvent) => retractReaction(reaction, {url})
 
-  const deleteReaction = async (event: TrustedEvent) =>
-    publishDelete({relays: [url], event, protect: await shouldProtect})
-
-  const createReaction = async (template: EventContent) =>
-    publishReaction({...template, event, relays: [url], protect: await shouldProtect})
+  const createReaction = (values: EventContent) => publishReaction(event, values, {url})
 </script>
 
 <div class="flex grow flex-wrap justify-end gap-2">
diff --git a/src/app/components/ThreadBoardItem.svelte b/src/app/components/ThreadBoardItem.svelte
index 6b8e9fce..74265a5b 100644
--- a/src/app/components/ThreadBoardItem.svelte
+++ b/src/app/components/ThreadBoardItem.svelte
@@ -1,8 +1,8 @@
 <script lang="ts">
+  import {goto} from "$app/navigation"
   import {formatTimestamp, max} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {COMMENT, getTagValue} from "@welshman/util"
-  import {goto} from "$app/navigation"
+  import {COMMENT, tagSpec, tagValue} from "@welshman/util"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
   import {deriveEventsForUrl} from "@app/repository"
@@ -20,7 +20,7 @@
   const replies = deriveEventsForUrl(url, filters)
   const replyCount = $derived($replies.length)
   const lastActive = $derived(max([...$replies, event].map(e => e.created_at)))
-  const title = getTagValue("title", event.tags)
+  const title = tagValue(tagSpec("title"), event.tags)
   const path = makeThreadPath(url, event.id)
 
   const goToThread = () => goto(path)
diff --git a/src/app/components/ThreadCreate.svelte b/src/app/components/ThreadCreate.svelte
index 0bce206f..7a578fb2 100644
--- a/src/app/components/ThreadCreate.svelte
+++ b/src/app/components/ThreadCreate.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {writable} from "svelte/store"
-  import {makeEvent, THREAD} from "@welshman/util"
-  import {publishThunk, waitForThunkError} from "@welshman/app"
+  import {Thread} from "@welshman/domain"
+  import {publish} from "@welshman/app"
   import {isMobile, preventDefault} from "@lib/html"
   import Paperclip from "@assets/icons/paperclip-2.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
@@ -16,11 +16,11 @@
   import Modal from "@lib/components/Modal.svelte"
   import ModalBody from "@lib/components/ModalBody.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
-  import {pushToast} from "@app/toast"
-  import {PROTECTED, publishRoomQuote} from "@app/groups"
-  import {makeEditor} from "@app/editor"
+  import {command, relays, writer} from "@app/core"
   import {DraftKey} from "@app/drafts"
-  import {canEnforceNip70} from "@app/relays"
+  import {makeEditor} from "@app/editor"
+  import {publishRoomQuote} from "@app/rooms"
+  import {pushToast} from "@app/toast"
 
   type Values = {
     content?: string | object
@@ -36,7 +36,7 @@
   const {url, h, shareToChat = false}: Props = $props()
   const draftKey = new DraftKey<Values>(`thread:${url}:${h ?? ""}`)
   const initialValues = draftKey.get()
-  const shouldProtect = canEnforceNip70(url)
+  const shouldProtect = $relays.hasNip(url, 70)
 
   const uploading = writable(false)
 
@@ -57,34 +57,30 @@
     const ed = await editor
     const content = ed.getText({blockSeparator: "\n"}).trim()
 
-    if (!content.trim()) {
+    if (!content) {
       return pushToast({
         theme: "error",
         message: "Please provide a message for your thread.",
       })
     }
 
-    const tags = [...ed.storage.nostr.getEditorTags(), ["title", title]]
-
     loading = true
 
     try {
       const protect = await shouldProtect
-
-      if (protect) {
-        tags.push(PROTECTED)
-      }
+      const eventWriter = writer(Thread)
+        .setContent(content)
+        .setTitle(title)
+        .setProtected(protect)
+        .addTags(...ed.storage.nostr.getEditorTags())
+        .forceRelays(url)
 
       if (h) {
-        tags.push(["h", h])
+        eventWriter.setRoom(url, h)
       }
 
-      const threadThunk = publishThunk({
-        relays: [url],
-        event: makeEvent(THREAD, {content, tags}),
-      })
-
-      const error = await waitForThunkError(threadThunk)
+      const thunk = await command(eventWriter).then(publish)
+      const error = await thunk.waitForError()
 
       if (error) {
         return pushToast({theme: "error", message: error})
@@ -94,7 +90,7 @@
       history.back()
 
       if (shareToChat) {
-        publishRoomQuote({url, h, parent: threadThunk.event, protect})
+        publishRoomQuote({url, h, parent: thunk.event, protect})
       }
     } finally {
       loading = false
diff --git a/src/app/components/ThreadItem.svelte b/src/app/components/ThreadItem.svelte
index bb50fab7..b0f97de7 100644
--- a/src/app/components/ThreadItem.svelte
+++ b/src/app/components/ThreadItem.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {formatTimestamp} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {tagSpec, tagValue} from "@welshman/util"
   import Link from "@lib/components/Link.svelte"
   import Content from "@app/components/Content.svelte"
   import ProfileLink from "@app/components/ProfileLink.svelte"
@@ -16,8 +16,8 @@
 
   const {url, event}: Props = $props()
 
-  const title = getTagValue("title", event.tags)
-  const h = getTagValue("h", event.tags)
+  const title = tagValue(tagSpec("title"), event.tags)
+  const h = tagValue(tagSpec("h"), event.tags)
 </script>
 
 <Link
diff --git a/src/app/components/ThreadPost.svelte b/src/app/components/ThreadPost.svelte
index e0626cd5..4a285333 100644
--- a/src/app/components/ThreadPost.svelte
+++ b/src/app/components/ThreadPost.svelte
@@ -1,8 +1,7 @@
 <script lang="ts">
   import {formatTimestamp} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {COMMENT} from "@welshman/util"
-  import {deriveHandleForPubkey, deriveProfileDisplay, displayHandle} from "@welshman/app"
+  import {COMMENT, displayHandle} from "@welshman/util"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import LinkRound from "@assets/icons/link-round.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -14,6 +13,7 @@
   import Content from "@app/components/Content.svelte"
   import CommentActions from "@app/components/CommentActions.svelte"
   import ThreadActions from "@app/components/ThreadActions.svelte"
+  import {handles, profiles} from "@app/core"
   import {makeEventPermalink} from "@app/routes"
   import {pushModal} from "@app/modal"
   import {clip} from "@app/toast"
@@ -27,8 +27,8 @@
 
   const {url, event, threadPubkey, onReply}: Props = $props()
 
-  const profileDisplay = deriveProfileDisplay(event.pubkey, [url])
-  const handle = deriveHandleForPubkey(event.pubkey)
+  const profileDisplay = $profiles.display(event.pubkey, [url]).$
+  const handle = $handles.forPubkey(event.pubkey).$
   const isOp = event.pubkey === threadPubkey
   const isComment = event.kind === COMMENT
 
diff --git a/src/app/components/ThunkFailure.svelte b/src/app/components/ThunkFailure.svelte
index 2e2a744b..ee0e7cea 100644
--- a/src/app/components/ThunkFailure.svelte
+++ b/src/app/components/ThunkFailure.svelte
@@ -1,44 +1,42 @@
 <script lang="ts">
   import {stopPropagation} from "svelte/legacy"
   import {noop} from "@welshman/lib"
-  import type {AbstractThunk} from "@welshman/app"
-  import {flattenThunks, getFailedThunkUrls, publishThunk, thunkIsComplete} from "@welshman/app"
+  import type {BaseThunk} from "@welshman/app"
   import Danger from "@assets/icons/danger-triangle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Tippy from "@lib/components/Tippy.svelte"
   import ThunkToast from "@app/components/ThunkToast.svelte"
   import ThunkStatusDetail from "@app/components/ThunkStatusDetail.svelte"
+  import {thunks} from "@app/core"
   import {pushToast} from "@app/toast"
 
-  interface Props {
-    thunk: AbstractThunk
+  type Props = {
+    thunk: BaseThunk
     showToastOnRetry?: boolean
     class?: string
   }
 
   const {thunk, showToastOnRetry, ...restProps}: Props = $props()
 
-  const showFailure = $derived(thunkIsComplete($thunk) && getFailedThunkUrls($thunk).length > 0)
+  const showFailure = $derived($thunk.isComplete() && $thunk.getFailedUrls().length > 0)
 
   const retry = (url: string) => {
-    for (const child of flattenThunks([thunk])) {
-      if (!child.options.relays.includes(url)) {
-        continue
+    for (const child of $thunks.flatten([thunk])) {
+      if (child.options.relays.includes(url)) {
+        const retried = $thunks.publish({...child.options, relays: [url]})
+
+        if (showToastOnRetry) {
+          pushToast({
+            timeout: 30_000,
+            children: {
+              component: ThunkToast,
+              props: {thunk: retried},
+            },
+          })
+        }
+
+        return
       }
-
-      const retried = publishThunk({...child.options, relays: [url]})
-
-      if (showToastOnRetry) {
-        pushToast({
-          timeout: 30_000,
-          children: {
-            component: ThunkToast,
-            props: {thunk: retried},
-          },
-        })
-      }
-
-      return
     }
   }
 </script>
diff --git a/src/app/components/ThunkPending.svelte b/src/app/components/ThunkPending.svelte
index e83d56a1..b3ae2e3a 100644
--- a/src/app/components/ThunkPending.svelte
+++ b/src/app/components/ThunkPending.svelte
@@ -1,19 +1,18 @@
 <script lang="ts">
   import {stopPropagation} from "svelte/legacy"
   import {PublishStatus} from "@welshman/net"
-  import type {AbstractThunk} from "@welshman/app"
-  import {abortThunk, thunkHasStatus} from "@welshman/app"
+  import type {BaseThunk} from "@welshman/app"
 
-  interface Props {
-    thunk: AbstractThunk
+  type Props = {
+    thunk: BaseThunk
     class?: string
   }
 
   const {thunk, ...restProps}: Props = $props()
 
-  const abort = () => abortThunk(thunk)
+  const abort = () => thunk.abort()
 
-  const isSending = $derived(thunkHasStatus(PublishStatus.Sending, $thunk))
+  const isSending = $derived($thunk.hasStatus(PublishStatus.Sending))
 </script>
 
 <div class="flex w-full justify-end px-1 text-xs {restProps.class}">
diff --git a/src/app/components/ThunkStatus.svelte b/src/app/components/ThunkStatus.svelte
index 81c4474e..4deb2dc9 100644
--- a/src/app/components/ThunkStatus.svelte
+++ b/src/app/components/ThunkStatus.svelte
@@ -1,19 +1,18 @@
 <script lang="ts">
-  import type {AbstractThunk} from "@welshman/app"
-  import {thunkIsComplete, getFailedThunkUrls} from "@welshman/app"
+  import {BaseThunk} from "@welshman/app"
   import ThunkFailure from "@app/components/ThunkFailure.svelte"
   import ThunkPending from "@app/components/ThunkPending.svelte"
 
   interface Props {
-    thunk: AbstractThunk
+    thunk: BaseThunk
     showToastOnRetry?: boolean
     class?: string
   }
 
   const {thunk, showToastOnRetry, ...restProps}: Props = $props()
 
-  const showFailure = $derived(thunkIsComplete($thunk) && getFailedThunkUrls($thunk).length > 0)
-  const showPending = $derived(!thunkIsComplete($thunk))
+  const showFailure = $derived($thunk.isComplete() && $thunk.getFailedUrls().length > 0)
+  const showPending = $derived(!$thunk.isComplete())
 </script>
 
 {#if showFailure}
diff --git a/src/app/components/ThunkStatusDetail.svelte b/src/app/components/ThunkStatusDetail.svelte
index b8a6dc68..25619488 100644
--- a/src/app/components/ThunkStatusDetail.svelte
+++ b/src/app/components/ThunkStatusDetail.svelte
@@ -1,9 +1,8 @@
 <script lang="ts">
   import {stopPropagation} from "svelte/legacy"
-  import type {AbstractThunk} from "@welshman/app"
-  import {getFailedThunkUrls, getThunkUrlsWithStatus} from "@welshman/app"
   import {PublishStatus} from "@welshman/net"
   import {displayRelayUrl} from "@welshman/util"
+  import {BaseThunk} from "@welshman/app"
   import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
   import Danger from "@assets/icons/danger-triangle.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -11,14 +10,14 @@
   import {addPeriod} from "@lib/util"
 
   interface Props {
-    thunk: AbstractThunk
+    thunk: BaseThunk
     retry: (url: string) => void
   }
 
   const {thunk, retry}: Props = $props()
 
-  const successUrls = $derived(getThunkUrlsWithStatus(PublishStatus.Success, $thunk))
-  const failedUrls = $derived(getFailedThunkUrls($thunk))
+  const successUrls = $derived($thunk.getUrlsWithStatus(PublishStatus.Success))
+  const failedUrls = $derived($thunk.getFailedUrls())
   const total = $derived(successUrls.length + failedUrls.length)
   const isPartial = $derived(successUrls.length > 0 && failedUrls.length > 0)
 
diff --git a/src/app/components/ThunkStatusOrDeleted.svelte b/src/app/components/ThunkStatusOrDeleted.svelte
index 1d661452..cd4d8787 100644
--- a/src/app/components/ThunkStatusOrDeleted.svelte
+++ b/src/app/components/ThunkStatusOrDeleted.svelte
@@ -2,9 +2,9 @@
   import type {Snippet} from "svelte"
   import type {TrustedEvent} from "@welshman/util"
   import {PublishStatus} from "@welshman/net"
-  import {deriveIsDeleted} from "@welshman/store"
-  import {thunks, mergeThunks, thunkHasStatus, repository} from "@welshman/app"
+  import {deriveIsDeleted} from "@app/repository"
   import ThunkStatus from "@app/components/ThunkStatus.svelte"
+  import {thunks} from "@app/core"
 
   type Props = {
     event: TrustedEvent
@@ -13,13 +13,14 @@
 
   const {event, children}: Props = $props()
 
-  const deleted = deriveIsDeleted(repository, event)
-  const thunk = $derived(mergeThunks($thunks.filter(t => t.event.id === event.id)))
+  const deleted = deriveIsDeleted(event)
+  const history = $thunks.history
+  const thunk = $derived($thunks.merge($history.filter(t => t.event.id === event.id)))
 </script>
 
 {#if $deleted}
   <div class="button button-error button-xs rounded-full">Deleted</div>
-{:else if thunk.thunks.length > 0 && !thunkHasStatus(PublishStatus.Success, thunk)}
+{:else if thunk.thunks.length > 0 && !thunk.hasStatus(PublishStatus.Success)}
   <ThunkStatus {thunk} />
 {:else if children}
   {@render children?.()}
diff --git a/src/app/components/ThunkToast.svelte b/src/app/components/ThunkToast.svelte
index d8fd74d9..2af0e9ad 100644
--- a/src/app/components/ThunkToast.svelte
+++ b/src/app/components/ThunkToast.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
-  import type {AbstractThunk} from "@welshman/app"
-  import {thunkHasStatus, thunkIsComplete} from "@welshman/app"
+  import type {BaseThunk} from "@welshman/app"
   import {PublishStatus} from "@welshman/net"
   import ThunkPending from "@app/components/ThunkPending.svelte"
   import type {Toast} from "@app/toast"
@@ -8,7 +7,7 @@
 
   type Props = {
     toast: Toast
-    thunk: AbstractThunk
+    thunk: BaseThunk
   }
 
   const {toast, ...props}: Props = $props()
@@ -16,8 +15,8 @@
   const id = toast.id
   const thunk = props.thunk
   const {Aborted, Timeout, Failure} = PublishStatus
-  const isFailure = $derived(thunkHasStatus([Aborted, Timeout, Failure], $thunk))
-  const isComplete = $derived(thunkIsComplete($thunk))
+  const isFailure = $derived($thunk.hasStatus([Aborted, Timeout, Failure]))
+  const isComplete = $derived($thunk.isComplete())
 
   $effect(() => {
     if (isFailure) {
diff --git a/src/app/components/TopicMultiSelect.svelte b/src/app/components/TopicMultiSelect.svelte
index d02213da..618c1d9a 100644
--- a/src/app/components/TopicMultiSelect.svelte
+++ b/src/app/components/TopicMultiSelect.svelte
@@ -3,7 +3,7 @@
   import type {Writable} from "svelte/store"
   import type {Instance} from "tippy.js"
   import {remove, reject, spec, uniq} from "@welshman/lib"
-  import {createSearch, topics} from "@welshman/app"
+  import {Topics, createSearch} from "@welshman/app"
   import {normalizeTopic} from "@lib/util"
   import Suggestions from "@lib/components/Suggestions.svelte"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
@@ -12,14 +12,17 @@
   import Tippy from "@lib/components/Tippy.svelte"
   import Button from "@lib/components/Button.svelte"
   import TopicSuggestion from "@app/components/TopicSuggestion.svelte"
+  import {app} from "@app/core"
 
-  interface Props {
+  type Props = {
     value: string[]
     term?: Writable<string>
   }
 
   let {value = $bindable(), term = writable("")}: Props = $props()
 
+  const topics = $app.use(Topics).all.$
+
   const topicSearch = $derived.by(() =>
     createSearch(reject(spec({name: value}), $topics), {
       getValue: topic => topic.name,
diff --git a/src/app/components/VideoCallContent.svelte b/src/app/components/VideoCallContent.svelte
index 3d784752..c5db244b 100644
--- a/src/app/components/VideoCallContent.svelte
+++ b/src/app/components/VideoCallContent.svelte
@@ -1,7 +1,8 @@
 <script lang="ts">
+  import {spec} from "@welshman/lib"
   import cx from "classnames"
   import {Track} from "livekit-client"
-  import {displayProfileByPubkey, loadProfile} from "@welshman/app"
+  import {get} from "svelte/store"
   import Pin from "@assets/icons/pin.svg?dataurl"
   import Button from "@lib/components/Button.svelte"
   import Icon from "@lib/components/Icon.svelte"
@@ -9,7 +10,6 @@
   import VideoCallTile from "@app/components/VideoCallTile.svelte"
   import VoiceWidget from "@app/components/VoiceWidget.svelte"
   import VoiceParticipantMediaBadges from "@app/components/VoiceParticipantMediaBadges.svelte"
-  import {get} from "svelte/store"
   import {
     VideoCallLayout,
     isDesktopLayout,
@@ -25,6 +25,7 @@
     pubkeyFromLiveKitIdentity,
     videoTrackRevision,
   } from "@app/call"
+  import {profiles} from "@app/core"
 
   type Props = {
     layout: VideoCallLayout
@@ -132,7 +133,7 @@
           source: Track.Source.ScreenShare,
         })
       }
-      if (!videoTiles.some(t => t.liveKitIdentity === rp.identity)) {
+      if (!videoTiles.some(spec({liveKitIdentity: rp.identity}))) {
         videoTiles.push({
           liveKitIdentity: rp.identity,
           isLocal: false,
@@ -143,7 +144,7 @@
       }
     }
 
-    if (!videoTiles.some(t => t.liveKitIdentity === user.identity)) {
+    if (!videoTiles.some(spec({liveKitIdentity: user.identity}))) {
       videoTiles.push({
         liveKitIdentity: user.identity,
         isLocal: true,
@@ -189,13 +190,13 @@
   $effect(() => {
     for (const t of videoTiles) {
       const pk = pubkeyFromLiveKitIdentity(t.liveKitIdentity)
-      if (pk) loadProfile(pk)
+      if (pk) $profiles.load(pk)
     }
   })
 
   const labelFor = (liveKitIdentity: string, source: VideoTileData["source"]) => {
     const pk = pubkeyFromLiveKitIdentity(liveKitIdentity)
-    const name = pk ? displayProfileByPubkey(pk) : "Unknown"
+    const name = pk ? $profiles.display(pk).get() : "Unknown"
     return source === Track.Source.ScreenShare ? `${name} · screen` : name
   }
 
diff --git a/src/app/components/VoiceCallAudioSettingsDialog.svelte b/src/app/components/VoiceCallAudioSettingsDialog.svelte
index ceba66c4..f074cc8d 100644
--- a/src/app/components/VoiceCallAudioSettingsDialog.svelte
+++ b/src/app/components/VoiceCallAudioSettingsDialog.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+  import {spec} from "@welshman/lib"
   import Button from "@lib/components/Button.svelte"
   import FieldInline from "@lib/components/FieldInline.svelte"
   import Modal from "@lib/components/Modal.svelte"
@@ -35,9 +36,9 @@
     if (!navigator.mediaDevices?.enumerateDevices) return
     try {
       const devices = await navigator.mediaDevices.enumerateDevices()
-      audioInputs = devices.filter(d => d.kind === "audioinput")
-      audioOutputs = devices.filter(d => d.kind === "audiooutput")
-      videoInputs = devices.filter(d => d.kind === "videoinput")
+      audioInputs = devices.filter(spec({kind: "audioinput"}))
+      audioOutputs = devices.filter(spec({kind: "audiooutput"}))
+      videoInputs = devices.filter(spec({kind: "videoinput"}))
     } catch {
       audioInputs = []
       audioOutputs = []
diff --git a/src/app/components/VoiceRoomItem.svelte b/src/app/components/VoiceRoomItem.svelte
index 44b847c2..c2b33cdd 100644
--- a/src/app/components/VoiceRoomItem.svelte
+++ b/src/app/components/VoiceRoomItem.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import cx from "classnames"
   import {goto} from "$app/navigation"
-  import {loadProfile, displayProfileByPubkey} from "@welshman/app"
+  import {makeRoomKey} from "@welshman/app"
   import SecondaryNavItem from "@lib/components/SecondaryNavItem.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
@@ -12,7 +12,6 @@
   import {pushModal} from "@app/modal"
   import VoiceRoomJoinDialog from "@app/components/VoiceRoomJoinDialog.svelte"
   import VoiceParticipantMediaBadges from "@app/components/VoiceParticipantMediaBadges.svelte"
-  import {makeRoomId} from "@app/groups"
   import {
     CallState,
     callTargetRoom,
@@ -25,6 +24,7 @@
     loadCallParticipants,
     type CallParticipant,
   } from "@app/call"
+  import {profiles} from "@app/core"
 
   interface Props {
     url: string
@@ -38,10 +38,10 @@
   const participants = deriveCallParticipants(url, h)
   const participantPubkeys = $derived($participants.flatMap(p => (p.pubkey ? [p.pubkey] : [])))
   const isActive = $derived(
-    $callState === CallState.Connected && $callTargetRoom?.id === makeRoomId(url, h),
+    $callState === CallState.Connected && $callTargetRoom?.id === makeRoomKey(url, h),
   )
   const isJoining = $derived(
-    $callState === CallState.Joining && $callTargetRoom?.id === makeRoomId(url, h),
+    $callState === CallState.Joining && $callTargetRoom?.id === makeRoomKey(url, h),
   )
 
   const handleClick = async (e: MouseEvent) => {
@@ -64,7 +64,7 @@
 
   $effect(() => {
     for (const p of $participants) {
-      if (p.pubkey) loadProfile(p.pubkey)
+      if (p.pubkey) $profiles.load(p.pubkey)
     }
   })
 </script>
@@ -98,7 +98,7 @@
               <ProfileCircle pubkey={p.pubkey} size={5} class="h-5 w-5" />
             </div>
             <span class="truncate min-w-0 flex-1 text-xs opacity-70">
-              {p.pubkey ? displayProfileByPubkey(p.pubkey) : "Unknown"}
+              {p.pubkey ? $profiles.display(p.pubkey).get() : "Unknown"}
             </span>
             <VoiceParticipantMediaBadges
               muted={media.muted}
diff --git a/src/app/components/VoiceRoomJoinDialog.svelte b/src/app/components/VoiceRoomJoinDialog.svelte
index b1425ea0..8b0cafe4 100644
--- a/src/app/components/VoiceRoomJoinDialog.svelte
+++ b/src/app/components/VoiceRoomJoinDialog.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+  import {spec} from "@welshman/lib"
   import {displayRelayUrl} from "@welshman/util"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Volume from "@assets/icons/volume.svg?dataurl"
@@ -13,7 +14,7 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import {AbortError, TimeoutError} from "$lib/util"
   import ProfileCircles from "@app/components/ProfileCircles.svelte"
-  import {displayRoom} from "@app/groups"
+  import {displayRoom} from "@app/rooms"
   import {deriveCallParticipants, joinVoiceRoom, loadCallParticipants} from "@app/call"
   import {popModal} from "@app/modal"
   import {pushToast} from "@app/toast"
@@ -37,7 +38,7 @@
     if (!navigator.mediaDevices?.enumerateDevices) return
     try {
       const devices = await navigator.mediaDevices.enumerateDevices()
-      audioInputs = devices.filter(d => d.kind === "audioinput")
+      audioInputs = devices.filter(spec({kind: "audioinput"}))
     } catch {
       audioInputs = []
     }
diff --git a/src/app/components/VoiceWidget.svelte b/src/app/components/VoiceWidget.svelte
index abb49039..88072da8 100644
--- a/src/app/components/VoiceWidget.svelte
+++ b/src/app/components/VoiceWidget.svelte
@@ -4,7 +4,9 @@
   import {goto} from "$app/navigation"
   import {page} from "$app/stores"
   import cx from "classnames"
+  import {Capacitor} from "@capacitor/core"
   import {displayRelayUrl} from "@welshman/util"
+  import type {Room} from "@welshman/app"
   import Microphone from "@assets/icons/microphone.svg?dataurl"
   import MicrophoneOff from "@assets/icons/microphone-off.svg?dataurl"
   import VideocameraOff from "@assets/icons/videocamera-off.svg?dataurl"
@@ -15,15 +17,14 @@
   import ChatRound from "@assets/icons/chat-round.svg?dataurl"
   import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
   import Settings from "@assets/icons/settings.svg?dataurl"
-  import {Capacitor} from "@capacitor/core"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import VoiceCallAudioSettingsDialog from "@app/components/VoiceCallAudioSettingsDialog.svelte"
   import VoiceRoomJoinDialog from "@app/components/VoiceRoomJoinDialog.svelte"
+  import {rooms} from "@app/core"
   import {decodeRelay} from "@app/relays"
-  import {deriveRoom, displayRoom, getRoomType, RoomType} from "@app/groups"
-  import type {Room} from "@app/groups"
+  import {RoomType, displayRoom, getRoomType} from "@app/rooms"
   import {pushModal} from "@app/modal"
   import {notifications} from "@app/notifications"
   import {makeRoomPath} from "@app/routes"
@@ -46,7 +47,7 @@
   const {relay, h} = $derived($page.params)
   const url = $derived(relay ? decodeRelay(relay) : undefined)
   const displayedRoomStore = $derived(
-    url && h && typeof h === "string" ? deriveRoom(url, h) : readable(undefined),
+    url && h && typeof h === "string" ? $rooms.forRoom(url, h) : readable(undefined),
   )
   const routeDisplayedRoom = $derived($displayedRoomStore)
 
diff --git a/src/app/components/WalletAsReceivingAddress.svelte b/src/app/components/WalletAsReceivingAddress.svelte
index 0bf97548..1c4c01fe 100644
--- a/src/app/components/WalletAsReceivingAddress.svelte
+++ b/src/app/components/WalletAsReceivingAddress.svelte
@@ -1,7 +1,5 @@
 <script lang="ts">
-  import {makeProfile} from "@welshman/util"
   import {getWalletAddress} from "@welshman/util"
-  import {userProfile, waitForThunkError, session} from "@welshman/app"
   import {errorMessage} from "@lib/util"
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
@@ -10,19 +8,21 @@
   import ModalHeader from "@lib/components/ModalHeader.svelte"
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {updateProfile} from "@app/profiles"
+  import {deriveUserItem, profiles} from "@app/core"
+  import {wallet} from "@app/lightning"
   import {clearModals} from "@app/modal"
   import {pushToast} from "@app/toast"
 
-  const lud16 = getWalletAddress($session!.wallet!)
+  const userProfile = deriveUserItem($app => $profiles)
+
+  const lud16 = getWalletAddress(wallet.get()!)
 
   const confirm = async () => {
-    const profile = $userProfile || makeProfile()
-
     loading = true
 
     try {
-      const error = await waitForThunkError(updateProfile({profile: {...profile, lud16}}))
+      const command = await $profiles.update(writer => writer.update({lud16}))
+      const error = await command.publish().waitForError()
 
       if (error) {
         pushToast({theme: "error", message: `Failed to update profile: ${errorMessage(error)}`})
@@ -46,7 +46,7 @@
     <ModalHeader>
       <ModalTitle>Set as Receiving Address?</ModalTitle>
     </ModalHeader>
-    {#if $userProfile?.lud16}
+    {#if $userProfile?.values.lud16}
       <p>
         Your current receiving address is different from the one provided by your connected wallet.
       </p>
diff --git a/src/app/components/WalletConnect.svelte b/src/app/components/WalletConnect.svelte
index 82be289b..6649bc67 100644
--- a/src/app/components/WalletConnect.svelte
+++ b/src/app/components/WalletConnect.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
   import {debounce} from "throttle-debounce"
   import {nwc} from "@getalby/sdk"
-  import {sleep, assoc} from "@welshman/lib"
+  import {sleep} from "@welshman/lib"
+  import {WalletType} from "@welshman/util"
   import type {NWCInfo} from "@welshman/util"
-  import {pubkey, userProfile, updateSession} from "@welshman/app"
   import Link from "@lib/components/Link.svelte"
   import Cpu from "@assets/icons/cpu-bolt.svg?dataurl"
   import Lock from "@assets/icons/lock-keyhole.svg?dataurl"
@@ -21,11 +21,14 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {getWebLn} from "@app/lightning"
+  import Divider from "@lib/components/Divider.svelte"
+  import WalletAsReceivingAddress from "@app/components/WalletAsReceivingAddress.svelte"
+  import {deriveUserItem, profiles} from "@app/core"
+  import {getWebLn, wallet} from "@app/lightning"
   import {pushToast} from "@app/toast"
   import {pushModal} from "@app/modal"
-  import WalletAsReceivingAddress from "@app/components/WalletAsReceivingAddress.svelte"
-  import Divider from "@lib/components/Divider.svelte"
+
+  const userProfile = deriveUserItem($app => $profiles)
 
   const back = () => history.back()
 
@@ -42,7 +45,7 @@
           message: "Your extension does not support lightning payments",
         })
       } else {
-        updateSession($pubkey!, assoc("wallet", {type: "webln", info}))
+        wallet.set({type: WalletType.WebLN, info})
         pushToast({message: "Wallet successfully connected!"})
 
         await sleep(400)
@@ -73,17 +76,14 @@
           message: "Wallet failed to connect",
         })
       } else {
-        updateSession(
-          $pubkey!,
-          assoc("wallet", {type: "nwc", info: client.options as unknown as NWCInfo}),
-        )
+        wallet.set({type: WalletType.NWC, info: client.options as unknown as NWCInfo})
         pushToast({message: "Wallet successfully connected!"})
 
         await sleep(400)
 
         back()
 
-        if (info.lud16 && info.lud16 !== $userProfile?.lud16) {
+        if (info.lud16 && info.lud16 !== $userProfile?.values.lud16) {
           pushModal(WalletAsReceivingAddress)
         }
       }
diff --git a/src/app/components/WalletDisconnect.svelte b/src/app/components/WalletDisconnect.svelte
index 78fa979d..f77cb4f9 100644
--- a/src/app/components/WalletDisconnect.svelte
+++ b/src/app/components/WalletDisconnect.svelte
@@ -1,11 +1,10 @@
 <script lang="ts">
-  import {dissoc} from "@welshman/lib"
-  import {pubkey, updateSession} from "@welshman/app"
   import Confirm from "@lib/components/Confirm.svelte"
+  import {wallet} from "@app/lightning"
   import {clearModals} from "@app/modal"
 
   const confirm = async () => {
-    updateSession($pubkey!, dissoc("wallet"))
+    wallet.set(undefined)
 
     clearModals()
   }
diff --git a/src/app/components/WalletUpdateReceivingAddress.svelte b/src/app/components/WalletUpdateReceivingAddress.svelte
index 8ceaf936..6b582259 100644
--- a/src/app/components/WalletUpdateReceivingAddress.svelte
+++ b/src/app/components/WalletUpdateReceivingAddress.svelte
@@ -1,6 +1,5 @@
 <script lang="ts">
   import {getWalletAddress} from "@welshman/util"
-  import {session, waitForThunkError, userProfile} from "@welshman/app"
   import {errorMessage} from "@lib/util"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
@@ -13,15 +12,16 @@
   import ModalBody from "@lib/components/ModalBody.svelte"
   import Wallet from "@assets/icons/wallet.svg?dataurl"
   import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
-  import {updateProfile} from "@app/profiles"
   import {pushToast} from "@app/toast"
+  import {profiles, user} from "@app/core"
+  import {wallet} from "@app/lightning"
 
   const back = () => history.back()
 
-  let address = $state($userProfile?.lud16 || "")
-  let loading = $state(false)
+  const walletLud16 = $derived($wallet ? getWalletAddress($wallet) : undefined)
 
-  const walletLud16 = $derived($session?.wallet ? getWalletAddress($session.wallet) : undefined)
+  let address = $state($profiles.get($user.pubkey)?.lnurl() || "")
+  let loading = $state(false)
 
   const useWalletAddress = () => {
     if (walletLud16) {
@@ -33,16 +33,12 @@
     loading = true
 
     try {
-      const error = await waitForThunkError(
-        updateProfile({
-          profile: {
-            ...$userProfile,
-            lud06: undefined,
-            lud16: address.trim() || undefined,
-          },
-        }),
+      const command = await $profiles.update(writer =>
+        writer.update({lud06: undefined, lud16: address.trim() || undefined}),
       )
 
+      const error = await command.publish().waitForError()
+
       if (error) {
         pushToast({theme: "error", message: `Failed to update profile: ${errorMessage(error)}`})
       } else {
diff --git a/src/app/components/WotScore.svelte b/src/app/components/WotScore.svelte
index 7f10b6a7..9279178f 100644
--- a/src/app/components/WotScore.svelte
+++ b/src/app/components/WotScore.svelte
@@ -15,7 +15,7 @@
 
 <script lang="ts">
   import {clamp} from "@welshman/lib"
-  import {pubkey, getFollows, deriveUserWotScore} from "@welshman/app"
+  import {followLists, user, wot} from "@app/core"
 
   interface Props {
     pubkey: string
@@ -27,8 +27,9 @@
   const radius = 6
   const center = radius + 1
 
-  const score = deriveUserWotScore(target)
-  const active = $derived(getFollows($pubkey!).includes(target))
+  const score = $derived($wot.wotScore($user.pubkey, target).$)
+  const follows = $derived($followLists.one($user.pubkey))
+  const active = $derived(($follows?.pubkeys() ?? []).includes(target))
   const normalizedScore = $derived(clamp([0, max], $score) / max)
   const dashOffset = $derived(100 - 44 * normalizedScore)
   const style = $derived(`transform: rotate(${135 - normalizedScore * 180}deg)`)
diff --git a/src/app/components/Zap.svelte b/src/app/components/Zap.svelte
index 63929ead..bc7bb4c8 100644
--- a/src/app/components/Zap.svelte
+++ b/src/app/components/Zap.svelte
@@ -1,9 +1,8 @@
 <script lang="ts">
-  import {first} from "@welshman/lib"
-  import {signer, deriveZapperForPubkey} from "@welshman/app"
-  import {load} from "@welshman/net"
-  import {Router} from "@welshman/router"
-  import {requestZap, makeZapRequest, getZapResponseFilter} from "@welshman/util"
+  import {first, uniq} from "@welshman/lib"
+  import {inbox} from "@welshman/util"
+  import {ZapRequest} from "@welshman/domain"
+  import {Zappers} from "@welshman/app"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -21,16 +20,19 @@
   import {payInvoice} from "@app/lightning"
   import {zapAmounts} from "@app/settings"
   import {pushToast} from "@app/toast"
+  import {app, domain, network, router} from "@app/core"
 
   type Props = {
     url?: string
     pubkey: string
     eventId?: string
+    // NIP-75 requires a zap to a goal to request its receipt on the goal's own relays.
+    goalRelays?: string[]
   }
 
-  const {url, pubkey, eventId}: Props = $props()
+  const {url, pubkey, eventId, goalRelays = []}: Props = $props()
 
-  const zapperStore = deriveZapperForPubkey(pubkey)
+  const zapper = $app.use(Zappers).forPubkey(pubkey)
 
   const back = () => history.back()
 
@@ -38,13 +40,24 @@
     loading = true
 
     try {
-      const zapper = $zapperStore!
-      const msats = amount * 1000
-      const relays = url ? [url] : Router.get().ForPubkey(pubkey).getUrls()
-      const filters = [getZapResponseFilter({zapper, pubkey, eventId})]
-      const params = {pubkey, content, eventId, msats, relays, zapper}
-      const event = await $signer!.sign(makeZapRequest(params))
-      const res = await requestZap({zapper, event})
+      const currentZapper = zapper.get()!
+      const relays = uniq([
+        ...(url ? [url] : await $router.resolver.relays([inbox(pubkey)])),
+        ...goalRelays,
+      ])
+      const writer = $domain
+        .writer(ZapRequest)
+        .setContent(content)
+        .setAmount(amount * 1000)
+        .setLnurl(currentZapper.lnurl)
+        .setRecipient(pubkey)
+        .setUrls(relays)
+
+      if (eventId) {
+        writer.setEventId(eventId)
+      }
+
+      const res = await writer.requestInvoice(currentZapper)
 
       if (!res.invoice) {
         return pushToast({
@@ -54,7 +67,10 @@
       }
 
       await payInvoice(res.invoice)
-      await load({relays, filters})
+      await $network.load({
+        relays,
+        filters: [currentZapper.getResponseFilter(pubkey, eventId)],
+      })
 
       pushToast({message: "Zap successfully sent!"})
       back()
diff --git a/src/app/components/ZapButton.svelte b/src/app/components/ZapButton.svelte
index 03f9cf31..98b3002f 100644
--- a/src/app/components/ZapButton.svelte
+++ b/src/app/components/ZapButton.svelte
@@ -1,12 +1,16 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
+  import {ZAP_GOAL} from "@welshman/util"
   import type {TrustedEvent} from "@welshman/util"
-  import {session, loadZapperForPubkey} from "@welshman/app"
+  import {ZapGoal} from "@welshman/domain"
+  import {Zappers} from "@welshman/app"
   import Button from "@lib/components/Button.svelte"
   import Zap from "@app/components/Zap.svelte"
   import ZapInvoice from "@app/components/ZapInvoice.svelte"
   import InfoZapperError from "@app/components/InfoZapperError.svelte"
   import {pushModal} from "@app/modal"
+  import {app, reader} from "@app/core"
+  import {wallet} from "@app/lightning"
 
   type Props = {
     url?: string
@@ -18,7 +22,11 @@
 
   const {url, event, children, replaceState, ...props}: Props = $props()
 
-  const zapperPromise = loadZapperForPubkey(event.pubkey)
+  const goal = event.kind === ZAP_GOAL ? reader(ZapGoal)(event) : undefined
+
+  const zapperPromise = $app.use(Zappers).loadForPubkey(event.pubkey)
+
+  const goalRelays = goal?.urls() ?? []
 
   const onClick = async () => {
     loading = true
@@ -28,10 +36,14 @@
 
       if (!zapper?.allowsNostr) {
         pushModal(InfoZapperError, {url, pubkey: event.pubkey, eventId: event.id}, {replaceState})
-      } else if ($session?.wallet) {
-        pushModal(Zap, {url, pubkey: event.pubkey, eventId: event.id}, {replaceState})
+      } else if ($wallet) {
+        pushModal(Zap, {url, pubkey: event.pubkey, eventId: event.id, goalRelays}, {replaceState})
       } else {
-        pushModal(ZapInvoice, {url, pubkey: event.pubkey, eventId: event.id}, {replaceState})
+        pushModal(
+          ZapInvoice,
+          {url, pubkey: event.pubkey, eventId: event.id, goalRelays},
+          {replaceState},
+        )
       }
     } finally {
       loading = false
diff --git a/src/app/components/ZapInvoice.svelte b/src/app/components/ZapInvoice.svelte
index 20f254aa..d37d418b 100644
--- a/src/app/components/ZapInvoice.svelte
+++ b/src/app/components/ZapInvoice.svelte
@@ -1,10 +1,9 @@
 <script lang="ts">
   import {onDestroy} from "svelte"
-  import {first} from "@welshman/lib"
-  import {signer, deriveZapperForPubkey} from "@welshman/app"
-  import {request} from "@welshman/net"
-  import {Router} from "@welshman/router"
-  import {requestZap, makeZapRequest, getZapResponseFilter} from "@welshman/util"
+  import {first, uniq} from "@welshman/lib"
+  import {inbox} from "@welshman/util"
+  import {ZapRequest} from "@welshman/domain"
+  import {Zappers} from "@welshman/app"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import Copy from "@assets/icons/copy.svg?dataurl"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
@@ -22,6 +21,7 @@
   import QRCode from "@app/components/QRCode.svelte"
   import WalletConnect from "@app/components/WalletConnect.svelte"
   import ZapForm from "@app/components/ZapForm.svelte"
+  import {app, domain, network, router} from "@app/core"
   import {pushModal} from "@app/modal"
   import {zapAmounts} from "@app/settings"
   import {clip, pushToast} from "@app/toast"
@@ -30,11 +30,13 @@
     url?: string
     pubkey: string
     eventId?: string
+    // NIP-75 requires a zap to a goal to request its receipt on the goal's own relays.
+    goalRelays?: string[]
   }
 
-  const {url, pubkey, eventId}: Props = $props()
+  const {url, pubkey, eventId, goalRelays = []}: Props = $props()
 
-  const zapperStore = deriveZapperForPubkey(pubkey)
+  const zapper = $app.use(Zappers).forPubkey(pubkey)
 
   const back = () => history.back()
 
@@ -42,12 +44,24 @@
     loading = true
 
     try {
-      const zapper = $zapperStore!
-      const msats = amount * 1000
-      const relays = url ? [url] : Router.get().ForPubkey(pubkey).getUrls()
-      const params = {pubkey, content, eventId, msats, relays, zapper}
-      const event = await $signer!.sign(makeZapRequest(params))
-      const res = await requestZap({zapper, event})
+      const currentZapper = zapper.get()!
+      const relays = uniq([
+        ...(url ? [url] : await $router.resolver.relays([inbox(pubkey)])),
+        ...goalRelays,
+      ])
+      const writer = $domain
+        .writer(ZapRequest)
+        .setContent(content)
+        .setAmount(amount * 1000)
+        .setLnurl(currentZapper.lnurl)
+        .setRecipient(pubkey)
+        .setUrls(relays)
+
+      if (eventId) {
+        writer.setEventId(eventId)
+      }
+
+      const res = await writer.requestInvoice(currentZapper)
 
       if (!res.invoice) {
         return pushToast({
@@ -61,10 +75,10 @@
       paymentController?.abort()
       paymentController = new AbortController()
 
-      request({
+      $network.request({
         relays,
         signal: paymentController.signal,
-        filters: [getZapResponseFilter({zapper, pubkey, eventId})],
+        filters: [currentZapper.getResponseFilter(pubkey, eventId)],
         onEvent: () => {
           pushToast({message: "Payment sent!"})
           paymentController?.abort()
diff --git a/src/app/components/hosting/CustomDomainModal.svelte b/src/app/components/hosting/CustomDomainModal.svelte
index df8f2e35..92fc7f47 100644
--- a/src/app/components/hosting/CustomDomainModal.svelte
+++ b/src/app/components/hosting/CustomDomainModal.svelte
@@ -17,11 +17,17 @@
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import {pushToast} from "@app/toast"
-  import {canonicalRelayHost, flagToBool, updateRelay, HostingError, type Relay} from "@app/hosting"
+  import {
+    canonicalRelayHost,
+    flagToBool,
+    updateRelay,
+    HostingError,
+    type HostedRelay,
+  } from "@app/hosting"
 
   type Props = {
-    relay: Relay
-    onUpdate?: (relay: Relay) => void
+    relay: HostedRelay
+    onUpdate?: (relay: HostedRelay) => void
   }
 
   const {relay, onUpdate}: Props = $props()
diff --git a/src/app/components/hosting/PaymentSetup.svelte b/src/app/components/hosting/PaymentSetup.svelte
index 78cc2947..e50953f7 100644
--- a/src/app/components/hosting/PaymentSetup.svelte
+++ b/src/app/components/hosting/PaymentSetup.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import cx from "classnames"
-  import {pubkey, session} from "@welshman/app"
+  import {WalletType} from "@welshman/util"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
   import Card from "@assets/icons/card.svg?dataurl"
   import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
@@ -16,8 +16,9 @@
   import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import {user} from "@app/core"
   import {pushToast} from "@app/toast"
-  import {getNwcClient} from "@app/lightning"
+  import {getNwcClient, wallet} from "@app/lightning"
   import {updateTenant, createPortalSession} from "@app/hosting"
 
   type Tab = "nwc" | "card"
@@ -50,7 +51,7 @@
   // Offer to reuse the app's spending wallet instead of re-pasting its NWC url.
   // The two wallets stay separate records, this just reuses the same connection.
   const spendingWalletUrl =
-    $session?.wallet?.type === "nwc" ? getNwcClient().nostrWalletConnectUrl : undefined
+    $wallet?.type === WalletType.NWC ? getNwcClient().nostrWalletConnectUrl : undefined
 
   // The tenant's autopay wallet (a backend NWC, write-only), distinct from the
   // app's own wallet.
@@ -60,7 +61,7 @@
     saving = true
 
     try {
-      await updateTenant($pubkey!, {nwc_url: url})
+      await updateTenant($user.pubkey, {nwc_url: url})
       saved = true
       onSaved?.()
     } catch (e) {
@@ -83,7 +84,7 @@
     saving = true
 
     try {
-      await updateTenant($pubkey!, {nwc_url: ""})
+      await updateTenant($user.pubkey, {nwc_url: ""})
       onSaved?.()
       pushToast({message: "Lightning wallet disconnected."})
       back()
@@ -101,7 +102,7 @@
     redirecting = true
 
     try {
-      const {url} = await createPortalSession($pubkey!)
+      const {url} = await createPortalSession($user.pubkey)
 
       window.location.href = url
     } catch (e) {
diff --git a/src/app/components/hosting/PlanModal.svelte b/src/app/components/hosting/PlanModal.svelte
index eb056222..1065ba44 100644
--- a/src/app/components/hosting/PlanModal.svelte
+++ b/src/app/components/hosting/PlanModal.svelte
@@ -13,9 +13,9 @@
   import PricingTable from "@app/components/hosting/PricingTable.svelte"
   import PaymentDialog from "@app/components/hosting/PaymentDialog.svelte"
   import PaymentSetup from "@app/components/hosting/PaymentSetup.svelte"
+  import {user} from "@app/core"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
-  import {pubkey} from "@welshman/app"
   import {
     autopayConfigured,
     derivePlans,
@@ -25,12 +25,12 @@
     reconcileTenant,
     selectPayableInvoice,
     updateRelay,
-    type Relay,
+    type HostedRelay,
   } from "@app/hosting"
 
   type Props = {
-    relay: Relay
-    onUpdate?: (relay: Relay) => void
+    relay: HostedRelay
+    onUpdate?: (relay: HostedRelay) => void
   }
 
   const {relay, onUpdate}: Props = $props()
@@ -70,14 +70,14 @@
         return
       }
 
-      await reconcileTenant($pubkey!)
+      await reconcileTenant($user.pubkey)
 
-      const tenant = await getTenant($pubkey!)
+      const tenant = await getTenant($user.pubkey)
 
       if (autopayConfigured(tenant)) {
         back()
       } else {
-        const invoice = selectPayableInvoice(await listTenantInvoices($pubkey!))
+        const invoice = selectPayableInvoice(await listTenantInvoices($user.pubkey))
 
         if (invoice) {
           pushModal(PaymentDialog, {invoice}, {replaceState: true})
diff --git a/src/app/components/hosting/RelayCreate.svelte b/src/app/components/hosting/RelayCreate.svelte
index 893dd222..f05e1446 100644
--- a/src/app/components/hosting/RelayCreate.svelte
+++ b/src/app/components/hosting/RelayCreate.svelte
@@ -1,11 +1,11 @@
 <script lang="ts">
   import {goto} from "$app/navigation"
-  import {pubkey} from "@welshman/app"
+  import {publish} from "@welshman/app"
   import RelayForm, {type RelayFormValues} from "@app/components/hosting/RelayForm.svelte"
   import PaymentDialog from "@app/components/hosting/PaymentDialog.svelte"
   import PaymentSetup from "@app/components/hosting/PaymentSetup.svelte"
+  import {roomLists, user} from "@app/core"
   import {pushModal} from "@app/modal"
-  import {addSpace} from "@app/groups"
   import {makeSpacePath} from "@app/routes"
   import {HOSTING_RELAY_DOMAIN} from "@app/env"
   import {
@@ -34,7 +34,7 @@
     }
 
     const overrides = {
-      tenant_pubkey: $pubkey!,
+      tenant_pubkey: $user.pubkey,
       zooid_domain: HOSTING_RELAY_DOMAIN,
       blossom_enabled: values.plan_id === "free" ? 0 : 1,
       livekit_enabled: values.plan_id === "free" ? 0 : 1,
@@ -51,15 +51,15 @@
 
     // Join the space we just made, otherwise the space layout prompts us to join
     // it, displacing the payment modals below.
-    await addSpace(url)
-    await reconcileTenant($pubkey!)
+    await $roomLists.addRelay(url).then(publish)
+    await reconcileTenant($user.pubkey)
 
-    const tenant = await getTenant($pubkey!)
+    const tenant = await getTenant($user.pubkey)
 
     await goto(makeSpacePath(url, "admin"), {replaceState: true})
 
     if (values.plan_id !== "free" && !autopayConfigured(tenant)) {
-      const invoice = selectPayableInvoice(await listTenantInvoices($pubkey!))
+      const invoice = selectPayableInvoice(await listTenantInvoices($user.pubkey))
 
       if (invoice) {
         pushModal(PaymentDialog, {invoice})
diff --git a/src/app/components/hosting/RelayDetailCard.svelte b/src/app/components/hosting/RelayDetailCard.svelte
index fb316e8f..6e6293e7 100644
--- a/src/app/components/hosting/RelayDetailCard.svelte
+++ b/src/app/components/hosting/RelayDetailCard.svelte
@@ -27,11 +27,11 @@
   import Confirm from "@lib/components/Confirm.svelte"
   import CustomDomainModal from "@app/components/hosting/CustomDomainModal.svelte"
   import PlanModal from "@app/components/hosting/PlanModal.svelte"
+  import {roomLists} from "@app/core"
   import RelayForm from "@app/components/hosting/RelayForm.svelte"
   import type {RelayFormValues} from "@app/components/hosting/RelayForm.svelte"
   import {pushModal, clearModals} from "@app/modal"
   import {clip, pushToast} from "@app/toast"
-  import {moveSpace} from "@app/groups"
   import {goToMovedSpace} from "@app/routes"
   import {
     HostingError,
@@ -46,13 +46,13 @@
     reactivateRelay,
     derivePlans,
     deriveRelayMembers,
-    type Relay,
+    type HostedRelay,
     type RelayFlag,
     type UpdateRelayInput,
   } from "@app/hosting"
 
   type Props = {
-    relay: Relay
+    relay: HostedRelay
   }
 
   const {relay}: Props = $props()
@@ -74,19 +74,19 @@
 
   // Adding, removing or verifying a custom domain moves the relay's host, so
   // migrate the admin's groups list and follow the space to its new url.
-  const setCurrentAndFollowHost = async (next: Relay) => {
+  const setCurrentAndFollowHost = async (next: HostedRelay) => {
     const previousUrl = getHostedRelayUrl(current)
     const nextUrl = getHostedRelayUrl(next)
 
     current = next
 
     if (previousUrl !== nextUrl) {
-      await moveSpace(previousUrl, nextUrl)
+      await $roomLists.migrateRelay(previousUrl, nextUrl).then(command => command?.publish())
       await goToMovedSpace(previousUrl, nextUrl)
     }
   }
 
-  const persist = async (next: Relay, input: UpdateRelayInput) => {
+  const persist = async (next: HostedRelay, input: UpdateRelayInput) => {
     const previous = current
 
     current = next
@@ -108,7 +108,7 @@
     persist({...current, ...input}, input)
   }
 
-  const setCurrent = (next: Relay) => {
+  const setCurrent = (next: HostedRelay) => {
     current = next
   }
 
diff --git a/src/app/components/hosting/RelayForm.svelte b/src/app/components/hosting/RelayForm.svelte
index df6749b8..6fea2edf 100644
--- a/src/app/components/hosting/RelayForm.svelte
+++ b/src/app/components/hosting/RelayForm.svelte
@@ -1,8 +1,8 @@
 <script module lang="ts">
-  import type {Relay} from "@app/hosting"
+  import type {HostedRelay} from "@app/hosting"
 
   export type RelayFormValues = Pick<
-    Relay,
+    HostedRelay,
     "info_name" | "subdomain" | "info_icon" | "info_description" | "plan_id"
   >
 </script>
diff --git a/src/app/components/hosting/RelayListItem.svelte b/src/app/components/hosting/RelayListItem.svelte
index 83c758c5..0dc00c14 100644
--- a/src/app/components/hosting/RelayListItem.svelte
+++ b/src/app/components/hosting/RelayListItem.svelte
@@ -4,11 +4,11 @@
   import Badge from "@lib/components/Badge.svelte"
   import ImageIcon from "@lib/components/ImageIcon.svelte"
   import Link from "@lib/components/Link.svelte"
-  import {canonicalRelayHost, getHostedRelayUrl, type Relay} from "@app/hosting"
+  import {canonicalRelayHost, getHostedRelayUrl, type HostedRelay} from "@app/hosting"
   import {makeSpacePath} from "@app/routes"
 
   type Props = {
-    relay: Relay
+    relay: HostedRelay
   }
 
   const {relay}: Props = $props()
diff --git a/src/app/content.ts b/src/app/content.ts
index cfcbbabc..39194ad5 100644
--- a/src/app/content.ts
+++ b/src/app/content.ts
@@ -12,7 +12,7 @@ import {
   REPOST,
   THREAD,
   ZAP_GOAL,
-  ZAP_RESPONSE,
+  ZAP_RECEIPT,
 } from "@welshman/util"
 import type {Filter} from "@welshman/util"
 import {ENABLE_ZAPS} from "@app/env"
@@ -37,7 +37,7 @@ export const REPOST_KINDS = [REPOST, GENERIC_REPOST]
 export const REACTION_KINDS = [REPORT, DELETE, REACTION]
 
 if (ENABLE_ZAPS) {
-  REACTION_KINDS.push(ZAP_RESPONSE)
+  REACTION_KINDS.push(ZAP_RECEIPT)
 }
 
 export const CONTENT_KINDS = [ZAP_GOAL, EVENT_TIME, THREAD, CLASSIFIED, POLL]
diff --git a/src/app/core.ts b/src/app/core.ts
new file mode 100644
index 00000000..15c42aa4
--- /dev/null
+++ b/src/app/core.ts
@@ -0,0 +1,177 @@
+import {derived, writable} from "svelte/store"
+import type {Readable} from "svelte/store"
+import {always} from "@welshman/lib"
+import type {Maybe} from "@welshman/lib"
+import {withGetter} from "@welshman/store"
+import type {ItemsByKey, ReadableWithGetter} from "@welshman/store"
+import {
+  App,
+  BlockedRelayLists,
+  BlossomServerLists,
+  Deletes,
+  Domain,
+  FollowLists,
+  Handles,
+  MessagingRelayLists,
+  MuteLists,
+  Network,
+  Profiles,
+  Reactions,
+  RelayLists,
+  RelayManagement,
+  RelayMemberLists,
+  RelayRoles,
+  RelayStats,
+  Relays,
+  RoomLists,
+  RoomPinLists,
+  Rooms,
+  Router,
+  SearchRelayLists,
+  Thunks,
+  User,
+  Wot,
+  Wraps,
+  appPolicyCacheDecrypt,
+  appPolicyLogSignerMethods,
+  appPolicyRelayStats,
+  appPolicyWraps,
+} from "@welshman/app"
+import type {AppPolicy, IApp, Projection, Session} from "@welshman/app"
+import type {BaseEventReader, EventWriter, KindFactory} from "@welshman/domain"
+import {maybeMakeRelayMockAdapter} from "@lib/test/relayMocks"
+import {DEFAULT_RELAYS, DEFAULT_SEARCH_RELAYS, DUFFLEPUD_URL, INDEXER_RELAYS} from "@app/env"
+
+// Flotilla's own policies (ingest, sockets, storage) can't be imported here — they depend on
+// this module — so they push themselves in on import, and the first app is built lazily so
+// they're all registered by the time it exists.
+export const appPolicies: AppPolicy[] = [
+  appPolicyWraps,
+  appPolicyRelayStats,
+  appPolicyCacheDecrypt,
+  appPolicyLogSignerMethods,
+]
+
+const makeApp = (user?: User) => {
+  const instance: App = new App({
+    user,
+    // Test-only: when Playwright has injected window.__RELAY_MOCKS__, serve relays from in-memory
+    // fixtures instead of the network. No-op for real users; stripped from production builds.
+    getAdapter: import.meta.env.DEV ? maybeMakeRelayMockAdapter() : undefined,
+    config: {
+      dufflepudUrl: DUFFLEPUD_URL,
+      getDefaultRelays: always(DEFAULT_RELAYS),
+      getIndexerRelays: always(INDEXER_RELAYS),
+      getSearchRelays: () => {
+        const urls = user ? instance.use(SearchRelayLists).urls(user.pubkey).get() : []
+
+        return urls.length > 0 ? urls : DEFAULT_SEARCH_RELAYS
+      },
+    },
+    policies: appPolicies,
+  })
+
+  return instance
+}
+
+const appStore = withGetter(writable<Maybe<App>>(undefined))
+
+const getApp = () => appStore.get() ?? setApp(makeApp())
+
+const setApp = (instance: App) => {
+  appStore.set(instance)
+
+  return instance
+}
+
+// An app is scoped to a single identity, so logging in replaces it wholesale rather than
+// attaching a user to the anonymous one.
+export const app: ReadableWithGetter<App> = {
+  get: getApp,
+  subscribe: run => {
+    getApp()
+
+    return appStore.subscribe($app => run($app!))
+  },
+}
+
+export const session = withGetter(writable<Maybe<Session>>(undefined))
+
+// The signed-in user, for the paths that require one — reading it while signed out throws, so
+// use `$app.user` where absence is a legitimate state.
+export const user = withGetter(derived(app, $app => User.require($app)))
+
+// Read a store off the current app, re-subscribing when login swaps in a new one. Anything
+// bound at module load has to go through this or it will keep reading a discarded app.
+export const fromApp = <T>(read: ($app: App) => Readable<T>): Readable<T> =>
+  derived(app, ($app, set: (value: T) => void) => read($app).subscribe(set))
+
+// The signed-in user's entry in a keyed collection, e.g.
+// deriveUserItem($app => $app.use(Profiles)).
+export const deriveUserItem = <T>(getPlugin: ($app: App) => {index: Projection<ItemsByKey<T>>}) =>
+  derived(
+    [app, fromApp($app => getPlugin($app).index.$)],
+    ([$app, $index]: [App, ItemsByKey<T>]) => {
+      const $pubkey = $app.user?.pubkey
+
+      return $pubkey ? $index.get($pubkey) : undefined
+    },
+  )
+
+export const login = async ($session: Session) => {
+  const $user = await User.fromSession($session)
+
+  if (!$user) {
+    throw new Error(`Unable to log in using ${$session.method}`)
+  }
+
+  // Read the store directly, so restoring a session at startup doesn't build an anonymous app
+  // just to tear it down.
+  appStore.get()?.cleanup()
+  setApp(makeApp($user))
+  session.set($session)
+}
+
+// Plugins bound to the current app, so `$profiles` in a component and `profiles.get()` in a
+// module both stay pointed at the right one after login swaps it. Flotilla's own plugins expose
+// themselves the same way.
+export const usePlugin = <T>(Ctor: new (app: IApp) => T) =>
+  withGetter(derived(app, $app => $app.use(Ctor)))
+
+export const blockedRelayLists = usePlugin(BlockedRelayLists)
+export const blossomServerLists = usePlugin(BlossomServerLists)
+export const deletes = usePlugin(Deletes)
+export const domain = usePlugin(Domain)
+export const followLists = usePlugin(FollowLists)
+export const handles = usePlugin(Handles)
+export const messagingRelayLists = usePlugin(MessagingRelayLists)
+export const muteLists = usePlugin(MuteLists)
+export const network = usePlugin(Network)
+export const profiles = usePlugin(Profiles)
+export const reactions = usePlugin(Reactions)
+export const relayLists = usePlugin(RelayLists)
+export const relayManagement = usePlugin(RelayManagement)
+export const relayMemberLists = usePlugin(RelayMemberLists)
+export const relayRoles = usePlugin(RelayRoles)
+export const relayStats = usePlugin(RelayStats)
+export const relays = usePlugin(Relays)
+export const roomLists = usePlugin(RoomLists)
+export const roomPinLists = usePlugin(RoomPinLists)
+export const rooms = usePlugin(Rooms)
+export const router = usePlugin(Router)
+export const searchRelayLists = usePlugin(SearchRelayLists)
+export const thunks = usePlugin(Thunks)
+export const wot = usePlugin(Wot)
+export const wraps = usePlugin(Wraps)
+
+// The domain entry points, since almost every read or write goes through one of them.
+export const reader = <R extends BaseEventReader, W extends EventWriter<R>>(
+  factory: KindFactory<R, W>,
+) => domain.get().reader(factory)
+
+export const writer = <R extends BaseEventReader, W extends EventWriter<R>>(
+  factory: KindFactory<R, W>,
+  seed?: R,
+) => domain.get().writer(factory, seed)
+
+export const command = (eventWriter: EventWriter<any>) => domain.get().command(eventWriter)
diff --git a/src/app/deletes.ts b/src/app/deletes.ts
deleted file mode 100644
index ad369714..00000000
--- a/src/app/deletes.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import type {TrustedEvent} from "@welshman/util"
-import {DELETE, getTag, makeEvent} from "@welshman/util"
-import {publishThunk, tagEvent} from "@welshman/app"
-import {PROTECTED} from "@app/groups"
-
-export type DeleteParams = {
-  protect: boolean
-  event: TrustedEvent
-  tags?: string[][]
-}
-
-export const makeDelete = ({protect, event, tags = []}: DeleteParams) => {
-  const thisTags = [["k", String(event.kind)], ...tagEvent(event), ...tags]
-  const groupTag = getTag("h", event.tags)
-
-  if (groupTag) {
-    thisTags.push(groupTag)
-  }
-
-  if (protect) {
-    thisTags.push(PROTECTED)
-  }
-
-  return makeEvent(DELETE, {tags: thisTags})
-}
-
-export const publishDelete = ({relays, ...params}: DeleteParams & {relays: string[]}) =>
-  publishThunk({event: makeDelete(params), relays})
diff --git a/src/app/editor/MentionNodeView.ts b/src/app/editor/MentionNodeView.ts
index 7daf06e6..1dbc4ce5 100644
--- a/src/app/editor/MentionNodeView.ts
+++ b/src/app/editor/MentionNodeView.ts
@@ -1,29 +1,26 @@
 import type {NodeViewProps} from "@tiptap/core"
-import {removeUndefined} from "@welshman/lib"
-import {deriveProfileDisplay} from "@welshman/app"
+import {profiles} from "@app/core"
 
-export const makeMentionNodeView =
-  (url?: string) =>
-  ({node}: NodeViewProps) => {
-    const dom = document.createElement("span")
-    const display = deriveProfileDisplay(node.attrs.pubkey, removeUndefined([url]))
+export const MentionNodeView = ({node}: NodeViewProps) => {
+  const dom = document.createElement("span")
+  const display = profiles.get().display(node.attrs.pubkey).$
 
-    dom.classList.add("tiptap-object")
+  dom.classList.add("tiptap-object")
 
-    const unsubDisplay = display.subscribe($display => {
-      dom.textContent = "@" + $display
-    })
+  const unsubDisplay = display.subscribe($display => {
+    dom.textContent = "@" + $display
+  })
 
-    return {
-      dom,
-      destroy: () => {
-        unsubDisplay()
-      },
-      selectNode() {
-        dom.classList.add("tiptap-active")
-      },
-      deselectNode() {
-        dom.classList.remove("tiptap-active")
-      },
-    }
+  return {
+    dom,
+    destroy: () => {
+      unsubDisplay()
+    },
+    selectNode() {
+      dom.classList.add("tiptap-active")
+    },
+    deselectNode() {
+      dom.classList.remove("tiptap-active")
+    },
   }
+}
diff --git a/src/app/editor/ProfileSuggestion.svelte b/src/app/editor/ProfileSuggestion.svelte
index c827eef4..00e8f016 100644
--- a/src/app/editor/ProfileSuggestion.svelte
+++ b/src/app/editor/ProfileSuggestion.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
-  import {removeUndefined} from "@welshman/lib"
-  import {displayPubkey} from "@welshman/util"
-  import {deriveHandleForPubkey, displayHandle, deriveProfileDisplay} from "@welshman/app"
+  import {displayHandle} from "@welshman/util"
+  import {displayPubkey} from "@welshman/domain"
+  import {handles, profiles} from "@app/core"
   import WotScore from "@app/components/WotScore.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
 
@@ -13,8 +13,8 @@
   const {value, url}: Props = $props()
 
   const pubkey = value
-  const profileDisplay = deriveProfileDisplay(pubkey, removeUndefined([url]))
-  const handle = deriveHandleForPubkey(pubkey)
+  const profileDisplay = $profiles.display(pubkey).$
+  const handle = $handles.forPubkey(pubkey).$
 </script>
 
 <div class="flex max-w-full gap-3">
diff --git a/src/app/editor/RoomReferenceNodeView.ts b/src/app/editor/RoomReferenceNodeView.ts
index 5c25bf58..6b03e9ad 100644
--- a/src/app/editor/RoomReferenceNodeView.ts
+++ b/src/app/editor/RoomReferenceNodeView.ts
@@ -1,17 +1,17 @@
 import type {NodeViewRendererProps} from "@tiptap/core"
 import {displayRelayUrl} from "@welshman/util"
-import {deriveRoom} from "@app/groups"
+import {rooms} from "@app/core"
 
 export const RoomReferenceNodeView = ({node}: NodeViewRendererProps) => {
   const dom = document.createElement("span")
   const url = typeof node.attrs.url === "string" ? node.attrs.url : ""
   const h = typeof node.attrs.h === "string" ? node.attrs.h : ""
-  const room = deriveRoom(url, h)
+  const room = rooms.get().forRoom(url, h)
 
   dom.classList.add("tiptap-object")
 
   const unsubRoom = room.subscribe($room => {
-    dom.textContent = `~${displayRelayUrl(url)} / ${$room.name || h}`
+    dom.textContent = `~${displayRelayUrl(url)} / ${$room?.meta?.name() || h}`
   })
 
   return {
diff --git a/src/app/editor/RoomSuggestion.svelte b/src/app/editor/RoomSuggestion.svelte
index b0182a4b..352442a9 100644
--- a/src/app/editor/RoomSuggestion.svelte
+++ b/src/app/editor/RoomSuggestion.svelte
@@ -1,14 +1,14 @@
 <script lang="ts">
   import {displayRelayUrl} from "@welshman/util"
+  import {splitRoomKey} from "@welshman/app"
   import RoomNameWithImage from "@app/components/RoomNameWithImage.svelte"
-  import {splitRoomId} from "@app/groups"
 
   type Props = {
     value: string
   }
 
   const {value}: Props = $props()
-  const [url = "", h = ""] = splitRoomId(value)
+  const [url, h] = splitRoomKey(value)
 </script>
 
 <div class="max-w-full overflow-hidden text-ellipsis flex flex-col">
diff --git a/src/app/editor/clipboard.ts b/src/app/editor/clipboard.ts
index fa3e8ed5..06cf6a62 100644
--- a/src/app/editor/clipboard.ts
+++ b/src/app/editor/clipboard.ts
@@ -1,3 +1,4 @@
+import {spec} from "@welshman/lib"
 import {Clipboard} from "@capacitor/clipboard"
 import {Capacitor} from "@capacitor/core"
 import {Extension} from "@tiptap/core"
@@ -13,7 +14,7 @@ const hasStandardPastePayload = (event: ClipboardEvent) => {
     return false
   }
 
-  if (Array.from(clipboardData.items).some(item => item.kind === "file")) {
+  if (Array.from(clipboardData.items).some(spec({kind: "file"}))) {
     return true
   }
 
diff --git a/src/app/editor/index.ts b/src/app/editor/index.ts
index 15148e27..71093bcd 100644
--- a/src/app/editor/index.ts
+++ b/src/app/editor/index.ts
@@ -1,18 +1,10 @@
 import {mount} from "svelte"
 import type {Writable} from "svelte/store"
 import {get, derived} from "svelte/store"
-import {Router} from "@welshman/router"
-import {dec, inc, uniq} from "@welshman/lib"
+import {sortBy, uniq} from "@welshman/lib"
 import {throttled} from "@welshman/store"
-import type {PublishedProfile, RoomMeta} from "@welshman/util"
-import {
-  createSearch,
-  profiles,
-  searchProfiles,
-  handlesByNip05,
-  getMaxWot,
-  getWotGraph,
-} from "@welshman/app"
+import {createSearch, splitRoomKey} from "@welshman/app"
+import type {Room} from "@welshman/app"
 import type {FileAttributes} from "@welshman/editor"
 import {
   Editor,
@@ -22,14 +14,14 @@ import {
   editorProps,
 } from "@welshman/editor"
 import {escapeHtml} from "@lib/html"
-import {makeMentionNodeView} from "@app/editor/MentionNodeView"
+import {profiles, relayLists, relayMemberLists, rooms} from "@app/core"
+import {MentionNodeView} from "@app/editor/MentionNodeView"
 import ProfileSuggestion from "@app/editor/ProfileSuggestion.svelte"
 import {RoomReferenceExtension} from "@app/editor/RoomReferenceExtension"
 import RoomSuggestion from "@app/editor/RoomSuggestion.svelte"
 import {NativeClipboardPasteExtension} from "@app/editor/clipboard"
 import {compressFileForUpload, uploadFile} from "@app/uploads"
-import {deriveSpaceMembers} from "@app/members"
-import {makeRoomId, splitRoomId, userSpaceUrls, roomsByUrl} from "@app/groups"
+import {userSpaceUrls} from "@app/rooms"
 import {PLATFORM_RELAYS} from "@app/env"
 import {pushToast} from "@app/toast"
 
@@ -56,49 +48,19 @@ export const makeEditor = async ({
   uploading?: Writable<boolean>
   wordCount?: Writable<number>
 }) => {
-  const profileSearch = derived(
-    [
-      throttled(800, profiles),
-      throttled(800, handlesByNip05),
-      throttled(800, deriveSpaceMembers(url || "")),
-    ],
-    ([$profiles, $handlesByNip05, $spaceMembers]) => {
-      // Remove invalid nip05's from profiles
-      const options = $profiles.map(p => {
-        const isNip05Valid = !p.nip05 || $handlesByNip05.get(p.nip05)?.pubkey === p.event.pubkey
+  const searchProfiles = derived(
+    [profiles.get().profileSearch, throttled(800, relayMemberLists.get().forUrl(url ?? ""))],
+    ([$profileSearch, $spaceMembers]) => {
+      const memberPubkeys = new Set($spaceMembers?.pubkeys())
 
-        return isNip05Valid ? p : {...p, nip05: ""}
-      })
-
-      return createSearch(options, {
-        onSearch: searchProfiles,
-        getValue: (profile: PublishedProfile) => profile.event.pubkey,
-        sortFn: ({score = 1, item}) => {
-          const wotScore = getWotGraph().get(item.event.pubkey) || 0
-          const membershipScale = $spaceMembers?.includes(item.event.pubkey) ? 2 : 1
-
-          return dec(score) * inc(wotScore / getMaxWot()) * membershipScale
-        },
-        fuseOptions: {
-          keys: [
-            "nip05",
-            {name: "name", weight: 0.8},
-            {name: "display_name", weight: 0.5},
-            {name: "about", weight: 0.3},
-          ],
-          threshold: 0.3,
-          shouldSort: false,
-        },
-      })
+      return (term: string) =>
+        sortBy(pubkey => (memberPubkeys.has(pubkey) ? 0 : 1), $profileSearch.searchValues(term))
     },
   )
 
   const roomReferenceSearch = derived(
-    [throttled(800, userSpaceUrls), throttled(800, roomsByUrl)],
+    [throttled(800, userSpaceUrls), throttled(800, rooms.get().byUrl.$)],
     ([$userSpaceUrls, $roomsByUrl]) => {
-      const roomIdByMeta = new WeakMap<RoomMeta, string>()
-      const options: RoomMeta[] = []
-
       // When platform relays are configured, restrict suggestions to those spaces.
       // Otherwise suggest rooms from the user's joined spaces plus the current one.
       const spaceUrls =
@@ -106,15 +68,16 @@ export const makeEditor = async ({
           ? PLATFORM_RELAYS
           : uniq(url ? [url, ...$userSpaceUrls] : $userSpaceUrls)
 
-      for (const roomUrl of spaceUrls) {
-        for (const room of $roomsByUrl.get(roomUrl) || []) {
-          roomIdByMeta.set(room, makeRoomId(roomUrl, room.h))
-          options.push(room)
-        }
-      }
+      const options = spaceUrls.flatMap(spaceUrl =>
+        ($roomsByUrl.get(spaceUrl) ?? []).map((room: Room) => ({
+          id: room.id,
+          h: room.h,
+          name: room.meta?.name() ?? "",
+        })),
+      )
 
       return createSearch(options, {
-        getValue: item => roomIdByMeta.get(item) || item.h,
+        getValue: option => option.id,
         fuseOptions: {
           keys: ["name", "h"],
           threshold: 0.3,
@@ -158,14 +121,14 @@ export const makeEditor = async ({
           },
           nprofile: {
             extend: {
-              addNodeView: () => makeMentionNodeView(url),
+              addNodeView: () => MentionNodeView,
               addProseMirrorPlugins() {
                 return [
                   MentionSuggestion({
                     editor: (this as any).editor,
-                    search: (term: string) => get(profileSearch).searchValues(term),
-                    getRelays: (pubkey: string) => Router.get().FromPubkeys([pubkey]).getUrls(),
-                    updateSignal: profileSearch,
+                    search: (term: string) => get(searchProfiles)(term),
+                    getRelays: (pubkey: string) => relayLists.get().writeUrls(pubkey).get(),
+                    updateSignal: searchProfiles,
                     createSuggestion: (value: string) => {
                       const target = document.createElement("div")
 
@@ -181,13 +144,11 @@ export const makeEditor = async ({
                     search: (term: string) => get(roomReferenceSearch).searchValues(term),
                     updateSignal: roomReferenceSearch,
                     select: (id: string, props) => {
-                      const [roomUrl, h] = splitRoomId(id)
+                      const [roomUrl, h] = splitRoomKey(id)
 
-                      if (!roomUrl || !h) {
-                        return
+                      if (roomUrl && h) {
+                        return props.command({url: roomUrl, h})
                       }
-
-                      return props.command({url: roomUrl, h})
                     },
                     createSuggestion: (value: string) => {
                       const target = document.createElement("div")
diff --git a/src/app/env.ts b/src/app/env.ts
index ccdcd593..313d4daf 100644
--- a/src/app/env.ts
+++ b/src/app/env.ts
@@ -1,8 +1,7 @@
-import {normalizeRelayUrl} from "@welshman/util"
 import {Capacitor} from "@capacitor/core"
-import {Router} from "@welshman/router"
 import * as nip19 from "nostr-tools/nip19"
 import {identity} from "@welshman/lib"
+import {normalizeRelayUrl} from "@welshman/util"
 
 const fromCsv = (s: string) => (s || "").split(",").filter(identity)
 
@@ -20,6 +19,10 @@ export const INDEXER_RELAYS = fromCsv(import.meta.env.VITE_INDEXER_RELAYS).map(n
 
 export const DEFAULT_RELAYS = fromCsv(import.meta.env.VITE_DEFAULT_RELAYS).map(normalizeRelayUrl)
 
+export const DEFAULT_SEARCH_RELAYS = fromCsv(import.meta.env.VITE_DEFAULT_SEARCH_RELAYS).map(
+  normalizeRelayUrl,
+)
+
 export const DEFAULT_MESSAGING_RELAYS = fromCsv(import.meta.env.VITE_DEFAULT_MESSAGING_RELAYS).map(
   normalizeRelayUrl,
 )
@@ -67,5 +70,5 @@ export const dufflepud = (path: string) => DUFFLEPUD_URL + "/" + path
 
 export const entityLink = (entity: string) => `https://coracle.social/${entity}`
 
-export const pubkeyLink = (pubkey: string, relays = Router.get().FromPubkeys([pubkey]).getUrls()) =>
+export const pubkeyLink = (pubkey: string, relays: string[] = []) =>
   entityLink(nip19.nprofileEncode({pubkey, relays}))
diff --git a/src/app/featured.ts b/src/app/featured.ts
index c7f50d5d..88507f71 100644
--- a/src/app/featured.ts
+++ b/src/app/featured.ts
@@ -1,8 +1,9 @@
 import {derived} from "svelte/store"
-import {now} from "@welshman/lib"
-import {APP_DATA, getTagValues} from "@welshman/util"
+import {APP_DATA, tagSpec, tagValues} from "@welshman/util"
+import {AppData} from "@welshman/domain"
+import {Domain} from "@welshman/app"
+import {app} from "@app/core"
 import {deriveRelaySignedEvents} from "@app/repository"
-import {signAsRelay} from "@app/relays"
 
 // NIP-78 app data published by the relay's self key. Each featured entry is a
 // ["content", <value>] tag (freeform text, intended to be a url or nevent).
@@ -11,21 +12,26 @@ export const FEATURED_CONTENT_D = "flotilla/featured-content"
 export const deriveFeaturedContent = (url: string) =>
   derived(
     deriveRelaySignedEvents(url, [{kinds: [APP_DATA], "#d": [FEATURED_CONTENT_D]}]),
-    ([event]) => getTagValues("content", event?.tags ?? []),
+    ([event]) => tagValues(tagSpec("content"), event?.tags ?? []),
   )
 
 // Publish the featured content list by asking the relay to sign it with its self
 // key (the unofficial NIP-86 "signevent" method).
-export const setFeaturedContent = (url: string, content: string[]): Promise<string | undefined> =>
-  signAsRelay(url, {
-    kind: APP_DATA,
-    created_at: now(),
-    content: "",
-    tags: [
-      ["d", FEATURED_CONTENT_D],
-      ...content
-        .map(value => value.trim())
-        .filter(Boolean)
-        .map(value => ["content", value]),
-    ],
-  })
+export const setFeaturedContent = async (url: string, content: string[]) => {
+  const tags = content
+    .map(value => value.trim())
+    .filter(Boolean)
+    .map(value => ["content", value])
+
+  const writer = app
+    .get()
+    .use(Domain)
+    .writer(AppData)
+    .forceRelays(url)
+    .setIdentifier(FEATURED_CONTENT_D)
+    .addTags(...tags)
+
+  const command = await app.get().use(Domain).command(writer)
+
+  return command.publishAsRelay(url)
+}
diff --git a/src/app/feeds.ts b/src/app/feeds.ts
index 2937ee10..53444734 100644
--- a/src/app/feeds.ts
+++ b/src/app/feeds.ts
@@ -1,12 +1,12 @@
-import {repository, tracker} from "@welshman/app"
 import {writable} from "svelte/store"
 import {batch, between, call, int, now, on, sortBy, uniqBy, MONTH, YEAR} from "@welshman/lib"
-import {EVENT_TIME, getAddress, getTagValue, matchFilters} from "@welshman/util"
+import {EVENT_TIME, getAddress, matchFilters, tagSpec, tagValue} from "@welshman/util"
 import type {Filter, TrustedEvent} from "@welshman/util"
-import {mergeRepositoryUpdates, request} from "@welshman/net"
+import {mergeRepositoryUpdates} from "@welshman/net"
 import type {RepositoryUpdate} from "@welshman/net"
 import {createScroller} from "@lib/html"
 import {daysBetween} from "@lib/util"
+import {app, network} from "@app/core"
 import {getEventsForUrl} from "@app/repository"
 
 export const makeFeed = ({
@@ -101,7 +101,7 @@ export const makeFeed = ({
     const matching: TrustedEvent[] = []
 
     for (const id of new Set(ids)) {
-      const event = repository.getEvent(id)
+      const event = app.get().repository.getEvent(id)
 
       if (event && matchFilters(filters, event)) {
         matching.push(event)
@@ -115,7 +115,7 @@ export const makeFeed = ({
 
   const unsubscribers = [
     on(
-      repository,
+      app.get().repository,
       "update",
       batch(150, (updates: RepositoryUpdate[]) => {
         const {added, removed} = mergeRepositoryUpdates(updates)
@@ -132,7 +132,7 @@ export const makeFeed = ({
         const matching = added.filter(
           event =>
             matchFilters(filters, event) &&
-            relays.some(url => tracker.getRelays(event.id).has(url)),
+            relays.some(url => app.get().tracker.getRelays(event.id).has(url)),
         )
 
         if (matching.length > 0) {
@@ -140,7 +140,7 @@ export const makeFeed = ({
         }
       }),
     ),
-    on(tracker, "add", (id: string, url: string) => {
+    on(app.get().tracker, "add", (id: string, url: string) => {
       if (relays.includes(url)) {
         onTrackedId(id)
       }
@@ -148,7 +148,7 @@ export const makeFeed = ({
   ]
 
   const loadTimeframe = async (since: number, until: number) => {
-    const events = await request({
+    const events = await network.get().request({
       relays,
       autoClose: true,
       signal: controller.signal,
@@ -238,9 +238,9 @@ export const makeCalendarFeed = ({
   let backwardWindow = [now() - interval, now()]
   let forwardWindow = [now(), now() + interval]
 
-  const getStart = (event: TrustedEvent) => parseInt(getTagValue("start", event.tags) || "")
+  const getStart = (event: TrustedEvent) => parseInt(tagValue(tagSpec("start"), event.tags) || "")
 
-  const getEnd = (event: TrustedEvent) => parseInt(getTagValue("end", event.tags) || "")
+  const getEnd = (event: TrustedEvent) => parseInt(tagValue(tagSpec("end"), event.tags) || "")
 
   const events = writable(
     sortBy(
@@ -291,7 +291,7 @@ export const makeCalendarFeed = ({
     const matching: TrustedEvent[] = []
 
     for (const id of new Set(ids)) {
-      const event = repository.getEvent(id)
+      const event = app.get().repository.getEvent(id)
 
       if (event && matchFilters(filters, event)) {
         matching.push(event)
@@ -305,7 +305,7 @@ export const makeCalendarFeed = ({
 
   const unsubscribers = [
     on(
-      repository,
+      app.get().repository,
       "update",
       batch(150, (updates: RepositoryUpdate[]) => {
         const {added, removed} = mergeRepositoryUpdates(updates)
@@ -325,7 +325,7 @@ export const makeCalendarFeed = ({
         }
       }),
     ),
-    on(tracker, "add", (id: string, url: string) => {
+    on(app.get().tracker, "add", (id: string, url: string) => {
       if (relays.includes(url)) {
         onTrackedId(id)
       }
@@ -335,7 +335,7 @@ export const makeCalendarFeed = ({
   const loadTimeframe = (since: number, until: number) => {
     const hashes = daysBetween(since, until).map(String)
 
-    request({
+    network.get().request({
       relays,
       autoClose: true,
       signal: controller.signal,
diff --git a/src/app/groups.ts b/src/app/groups.ts
deleted file mode 100644
index 24a62139..00000000
--- a/src/app/groups.ts
+++ /dev/null
@@ -1,433 +0,0 @@
-import * as nip19 from "nostr-tools/nip19"
-import {
-  MESSAGE,
-  ROOMS,
-  ROOM_DELETE,
-  ROOM_META,
-  addToListPublicly,
-  asDecryptedEvent,
-  getGroupTags,
-  getListTags,
-  getRelayTagValues,
-  getTagValues,
-  isRelayUrl,
-  makeEvent,
-  makeList,
-  makeRoomMeta,
-  normalizeRelayUrl,
-  readList,
-  readRoomMeta,
-  removeFromListByPredicate,
-  toNostrURI,
-  updateList,
-  RelayMode,
-} from "@welshman/util"
-import type {EventContent, List, PublishedRoomMeta, RoomMeta, TrustedEvent} from "@welshman/util"
-import {
-  deriveEventsByIdByUrl,
-  deriveItemsByKey,
-  getter,
-  makeDeriveItem,
-  makeLoadItem,
-} from "@welshman/store"
-import {
-  getPubkeyRelays,
-  makeOutboxLoader,
-  makeUserData,
-  makeUserLoader,
-  nip44EncryptToSelf,
-  publishThunk,
-  repository,
-  tagEventForQuote,
-  tagPubkey,
-  tracker,
-} from "@welshman/app"
-import {derived, get} from "svelte/store"
-import {
-  addToMapKey,
-  call,
-  equals,
-  gte,
-  identity,
-  indexBy,
-  max,
-  partition,
-  sortBy,
-  spec,
-  tryCatch,
-  uniq,
-} from "@welshman/lib"
-import {load} from "@welshman/net"
-import {Router} from "@welshman/router"
-import {INDEXER_RELAYS} from "@app/env"
-
-export const ROOM = "h"
-
-export const PROTECTED = ["-"]
-
-export enum RoomType {
-  Text = "text",
-  Voice = "voice",
-}
-
-export type Room = PublishedRoomMeta & {
-  id: string
-  url: string
-}
-
-export const getRoomType = (room: RoomMeta): RoomType =>
-  room.livekit ? RoomType.Voice : RoomType.Text
-
-export const makeRoomId = (url: string, h: string) => `${url}'${h}`
-
-export const isRoomId = (id: string) => id.includes("'")
-
-export const splitRoomId = (id: string) => id.split("'")
-
-export const roomMetaEventsByIdByUrl = deriveEventsByIdByUrl({
-  tracker,
-  repository,
-  filters: [{kinds: [ROOM_META, ROOM_DELETE]}],
-})
-
-export const roomsByUrl = derived(roomMetaEventsByIdByUrl, roomMetaEventsByIdByUrl => {
-  const result = new Map<string, Room[]>()
-
-  for (const [url, events] of roomMetaEventsByIdByUrl.entries()) {
-    const [metaEvents, deleteEvents] = partition(spec({kind: ROOM_META}), events.values())
-    const deletedByH = new Map<string, number>()
-
-    for (const event of deleteEvents) {
-      for (const h of getTagValues("h", event.tags)) {
-        deletedByH.set(h, max([deletedByH.get(h), event.created_at]))
-      }
-    }
-
-    const metaById = new Map<string, Room>()
-
-    for (const event of metaEvents) {
-      const meta = tryCatch(() => readRoomMeta(event))
-
-      if (!meta || gte(deletedByH.get(meta.h), meta.event.created_at)) {
-        continue
-      }
-
-      const id = makeRoomId(url, meta.h)
-
-      metaById.set(id, {...meta, url, id})
-    }
-
-    if (metaById.size > 0) {
-      result.set(url, Array.from(metaById.values()))
-    }
-  }
-
-  return result
-})
-
-export const roomsById = derived(roomsByUrl, roomsByUrl =>
-  indexBy(room => room.id, Array.from(roomsByUrl.values()).flatMap(identity)),
-)
-
-export const getRoomsById = getter(roomsById)
-
-export const getRoom = (id: string) => getRoomsById().get(id)
-
-export const loadRoom = call(() => {
-  const _fetchRoom = async (id: string) => {
-    const [url, h] = splitRoomId(id)
-
-    await load({
-      relays: [url],
-      filters: [
-        {kinds: [ROOM_META], "#d": [h]},
-        {kinds: [ROOM_DELETE], "#h": [h]},
-      ],
-    })
-  }
-
-  const _loadRoom = makeLoadItem(_fetchRoom, getRoom)
-
-  return (url: string, h: string) => _loadRoom(makeRoomId(url, h))
-})
-
-export const deriveRoom = call(() => {
-  const _deriveRoom = makeDeriveItem(roomsById, loadRoom)
-
-  return (url: string, h: string) =>
-    derived(
-      _deriveRoom(makeRoomId(url, h)),
-      room => (room || {url, id: makeRoomId(url, h), ...makeRoomMeta({h})}) as Room,
-    )
-})
-
-export const displayRoom = (url: string, h: string) => getRoom(makeRoomId(url, h))?.name || h
-
-export const roomComparator = (url: string) => (h: string) => displayRoom(url, h).toLowerCase()
-
-export const deriveVoiceRooms = (url: string) =>
-  derived(roomsById, $roomsById => {
-    const set = new Set<string>()
-    for (const room of $roomsById.values()) {
-      if (room.url === url && room.livekit) {
-        set.add(room.h)
-      }
-    }
-    return set
-  })
-
-export const deriveOtherVoiceRooms = (url: string) =>
-  derived([deriveVoiceRooms(url), deriveUserRooms(url)], ([$roomsWithLivekit, $userRooms]) => {
-    const rooms: string[] = []
-
-    for (const h of $roomsWithLivekit) {
-      if (!$userRooms.includes(h)) {
-        rooms.push(h)
-      }
-    }
-
-    return sortBy(roomComparator(url), uniq(rooms))
-  })
-
-// User space/room lists
-
-export const groupListsByPubkey = deriveItemsByKey({
-  repository,
-  filters: [{kinds: [ROOMS]}],
-  getKey: list => list.event.pubkey,
-  eventToItem: (event: TrustedEvent) => readList(asDecryptedEvent(event)),
-})
-
-export const getGroupListsByPubkey = getter(groupListsByPubkey)
-
-export const getGroupList = (pubkey: string) => getGroupListsByPubkey().get(pubkey)
-
-export const loadGroupList = makeLoadItem(makeOutboxLoader(ROOMS), getGroupList)
-
-export const deriveGroupList = makeDeriveItem(groupListsByPubkey, loadGroupList)
-
-export const groupListPubkeysByUrl = derived(groupListsByPubkey, $groupListsByPubkey => {
-  const result = new Map<string, Set<string>>()
-
-  for (const list of $groupListsByPubkey.values()) {
-    const tags = getListTags(list)
-
-    for (const url of getRelayTagValues(tags)) {
-      addToMapKey(result, normalizeRelayUrl(url), list.event.pubkey)
-    }
-
-    for (const tag of getGroupTags(tags)) {
-      const url = tag[2] || ""
-
-      if (isRelayUrl(url)) {
-        addToMapKey(result, normalizeRelayUrl(url), list.event.pubkey)
-      }
-    }
-  }
-
-  return result
-})
-
-export const deriveGroupListPubkeys = (url: string) =>
-  derived(groupListPubkeysByUrl, $groupListPubkeysByUrl => new Set($groupListPubkeysByUrl.get(url)))
-
-export const getSpaceUrlsFromGroupList = (groupList: List | undefined) => {
-  const tags = getListTags(groupList)
-  const urls = getRelayTagValues(tags)
-
-  for (const tag of getGroupTags(tags)) {
-    const url = tag[2] || ""
-
-    if (isRelayUrl(url)) {
-      urls.push(url)
-    }
-  }
-
-  return uniq(urls.map(normalizeRelayUrl))
-}
-
-export const getSpaceRoomsFromGroupList = (url: string, groupList: List | undefined) => {
-  const rooms: string[] = []
-  const normalizedUrl = normalizeRelayUrl(url)
-
-  for (const [_, h, relay] of getGroupTags(getListTags(groupList))) {
-    if (normalizedUrl === normalizeRelayUrl(relay)) {
-      rooms.push(h)
-    }
-  }
-
-  return sortBy(roomComparator(url), uniq(rooms))
-}
-
-export const userGroupList = makeUserData(groupListsByPubkey, loadGroupList)
-
-export const loadUserGroupList = makeUserLoader(loadGroupList)
-
-export const userSpaceUrls = derived(userGroupList, getSpaceUrlsFromGroupList)
-
-export const deriveUserRooms = (url: string) =>
-  derived([userGroupList, roomsById], ([$userGroupList, $roomsById]) => {
-    const rooms: string[] = []
-
-    for (const h of getSpaceRoomsFromGroupList(url, $userGroupList)) {
-      if ($roomsById.has(makeRoomId(url, h))) {
-        rooms.push(h)
-      }
-    }
-
-    return sortBy(roomComparator(url), rooms)
-  })
-
-export const deriveOtherRooms = (url: string) =>
-  derived(
-    [deriveUserRooms(url), deriveVoiceRooms(url), roomsByUrl],
-    ([$userRooms, voiceRooms, $roomsByUrl]) => {
-      const rooms: string[] = []
-
-      for (const {h} of $roomsByUrl.get(url) || []) {
-        if (!$userRooms.includes(h) && !voiceRooms.has(h)) {
-          rooms.push(h)
-        }
-      }
-
-      return sortBy(roomComparator(url), uniq(rooms))
-    },
-  )
-
-export const addSpace = async (url: string) => {
-  const list = get(userGroupList) || makeList({kind: ROOMS})
-  const event = await addToListPublicly(list, ["r", url]).reconcile(nip44EncryptToSelf)
-  const relays = uniq([...Router.get().FromUser().getUrls(), ...getRelayTagValues(event.tags)])
-
-  return publishThunk({event, relays})
-}
-
-export const removeSpace = async (url: string) => {
-  const list = get(userGroupList) || makeList({kind: ROOMS})
-  const pred = (t: string[]) => normalizeRelayUrl(t[t[0] === "r" ? 1 : 2]) === url
-  const event = await removeFromListByPredicate(list, pred).reconcile(nip44EncryptToSelf)
-  const relays = uniq([url, ...Router.get().FromUser().getUrls(), ...getRelayTagValues(event.tags)])
-
-  return publishThunk({event, relays})
-}
-
-export const setSpaces = async (urls: string[]) => {
-  const list = get(userGroupList) || makeList({kind: ROOMS})
-  const orderedUrls = uniq(urls.map(normalizeRelayUrl))
-  const relayTags = list.publicTags.filter(t => t[0] === "r")
-  const otherPublicTags = list.publicTags.filter(t => t[0] !== "r")
-  const relayTagByUrl = new Map(relayTags.map(t => [normalizeRelayUrl(t[1]), t]))
-  const orderedRelayTags = orderedUrls.map(url => relayTagByUrl.get(url) || ["r", url])
-  const publicTags = [...orderedRelayTags, ...otherPublicTags]
-  const event = await updateList(list, {publicTags}).reconcile(nip44EncryptToSelf)
-  const relays = uniq([...Router.get().FromUser().getUrls(), ...getRelayTagValues(event.tags)])
-
-  return publishThunk({event, relays})
-}
-
-export const moveSpace = async (oldUrl: string, newUrl: string) => {
-  const from = normalizeRelayUrl(oldUrl)
-  const to = normalizeRelayUrl(newUrl)
-  const list = get(userGroupList)
-
-  if (!list || from === to) return
-
-  const rewrite = (tags: string[][]) =>
-    tags.map(t => {
-      if (t[0] === "r" && normalizeRelayUrl(t[1]) === from) return ["r", to]
-      if (t[0] === "group" && normalizeRelayUrl(t[2] || "") === from) return ["group", t[1], to]
-      return t
-    })
-
-  const publicTags = rewrite(list.publicTags)
-  const privateTags = rewrite(list.privateTags)
-  const publicChanged = !equals(publicTags, list.publicTags)
-  const privateChanged = !equals(privateTags, list.privateTags)
-
-  if (!publicChanged && !privateChanged) return
-
-  const event = await updateList(list, {
-    publicTags: publicChanged ? publicTags : undefined,
-    privateTags: privateChanged ? privateTags : undefined,
-  }).reconcile(nip44EncryptToSelf)
-  const relays = uniq([
-    oldUrl,
-    newUrl,
-    ...Router.get().FromUser().getUrls(),
-    ...getRelayTagValues(event.tags),
-  ])
-
-  return publishThunk({event, relays})
-}
-
-export const addRoom = async (url: string, h: string) => {
-  const list = get(userGroupList) || makeList({kind: ROOMS})
-  const newTags = [
-    ["r", url],
-    ["group", h, url],
-  ]
-  const event = await addToListPublicly(list, ...newTags).reconcile(nip44EncryptToSelf)
-  const relays = uniq([...Router.get().FromUser().getUrls(), ...getRelayTagValues(event.tags)])
-
-  return publishThunk({event, relays})
-}
-
-export const removeRoom = async (url: string, h: string) => {
-  const list = get(userGroupList) || makeList({kind: ROOMS})
-  const pred = (t: string[]) => equals(["group", h, url], t.slice(0, 3))
-  const event = await removeFromListByPredicate(list, pred).reconcile(nip44EncryptToSelf)
-  const relays = uniq([url, ...Router.get().FromUser().getUrls(), ...getRelayTagValues(event.tags)])
-
-  return publishThunk({event, relays})
-}
-
-export const getPubkeyHints = (pubkey: string) => {
-  const relays = getPubkeyRelays(pubkey, RelayMode.Write)
-  const hints = relays.length ? relays : INDEXER_RELAYS
-
-  return hints
-}
-
-export const prependParent = (
-  parent: TrustedEvent | undefined,
-  {content, tags}: EventContent,
-  url?: string,
-) => {
-  if (parent) {
-    const relays = url ? [url] : Router.get().Event(parent).limit(3).getUrls()
-    const nevent = nip19.neventEncode({...parent, relays})
-
-    tags = [...tags, tagEventForQuote(parent, url), tagPubkey(parent.pubkey)]
-    content = toNostrURI(nevent) + "\n\n" + content
-  }
-
-  return {content, tags}
-}
-
-export const publishRoomQuote = ({
-  url,
-  h,
-  parent,
-  protect,
-  delay,
-}: {
-  url: string
-  h?: string
-  parent: TrustedEvent
-  protect: boolean
-  delay?: number
-}) => {
-  const tags: string[][] = []
-
-  if (h) {
-    tags.push(["h", h])
-  }
-
-  if (protect) {
-    tags.push(PROTECTED)
-  }
-
-  const event = makeEvent(MESSAGE, prependParent(parent, {content: "", tags}, url))
-
-  return publishThunk({relays: [url], event, delay})
-}
diff --git a/src/app/healthChecks.ts b/src/app/healthChecks.ts
index 27e7eff2..40f97cbf 100644
--- a/src/app/healthChecks.ts
+++ b/src/app/healthChecks.ts
@@ -1,17 +1,16 @@
-import {derived, get} from "svelte/store"
-import {not, ifLet, sample} from "@welshman/lib"
-import {getRelaysFromList, RelayMode} from "@welshman/util"
+import {derived} from "svelte/store"
+import {sample} from "@welshman/lib"
 import {
-  getRelay,
-  setWriteRelays,
-  setReadRelays,
-  setSearchRelays,
-  setMessagingRelays,
-  userRelayList,
-  userSearchRelayList,
-  userMessagingRelayList,
+  MessagingRelayLists,
+  RelayLists,
+  Relays,
+  SearchRelayLists,
+  projectFrom,
+  projection,
+  publish,
 } from "@welshman/app"
-import {hasNip50} from "@app/relays"
+import type {IApp, Projection} from "@welshman/app"
+import {usePlugin} from "@app/core"
 import {DEFAULT_RELAYS, DEFAULT_MESSAGING_RELAYS} from "@app/env"
 
 export type HealthCheckContext = {
@@ -29,80 +28,106 @@ export type HealthCheck = {
   apply: (context: HealthCheckContext) => unknown
 }
 
-export const healthCheckContext = derived(
-  [userRelayList, userSearchRelayList, userMessagingRelayList],
-  ([$userRelayList, $userSearchRelayList, $userMessagingRelayList]) => {
-    return {
-      readRelays: getRelaysFromList($userRelayList, RelayMode.Read),
-      writeRelays: getRelaysFromList($userRelayList, RelayMode.Write),
-      searchRelays: getRelaysFromList($userSearchRelayList),
-      messagingRelays: getRelaysFromList($userMessagingRelayList),
-    }
-  },
-)
+export class HealthChecks {
+  context: Projection<HealthCheckContext>
+  pending: Projection<HealthCheck[]>
 
-const healthChecks: HealthCheck[] = [
-  {
-    title: "Missing Inbox Relays",
-    description: "Other people aren't currently able to reliably tag you in public notes.",
-    action: "Update",
-    isPending: context => context.readRelays.length <= 1,
-    apply: () => setReadRelays(DEFAULT_RELAYS),
-  },
-  {
-    title: "Missing Outbox Relays",
-    description: "Other people aren't currently able to reliably find your public notes.",
-    action: "Update",
-    isPending: context => context.writeRelays.length <= 1,
-    apply: () => setWriteRelays(DEFAULT_RELAYS),
-  },
-  {
-    title: "Missing DM Relays",
-    description: "You aren't currently able to reliably send or receive direct messages.",
-    action: "Update",
-    isPending: context => context.messagingRelays.length <= 1,
-    apply: () => setMessagingRelays(DEFAULT_MESSAGING_RELAYS),
-  },
-  {
-    title: "Too Many Inbox Relays",
-    description:
-      "You have more inbox relays than is really necessary, which can affect resource usage.",
-    action: "Prune Selections",
-    isPending: context => context.readRelays.length > 8,
-    apply: context => setReadRelays(sample(5, context.readRelays)),
-  },
-  {
-    title: "Too Many Outbox Relays",
-    description:
-      "You have more outbox relays than is really necessary, which can affect resource usage.",
-    action: "Prune Selections",
-    isPending: context => context.writeRelays.length > 8,
-    apply: context => setWriteRelays(sample(5, context.writeRelays)),
-  },
-  {
-    title: "Too Many DM Relays",
-    description:
-      "You have more DM relays than is really necessary, which can affect resource usage.",
-    action: "Prune Selections",
-    isPending: context => context.messagingRelays.length > 8,
-    apply: context => setMessagingRelays(sample(5, context.messagingRelays)),
-  },
-  {
-    title: "Invalid Search Relays",
-    description: "Some of your search relays don't support search.",
-    action: "Remove Invalid",
-    isPending: context => context.searchRelays.some(url => not(ifLet(getRelay(url), hasNip50))),
-    apply: context =>
-      setSearchRelays(context.searchRelays.filter(url => ifLet(getRelay(url), hasNip50))),
-  },
-]
+  constructor(private readonly app: IApp) {
+    const pubkey = app.user?.pubkey ?? ""
 
-export const isHealthCheckPending = (healthCheck: HealthCheck) =>
-  healthCheck.isPending(get(healthCheckContext))
+    this.context = projection(
+      derived(
+        [
+          app.use(RelayLists).index.$,
+          app.use(SearchRelayLists).index.$,
+          app.use(MessagingRelayLists).index.$,
+        ],
+        ([$relayLists, $searchRelayLists, $messagingRelayLists]) => {
+          const relayList = $relayLists.get(pubkey)
 
-export const applyHealthCheck = (healthCheck: HealthCheck) =>
-  healthCheck.apply(get(healthCheckContext))
+          return {
+            readRelays: relayList?.readUrls() ?? [],
+            writeRelays: relayList?.writeUrls() ?? [],
+            searchRelays: $searchRelayLists.get(pubkey)?.urls() ?? [],
+            messagingRelays: $messagingRelayLists.get(pubkey)?.urls() ?? [],
+          }
+        },
+      ),
+    )
 
-export const pendingHealthChecks = derived(healthCheckContext, ctx =>
-  healthChecks.filter(hc => hc.isPending(ctx)),
-)
+    this.pending = projectFrom(this.context, $context =>
+      this.checks.filter(check => check.isPending($context)),
+    )
+  }
+
+  private supportsSearch = (url: string) => this.app.use(Relays).get(url)?.hasNip(50)
+
+  private checks: HealthCheck[] = [
+    {
+      title: "Missing Inbox Relays",
+      description: "Other people aren't currently able to reliably tag you in public notes.",
+      action: "Update",
+      isPending: context => context.readRelays.length <= 1,
+      apply: () => this.app.use(RelayLists).setReadUrls(DEFAULT_RELAYS).then(publish),
+    },
+    {
+      title: "Missing Outbox Relays",
+      description: "Other people aren't currently able to reliably find your public notes.",
+      action: "Update",
+      isPending: context => context.writeRelays.length <= 1,
+      apply: () => this.app.use(RelayLists).setWriteUrls(DEFAULT_RELAYS).then(publish),
+    },
+    {
+      title: "Missing DM Relays",
+      description: "You aren't currently able to reliably send or receive direct messages.",
+      action: "Update",
+      isPending: context => context.messagingRelays.length <= 1,
+      apply: () =>
+        this.app.use(MessagingRelayLists).setUrls(DEFAULT_MESSAGING_RELAYS).then(publish),
+    },
+    {
+      title: "Too Many Inbox Relays",
+      description:
+        "You have more inbox relays than is really necessary, which can affect resource usage.",
+      action: "Prune Selections",
+      isPending: context => context.readRelays.length > 8,
+      apply: context =>
+        this.app.use(RelayLists).setReadUrls(sample(5, context.readRelays)).then(publish),
+    },
+    {
+      title: "Too Many Outbox Relays",
+      description:
+        "You have more outbox relays than is really necessary, which can affect resource usage.",
+      action: "Prune Selections",
+      isPending: context => context.writeRelays.length > 8,
+      apply: context =>
+        this.app.use(RelayLists).setWriteUrls(sample(5, context.writeRelays)).then(publish),
+    },
+    {
+      title: "Too Many DM Relays",
+      description:
+        "You have more DM relays than is really necessary, which can affect resource usage.",
+      action: "Prune Selections",
+      isPending: context => context.messagingRelays.length > 8,
+      apply: context =>
+        this.app.use(MessagingRelayLists).setUrls(sample(5, context.messagingRelays)).then(publish),
+    },
+    {
+      title: "Invalid Search Relays",
+      description: "Some of your search relays don't support search.",
+      action: "Remove Invalid",
+      isPending: context => context.searchRelays.some(url => !this.supportsSearch(url)),
+      apply: context =>
+        this.app
+          .use(SearchRelayLists)
+          .setUrls(context.searchRelays.filter(this.supportsSearch))
+          .then(publish),
+    },
+  ]
+
+  isPending = (healthCheck: HealthCheck) => healthCheck.isPending(this.context.get())
+
+  apply = (healthCheck: HealthCheck) => healthCheck.apply(this.context.get())
+}
+
+export const healthChecks = usePlugin(HealthChecks)
diff --git a/src/app/hosting.ts b/src/app/hosting.ts
index 6f937ed0..5266a14d 100644
--- a/src/app/hosting.ts
+++ b/src/app/hosting.ts
@@ -4,7 +4,7 @@ import {Capacitor} from "@capacitor/core"
 import type {Maybe} from "@welshman/lib"
 import {sortBy, int, MINUTE, ms} from "@welshman/lib"
 import {makeHttpAuth, makeHttpAuthHeader, normalizeRelayUrl} from "@welshman/util"
-import {pubkey, signer} from "@welshman/app"
+import {user} from "@app/core"
 import {HOSTING_BACKEND_URL, PLATFORM_URL} from "@app/env"
 
 // Apple doesn't allow selling hosting outside their payment system, so on iOS we
@@ -21,7 +21,7 @@ export type Plan = {
   livekit: boolean
 }
 
-export type Relay = {
+export type HostedRelay = {
   id: string
   tenant_pubkey: string
   subdomain: string
@@ -180,15 +180,12 @@ const AUTH_TTL = ms(int(10, MINUTE))
 // switching accounts doesn't keep signing as the old one.
 let cachedAuth: Maybe<{pubkey: string; expiresAt: number; header: Promise<string>}>
 
-const getAuthHeader = (): Maybe<Promise<string>> => {
-  const $pubkey = pubkey.get()
-  const $signer = signer.get()
+const getAuthHeader = (): Promise<string> => {
+  const {pubkey, signer} = user.get()
 
-  if (!$pubkey || !$signer) return undefined
-
-  if (cachedAuth?.pubkey !== $pubkey || cachedAuth.expiresAt < Date.now()) {
+  if (cachedAuth?.pubkey !== pubkey || cachedAuth.expiresAt < Date.now()) {
     const header = makeHttpAuth(HOSTING_BACKEND_URL, "GET")
-      .then(template => $signer.sign(template))
+      .then(template => signer.sign(template))
       .then(makeHttpAuthHeader)
 
     // A declined signature shouldn't be cached, or the user can't retry.
@@ -196,7 +193,7 @@ const getAuthHeader = (): Maybe<Promise<string>> => {
       if (cachedAuth?.header === header) cachedAuth = undefined
     })
 
-    cachedAuth = {pubkey: $pubkey, expiresAt: Date.now() + AUTH_TTL, header}
+    cachedAuth = {pubkey, expiresAt: Date.now() + AUTH_TTL, header}
   }
 
   return cachedAuth.header
@@ -205,10 +202,11 @@ const getAuthHeader = (): Maybe<Promise<string>> => {
 type HostingResponse<T> = {data: T; error?: string}
 
 export const hostingFetch = async <T>(method: string, path: string, body?: unknown): Promise<T> => {
-  const auth = await getAuthHeader()
-  const headers: Record<string, string> = {Accept: "application/json"}
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    Authorization: await getAuthHeader(),
+  }
 
-  if (auth) headers["Authorization"] = auth
   if (body !== undefined) headers["Content-Type"] = "application/json"
 
   const response = await fetch(new URL(path, HOSTING_BACKEND_URL).toString(), {
@@ -237,7 +235,7 @@ export const updateTenant = (pubkey: string, input: UpdateTenantInput) =>
   hostingFetch<Tenant>("PUT", `/tenants/${pubkey}`, input)
 
 export const listTenantRelays = (pubkey: string) =>
-  hostingFetch<Relay[]>("GET", `/tenants/${pubkey}/relays`)
+  hostingFetch<HostedRelay[]>("GET", `/tenants/${pubkey}/relays`)
 
 export const listTenantInvoices = (pubkey: string) =>
   hostingFetch<Invoice[]>("GET", `/tenants/${pubkey}/invoices`)
@@ -256,12 +254,12 @@ export const createPortalSession = (pubkey: string, returnUrl: string = hostingR
   )
 
 export const createRelay = (input: CreateRelayInput) =>
-  hostingFetch<Relay>("POST", "/relays", input)
+  hostingFetch<HostedRelay>("POST", "/relays", input)
 
-export const getRelay = (id: string) => hostingFetch<Relay>("GET", `/relays/${id}`)
+export const getRelay = (id: string) => hostingFetch<HostedRelay>("GET", `/relays/${id}`)
 
 export const updateRelay = (id: string, input: UpdateRelayInput) =>
-  hostingFetch<Relay>("PUT", `/relays/${id}`, input)
+  hostingFetch<HostedRelay>("PUT", `/relays/${id}`, input)
 
 export const deactivateRelay = (id: string) =>
   hostingFetch<void>("POST", `/relays/${id}/deactivate`)
@@ -322,16 +320,16 @@ export const formatPeriod = (startSecs?: number, endSecs?: number) =>
     : `${new Date(ms(startSecs)).toLocaleDateString()} – ${new Date(ms(endSecs)).toLocaleDateString()}`
 
 // A verified custom domain when present, otherwise the platform subdomain.
-export const relayHost = (relay: Relay): string =>
+export const relayHost = (relay: HostedRelay): string =>
   relay.custom_domain_verified && relay.custom_domain
     ? relay.custom_domain
     : canonicalRelayHost(relay)
 
 // The host a custom domain must CNAME to.
-export const canonicalRelayHost = (relay: Relay): string =>
+export const canonicalRelayHost = (relay: HostedRelay): string =>
   `${relay.subdomain}.${relay.zooid_domain}`
 
-export const getHostedRelayUrl = (relay: Relay): string =>
+export const getHostedRelayUrl = (relay: HostedRelay): string =>
   normalizeRelayUrl("wss://" + relayHost(relay))
 
 // On native, redirects can't round-trip through location.origin; use the
@@ -345,9 +343,7 @@ export const hostingReturnUrl = (path = "/settings/hosting"): string =>
 let tenantPromise: Maybe<{pubkey: string; promise: Promise<Tenant>}>
 
 export const ensureSessionTenant = async () => {
-  const $pubkey = pubkey.get()
-
-  if (!$pubkey) return
+  const $pubkey = user.get().pubkey
 
   if (tenantPromise?.pubkey !== $pubkey) {
     const promise = createTenant(hostingReturnUrl())
@@ -399,17 +395,15 @@ export const deriveRelayActivity = (id: Readable<Maybe<string>>) =>
 
 // Loading is distinct from "not hosted here" — both leave `relay` undefined, but
 // only one of them should keep the caller waiting.
-export type HostedRelayState = {loading: boolean; relay: Maybe<Relay>}
+export type HostedRelayState = {loading: boolean; relay: Maybe<HostedRelay>}
 
 export const deriveHostedRelay = (url: string) =>
-  derived<typeof pubkey, HostedRelayState>(
-    pubkey,
-    ($pubkey, set) => {
-      if (!$pubkey) return set({loading: false, relay: undefined})
-
+  derived<typeof user, HostedRelayState>(
+    user,
+    ($user, set) => {
       set({loading: true, relay: undefined})
 
-      listTenantRelays($pubkey).then(
+      listTenantRelays($user.pubkey).then(
         relays => set({loading: false, relay: relays.find(r => getHostedRelayUrl(r) === url)}),
         () => set({loading: false, relay: undefined}),
       )
diff --git a/src/app/lightning.ts b/src/app/lightning.ts
index d7f7fae2..fd7f4c86 100644
--- a/src/app/lightning.ts
+++ b/src/app/lightning.ts
@@ -1,16 +1,22 @@
+import {writable} from "svelte/store"
 import {nwc} from "@getalby/sdk"
-import {session} from "@welshman/app"
+import type {Maybe} from "@welshman/lib"
+import {isNWCWallet, isWebLNWallet} from "@welshman/util"
+import type {Wallet} from "@welshman/util"
+import {withGetter} from "@welshman/store"
+
+export const wallet = withGetter(writable<Maybe<Wallet>>(undefined))
 
 export const getWebLn = () => (window as any).webln
 
 export const getNwcClient = () => {
-  const $session = session.get()
+  const $wallet = wallet.get()
 
-  if (!$session?.wallet || $session.wallet.type !== "nwc") {
+  if (!$wallet || !isNWCWallet($wallet)) {
     throw new Error("No NWC wallet is connected")
   }
 
-  const {info} = $session.wallet
+  const {info} = $wallet
 
   if (info.nostrWalletConnectUrl) {
     return new nwc.NWCClient({nostrWalletConnectUrl: info.nostrWalletConnectUrl})
@@ -20,17 +26,17 @@ export const getNwcClient = () => {
 }
 
 export const payInvoice = async (invoice: string, msats?: number) => {
-  const $session = session.get()
+  const $wallet = wallet.get()
 
-  if (!$session?.wallet) {
+  if (!$wallet) {
     throw new Error("No wallet is connected")
   }
 
-  if ($session.wallet.type === "nwc") {
+  if (isNWCWallet($wallet)) {
     const params: {invoice: string; amount?: number} = {invoice}
     if (msats) params.amount = msats
     return getNwcClient().payInvoice(params)
-  } else if ($session.wallet.type === "webln") {
+  } else if (isWebLNWallet($wallet)) {
     if (msats) throw new Error("Unable to pay zero invoices with webln")
     return getWebLn()
       .enable()
@@ -47,9 +53,9 @@ export const createInvoice = async ({
   sats,
   description = "Receive via lightning",
 }: CreateInvoiceParams) => {
-  const $session = session.get()
+  const $wallet = wallet.get()
 
-  if (!$session?.wallet) {
+  if (!$wallet) {
     throw new Error("No wallet is connected")
   }
 
@@ -59,7 +65,7 @@ export const createInvoice = async ({
     throw new Error("Invalid satoshi amount")
   }
 
-  if ($session.wallet.type === "nwc") {
+  if (isNWCWallet($wallet)) {
     const createdInvoice = await getNwcClient().makeInvoice({
       amount: satAmount * 1000,
       description,
@@ -72,7 +78,7 @@ export const createInvoice = async ({
     return createdInvoice.invoice
   }
 
-  if ($session.wallet.type === "webln") {
+  if (isWebLNWallet($wallet)) {
     const webLn = getWebLn()
 
     if (!webLn) {
diff --git a/src/app/management.ts b/src/app/management.ts
new file mode 100644
index 00000000..a63c0c62
--- /dev/null
+++ b/src/app/management.ts
@@ -0,0 +1,61 @@
+import {derived, readable, writable} from "svelte/store"
+import {ago, MINUTE, now, simpleCache} from "@welshman/lib"
+import {ROOM_CREATE_PERMISSION, hexTags, tagValues} from "@welshman/util"
+import {relayManagement, user} from "@app/core"
+import {deriveEventsForUrl} from "@app/repository"
+
+export type BannedPubkeyItem = {
+  pubkey: string
+  reason: string
+}
+
+export const deriveSpaceBannedPubkeyItems = (url: string) => {
+  const store = writable<BannedPubkeyItem[]>([])
+
+  relayManagement
+    .get()
+    .forUrl(url)
+    .listBannedPubkeys()
+    .then(({result = []}) => store.set(result))
+
+  return store
+}
+
+// A relay only answers NIP-86 for its admins, so the methods it reports double as the user's
+// permissions. This costs a signature and an http round trip, so share one store per url and
+// only re-check when the answer has had time to go stale (or when a check failed).
+export const deriveSpaceSupportedMethods = simpleCache(([url]: [string | undefined]) => {
+  let checkedAt = 0
+
+  return readable<string[]>([], set => {
+    if (url && checkedAt < ago(5, MINUTE)) {
+      checkedAt = now()
+
+      relayManagement
+        .get()
+        .forUrl(url)
+        .supportedMethods()
+        .then(({result = []}) => set(result))
+        .catch(error => {
+          checkedAt = 0
+          console.error(error)
+        })
+    }
+  })
+})
+
+// User
+
+export const deriveUserIsSpaceAdmin = (url?: string) =>
+  derived(deriveSpaceSupportedMethods(url), $methods => $methods.length > 0)
+
+export const deriveUserCanCreateRoom = (url: string) =>
+  derived(
+    [
+      user,
+      deriveEventsForUrl(url, [{kinds: [ROOM_CREATE_PERMISSION]}]),
+      deriveUserIsSpaceAdmin(url),
+    ],
+    ([$user, $events, $isAdmin]) =>
+      $isAdmin || $events.some(event => tagValues(hexTags("p"), event.tags).includes($user.pubkey)),
+  )
diff --git a/src/app/members.ts b/src/app/members.ts
deleted file mode 100644
index 1f9aea82..00000000
--- a/src/app/members.ts
+++ /dev/null
@@ -1,505 +0,0 @@
-import {derived, readable, writable} from "svelte/store"
-import {
-  ManagementMethod,
-  RELAY_ADD_MEMBER,
-  RELAY_JOIN,
-  RELAY_LEAVE,
-  RELAY_MEMBERS,
-  RELAY_REMOVE_MEMBER,
-  ROOM_ADD_MEMBER,
-  ROOM_ADMINS,
-  ROOM_CREATE_PERMISSION,
-  ROOM_JOIN,
-  ROOM_LEAVE,
-  ROOM_MEMBERS,
-  ROOM_REMOVE_MEMBER,
-  getPubkeyTagValues,
-  getTags,
-  getTagValue,
-  getTagValues,
-  sortEventsAsc,
-} from "@welshman/util"
-import type {Filter, ManagementRequest, PublishedRoomMeta, TrustedEvent} from "@welshman/util"
-import {ago, first, MINUTE, now, simpleCache, sortBy, spec, uniq} from "@welshman/lib"
-import {addRoomMember, manageRelay, pubkey, waitForThunkError} from "@welshman/app"
-import {load} from "@welshman/net"
-import {get} from "svelte/store"
-import {deriveEventsForUrl, deriveRelaySignedEvents} from "@app/repository"
-
-export const deriveSpaceMembers = (url: string) =>
-  derived(deriveRelaySignedEvents(url, [{kinds: [RELAY_MEMBERS]}]), ([event]) =>
-    uniq(getTagValues("member", event?.tags ?? [])),
-  )
-
-export const RELAY_ROLE = 33534
-
-export type SpaceRole = {
-  id: string
-  label: string
-  description: string
-  color: number // hue, 0 to 360
-  order: number
-}
-
-// Defaults for the components the client supplies, chosen to read on both themes.
-const DEFAULT_SATURATION = 0.7
-const DEFAULT_LIGHTNESS = 0.5
-
-// Parse the hue from a ["color", hue] tag, falling back to 0.
-export const parseRoleColor = (tags: string[][]): number => {
-  const hue = parseFloat(getTagValue("color", tags) ?? "")
-
-  return isNaN(hue) ? 0 : hue
-}
-
-// Build an hsl() string from a role's hue, using our default saturation and lightness.
-export const roleColor = (hue: number) =>
-  `hsl(${hue}, ${DEFAULT_SATURATION * 100}%, ${DEFAULT_LIGHTNESS * 100}%)`
-
-// A translucent tint of the role color for use as a background fill.
-export const roleColorSoft = (hue: number) =>
-  `hsl(${hue}, ${DEFAULT_SATURATION * 100}%, ${DEFAULT_LIGHTNESS * 100}%, 0.15)`
-
-export const deriveSpaceRoles = (url: string) =>
-  derived(deriveRelaySignedEvents(url, [{kinds: [RELAY_ROLE]}]), $events => {
-    const roles: SpaceRole[] = []
-
-    for (const event of $events) {
-      const id = getTagValue("d", event.tags)
-
-      if (id) {
-        roles.push({
-          id,
-          label: getTagValue("label", event.tags) ?? "",
-          description: getTagValue("description", event.tags) ?? "",
-          color: parseRoleColor(event.tags),
-          order: Math.max(1, parseInt(getTagValue("order", event.tags) ?? "1", 10) || 1),
-        })
-      }
-    }
-
-    return sortBy(r => [r.order, r.label] as [number, string], roles)
-  })
-
-// Map<pubkey, roleId[]> parsed from EXTRA values on ["member", pubkey, ...roleIds] tags
-export const deriveSpaceMemberRoles = (url: string) =>
-  derived(deriveRelaySignedEvents(url, [{kinds: [RELAY_MEMBERS]}]), ([event]) => {
-    const memberRoles = new Map<string, string[]>()
-
-    if (event) {
-      for (const tag of getTags("member", event.tags)) {
-        const pubkey = tag[1]
-        const roleIds = tag.slice(2)
-
-        if (pubkey) {
-          memberRoles.set(pubkey, roleIds)
-        }
-      }
-    }
-
-    return memberRoles
-  })
-
-// Pull the relay's freshly-signed role event so the UI reflects the change immediately,
-// rather than waiting for the live subscription to catch up.
-const reloadRole = (url: string, id: string) =>
-  load({relays: [url], filters: [{kinds: [RELAY_ROLE], "#d": [id]}]})
-
-// Roles extend NIP-86: these methods aren't in welshman's ManagementMethod, and hue and
-// order go over the wire as JSON numbers, not strings, per the relay's implementation.
-const manageRole = (url: string, method: string, params: (string | number)[]) =>
-  manageRelay(url, {method, params} as ManagementRequest)
-
-export const createRole = async (
-  url: string,
-  id: string,
-  label: string,
-  description: string,
-  color: number,
-  order: number,
-): Promise<string | undefined> => {
-  const {error} = await manageRole(url, "createrole", [id, label, description, color, order])
-
-  if (!error) {
-    await reloadRole(url, id)
-  }
-
-  return error
-}
-
-export const editRole = async (
-  url: string,
-  id: string,
-  label: string,
-  description: string,
-  color: number,
-  order: number,
-): Promise<string | undefined> => {
-  const {error} = await manageRole(url, "editrole", [id, label, description, color, order])
-
-  if (!error) {
-    await reloadRole(url, id)
-  }
-
-  return error
-}
-
-export const deleteRole = async (url: string, id: string): Promise<string | undefined> => {
-  const {error} = await manageRole(url, "deleterole", [id])
-
-  return error
-}
-
-export const assignRole = async (
-  url: string,
-  pubkey: string,
-  roleId: string,
-): Promise<string | undefined> => {
-  const {error} = await manageRole(url, "assignrole", [pubkey, roleId])
-
-  return error
-}
-
-export const unassignRole = async (
-  url: string,
-  pubkey: string,
-  roleId: string,
-): Promise<string | undefined> => {
-  const {error} = await manageRole(url, "unassignrole", [pubkey, roleId])
-
-  return error
-}
-
-export const deriveRoomMembers = (url: string, h: string) => {
-  const filters: Filter[] = [{kinds: [ROOM_MEMBERS], "#d": [h]}]
-
-  return derived(deriveEventsForUrl(url, filters), ([event]) =>
-    uniq(getPubkeyTagValues(event?.tags ?? [])),
-  )
-}
-
-export type BannedPubkeyItem = {
-  pubkey: string
-  reason: string
-}
-
-export const spaceBannedPubkeyItems = new Map<string, BannedPubkeyItem[]>()
-
-export const deriveSpaceBannedPubkeyItems = (url: string) => {
-  const store = writable(spaceBannedPubkeyItems.get(url) || [])
-
-  manageRelay(url, {method: ManagementMethod.ListBannedPubkeys, params: []}).then(res => {
-    spaceBannedPubkeyItems.set(url, res.result)
-    store.set(res.result)
-  })
-
-  return store
-}
-
-export const deriveRoomAdmins = (url: string, h: string) => {
-  const filters: Filter[] = [{kinds: [ROOM_ADMINS], "#d": [h]}]
-
-  return derived(deriveEventsForUrl(url, filters), $events => {
-    const adminsEvent = first($events)
-
-    if (adminsEvent) {
-      return getPubkeyTagValues(adminsEvent.tags)
-    }
-
-    return []
-  })
-}
-
-export const getRoomMembers = (_url: string, h: string, events: TrustedEvent[]) => {
-  const members = new Set<string>()
-
-  for (const event of sortEventsAsc(events)) {
-    if (event.kind === ROOM_MEMBERS && getTagValue("d", event.tags) === h) {
-      members.clear()
-
-      for (const pubkey of uniq(getPubkeyTagValues(event.tags))) {
-        members.add(pubkey)
-      }
-
-      continue
-    }
-
-    if (getTagValue("h", event.tags) !== h) {
-      continue
-    }
-
-    const pubkeys = getPubkeyTagValues(event.tags)
-
-    if (event.kind === ROOM_ADD_MEMBER) {
-      for (const pubkey of pubkeys) {
-        members.add(pubkey)
-      }
-    }
-
-    if (event.kind === ROOM_REMOVE_MEMBER) {
-      for (const pubkey of pubkeys) {
-        members.delete(pubkey)
-      }
-    }
-  }
-
-  return Array.from(members)
-}
-
-// User membership status
-
-export enum MembershipStatus {
-  Initial,
-  Pending,
-  Granted,
-}
-
-// This costs a signature and an http round trip, so share one store per url and only
-// re-check when the answer has had time to go stale (or when a check failed).
-export const deriveUserIsSpaceAdmin = simpleCache(([url]: [string | undefined]) => {
-  let checkedAt = 0
-
-  return readable(false, set => {
-    if (url && checkedAt < ago(5, MINUTE)) {
-      checkedAt = now()
-
-      manageRelay(url, {method: ManagementMethod.SupportedMethods, params: []})
-        .then(({result}) => set(Boolean(result?.length)))
-        .catch(error => {
-          checkedAt = 0
-          console.error(error)
-        })
-    }
-  })
-})
-
-export const deriveUserSpaceMembershipStatus = (url: string) => {
-  // Fetch member list and user add/remove events directly in this derivation.
-  const memberListFilters: Filter[] = [{kinds: [RELAY_MEMBERS]}]
-  const userEventFilters: Filter[] = [{kinds: [RELAY_ADD_MEMBER, RELAY_REMOVE_MEMBER]}]
-
-  return derived(
-    [
-      pubkey,
-      deriveRelaySignedEvents(url, memberListFilters),
-      deriveRelaySignedEvents(url, userEventFilters),
-      deriveEventsForUrl(url, [{kinds: [RELAY_JOIN, RELAY_LEAVE]}]),
-      deriveUserIsSpaceAdmin(url),
-    ],
-    ([$pubkey, $memberListEvents, $userAddRemoveEvents, $joinLeaveEvents, $isAdmin]) => {
-      // If admin, always granted.
-      if ($isAdmin) {
-        return MembershipStatus.Granted
-      }
-
-      const membersEvent = $memberListEvents.find(spec({kind: RELAY_MEMBERS}))
-      const memberList = membersEvent ? uniq(getTagValues("member", membersEvent.tags)) : undefined
-
-      let isMember = false
-
-      if (memberList) {
-        // Member list exists - check if user is in it.
-        isMember = memberList.includes($pubkey!)
-      } else {
-        // No member list available - replay the user's add/remove history.
-        for (const event of sortBy(e => e.created_at, $userAddRemoveEvents)) {
-          if (event.pubkey !== $pubkey) {
-            continue
-          }
-
-          if (event.kind === RELAY_ADD_MEMBER) {
-            isMember = true
-          } else if (event.kind === RELAY_REMOVE_MEMBER) {
-            isMember = false
-          }
-        }
-      }
-
-      for (const event of $joinLeaveEvents) {
-        // Join events indicate pending or granted status, leave resets to initial.
-        if (event.pubkey !== $pubkey) {
-          continue
-        }
-
-        if (event.kind === RELAY_JOIN) {
-          return isMember ? MembershipStatus.Granted : MembershipStatus.Pending
-        }
-
-        if (event.kind === RELAY_LEAVE) {
-          return MembershipStatus.Initial
-        }
-      }
-
-      return isMember ? MembershipStatus.Granted : MembershipStatus.Initial
-    },
-  )
-}
-
-export const deriveUserIsRoomAdmin = (url: string, h: string) =>
-  derived(
-    [pubkey, deriveRoomAdmins(url, h), deriveUserIsSpaceAdmin(url)],
-    ([$pubkey, $admins, $isSpaceAdmin]) => $isSpaceAdmin || $admins.includes($pubkey!),
-  )
-
-export const deriveUserRoomMembershipStatus = (url: string, h: string) => {
-  // Fetch the room member list and the current user's add/remove events.
-  const userEventFilters: Filter[] = [{kinds: [ROOM_ADD_MEMBER, ROOM_REMOVE_MEMBER], "#h": [h]}]
-  const joinLeaveFilters: Filter[] = [{kinds: [ROOM_JOIN, ROOM_LEAVE], "#h": [h]}]
-
-  return derived(
-    [
-      pubkey,
-      deriveRoomMembers(url, h),
-      deriveEventsForUrl(url, userEventFilters),
-      deriveEventsForUrl(url, joinLeaveFilters),
-      deriveUserIsRoomAdmin(url, h),
-    ],
-    ([$pubkey, $memberList, $userAddRemoveEvents, $joinLeaveEvents, $isAdmin]) => {
-      // If admin of this room's space, always granted.
-      if ($isAdmin) {
-        return MembershipStatus.Granted
-      }
-
-      let isMember = false
-
-      if ($memberList) {
-        // Member list exists - check if user is in it.
-        isMember = $memberList.includes($pubkey!)
-      } else {
-        // No member list available - replay the user's add/remove history.
-        for (const event of sortEventsAsc($userAddRemoveEvents)) {
-          if (event.pubkey !== $pubkey) {
-            continue
-          }
-
-          if (event.kind === ROOM_ADD_MEMBER) {
-            isMember = true
-          } else if (event.kind === ROOM_REMOVE_MEMBER) {
-            isMember = false
-          }
-        }
-      }
-
-      for (const event of $joinLeaveEvents) {
-        // Join events indicate pending or granted status, leave resets to initial.
-        if (event.pubkey !== $pubkey) {
-          continue
-        }
-
-        if (event.kind === ROOM_JOIN) {
-          return isMember ? MembershipStatus.Granted : MembershipStatus.Pending
-        }
-
-        if (event.kind === ROOM_LEAVE) {
-          return MembershipStatus.Initial
-        }
-      }
-
-      return isMember ? MembershipStatus.Granted : MembershipStatus.Initial
-    },
-  )
-}
-
-export const deriveUserCanCreateRoom = (url: string) => {
-  const filters: Filter[] = [{kinds: [ROOM_CREATE_PERMISSION]}]
-
-  return derived(
-    [pubkey, deriveEventsForUrl(url, filters), deriveUserIsSpaceAdmin(url)],
-    ([$pubkey, $events, $isAdmin]) => {
-      for (const event of $events) {
-        if (getPubkeyTagValues(event.tags).includes($pubkey!)) {
-          return true
-        }
-      }
-
-      return $isAdmin
-    },
-  )
-}
-
-export const addSpaceMembers = async (
-  url: string,
-  pubkeys: string[],
-): Promise<string | undefined> => {
-  const spaceMembers = get(deriveSpaceMembers(url))
-
-  const results = await Promise.all(
-    pubkeys
-      .filter(pubkey => !spaceMembers || !spaceMembers.includes(pubkey))
-      .map(pubkey =>
-        manageRelay(url, {
-          method: ManagementMethod.AllowPubkey,
-          params: [pubkey],
-        }),
-      ),
-  )
-
-  for (const {error} of results) {
-    if (error) {
-      return error
-    }
-  }
-}
-
-export const removeSpaceMembers = async (
-  url: string,
-  pubkeys: string[],
-): Promise<string | undefined> => {
-  const results = await Promise.all(
-    pubkeys.map(pubkey =>
-      manageRelay(url, {
-        method: ManagementMethod.UnallowPubkey,
-        params: [pubkey],
-      }),
-    ),
-  )
-
-  for (const {error} of results) {
-    if (error) {
-      return error
-    }
-  }
-}
-
-export const banSpaceMembers = async (
-  url: string,
-  pubkeys: string[],
-  reason = "",
-): Promise<string | undefined> => {
-  const results = await Promise.all(
-    pubkeys.map(pubkey =>
-      manageRelay(url, {
-        method: ManagementMethod.BanPubkey,
-        params: reason ? [pubkey, reason] : [pubkey],
-      }),
-    ),
-  )
-
-  for (const {error} of results) {
-    if (error) {
-      return error
-    }
-  }
-}
-
-export const addRoomMembers = async (
-  url: string,
-  room: PublishedRoomMeta,
-  pubkeys: string[],
-): Promise<string | undefined> => {
-  const error = await addSpaceMembers(url, pubkeys)
-
-  if (error) {
-    return error
-  }
-
-  const errors = await Promise.all(
-    pubkeys.map(pubkey => waitForThunkError(addRoomMember(url, room, pubkey))),
-  )
-
-  for (const error of errors) {
-    if (error) {
-      return error
-    }
-  }
-}
diff --git a/src/app/nip46.ts b/src/app/nip46.ts
index 5388c0dd..76c9d044 100644
--- a/src/app/nip46.ts
+++ b/src/app/nip46.ts
@@ -1,3 +1,4 @@
+import {get, writable} from "svelte/store"
 import {
   CLASSIFIED,
   CLIENT_AUTH,
@@ -10,7 +11,6 @@ import {
   WRAP,
   ZAP_REQUEST,
 } from "@welshman/util"
-import {get, writable} from "svelte/store"
 import type {Nip46ResponseWithResult} from "@welshman/signer"
 import {Nip46Broker} from "@welshman/signer"
 import {makeSecret} from "@welshman/util"
diff --git a/src/app/notifications.ts b/src/app/notifications.ts
index 5c0e7231..5aa847e7 100644
--- a/src/app/notifications.ts
+++ b/src/app/notifications.ts
@@ -1,26 +1,26 @@
 import {derived, get, writable} from "svelte/store"
 import {Badge} from "@capawesome/capacitor-badge"
-import {synced, throttled, withGetter} from "@welshman/store"
-import {pubkey, signer, tracker, repository, relaysByUrl} from "@welshman/app"
+import {page} from "$app/stores"
 import {assoc, prop, first, identity, groupBy, now, throttle, parseJson, gt} from "@welshman/lib"
 import type {SignedEvent, TrustedEvent} from "@welshman/util"
-import {deriveEventsByIdByUrl} from "@welshman/store"
 import {
   sortEventsDesc,
-  getTagValue,
+  tagSpec,
+  tagValue,
   MESSAGE,
   makeHttpAuth,
   makeHttpAuthHeader,
 } from "@welshman/util"
+import {synced, throttled, withGetter} from "@welshman/store"
+import {Relays, RoomLists} from "@welshman/app"
+import {deriveEventsByIdByUrl} from "@app/repository"
+import {app, fromApp} from "@app/core"
 import {makeSpacePath, makeRoomPath, makeSpaceChatPath, makeChatPath} from "@app/routes"
 import {CONTENT_KINDS, makeCommentFilter} from "@app/content"
 import {notificationSettings} from "@app/settings"
 import {chatsById} from "@app/chats"
-import {userGroupList, getSpaceUrlsFromGroupList} from "@app/groups"
-import {hasNip29} from "@app/relays"
 import {dufflepud, DUFFLEPUD_URL, PLATFORM_RELAYS} from "@app/env"
 import {kv} from "@app/storage"
-import {page} from "$app/stores"
 
 // Checked state
 
@@ -84,7 +84,7 @@ const NIP98_MAX_AGE = 23 * 60 * 60
 let nip98Auth: SignedEvent | undefined
 
 const nip98Header = async () => {
-  const $signer = signer.get()
+  const $signer = app.get().user?.signer
 
   if (!$signer) {
     return undefined
@@ -148,11 +148,11 @@ const pushCheckedRemote = throttle(3000, async () => {
 export const syncCheckedRemote = () => {
   let ready = false
 
-  const unsubscribePubkey = pubkey.subscribe($pubkey => {
+  const unsubscribeUser = app.subscribe($app => {
     ready = false
     nip98Auth = undefined
 
-    if ($pubkey) {
+    if ($app.user) {
       pullCheckedRemote().then(() => {
         ready = true
         pushCheckedRemote()
@@ -161,13 +161,13 @@ export const syncCheckedRemote = () => {
   })
 
   const unsubscribeChecked = checked.subscribe(() => {
-    if (ready && pubkey.get()) {
+    if (ready && app.get().user?.pubkey) {
       pushCheckedRemote()
     }
   })
 
   return () => {
-    unsubscribePubkey()
+    unsubscribeUser()
     unsubscribeChecked()
   }
 }
@@ -179,23 +179,22 @@ export const allNotifications = derived(
     1000,
     derived(
       [
-        pubkey,
+        app,
         checked,
         chatsById,
-        relaysByUrl,
-        userGroupList,
-        deriveEventsByIdByUrl({
-          tracker,
-          repository,
-          filters: [{kinds: [MESSAGE, ...CONTENT_KINDS]}, makeCommentFilter(CONTENT_KINDS)],
-        }),
+        fromApp($app => $app.use(Relays).index.$),
+        fromApp($app => $app.use(RoomLists).index.$),
+        deriveEventsByIdByUrl([
+          {kinds: [MESSAGE, ...CONTENT_KINDS]},
+          makeCommentFilter(CONTENT_KINDS),
+        ]),
       ],
       identity,
     ),
   ),
-  ([$pubkey, $checked, $chatsById, $relaysByUrl, $userGroupList, eventsByIdByUrl]) => {
+  ([$app, $checked, $chatsById, $relays, $roomLists, eventsByIdByUrl]) => {
     const hasNotification = (path: string, latestEvent?: TrustedEvent) => {
-      if (!latestEvent || latestEvent.pubkey === $pubkey) {
+      if (!latestEvent || latestEvent.pubkey === $app.user?.pubkey) {
         return false
       }
 
@@ -224,15 +223,15 @@ export const allNotifications = derived(
       }
     }
 
-    const urls =
-      PLATFORM_RELAYS.length > 0 ? PLATFORM_RELAYS : getSpaceUrlsFromGroupList($userGroupList)
+    const roomList = $app.user?.pubkey ? $roomLists.get($app.user?.pubkey) : undefined
+    const urls = PLATFORM_RELAYS.length > 0 ? PLATFORM_RELAYS : (roomList?.urls() ?? [])
 
     for (const url of urls) {
       const spacePath = makeSpacePath(url)
       const events = sortEventsDesc((eventsByIdByUrl.get(url) || new Map()).values())
 
-      if (hasNip29($relaysByUrl.get(url))) {
-        for (const [h, [latestEvent]] of groupBy(e => getTagValue("h", e.tags), events)) {
+      if ($relays.get(url)?.hasNip(29)) {
+        for (const [h, [latestEvent]] of groupBy(e => tagValue(tagSpec("h"), e.tags), events)) {
           if (h) {
             const roomPath = makeRoomPath(url, h)
 
diff --git a/src/app/pinboards.ts b/src/app/pinboards.ts
index c9ce4b10..0dbc344a 100644
--- a/src/app/pinboards.ts
+++ b/src/app/pinboards.ts
@@ -1,236 +1,83 @@
-import {derived, readable} from "svelte/store"
-import type {Readable} from "svelte/store"
 import * as nip19 from "nostr-tools/nip19"
-import {now, randomId} from "@welshman/lib"
-import {
-  Address,
-  DELETE,
-  asDecryptedEvent,
-  fromNostrURI,
-  getAddress,
-  getListTags,
-  getTagValue,
-  getTagValues,
-  isReplaceableKind,
-  readList,
-  sortEventsDesc,
-} from "@welshman/util"
+import {Address, fromNostrURI, getAddress, isReplaceable} from "@welshman/util"
 import type {TrustedEvent} from "@welshman/util"
+import type {PinReader, PinReference, PinWriter} from "@welshman/domain"
 import {isLink, parse} from "@welshman/content"
-import {deriveEventsForUrl, deriveRelaySignedEvents} from "@app/repository"
-import {signAsRelay} from "@app/relays"
 
-export const BOARD = 30067
-
-export const PIN = 39067
-
-export type Board = {
-  event?: TrustedEvent
-  address: string
-  identifier: string
-  title: string
-  description: string
-  image: string
-  topics: string[]
-  collaborative: boolean
-}
-
-export type PublishedBoard = Board & {
-  event: TrustedEvent
-}
-
-export type Pin = {
-  event?: TrustedEvent
-  id: string
-  pubkey: string
-  identifier: string
-  boards: string[]
-  description: string
-  title: string
-  topics: string[]
-  // The pin's content reference: the first e/a/p/i tag found, e.g. ["e", <id>],
-  // ["a", <coord>], ["p", <pubkey>], or ["i", <url>]. Empty when the pin has no
-  // reference.
-  value: string[]
-}
-
-export type PublishedPin = Pin & {
-  event: TrustedEvent
-}
-
-export const readBoard = (event: TrustedEvent): PublishedBoard => {
-  const tags = getListTags(readList(asDecryptedEvent(event)))
-
-  return {
-    event,
-    address: getAddress(event),
-    identifier: getTagValue("d", tags) ?? "",
-    title: getTagValue("title", tags) ?? "",
-    description: getTagValue("description", tags) ?? "",
-    image: getTagValue("image", tags) ?? "",
-    topics: getTagValues("t", tags),
-    collaborative: tags.some(tag => tag[0] === "collaborative"),
-  }
-}
-
-export const readPin = (event: TrustedEvent): PublishedPin => ({
-  event,
-  id: event.id,
-  pubkey: event.pubkey,
-  identifier: getTagValue("d", event.tags) ?? "",
-  boards: getTagValues("A", event.tags),
-  description: event.content,
-  title: getTagValue("title", event.tags) ?? "",
-  topics: getTagValues("t", event.tags),
-  value: event.tags.find(tag => ["e", "a", "p", "i"].includes(tag[0])) ?? [],
-})
-
-export const deriveBoards = (url: string) =>
-  derived(deriveEventsForUrl(url, [{kinds: [BOARD]}]), $events => $events.map(readBoard))
-
-export const deriveBoard = (url: string, identifier: string) =>
-  derived(deriveRelaySignedEvents(url, [{kinds: [BOARD], "#d": [identifier]}]), ([event]) =>
-    event ? readBoard(event) : undefined,
-  )
-
-export const deriveBoardByAddress = (
-  url: string,
-  address: string,
-): Readable<PublishedBoard | undefined> =>
-  Address.isAddress(address)
-    ? deriveBoard(url, Address.from(address).identifier)
-    : readable(undefined)
-
-export const derivePins = (url: string, address: string) =>
-  derived(deriveRelaySignedEvents(url, [{kinds: [PIN], "#A": [address]}]), $events =>
-    sortEventsDesc($events).map(readPin),
-  )
-
-const makeBoardTemplate = ({
-  identifier,
-  title,
-  description,
-  image,
-  topics,
-  collaborative,
-}: Omit<Board, "address">) => ({
-  kind: BOARD,
-  created_at: now(),
-  content: "",
-  tags: [
-    ["d", identifier],
-    ["title", title],
-    ...(description ? [["description", description]] : []),
-    ...(image ? [["image", image]] : []),
-    ...topics.map(topic => ["t", topic]),
-    ...(collaborative ? [["collaborative"]] : []),
-  ],
-})
-
-const makePinTemplate = ({
-  identifier = "",
-  boards = [],
-  description = "",
-  title = "",
-  topics = [],
-  value = [],
-}: Partial<Pin>) => ({
-  kind: PIN,
-  created_at: now(),
-  content: description,
-  tags: [
-    // Reuse the identifier when editing so the addressable event is replaced;
-    // fall back to a random one for new pins.
-    ["d", identifier || randomId()],
-    ...boards.map(board => ["A", board]),
-    ...(value.length ? [value] : []),
-    ...(title ? [["title", title]] : []),
-    ...topics.map(topic => ["t", topic]),
-  ],
-})
-
-const makeDeleteTemplate = (tags: string[][]) => ({
-  kind: DELETE,
-  created_at: now(),
-  content: "",
-  tags,
-})
-
-export const editBoard = (url: string, board: Board) => signAsRelay(url, makeBoardTemplate(board))
-
-export const createPin = (url: string, pin: Partial<Pin>) => signAsRelay(url, makePinTemplate(pin))
-
-export const deletePin = (url: string, id: string) =>
-  signAsRelay(
-    url,
-    makeDeleteTemplate([
-      ["e", id],
-      ["k", String(PIN)],
-    ]),
-  )
-
-export const deleteBoard = (url: string, address: string) =>
-  signAsRelay(
-    url,
-    makeDeleteTemplate([
-      ["a", address],
-      ["k", String(BOARD)],
-    ]),
-  )
-
-const valueToReference = (value: string[]): string => {
-  const [type, data = "", relay] = value
-  const relays = relay ? [relay] : []
-
-  if (type === "e") return nip19.neventEncode({id: data, relays})
-
-  if (type === "p") return nip19.nprofileEncode({pubkey: data, relays})
-
-  if (type === "a") {
-    const {kind, pubkey, identifier} = Address.from(data)
-
-    return nip19.naddrEncode({kind, pubkey, identifier, relays})
+const encodeReference = (reference: PinReference) => {
+  if (reference.type === "event") {
+    return nip19.neventEncode({id: reference.id, relays: reference.relay ? [reference.relay] : []})
   }
 
-  return data
+  if (reference.type === "address") {
+    const {kind, pubkey, identifier} = Address.from(reference.address)
+
+    return nip19.naddrEncode({
+      kind,
+      pubkey,
+      identifier,
+      relays: reference.relay ? [reference.relay] : [],
+    })
+  }
+
+  return reference.id
 }
 
-export const pinToReference = (pin: Pin): string => valueToReference(pin.value)
+export const pinToReference = (pin: PinReader) => {
+  const reference = pin.reference()
 
-export const eventToReference = (event: TrustedEvent): string =>
-  valueToReference(isReplaceableKind(event.kind) ? ["a", getAddress(event)] : ["e", event.id])
+  return reference ? encodeReference(reference) : ""
+}
 
-export const referenceToPin = (reference: string): Partial<Pin> | undefined => {
+export const eventToReference = (event: TrustedEvent) =>
+  encodeReference(
+    isReplaceable(event)
+      ? {type: "address", address: getAddress(event)}
+      : {type: "event", id: event.id},
+  )
+
+// Point a pin at a user-entered nostr link or external url, false if it's neither.
+export const setPinReference = (writer: PinWriter, reference: string) => {
   const trimmed = reference.trim()
 
   try {
     const decoded = nip19.decode(fromNostrURI(trimmed))
 
-    if (decoded.type === "note") return {value: ["e", decoded.data]}
-    if (decoded.type === "npub") return {value: ["p", decoded.data]}
+    if (decoded.type === "note") {
+      writer.setEvent(decoded.data)
+      return true
+    }
+
     if (decoded.type === "nevent") {
-      const {id, relays} = decoded.data
-
-      return {value: relays?.[0] ? ["e", id, relays[0]] : ["e", id]}
+      writer.setEvent(decoded.data.id, decoded.data.relays?.[0])
+      return true
     }
-    if (decoded.type === "nprofile") {
-      const {pubkey, relays} = decoded.data
 
-      return {value: relays?.[0] ? ["p", pubkey, relays[0]] : ["p", pubkey]}
+    // Pins have no pubkey reference type, so a person gets stored as an external
+    // id — keep the bech32 the user gave us so it round-trips and still embeds.
+    if (decoded.type === "npub" || decoded.type === "nprofile") {
+      writer.setExternal(fromNostrURI(trimmed))
+      return true
     }
+
     if (decoded.type === "naddr") {
       const {kind, pubkey, identifier, relays} = decoded.data
-      const coordinate = `${kind}:${pubkey}:${identifier}`
 
-      return {value: relays?.[0] ? ["a", coordinate, relays[0]] : ["a", coordinate]}
+      writer.setAddress(new Address(kind, pubkey, identifier).toString(), relays?.[0])
+      return true
     }
 
-    return undefined
+    return false
   } catch {
     // Not a nostr entity; fall through to external url handling.
   }
 
   const parsed = parse({content: trimmed})
 
-  return parsed.length === 1 && isLink(parsed[0]) ? {value: ["i", trimmed]} : undefined
+  if (parsed.length === 1 && isLink(parsed[0])) {
+    writer.setExternal(trimmed)
+    return true
+  }
+
+  return false
 }
diff --git a/src/app/pins.ts b/src/app/pins.ts
deleted file mode 100644
index e1844ff2..00000000
--- a/src/app/pins.ts
+++ /dev/null
@@ -1,99 +0,0 @@
-import {derived} from "svelte/store"
-import type {Readable} from "svelte/store"
-import {makeEvent, getTagValues} from "@welshman/util"
-import type {TrustedEvent} from "@welshman/util"
-import {publishThunk, waitForThunkError} from "@welshman/app"
-import {load} from "@welshman/net"
-import {deriveEventsForUrl, deriveLatestEventForUrl} from "@app/repository"
-import {PROTECTED} from "@app/groups"
-import {canEnforceNip70} from "@app/relays"
-
-// NIP-29 proposed pin list kinds (see https://github.com/nostr-protocol/nips/pull/2379)
-export const ROOM_PINS = 39005
-export const ROOM_UPDATE_PIN_LIST = 9010
-
-const pinListFilters = (h: string) => [{kinds: [ROOM_PINS], "#d": [h]}]
-
-export const deriveRoomPinIds = (url: string, h: string) =>
-  derived(deriveLatestEventForUrl(url, pinListFilters(h)), event =>
-    getTagValues("e", event?.tags ?? []),
-  )
-
-export const deriveRoomPinnedEvents = (
-  url: string,
-  pinIds: Readable<string[]>,
-): Readable<TrustedEvent[]> =>
-  derived(pinIds, ($pinIds, set) => {
-    if ($pinIds.length === 0) {
-      set([] as TrustedEvent[])
-
-      return () => {}
-    }
-
-    const events = deriveEventsForUrl(url, [{ids: $pinIds}])
-
-    const unsub = events.subscribe($events => {
-      const byId = new Map($events.map(event => [event.id, event]))
-
-      set(
-        $pinIds.flatMap(id => {
-          const event = byId.get(id)
-
-          return event ? [event] : []
-        }),
-      )
-    })
-
-    return () => unsub()
-  })
-
-export const loadRoomPinList = (url: string, h: string, signal?: AbortSignal) =>
-  load({relays: [url], signal, filters: pinListFilters(h)})
-
-export const loadRoomPinnedMessages = (url: string, ids: string[], signal?: AbortSignal) => {
-  if (ids.length === 0) {
-    return
-  }
-
-  return load({relays: [url], signal, filters: [{ids}]})
-}
-
-export const updateRoomPins = async (url: string, h: string, eventIds: string[]) => {
-  const tags: string[][] = [["h", h], ...eventIds.map(id => ["e", id])]
-
-  if (await canEnforceNip70(url)) {
-    tags.push(PROTECTED)
-  }
-
-  const event = makeEvent(ROOM_UPDATE_PIN_LIST, {
-    content: "",
-    tags,
-  })
-
-  return waitForThunkError(publishThunk({relays: [url], event}))
-}
-
-export const pinRoomMessage = async (
-  url: string,
-  h: string,
-  eventId: string,
-  currentIds: string[],
-) => {
-  if (currentIds.includes(eventId)) {
-    return undefined
-  }
-
-  return updateRoomPins(url, h, [...currentIds, eventId])
-}
-
-export const unpinRoomMessage = async (
-  url: string,
-  h: string,
-  eventId: string,
-  currentIds: string[],
-) =>
-  updateRoomPins(
-    url,
-    h,
-    currentIds.filter(id => id !== eventId),
-  )
diff --git a/src/app/policies.ts b/src/app/policies.ts
index 31c4570b..e2d4358f 100644
--- a/src/app/policies.ts
+++ b/src/app/policies.ts
@@ -1,9 +1,9 @@
 import {get, writable} from "svelte/store"
-import {on, call, dissoc, assoc, uniq} from "@welshman/lib"
-import {RelayMode} from "@welshman/util"
+import {on, call, dissoc, assoc, noop, uniq} from "@welshman/lib"
+import {isDVMKind, isEphemeralKind, verifyEvent} from "@welshman/util"
 import type {Socket, RelayMessage, ClientMessage} from "@welshman/net"
 import {
-  makeSocketPolicyAuth,
+  AuthStatus,
   SocketEvent,
   isRelayEvent,
   isRelayOk,
@@ -15,10 +15,19 @@ import {
   isClientNegOpen,
   isClientNegClose,
 } from "@welshman/net"
-import {sign, pubkey, thunks, getPubkeyRelays} from "@welshman/app"
+import {merged} from "@welshman/store"
+import {
+  BlockedRelayLists,
+  MessagingRelayLists,
+  RelayLists,
+  RoomLists,
+  Thunks,
+  makeAppPolicyAuth,
+} from "@welshman/app"
+import type {AppPolicy, IApp} from "@welshman/app"
+import {app, appPolicies} from "@app/core"
 import {BLOCKED_RELAYS} from "@app/env"
 import {userSettingsValues, getSetting, RelayAuthMode} from "@app/settings"
-import {userSpaceUrls} from "@app/groups"
 
 // Relays sending events with empty signatures that the user has to choose to trust
 export const relaysPendingTrust = writable<string[]>([])
@@ -26,31 +35,52 @@ export const relaysPendingTrust = writable<string[]>([])
 // Relays that mostly send restricted responses to requests and events
 export const relaysMostlyRestricted = writable<Record<string, string>>({})
 
-export const authPolicy = makeSocketPolicyAuth({
-  sign,
-  shouldAuth: (socket: Socket) => {
-    const $pubkey = pubkey.get()
-    const mode = getSetting<RelayAuthMode>("relay_auth")
+// Welshman's default ingest policy drops anything that fails signature verification, but relays
+// the user has explicitly trusted are allowed to send events with an empty signature.
+export const ingestPolicy: AppPolicy = app =>
+  app.pool.subscribe(socket => {
+    const onReceive = (message: RelayMessage) => {
+      if (isRelayEvent(message)) {
+        const event = message[2]
+        const trusted = getSetting("trusted_relays").includes(socket.url)
 
-    if (!$pubkey) return false
-    if (mode === RelayAuthMode.Aggressive) return true
-    if (get(userSpaceUrls).includes(socket.url)) return true
-    if (getPubkeyRelays($pubkey).includes(socket.url)) return true
-    if (get(thunks).some(t => t.options.relays.includes(socket.url))) return true
-    if (getPubkeyRelays($pubkey, RelayMode.Messaging).includes(socket.url)) return true
+        if (isDVMKind(event.kind) || isEphemeralKind(event.kind)) return
+        if (!trusted && !verifyEvent(event)) return
 
-    return false
-  },
+        app.tracker.track(event.id, socket.url)
+        app.repository.publish(event)
+      }
+    }
+
+    socket.on(SocketEvent.Receive, onReceive)
+
+    return () => socket.off(SocketEvent.Receive, onReceive)
+  })
+
+// Welshman's appPolicyAuthUnlessBlocked, plus the conservative mode: only identify to relays
+// the user already has a relationship with.
+export const authPolicy = makeAppPolicyAuth((socket, $app) => {
+  const $pubkey = app.get().user?.pubkey
+
+  if (!$pubkey) return false
+  if ($app.use(BlockedRelayLists).urls($pubkey).get().includes(socket.url)) return false
+  if (getSetting("relay_auth") === RelayAuthMode.Aggressive) return true
+  if ($app.use(RoomLists).urls($pubkey).get().includes(socket.url)) return true
+  if ($app.use(RelayLists).urls($pubkey).get().includes(socket.url)) return true
+  if (get($app.use(Thunks).history).some(t => t.options.relays.includes(socket.url))) return true
+  if ($app.use(MessagingRelayLists).urls($pubkey).get().includes(socket.url)) return true
+
+  return false
 })
 
-export const blockPolicy = (socket: Socket) => {
+const makeBlockPolicy = ($app: IApp) => (socket: Socket) => {
   const previousOpen = socket.open
 
   socket.open = () => {
-    const $pubkey = pubkey.get()
+    const $pubkey = $app.user?.pubkey
 
     if (BLOCKED_RELAYS.includes(socket.url)) return
-    if ($pubkey && getPubkeyRelays($pubkey, RelayMode.Blocked).includes(socket.url)) return
+    if ($pubkey && $app.use(BlockedRelayLists).urls($pubkey).get().includes(socket.url)) return
 
     previousOpen()
   }
@@ -60,7 +90,7 @@ export const blockPolicy = (socket: Socket) => {
   }
 }
 
-export const trustPolicy = (socket: Socket) => {
+const trustPolicy = (socket: Socket) => {
   const buffer: RelayMessage[] = []
 
   const unsubscribers = [
@@ -76,7 +106,7 @@ export const trustPolicy = (socket: Socket) => {
     // the receive queue. If trust status is undefined, buffer it for later.
     on(socket, SocketEvent.Receiving, (message: RelayMessage) => {
       if (isRelayEvent(message) && !message[2]?.sig) {
-        const isTrusted = getSetting<string[]>("trusted_relays").includes(socket.url)
+        const isTrusted = getSetting("trusted_relays").includes(socket.url)
 
         if (!isTrusted) {
           buffer.push(message)
@@ -92,7 +122,7 @@ export const trustPolicy = (socket: Socket) => {
   }
 }
 
-export const mostlyRestrictedPolicy = (socket: Socket) => {
+const mostlyRestrictedPolicy = (socket: Socket) => {
   let total = 0
   let restricted = 0
 
@@ -173,3 +203,17 @@ export const mostlyRestrictedPolicy = (socket: Socket) => {
     unsubscribers.forEach(call)
   }
 }
+
+// Socket policies are installed on the pool rather than the app, so wrap them in an app policy
+// to get the same construction/cleanup lifecycle as everything else.
+export const socketPolicy: AppPolicy = $app => {
+  const policies = [makeBlockPolicy($app), trustPolicy, mostlyRestrictedPolicy]
+
+  $app.pool.socketPolicies.push(...policies)
+
+  return () => {
+    $app.pool.socketPolicies = $app.pool.socketPolicies.filter(p => !policies.includes(p))
+  }
+}
+
+appPolicies.push(ingestPolicy, authPolicy, socketPolicy)
diff --git a/src/app/polls.ts b/src/app/polls.ts
deleted file mode 100644
index e66de38c..00000000
--- a/src/app/polls.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import {now, removeUndefined, uniq} from "@welshman/lib"
-import type {TrustedEvent} from "@welshman/util"
-import {POLL_RESPONSE, getTagValue, getTags, getTagValues, makeEvent} from "@welshman/util"
-import {publishThunk} from "@welshman/app"
-
-export type PollType = "singlechoice" | "multiplechoice"
-
-export type PollOption = {
-  id: string
-  label: string
-  votes: number
-}
-
-export const getPollType = (event: TrustedEvent): PollType =>
-  getTagValue("polltype", event.tags) === "multiplechoice" ? "multiplechoice" : "singlechoice"
-
-export const getPollOptions = (event: TrustedEvent) =>
-  removeUndefined(
-    getTags("option", event.tags).map(tag => {
-      const [, id, label = id] = tag
-
-      if (!id) return undefined
-
-      return {id, label}
-    }),
-  )
-
-export const getPollEndsAt = (event: TrustedEvent) => {
-  const endsAt = getTagValue("endsAt", event.tags)
-
-  if (!endsAt) return undefined
-
-  const timestamp = parseInt(endsAt)
-
-  return Number.isNaN(timestamp) ? undefined : timestamp
-}
-
-export const isPollClosed = (event: TrustedEvent) => {
-  const endsAt = getPollEndsAt(event)
-
-  return typeof endsAt === "number" ? endsAt <= now() : false
-}
-
-export const getPollResponseSelections = (event: TrustedEvent, pollType = getPollType(event)) => {
-  const selections = getTagValues("response", event.tags)
-
-  return pollType === "singlechoice" ? selections.slice(0, 1) : uniq(selections)
-}
-
-export const getPollResults = (event: TrustedEvent, responses: TrustedEvent[]) => {
-  const options = getPollOptions(event).map(option => ({...option, votes: 0}))
-  const counts = new Map(options.map(option => [option.id, option]))
-  const latestByPubkey = new Map<string, TrustedEvent>()
-
-  for (const response of responses) {
-    const current = latestByPubkey.get(response.pubkey)
-
-    if (!current || response.created_at > current.created_at) {
-      latestByPubkey.set(response.pubkey, response)
-    }
-  }
-
-  for (const response of latestByPubkey.values()) {
-    for (const optionId of getPollResponseSelections(response, getPollType(event))) {
-      const option = counts.get(optionId)
-
-      if (option) {
-        option.votes += 1
-      }
-    }
-  }
-
-  return {
-    options,
-    voters: latestByPubkey.size,
-  }
-}
-
-export type PollResponseParams = {
-  event: TrustedEvent
-  selectedIds: string[]
-}
-
-export const makePollResponse = ({event, selectedIds}: PollResponseParams) =>
-  makeEvent(POLL_RESPONSE, {
-    content: "",
-    tags: [["e", event.id], ...selectedIds.map(selectedId => ["response", selectedId])],
-  })
-
-export const publishPollResponse = ({relays, ...params}: PollResponseParams & {relays: string[]}) =>
-  publishThunk({event: makePollResponse(params), relays})
diff --git a/src/app/pomade.ts b/src/app/pomade.ts
index 3709a60e..aea4d784 100644
--- a/src/app/pomade.ts
+++ b/src/app/pomade.ts
@@ -1,13 +1,30 @@
-import {get} from "svelte/store"
 import {Client, type SessionItem, type ClientOptions} from "@pomade/core"
 import {ifLet, reject, spec} from "@welshman/lib"
-import {session, isPomadeSession, loginWithPomade as _loginWithPomade} from "@welshman/app"
+import type {Maybe} from "@welshman/lib"
+import {pomade, toSession} from "@welshman/app"
+import type {Session} from "@welshman/app"
+import {login, session} from "@app/core"
+
+export type PomadeSession = Session<"pomade", {clientOptions: ClientOptions; email: string}>
+
+export const isPomadeSession = ($session: Maybe<Session>): $session is PomadeSession =>
+  $session?.method === pomade.method
+
+// The pomade-only screens are only reachable from a pomade session, so narrow rather than
+// thread undefined through every field they read off it.
+export const requirePomadeSession = ($session: Maybe<Session>) => {
+  if (!isPomadeSession($session)) {
+    throw new Error("This action requires an email login")
+  }
+
+  return $session
+}
 
 export const getPomadeClient = async () => {
-  const $session = get(session)
+  const $session = session.get()
 
   if (isPomadeSession($session)) {
-    return new Client($session.clientOptions)
+    return new Client($session.data.clientOptions)
   }
 }
 
@@ -75,7 +92,7 @@ export const deleteDeactivatedPomadeSessions = async () => {
 }
 
 export const loginWithPomade = (clientOptions: ClientOptions, email: string) =>
-  _loginWithPomade(clientOptions.group.group_pk.slice(2), email, clientOptions)
+  login(toSession(pomade, {clientOptions, email}))
 
 export const POMADE_INVALID_LOGIN_MESSAGE = "Invalid login information"
 export const POMADE_NETWORK_ERROR_MESSAGE = "Network error, please try again"
diff --git a/src/app/profiles.ts b/src/app/profiles.ts
deleted file mode 100644
index 947027d0..00000000
--- a/src/app/profiles.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import {get} from "svelte/store"
-import {
-  FOLLOWS,
-  MESSAGING_RELAYS,
-  PROFILE,
-  RELAYS,
-  createProfile,
-  editProfile,
-  isPublishedProfile,
-  isSignedEvent,
-  makeEvent,
-} from "@welshman/util"
-import type {Profile} from "@welshman/util"
-import {nthNe} from "@welshman/lib"
-import {publishThunk, pubkey, repository} from "@welshman/app"
-import {Router} from "@welshman/router"
-import {userSpaceUrls} from "@app/groups"
-
-export const broadcastUserData = async (relays: string[]) => {
-  const authors = [pubkey.get()!]
-  const kinds = [RELAYS, MESSAGING_RELAYS, FOLLOWS, PROFILE]
-  const events = repository.query([{kinds, authors}])
-
-  for (const event of events) {
-    if (isSignedEvent(event)) {
-      await publishThunk({event, relays}).complete
-    }
-  }
-}
-
-export const updateProfile = ({profile}: {profile: Profile}) => {
-  const router = Router.get()
-  const template = isPublishedProfile(profile) ? editProfile(profile) : createProfile(profile)
-  const scenarios = [router.FromRelays(get(userSpaceUrls)), router.FromUser(), router.Index()]
-
-  // Remove protected tag, we used to add it
-  template.tags = template.tags.filter(nthNe(0, "-"))
-
-  const event = makeEvent(template.kind, template)
-  const relays = router.merge(scenarios).getUrls()
-
-  return publishThunk({event, relays})
-}
diff --git a/src/app/push/adapters/android.ts b/src/app/push/adapters/android.ts
index ab2899ab..7a642c19 100644
--- a/src/app/push/adapters/android.ts
+++ b/src/app/push/adapters/android.ts
@@ -1,10 +1,10 @@
 import {throttle} from "throttle-debounce"
 import {App} from "@capacitor/app"
 import {registerPlugin} from "@capacitor/core"
-import {session} from "@welshman/app"
-import type {Session} from "@welshman/app"
 import {maybe, now} from "@welshman/lib"
 import type {Filter} from "@welshman/util"
+import type {Session} from "@welshman/app"
+import {app, session} from "@app/core"
 import {pushState} from "@app/push/adapters/common"
 import type {IPushAdapter} from "@app/push/adapters/common"
 import {requestPermissions, syncRelaySubscriptions} from "@app/push/adapters/common"
@@ -16,7 +16,10 @@ type AndroidFallbackSubscription = {
   ignore: Array<Filter>
 }
 
+// A Session no longer carries the pubkey it belongs to, but the worker needs it to build auth
+// events, so it's passed alongside. Keep this in sync with AndroidPushFallbackWorker.kt.
 type AndroidPushFallbackState = {
+  pubkey?: string
   session?: Session
   activeSince?: number
   subscriptions?: Array<AndroidFallbackSubscription>
@@ -44,6 +47,7 @@ export class AndroidFallbackNotifications implements IPushAdapter {
       const doSync = throttle(1000, () => {
         AndroidPushFallback.syncState({
           state: {
+            pubkey: app.get().user?.pubkey,
             session: session.get(),
             activeSince: this._activeSince,
             subscriptions: Array.from(this._subscriptions.values()),
diff --git a/src/app/push/adapters/capacitor.ts b/src/app/push/adapters/capacitor.ts
index f1159ddc..0cbd5a74 100644
--- a/src/app/push/adapters/capacitor.ts
+++ b/src/app/push/adapters/capacitor.ts
@@ -1,21 +1,14 @@
-import {get} from "svelte/store"
 import {Capacitor} from "@capacitor/core"
 import {PushNotifications} from "@capacitor/push-notifications"
-import {
-  pubkey,
-  publishThunk,
-  loadRelay,
-  waitForThunkError,
-  userMessagingRelayList,
-} from "@welshman/app"
 import {assoc, hash, maybe} from "@welshman/lib"
 import type {Filter} from "@welshman/util"
-import {DELETE, getRelaysFromList, makeEvent, Address} from "@welshman/util"
+import {Address, DELETE, makeEvent} from "@welshman/util"
+import {Relays, User} from "@welshman/app"
 import {buildUrl} from "@lib/util"
+import {app, messagingRelayLists, roomLists, thunks} from "@app/core"
+import {device} from "@app/device"
 import {PUSH_BRIDGE, PUSH_SERVER} from "@app/env"
 import {pushState} from "@app/push/adapters/common"
-import {userSpaceUrls} from "@app/groups"
-import {device} from "@app/device"
 import type {IPushAdapter} from "@app/push/adapters/common"
 import {
   onPushNotificationAction,
@@ -84,9 +77,9 @@ export class CapacitorNotifications implements IPushAdapter {
 
   _getPushUrl = async (url: string) => {
     for (const candidate of [url, PUSH_BRIDGE]) {
-      const relay = await loadRelay(candidate)
+      const relay = await app.get().use(Relays).load(candidate)
 
-      if (relay?.supported_nips?.map(String)?.includes("9a")) {
+      if (relay?.hasNip("9a")) {
         return candidate
       }
     }
@@ -109,7 +102,7 @@ export class CapacitorNotifications implements IPushAdapter {
 
     const identifier = this._getSubscriptionIdentifier(relay, key)
 
-    const thunk = publishThunk({
+    const thunk = thunks.get().publish({
       relays: [url],
       event: makeEvent(30390, {
         tags: [
@@ -122,7 +115,7 @@ export class CapacitorNotifications implements IPushAdapter {
       }),
     })
 
-    const error = await waitForThunkError(thunk)
+    const error = await thunk.waitForError()
 
     if (error) {
       console.warn(`Failed to subscribe ${relay} to ${key} notifications:`, error)
@@ -139,9 +132,9 @@ export class CapacitorNotifications implements IPushAdapter {
 
     const relays = [url]
     const identifier = this._getSubscriptionIdentifier(relay, key)
-    const address = new Address(30390, pubkey.get()!, identifier).toString()
+    const address = new Address(30390, User.require(app.get()).pubkey, identifier).toString()
     const event = makeEvent(DELETE, {tags: [["a", address]]})
-    const error = await waitForThunkError(publishThunk({relays, event}))
+    const error = await thunks.get().publish({relays, event}).waitForError()
 
     if (error) {
       console.warn(`Failed to unsubscribe ${relay} from notifications:`, error)
@@ -192,10 +185,24 @@ export class CapacitorNotifications implements IPushAdapter {
 
     pushState.set({})
 
-    await Promise.all(get(userSpaceUrls).map(url => this._unsyncRelay(url, "spaces")))
+    const $pubkey = app.get().user?.pubkey
 
-    await Promise.all(
-      getRelaysFromList(get(userMessagingRelayList)).map(url => this._unsyncRelay(url, "messages")),
-    )
+    if ($pubkey) {
+      await Promise.all(
+        roomLists
+          .get()
+          .urls($pubkey)
+          .get()
+          .map(url => this._unsyncRelay(url, "spaces")),
+      )
+
+      await Promise.all(
+        messagingRelayLists
+          .get()
+          .urls($pubkey)
+          .get()
+          .map(url => this._unsyncRelay(url, "messages")),
+      )
+    }
   }
 }
diff --git a/src/app/push/adapters/common.ts b/src/app/push/adapters/common.ts
index 9e0e12b5..5ebad87e 100644
--- a/src/app/push/adapters/common.ts
+++ b/src/app/push/adapters/common.ts
@@ -1,6 +1,4 @@
-import {withGetter} from "@welshman/store"
 import {writable} from "svelte/store"
-import {goto} from "$app/navigation"
 import type {Subscriber, Unsubscriber} from "svelte/store"
 import {
   PushNotifications,
@@ -9,23 +7,24 @@ import {
   type Token,
 } from "@capacitor/push-notifications"
 import type {PluginListenerHandle} from "@capacitor/core"
-import {pubkey, repository, tracker, userMessagingRelayList} from "@welshman/app"
-import {merged} from "@welshman/store"
+import {goto} from "$app/navigation"
 import {assoc, call, now, on, poll, spec, throttle} from "@welshman/lib"
-import {load, LOCAL_RELAY_URL} from "@welshman/net"
+import {LOCAL_RELAY_URL} from "@welshman/net"
 import type {RepositoryUpdate} from "@welshman/net"
 import {
   getIdFilters,
-  getRelaysFromList,
-  getTagValue,
   matchFilters,
+  tagSpec,
+  tagValue,
   MESSAGE,
   type Filter,
   type TrustedEvent,
 } from "@welshman/util"
+import {merged, withGetter} from "@welshman/store"
+import {User} from "@welshman/app"
+import {app, messagingRelayLists, network, roomLists} from "@app/core"
 import {DM_KINDS, CONTENT_KINDS, makeCommentFilter} from "@app/content"
 import {notificationSettings, shouldNotify, userSettingsValues} from "@app/settings"
-import {userSpaceUrls} from "@app/groups"
 import {getEventPath, goToSpace} from "@app/routes"
 
 export type PushSubscription = {
@@ -66,17 +65,19 @@ export const onNotification = call(() => {
     subscribers.push(f)
 
     if (!unsubscribe) {
-      unsubscribe = on(repository, "update", ({added}: RepositoryUpdate) => {
-        const $pubkey = pubkey.get()
+      unsubscribe = on(app.get().repository, "update", ({added}: RepositoryUpdate) => {
+        const $pubkey = app.get().user?.pubkey
 
         for (const event of added) {
           if (event.pubkey == $pubkey) {
             continue
           }
 
-          const h = getTagValue("h", event.tags)
+          const h = tagValue(tagSpec("h"), event.tags)
 
-          if (Array.from(tracker.getRelays(event.id)).every(url => !shouldNotify(url, h))) {
+          if (
+            Array.from(app.get().tracker.getRelays(event.id)).every(url => !shouldNotify(url, h))
+          ) {
             continue
           }
 
@@ -103,7 +104,7 @@ export const onNotification = call(() => {
 export const onPushNotificationAction = async (action: ActionPerformed) => {
   const {relay, id} = action.notification.data
 
-  const [event] = await load({
+  const [event] = await network.get().load({
     relays: [relay, LOCAL_RELAY_URL],
     filters: getIdFilters([id]),
   })
@@ -157,21 +158,17 @@ export const syncRelaySubscriptions = (
   signal: AbortSignal,
   sync: (url: string, key: string, filters: Filter[], ignore: Filter[]) => void,
 ) => {
-  const $pubkey = pubkey.get()
-
-  if (!$pubkey) {
-    throw new Error("Attempted to sync push subscriptions without an active pubkey")
-  }
+  const $pubkey = User.require(app.get()).pubkey
 
   const unsubscribeSpaces = merged([
-    userSpaceUrls,
+    roomLists.get().urls($pubkey).$,
     notificationSettings,
     userSettingsValues,
   ]).subscribe(
-    throttle(3000, ([$userSpaceUrls, {spaces, mentions}, {alerts}]) => {
+    throttle(3000, ([$spaceUrls, {spaces, mentions}, {alerts}]) => {
       const baseFilters = [{kinds: [MESSAGE, ...CONTENT_KINDS]}, makeCommentFilter(CONTENT_KINDS)]
 
-      for (const url of $userSpaceUrls) {
+      for (const url of $spaceUrls) {
         const {notify = true, exceptions = []} = alerts.find(spec({url})) || {}
         const filters: Filter[] = []
         const ignore: Filter[] = []
@@ -198,9 +195,12 @@ export const syncRelaySubscriptions = (
     }),
   )
 
-  const unsubscribeMessages = merged([userMessagingRelayList, notificationSettings]).subscribe(
-    throttle(3000, ([$userMessagingRelayList, {messages}]) => {
-      for (const url of getRelaysFromList($userMessagingRelayList)) {
+  const unsubscribeMessages = merged([
+    messagingRelayLists.get().urls($pubkey).$,
+    notificationSettings,
+  ]).subscribe(
+    throttle(3000, ([$messagingUrls, {messages}]) => {
+      for (const url of $messagingUrls) {
         const filters: Filter[] = []
 
         if (messages) {
diff --git a/src/app/push/adapters/web.ts b/src/app/push/adapters/web.ts
index 24c1a948..f33a491b 100644
--- a/src/app/push/adapters/web.ts
+++ b/src/app/push/adapters/web.ts
@@ -1,8 +1,8 @@
-import {pubkey} from "@welshman/app"
-import {maybe} from "@welshman/lib"
 import type {Unsubscriber} from "svelte/store"
-import {getPubkeyTagValues, matchFilter, type TrustedEvent} from "@welshman/util"
+import {maybe} from "@welshman/lib"
+import {hexTags, matchFilter, tagValues, type TrustedEvent} from "@welshman/util"
 import {DM_KINDS} from "@app/content"
+import {app} from "@app/core"
 import {notificationSettings} from "@app/settings"
 import type {IPushAdapter} from "@app/push/adapters/common"
 import {onNotification} from "@app/push/adapters/common"
@@ -49,15 +49,12 @@ export class WebNotifications implements IPushAdapter {
     if (!this._unsubscriber) {
       this._unsubscriber = onNotification(event => {
         const {push, messages, mentions, spaces} = notificationSettings.get()
+        const $pubkey = app.get().user?.pubkey
 
         if (push && document.hidden && Notification?.permission === "granted") {
           if (messages && matchFilter({kinds: DM_KINDS}, event)) {
             this._notify(event, "New direct message", "Someone sent you a direct message.")
-          } else if (
-            mentions &&
-            event.pubkey !== pubkey.get() &&
-            getPubkeyTagValues(event.tags).includes(pubkey.get()!)
-          ) {
+          } else if (mentions && $pubkey && tagValues(hexTags("p"), event.tags).includes($pubkey)) {
             this._notify(event, "Someone mentioned you", "Someone tagged you in a message.")
           } else if (spaces) {
             this._notify(event, "New activity", "Someone posted a new message.")
diff --git a/src/app/reactions.ts b/src/app/reactions.ts
index 4ef54b18..f4ba8441 100644
--- a/src/app/reactions.ts
+++ b/src/app/reactions.ts
@@ -1,37 +1,53 @@
-import type {TrustedEvent} from "@welshman/util"
-import {REACTION, getTag, makeEvent} from "@welshman/util"
-import {publishThunk, tagEventForReaction} from "@welshman/app"
-import {PROTECTED} from "@app/groups"
+import {removeUndefined} from "@welshman/lib"
+import type {EventContent, TrustedEvent} from "@welshman/util"
+import {deletes, reactions, relays, wraps} from "@app/core"
 
-export type ReactionParams = {
-  protect: boolean
-  event: TrustedEvent
-  content: string
+export type ReactionTarget = {
   url?: string
-  tags?: string[][]
+  h?: string
+  // Where to publish, when it isn't just the space's own relay.
+  urls?: string[]
 }
 
-export const makeReaction = ({
-  url,
-  protect,
-  content,
-  event,
-  tags: paramTags = [],
-}: ReactionParams) => {
-  const tags = [...paramTags, ...tagEventForReaction(event, url)]
-  const groupTag = getTag("h", event.tags)
+// A reaction has to travel the same way as the event it's about — protected on relays that
+// enforce NIP-70, and tagged into the room the event lives in.
+export const publishReaction = async (
+  event: TrustedEvent,
+  {content, tags}: EventContent,
+  {url, h, urls}: ReactionTarget,
+) => {
+  const protect = url ? await relays.get().hasNip(url, 70) : false
+  const command = await reactions.get().react(event, content, writer => {
+    writer.addTags(...tags).setProtected(protect)
 
-  if (groupTag) {
-    tags.push(groupTag)
-  }
+    if (url && h) {
+      writer.setRoom(url, h)
+    }
+  })
 
-  if (protect) {
-    tags.push(PROTECTED)
-  }
-
-  return makeEvent(REACTION, {content, tags})
+  return command.publishToRelays(urls ?? removeUndefined([url]))
 }
 
-export const publishReaction = ({relays, ...params}: ReactionParams & {relays: string[]}) => {
-  publishThunk({event: makeReaction({url: relays[0], ...params}), relays})
+export const retractReaction = async (reaction: TrustedEvent, {url, urls}: ReactionTarget) => {
+  const protect = url ? await relays.get().hasNip(url, 70) : false
+  const command = await deletes.get().deleteEvent(reaction, writer => writer.setProtected(protect))
+
+  return command.publishToRelays(urls ?? removeUndefined([url]))
+}
+
+// Chat reactions go out gift-wrapped to the conversation rather than to a relay.
+export const publishWrappedReaction = async (
+  event: TrustedEvent,
+  {content, tags}: EventContent,
+  pubkeys: string[],
+) => {
+  const command = await reactions.get().react(event, content, writer => writer.addTags(...tags))
+
+  return wraps.get().publish({event: command.event, recipients: pubkeys, pow: 16})
+}
+
+export const retractWrappedReaction = async (reaction: TrustedEvent, pubkeys: string[]) => {
+  const command = await deletes.get().deleteEvent(reaction)
+
+  return wraps.get().publish({event: command.event, recipients: pubkeys, pow: 16})
 }
diff --git a/src/app/recent.ts b/src/app/recent.ts
index a912a536..071a0227 100644
--- a/src/app/recent.ts
+++ b/src/app/recent.ts
@@ -1,8 +1,8 @@
 import {derived} from "svelte/store"
 import {groupBy, first, sortBy, uniqBy, ago, MONTH} from "@welshman/lib"
-import {MESSAGE, COMMENT, getTagValue, getTagValues, getIdAndAddress} from "@welshman/util"
+import {MESSAGE, COMMENT, getIdAndAddress, tagSpec, tagValue, tagValues} from "@welshman/util"
 import type {TrustedEvent} from "@welshman/util"
-import {repository} from "@welshman/app"
+import {app} from "@app/core"
 import {deriveEventsForUrl} from "@app/repository"
 import {CONTENT_KINDS} from "@app/content"
 
@@ -24,7 +24,7 @@ export const deriveRecentActivity = (url: string) => {
   return derived([messages, content, comments], ([$messages, $content, $comments]) => {
     const activity: RecentActivityItem[] = []
 
-    const byRoom = groupBy(e => getTagValue("h", e.tags), $messages)
+    const byRoom = groupBy(e => tagValue(tagSpec("h"), e.tags), $messages)
     for (const roomMessages of byRoom.values()) {
       const latest = first(roomMessages)
       if (latest) {
@@ -46,13 +46,13 @@ export const deriveRecentActivity = (url: string) => {
     }
 
     for (const event of $comments) {
-      for (const k of getTagValues(["E", "A"], event.tags)) {
+      for (const k of tagValues(tagSpec(["E", "A"]), event.tags)) {
         latestActivityByKey.set(k, Math.max(latestActivityByKey.get(k) || 0, event.created_at))
       }
     }
 
     for (const [address, timestamp] of latestActivityByKey.entries()) {
-      const event = repository.getEvent(address)
+      const event = app.get().repository.getEvent(address)
 
       if (event) {
         activity.push({type: "content", event, timestamp, count: 1})
diff --git a/src/app/relays.ts b/src/app/relays.ts
index 07b6eddc..33ce7840 100644
--- a/src/app/relays.ts
+++ b/src/app/relays.ts
@@ -1,30 +1,12 @@
-import {
-  ManagementMethod,
-  getRelaysFromList,
-  isShareableRelayUrl,
-  isSignedEvent,
-  normalizeRelayUrl,
-} from "@welshman/util"
-import type {List, RelayProfile} from "@welshman/util"
-import {AuthStateEvent, AuthStatus, Pool, SocketEvent, SocketStatus} from "@welshman/net"
 import {derived, readable} from "svelte/store"
-import type {Maybe} from "@welshman/lib"
-import {call, on, simpleCache, uniq} from "@welshman/lib"
+import {call, on, simpleCache} from "@welshman/lib"
+import {normalizeRelayUrl} from "@welshman/util"
+import {AuthStateEvent, AuthStatus, SocketEvent, SocketStatus} from "@welshman/net"
 import {throttled} from "@welshman/store"
-import {getRelay, loadRelay, manageRelay, publishThunk, waitForThunkError} from "@welshman/app"
 import {checkRelayHasLivekit} from "$lib/livekit"
-import {stripPrefix} from "@lib/util"
+import {app} from "@app/core"
 import {relaysMostlyRestricted} from "@app/policies"
 
-export const hasNip29 = (relay?: RelayProfile) =>
-  Boolean(relay?.supported_nips?.map?.(String)?.includes?.("29"))
-
-export const hasNip50 = (relay?: RelayProfile) =>
-  Boolean(relay?.supported_nips?.map?.(String)?.includes?.("50"))
-
-export const hasNip70 = (relay?: RelayProfile) =>
-  Boolean(relay?.supported_nips?.map?.(String)?.includes?.("70"))
-
 export const encodeRelay = (url: string) =>
   encodeURIComponent(
     normalizeRelayUrl(url)
@@ -34,27 +16,8 @@ export const encodeRelay = (url: string) =>
 
 export const decodeRelay = (url: string) => normalizeRelayUrl(decodeURIComponent(url))
 
-// A hosted relay whose custom domain changed keeps 301-ing its old host to the
-// new one; the NIP-11 fetch surfaces that (the socket can't). Returns the new
-// wss:// url, or undefined when there's no redirect or the fetch fails.
-export const fetchRelayRedirect = async (url: string): Promise<Maybe<string>> => {
-  try {
-    const response = await fetch(url.replace(/^ws/, "http"), {
-      headers: {Accept: "application/nostr+json"},
-    })
-
-    if (!response.redirected) return undefined
-
-    const next = normalizeRelayUrl(response.url.replace(/^http/, "ws"))
-
-    return next === normalizeRelayUrl(url) ? undefined : next
-  } catch {
-    return undefined
-  }
-}
-
 export const deriveSocket = (url: string) => {
-  const socket = Pool.get().get(url)
+  const socket = app.get().pool.get(url)
 
   return readable(socket, set => {
     const subs = [
@@ -115,39 +78,8 @@ export const deriveSocketStatus = (url: string) =>
     }),
   )
 
-export const signAsRelay = async (url: string, template: object): Promise<string | undefined> => {
-  const {result, error} = await manageRelay(url, {
-    method: "signevent" as ManagementMethod,
-    params: [template as unknown as string],
-  })
-
-  if (error) return error
-
-  if (!isSignedEvent(result)) return "Relay returned an invalid event"
-
-  return stripPrefix(await waitForThunkError(publishThunk({event: result, relays: [url]})))
-}
-
-export const deriveSupportedMethods = simpleCache(([url]: [string]) => {
-  return readable<ManagementMethod[]>([], set => {
-    manageRelay(url, {
-      method: ManagementMethod.SupportedMethods,
-      params: [],
-    }).then(({result = []}) => set(result))
-  })
-})
-
 export const deriveHasLivekit = simpleCache(([url]: [string]) =>
   readable<boolean | undefined>(undefined, set => {
     checkRelayHasLivekit(url).then(has => set(has))
   }),
 )
-
-export const discoverRelays = (lists: List[]) =>
-  Promise.all(
-    uniq(lists.flatMap($l => getRelaysFromList($l)))
-      .filter(isShareableRelayUrl)
-      .map(url => loadRelay(url)),
-  )
-
-export const canEnforceNip70 = (url: string) => hasNip70(getRelay(url))
diff --git a/src/app/reports.ts b/src/app/reports.ts
deleted file mode 100644
index eaffb8dd..00000000
--- a/src/app/reports.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import type {TrustedEvent} from "@welshman/util"
-import {REPORT, makeEvent} from "@welshman/util"
-import {publishThunk} from "@welshman/app"
-
-export type ReportParams = {
-  event: TrustedEvent
-  content: string
-  reason: string
-}
-
-export const makeReport = ({event, reason, content}: ReportParams) => {
-  const tags = [
-    ["p", event.pubkey],
-    ["e", event.id, reason],
-  ]
-
-  return makeEvent(REPORT, {content, tags})
-}
-
-export const publishReport = ({
-  relays,
-  event,
-  reason,
-  content,
-}: ReportParams & {relays: string[]}) =>
-  publishThunk({event: makeReport({event, reason, content}), relays})
diff --git a/src/app/repository.ts b/src/app/repository.ts
index 3d78c531..8c2ef850 100644
--- a/src/app/repository.ts
+++ b/src/app/repository.ts
@@ -1,46 +1,63 @@
-import {
-  deriveArray,
-  deriveDeduplicated,
-  deriveEventsAsc,
-  deriveEventsById,
-  deriveEventsByIdForUrl,
-  deriveEventsDesc,
-  getEventsByIdForUrl,
-  makeDeriveEvent,
-} from "@welshman/store"
-import {deriveRelay, repository, tracker} from "@welshman/app"
-import {sortEventsDesc} from "@welshman/util"
-import type {Filter} from "@welshman/util"
-import {load} from "@welshman/net"
-import {filter, first, spec} from "@welshman/lib"
 import {derived} from "svelte/store"
-export const deriveEvent = makeDeriveEvent({
-  repository,
-  includeDeleted: true,
-  onDerive: (filters: Filter[], relays: string[]) => load({filters, relays}),
-})
+import {filter, spec} from "@welshman/lib"
+import type {Filter, TrustedEvent} from "@welshman/util"
+import * as store from "@welshman/store"
+import {Network, Relays} from "@welshman/app"
+import {app, fromApp} from "@app/core"
+
+// Events
+
+export const deriveEvent = (idOrAddress: string, relays: string[] = []) =>
+  fromApp($app =>
+    store.makeDeriveEvent({
+      repository: $app.repository,
+      includeDeleted: true,
+      onDerive: (filters: Filter[], hints: string[]) =>
+        $app.use(Network).load({filters, relays: hints}),
+    })(idOrAddress, relays),
+  )
+
+export const deriveEventsById = (filters: Filter[] = [{}]) =>
+  fromApp($app => store.deriveEventsById({repository: $app.repository, filters}))
 
 export const deriveEvents = (filters: Filter[] = [{}]) =>
-  deriveEventsDesc(deriveEventsById({repository, filters}))
+  store.deriveEventsDesc(deriveEventsById(filters))
+
+export const deriveIsDeleted = (event: TrustedEvent) =>
+  fromApp($app => store.deriveIsDeleted($app.repository, event))
+
+// Events on a relay
 
 export const getEventsForUrl = (url: string, filters: Filter[] = [{}]) =>
-  getEventsByIdForUrl({url, tracker, repository, filters}).values()
+  store
+    .getEventsByIdForUrl({
+      url,
+      filters,
+      tracker: app.get().tracker,
+      repository: app.get().repository,
+    })
+    .values()
+
+export const deriveEventsByIdForUrl = (url: string, filters: Filter[] = [{}]) =>
+  fromApp($app =>
+    store.deriveEventsByIdForUrl({
+      url,
+      filters,
+      tracker: $app.tracker,
+      repository: $app.repository,
+    }),
+  )
 
 export const deriveEventsForUrl = (url: string, filters: Filter[] = [{}]) =>
-  deriveArray(deriveEventsByIdForUrl({url, tracker, repository, filters}))
+  store.deriveArray(deriveEventsByIdForUrl(url, filters))
 
-export const deriveEventsForUrlAsc = (url: string, filters: Filter[] = [{}]) =>
-  deriveEventsAsc(deriveEventsByIdForUrl({url, tracker, repository, filters}))
-
-export const deriveEventsForUrlDesc = (url: string, filters: Filter[] = [{}]) =>
-  deriveEventsDesc(deriveEventsByIdForUrl({url, tracker, repository, filters}))
-
-export const deriveLatestEventForUrl = (url: string, filters: Filter[] = [{}]) =>
-  deriveDeduplicated(deriveEventsByIdForUrl({url, tracker, repository, filters}), $eventsById =>
-    first(sortEventsDesc($eventsById.values())),
+export const deriveEventsByIdByUrl = (filters: Filter[] = [{}]) =>
+  fromApp($app =>
+    store.deriveEventsByIdByUrl({filters, tracker: $app.tracker, repository: $app.repository}),
   )
 
 export const deriveRelaySignedEvents = (url: string, filters: Filter[] = [{}]) =>
-  derived([deriveRelay(url), deriveEventsForUrl(url, filters)], ([relay, events]) =>
-    filter(spec({pubkey: relay?.self}), events),
+  derived(
+    [fromApp($app => $app.use(Relays).one(url)), deriveEventsForUrl(url, filters)],
+    ([$relay, $events]) => filter(spec({pubkey: $relay?.self}), $events as TrustedEvent[]),
   )
diff --git a/src/app/roles.ts b/src/app/roles.ts
new file mode 100644
index 00000000..0d1ad4bb
--- /dev/null
+++ b/src/app/roles.ts
@@ -0,0 +1,23 @@
+import {derived} from "svelte/store"
+import {matchTags, tagSpec} from "@welshman/util"
+import {relayMemberLists} from "@app/core"
+
+// Roles are rendered at a fixed saturation and lightness, chosen to read on both themes.
+export const roleColor = (hue: number) => `hsl(${hue}, 70%, 50%)`
+
+// A translucent tint of the role color for use as a background fill.
+export const roleColorSoft = (hue: number) => `hsl(${hue}, 70%, 50%, 0.15)`
+
+// Map<pubkey, roleId[]> parsed from EXTRA values on ["member", pubkey, ...roleIds] tags
+export const deriveSpaceMemberRoles = (url: string) =>
+  derived(relayMemberLists.get().forUrl(url), $members => {
+    const rolesByPubkey = new Map<string, string[]>()
+
+    for (const [, member, ...roleIds] of matchTags(tagSpec("member"), $members?.tags() ?? [])) {
+      if (member) {
+        rolesByPubkey.set(member, roleIds)
+      }
+    }
+
+    return rolesByPubkey
+  })
diff --git a/src/app/roomPins.ts b/src/app/roomPins.ts
new file mode 100644
index 00000000..8fad842c
--- /dev/null
+++ b/src/app/roomPins.ts
@@ -0,0 +1,50 @@
+import {derived, readable} from "svelte/store"
+import type {Readable} from "svelte/store"
+import {getIdFilters, getIdOrAddress} from "@welshman/util"
+import type {TrustedEvent} from "@welshman/util"
+import {network, roomPinLists} from "@app/core"
+import {deriveEventsForUrl} from "@app/repository"
+
+export const deriveRoomPinnedEvents = (url: string, h: string): Readable<TrustedEvent[]> =>
+  readable<TrustedEvent[]>([], set => {
+    const controller = new AbortController()
+
+    roomPinLists.get().loadForRoom(url, h, controller.signal)
+
+    const unsubscribe = derived<Readable<string[]>, TrustedEvent[]>(
+      roomPinLists.get().pins(url, h).$,
+      ($pins, setEvents) => {
+        if ($pins.length === 0) {
+          setEvents([])
+
+          return () => {}
+        }
+
+        const filters = getIdFilters($pins)
+
+        network.get().load({relays: [url], filters, signal: controller.signal})
+
+        return deriveEventsForUrl(url, filters).subscribe($events => {
+          const byPin = new Map(
+            $events.flatMap(event => [
+              [event.id, event],
+              [getIdOrAddress(event), event],
+            ]),
+          )
+
+          setEvents(
+            $pins.flatMap(pin => {
+              const event = byPin.get(pin)
+
+              return event ? [event] : []
+            }),
+          )
+        })
+      },
+    ).subscribe(set)
+
+    return () => {
+      controller.abort()
+      unsubscribe()
+    }
+  })
diff --git a/src/app/rooms.ts b/src/app/rooms.ts
new file mode 100644
index 00000000..4b9cb8a1
--- /dev/null
+++ b/src/app/rooms.ts
@@ -0,0 +1,220 @@
+import * as nip19 from "nostr-tools/nip19"
+import {derived} from "svelte/store"
+import {sortBy, uniq} from "@welshman/lib"
+import type {Maybe} from "@welshman/lib"
+import {
+  MESSAGE,
+  ROOM_ADD_MEMBER,
+  ROOM_JOIN,
+  ROOM_LEAVE,
+  ROOM_REMOVE_MEMBER,
+  makeEvent,
+  outbox,
+  seen,
+  sortEventsAsc,
+  toNostrURI,
+} from "@welshman/util"
+import type {EventContent, TrustedEvent} from "@welshman/util"
+import {RoomLists, makeRoomKey} from "@welshman/app"
+import type {Room, RoomMeta} from "@welshman/app"
+import {
+  deriveUserItem,
+  relayManagement,
+  relayMemberLists,
+  roomLists,
+  rooms,
+  router,
+  thunks,
+  user,
+} from "@app/core"
+import {deriveUserIsSpaceAdmin} from "@app/management"
+import {deriveEventsForUrl} from "@app/repository"
+
+export enum MembershipStatus {
+  Initial,
+  Pending,
+  Granted,
+}
+
+export const ROOM = "h"
+
+export const PROTECTED = ["-"]
+
+export enum RoomType {
+  Text = "text",
+  Voice = "voice",
+}
+
+export const getRoomType = (room: Maybe<Room>) =>
+  room?.meta?.hasLivekit() ? RoomType.Voice : RoomType.Text
+
+export const isRoomId = (id: string) => id.includes("'")
+
+export const displayRoom = (url: string, h: string) =>
+  rooms.get().get(makeRoomKey(url, h))?.meta?.name() || h
+
+export const roomComparator = (url: string) => (h: string) => displayRoom(url, h).toLowerCase()
+
+export const deriveRoomMembers = (url: string, h: string) =>
+  derived(rooms.get().forRoom(url, h), $room => $room?.members?.members() ?? [])
+
+// A room member also has to be allowed at the relay level, or they won't be able to read the
+// room at all.
+export const addRoomMembers = async (url: string, room: RoomMeta, pubkeys: string[]) => {
+  const members = relayMemberLists.get().get(url)
+  const management = relayManagement.get().forUrl(url)
+
+  const responses = await Promise.all(
+    pubkeys.filter(pk => !members?.isMember(pk)).map(pk => management.allowPubkey(pk)),
+  )
+
+  for (const {error} of responses) {
+    if (error) {
+      return error
+    }
+  }
+
+  const errors = await Promise.all(
+    pubkeys.map(pk =>
+      rooms
+        .get()
+        .addMember(url, room, pk)
+        .then(command => command.publish().waitForError()),
+    ),
+  )
+
+  for (const error of errors) {
+    if (error) {
+      return error
+    }
+  }
+}
+
+export const prependParent = async (
+  parent: Maybe<TrustedEvent>,
+  {content, tags}: EventContent,
+  url?: string,
+): Promise<EventContent> => {
+  if (parent) {
+    const resolver = router.get().resolver
+    const relays = url ? [url] : await resolver.relays([seen(parent)])
+    const hint = url ?? (await resolver.relay([outbox(parent.pubkey)])) ?? ""
+    const nevent = nip19.neventEncode({...parent, relays})
+
+    content = toNostrURI(nevent) + "\n\n" + content
+    tags = [...tags, ["q", parent.id, hint, parent.pubkey], ["p", parent.pubkey, hint]]
+  }
+
+  return {content, tags}
+}
+
+export const publishRoomQuote = async ({
+  url,
+  h,
+  parent,
+  protect,
+  delay,
+}: {
+  url: string
+  h?: string
+  parent: TrustedEvent
+  protect: boolean
+  delay?: number
+}) => {
+  const tags: string[][] = []
+
+  if (h) {
+    tags.push([ROOM, h])
+  }
+
+  if (protect) {
+    tags.push(PROTECTED)
+  }
+
+  const event = makeEvent(MESSAGE, await prependParent(parent, {content: "", tags}, url))
+
+  return thunks.get().publish({relays: [url], event, delay})
+}
+
+// User
+
+export const userRoomList = deriveUserItem($app => $app.use(RoomLists))
+
+export const userSpaceUrls = derived(userRoomList, $userRoomList => $userRoomList?.urls() ?? [])
+
+// Rooms in the space the user has joined, limited to those the relay still advertises.
+export const deriveUserRooms = (url: string) =>
+  derived(
+    [roomLists.get().roomsForUrl(user.get().pubkey, url).$, rooms.get().forUrl(url).$],
+    ([$rooms, $spaceRooms]) => {
+      const known = new Set($spaceRooms.map(room => room.h))
+
+      return sortBy(roomComparator(url), uniq($rooms.filter(h => known.has(h))))
+    },
+  )
+
+export const deriveOtherRooms = (url: string) =>
+  derived([deriveUserRooms(url), rooms.get().forUrl(url).$], ([$userRooms, $spaceRooms]) => {
+    const result = $spaceRooms
+      .filter(room => !room.meta?.hasLivekit() && !$userRooms.includes(room.h))
+      .map(room => room.h)
+
+    return sortBy(roomComparator(url), uniq(result))
+  })
+
+export const deriveOtherVoiceRooms = (url: string) =>
+  derived([deriveUserRooms(url), rooms.get().forUrl(url).$], ([$userRooms, $spaceRooms]) => {
+    const result = $spaceRooms
+      .filter(room => room.meta?.hasLivekit() && !$userRooms.includes(room.h))
+      .map(room => room.h)
+
+    return sortBy(roomComparator(url), uniq(result))
+  })
+
+// A space admin administers every room in it, so space admin implies room admin.
+export const deriveUserIsRoomAdmin = (url: string, h: string) =>
+  derived(
+    [user, rooms.get().forRoom(url, h), deriveUserIsSpaceAdmin(url)],
+    ([$user, $room, $isSpaceAdmin]) =>
+      $isSpaceAdmin || Boolean($room?.admins?.pubkeys().includes($user.pubkey)),
+  )
+
+export const deriveUserRoomMembershipStatus = (url: string, h: string) =>
+  derived(
+    [
+      user,
+      rooms.get().forRoom(url, h),
+      deriveEventsForUrl(url, [{kinds: [ROOM_ADD_MEMBER, ROOM_REMOVE_MEMBER], "#h": [h]}]),
+      deriveEventsForUrl(url, [{kinds: [ROOM_JOIN, ROOM_LEAVE], "#h": [h]}]),
+      deriveUserIsRoomAdmin(url, h),
+    ],
+    ([$user, $room, $addRemoveEvents, $joinLeaveEvents, $isAdmin]) => {
+      if ($isAdmin) {
+        return MembershipStatus.Granted
+      }
+
+      let isMember = false
+
+      if ($room?.members) {
+        isMember = $room.members.isMember($user.pubkey)
+      } else {
+        for (const event of sortEventsAsc($addRemoveEvents)) {
+          if (event.pubkey === $user.pubkey) {
+            isMember = event.kind === ROOM_ADD_MEMBER
+          }
+        }
+      }
+
+      for (const event of $joinLeaveEvents) {
+        if (event.pubkey === $user.pubkey) {
+          if (event.kind === ROOM_JOIN) {
+            return isMember ? MembershipStatus.Granted : MembershipStatus.Pending
+          }
+
+          return MembershipStatus.Initial
+        }
+      }
+
+      return isMember ? MembershipStatus.Granted : MembershipStatus.Initial
+    },
+  )
diff --git a/src/app/routes.ts b/src/app/routes.ts
index 02c20fb1..c171488f 100644
--- a/src/app/routes.ts
+++ b/src/app/routes.ts
@@ -3,27 +3,28 @@ import {get} from "svelte/store"
 import * as nip19 from "nostr-tools/nip19"
 import {goto} from "$app/navigation"
 import {page} from "$app/stores"
-import type {TrustedEvent} from "@welshman/util"
-import {getAddress} from "@welshman/util"
-import {tracker, userMessagingRelayList, getRelay} from "@welshman/app"
 import {identity} from "@welshman/lib"
+import type {TrustedEvent} from "@welshman/util"
 import {
-  getTagValue,
-  MESSAGE,
-  THREAD,
   CLASSIFIED,
-  ZAP_GOAL,
   EVENT_TIME,
+  MESSAGE,
+  PINBOARD,
   POLL,
-  getPubkeyTagValues,
-  getRelaysFromList,
+  THREAD,
+  ZAP_GOAL,
+  getAddress,
+  hexTags,
+  tagSpec,
+  tagValue,
+  tagValues,
 } from "@welshman/util"
+import {app, messagingRelayLists, relays, user} from "@app/core"
 import {makeChatId} from "@app/chats"
 import {entityLink, PLATFORM_URL, PLATFORM_RELAYS} from "@app/env"
-import {encodeRelay, hasNip29} from "@app/relays"
+import {encodeRelay} from "@app/relays"
 import {DM_KINDS} from "@app/content"
-import {ROOM} from "@app/groups"
-import {BOARD} from "@app/pinboards"
+import {ROOM} from "@app/rooms"
 import {pushModal} from "@app/modal"
 import ChatEnable from "@app/components/ChatEnable.svelte"
 
@@ -57,7 +58,7 @@ export const makeRoomPath = (url: string, h: string) => `/spaces/${encodeRelay(u
 export const makeSpaceChatPath = (url: string) => makeRoomPath(url, "chat")
 
 export const goToChat = (pubkeys: string[] = []) => {
-  if (getRelaysFromList(get(userMessagingRelayList)).length === 0) {
+  if (messagingRelayLists.get().urls(user.get().pubkey).get().length === 0) {
     pushModal(ChatEnable, {next: () => goToChat(pubkeys)})
   } else if (pubkeys.length === 0) {
     goto(lastChatUrl ?? "/chat")
@@ -90,7 +91,7 @@ export const goToSpace = (url: string, hash = "") => {
     return goto(prevPath + hash, {replaceState: true})
   }
 
-  if (!hasNip29(getRelay(url))) {
+  if (!relays.get().get(url)?.hasNip(29)) {
     return goto(makeSpaceChatPath(url) + hash, {replaceState: true})
   }
 
@@ -115,7 +116,7 @@ export const goToHome = () => {
 // Content types, events
 
 export const makeMessagePath = (url: string, event: TrustedEvent) => {
-  const h = getTagValue(ROOM, event.tags)
+  const h = tagValue(tagSpec(ROOM), event.tags)
   const path = h ? makeRoomPath(url, h) : makeSpaceChatPath(url)
   const qp = new URLSearchParams({at: String(event.created_at)})
 
@@ -157,7 +158,7 @@ export const scrollToEvent = (id: string) => {
 }
 
 export const goToEvent = (event: TrustedEvent, options: Record<string, any> = {}) => {
-  const urls = Array.from(tracker.getRelays(event.id))
+  const urls = Array.from(app.get().tracker.getRelays(event.id))
   const path = getEventPath(event, urls)
 
   if (path.includes("://")) {
@@ -171,7 +172,7 @@ export const goToEvent = (event: TrustedEvent, options: Record<string, any> = {}
 
 export const getEventPath = (event: TrustedEvent, urls: string[]) => {
   if (DM_KINDS.includes(event.kind)) {
-    return makeChatPath([event.pubkey, ...getPubkeyTagValues(event.tags)])
+    return makeChatPath([event.pubkey, ...tagValues(hexTags("p"), event.tags)])
   }
 
   if (urls.length > 0) {
@@ -193,7 +194,7 @@ export const getEventPath = (event: TrustedEvent, urls: string[]) => {
       return makeCalendarPath(url, getAddress(event))
     }
 
-    if (event.kind === BOARD) {
+    if (event.kind === PINBOARD) {
       return makeLibraryPath(url, getAddress(event))
     }
 
@@ -205,9 +206,9 @@ export const getEventPath = (event: TrustedEvent, urls: string[]) => {
       return makeMessagePath(url, event)
     }
 
-    const address = getTagValue("A", event.tags)
-    const kind = getTagValue("K", event.tags)
-    const id = getTagValue("E", event.tags)
+    const address = tagValue(tagSpec("A"), event.tags)
+    const kind = tagValue(tagSpec("K"), event.tags)
+    const id = tagValue(tagSpec("E"), event.tags)
 
     if (id && kind) {
       if (parseInt(kind) === ZAP_GOAL) {
@@ -238,7 +239,7 @@ export const getEventPath = (event: TrustedEvent, urls: string[]) => {
 }
 
 export const makeEventPermalink = (event: TrustedEvent, url?: string) => {
-  const urls = url ? [url] : Array.from(tracker.getRelays(event.id))
+  const urls = url ? [url] : Array.from(app.get().tracker.getRelays(event.id))
   const path = getEventPath(event, urls)
 
   if (path.includes("://")) {
@@ -258,7 +259,7 @@ export const getRoomItemPath = (url: string, event: TrustedEvent) => {
       return makeGoalPath(url, event.id)
     case EVENT_TIME:
       return makeCalendarPath(url, getAddress(event))
-    case BOARD:
+    case PINBOARD:
       return makeLibraryPath(url, getAddress(event))
     case POLL:
       return makePollPath(url, event.id)
diff --git a/src/app/session.ts b/src/app/session.ts
index 2518fc99..33b10a72 100644
--- a/src/app/session.ts
+++ b/src/app/session.ts
@@ -1,14 +1,87 @@
-import {db, kv, ss} from "@app/storage"
+import type {ClientOptions} from "@pomade/core"
+import type {Wallet} from "@welshman/util"
+import {nip01, nip07, nip46, nip55, pomade, toSession} from "@welshman/app"
+import type {Session} from "@welshman/app"
+import {app, login, session} from "@app/core"
+import {wallet} from "@app/lightning"
+import {kv, ss, storage} from "@app/storage"
 import {deactivateCurrentPomadeSession} from "@app/pomade"
 import {Push} from "@app/push"
 
+// Sessions used to be a Record<pubkey, session> keyed by an active pubkey, and carried their
+// pubkey plus method-specific fields inline. Convert one so upgrading doesn't log people out.
+type LegacySession = {
+  method: string
+  pubkey: string
+  secret?: string
+  signer?: string
+  email?: string
+  clientOptions?: ClientOptions
+  handler?: {pubkey: string; relays: string[]}
+  wallet?: Wallet
+}
+
+const toCurrentSession = (legacy: LegacySession): Session | undefined => {
+  switch (legacy.method) {
+    case "nip01":
+      return legacy.secret ? toSession(nip01, {secret: legacy.secret}) : undefined
+    case "nip07":
+      return toSession(nip07, {})
+    case "nip46":
+      return legacy.secret && legacy.handler
+        ? toSession(nip46, {
+            clientSecret: legacy.secret,
+            signerPubkey: legacy.handler.pubkey,
+            relays: legacy.handler.relays,
+          })
+        : undefined
+    case "nip55":
+      return legacy.signer
+        ? toSession(nip55, {pubkey: legacy.pubkey, signer: legacy.signer})
+        : undefined
+    case "pomade":
+      return legacy.clientOptions && legacy.email
+        ? toSession(pomade, {clientOptions: legacy.clientOptions, email: legacy.email})
+        : undefined
+  }
+}
+
+const readLegacySession = async () => {
+  const pubkey = await kv.get<string>("pubkey")
+  const sessions = await ss.get<Record<string, LegacySession>>("sessions")
+  const legacy = pubkey ? sessions?.[pubkey] : undefined
+
+  if (legacy?.wallet) {
+    wallet.set(legacy.wallet)
+  }
+
+  return legacy ? toCurrentSession(legacy) : undefined
+}
+
+// The session is derived from the app's user, so it can't be synced to storage directly —
+// read it back once at startup, then persist it whenever the identity changes.
+export const restoreSession = async () => {
+  const $session = (await ss.get<Session>("session")) ?? (await readLegacySession())
+
+  if ($session) {
+    await login($session)
+  }
+
+  return session.subscribe($session => {
+    if ($session) {
+      ss.set("session", $session)
+    }
+  })
+}
+
 export const logout = async () => {
   await deactivateCurrentPomadeSession()
   await Push.disable()
   await kv.clear()
   await ss.clear()
-  await db.clear()
+  await storage.get()?.clear()
 
+  app.get().cleanup()
   localStorage.clear()
 
   window.location.href = "/"
diff --git a/src/app/settings.ts b/src/app/settings.ts
index c2232acc..8e43e808 100644
--- a/src/app/settings.ts
+++ b/src/app/settings.ts
@@ -1,19 +1,13 @@
-import {APP_DATA, makeEvent} from "@welshman/util"
-import type {TrustedEvent} from "@welshman/util"
-import {deriveItemsByKey, getter, makeLoadItem, withGetter} from "@welshman/store"
-import {
-  ensurePlaintext,
-  makeOutboxLoader,
-  makeUserData,
-  makeUserLoader,
-  publishThunk,
-  pubkey,
-  repository,
-  signer,
-} from "@welshman/app"
-import {append, parseJson, remove, spec} from "@welshman/lib"
-import {derived, get, writable} from "svelte/store"
-import {Router} from "@welshman/router"
+import {derived, writable} from "svelte/store"
+import {append, remove, spec} from "@welshman/lib"
+import {APP_DATA} from "@welshman/util"
+import {withGetter} from "@welshman/store"
+import {AppData} from "@welshman/domain"
+import type {AppDataReader} from "@welshman/domain"
+import {DerivedPlugin, Domain, Network, User, projectFrom} from "@welshman/app"
+import type {IApp, Projection} from "@welshman/app"
+import {app, fromApp, usePlugin} from "@app/core"
+
 export const SETTINGS = "flotilla/settings"
 
 export enum RelayAuthMode {
@@ -40,11 +34,6 @@ export type SettingsValues = {
   zap_amounts: number[]
 }
 
-export type Settings = {
-  event: TrustedEvent
-  values: SettingsValues
-}
-
 export const defaultSettings: SettingsValues = {
   show_media: true,
   hide_sensitive: true,
@@ -58,46 +47,46 @@ export const defaultSettings: SettingsValues = {
   zap_amounts: [21, 210, 2100, 21000],
 }
 
-export const settingsByPubkey = deriveItemsByKey({
-  repository,
-  getKey: settings => settings.event.pubkey,
-  filters: [{kinds: [APP_DATA], "#d": [SETTINGS]}],
-  eventToItem: async (event: TrustedEvent) => {
-    const values = {...defaultSettings, ...parseJson(await ensurePlaintext(event))}
+export class Settings extends DerivedPlugin<AppDataReader> {
+  values: Projection<SettingsValues>
 
-    return {event, values}
-  },
-})
+  constructor(app: IApp) {
+    super(app, {
+      filters: [{kinds: [APP_DATA], "#d": [SETTINGS]}],
+      eventToItem: app.use(Domain).reader(AppData),
+      getKey: settings => settings.author(),
+    })
 
-export const getSettingsByPubkey = getter(settingsByPubkey)
+    this.values = projectFrom(this.index, $settings => ({
+      ...defaultSettings,
+      ...$settings.get(app.user?.pubkey ?? "")?.values<Partial<SettingsValues>>(),
+    }))
+  }
 
-export const loadSettings = makeLoadItem(
-  makeOutboxLoader(APP_DATA, {"#d": [SETTINGS]}),
-  (pubkey: string) => getSettingsByPubkey().get(pubkey),
-)
+  fetch(pubkey: string) {
+    return this.app.use(Network).loadUsingOutbox(pubkey, {kinds: [APP_DATA], "#d": [SETTINGS]})
+  }
+}
 
-export const userSettings = makeUserData(settingsByPubkey, loadSettings)
+export const settings = usePlugin(Settings)
 
-export const loadUserSettings = makeUserLoader(loadSettings)
-
-export const userSettingsValues = derived(userSettings, $s => $s?.values || defaultSettings)
+export const userSettingsValues = withGetter(fromApp($app => $app.use(Settings).values.$))
 
 export const zapAmounts = derived(userSettingsValues, $settings => $settings.zap_amounts)
 
-export const getSettings = getter(userSettingsValues)
-
-export const getSetting = <T>(key: keyof Settings["values"]) => getSettings()[key] as T
+export const getSetting = <K extends keyof SettingsValues>(key: K) => userSettingsValues.get()[key]
 
 export const getShouldNotify = ({alerts}: SettingsValues, url: string, h?: string) => {
   const pref = alerts.find(spec({url}))
 
   if (!pref) return true
   if (!h) return pref.notify
-  if (pref.notify) return !pref.exceptions.includes(h)
-  if (!pref.notify) return pref.exceptions.includes(h)
+
+  return pref.notify ? !pref.exceptions.includes(h) : pref.exceptions.includes(h)
 }
 
-export const shouldNotify = (url: string, h?: string) => getShouldNotify(getSettings(), url, h)
+export const shouldNotify = (url: string, h?: string) =>
+  getShouldNotify(userSettingsValues.get(), url, h)
 
 export const deriveShouldNotify = (url: string, h?: string) =>
   derived(userSettingsValues, $settings => getShouldNotify($settings, url, h))
@@ -113,55 +102,51 @@ export const notificationSettings = withGetter(
   }),
 )
 
-export const makeSettings = async (params: Partial<SettingsValues>) => {
-  const json = JSON.stringify({...get(userSettingsValues), ...params})
-  const content = await signer.get().nip44.encrypt(pubkey.get()!, json)
-  const tags = [["d", SETTINGS]]
+export const publishSettings = async (params: Partial<SettingsValues>) => {
+  const $app = app.get()
+  const reader = await settings.get().forceLoad(User.require($app).pubkey)
+  const writer = $app
+    .use(Domain)
+    .writer(AppData, reader)
+    .setIdentifier(SETTINGS)
+    .setEncrypted(true)
+    .setValues({...userSettingsValues.get(), ...params})
 
-  return makeEvent(APP_DATA, {content, tags})
+  const command = await $app.use(Domain).command(writer)
+
+  return command.publish()
 }
 
-export const publishSettings = async (params: Partial<SettingsValues>) =>
-  publishThunk({event: await makeSettings(params), relays: Router.get().FromUser().getUrls()})
+export const addTrustedRelay = (url: string) =>
+  publishSettings({trusted_relays: append(url, getSetting("trusted_relays"))})
 
-export const addTrustedRelay = async (url: string) =>
-  publishSettings({trusted_relays: append(url, getSetting<string[]>("trusted_relays"))})
+export const removeTrustedRelay = (url: string) =>
+  publishSettings({trusted_relays: remove(url, getSetting("trusted_relays"))})
 
-export const removeTrustedRelay = async (url: string) =>
-  publishSettings({trusted_relays: remove(url, getSetting<string[]>("trusted_relays"))})
-
-export const setSpaceNotifications = async (url: string, notify: boolean) => {
-  const {alerts} = getSettings()
-  const existing = alerts.find((s: SpaceNotificationSettings) => s.url === url)
-
-  let updated: typeof alerts
+export const setSpaceNotifications = (url: string, notify: boolean) => {
+  const alerts = getSetting("alerts")
+  const existing = alerts.find(spec({url}))
 
   if (existing) {
-    updated = alerts.map((s: SpaceNotificationSettings) =>
-      s.url === url ? {...s, notify, exceptions: []} : s,
-    )
-  } else {
-    updated = [...alerts, {url, notify, exceptions: []}]
+    return publishSettings({
+      alerts: alerts.map(s => (s.url === url ? {...s, notify, exceptions: []} : s)),
+    })
   }
 
-  return publishSettings({alerts: updated})
+  return publishSettings({alerts: [...alerts, {url, notify, exceptions: []}]})
 }
 
-export const toggleRoomNotifications = async (url: string, h: string) => {
-  const {alerts} = getSettings()
-  const existing = alerts.find((s: SpaceNotificationSettings) => s.url === url)
+export const toggleRoomNotifications = (url: string, h: string) => {
+  const alerts = getSetting("alerts")
+  const existing = alerts.find(spec({url}))
 
-  let updated: typeof alerts
-
-  if (!existing) {
-    updated = [...alerts, {url, notify: true, exceptions: [h]}]
-  } else {
+  if (existing) {
     const exceptions = existing.exceptions.includes(h)
       ? remove(h, existing.exceptions)
       : append(h, existing.exceptions)
 
-    updated = alerts.map((s: SpaceNotificationSettings) => (s.url === url ? {...s, exceptions} : s))
+    return publishSettings({alerts: alerts.map(s => (s.url === url ? {...s, exceptions} : s))})
   }
 
-  return publishSettings({alerts: updated})
+  return publishSettings({alerts: [...alerts, {url, notify: true, exceptions: [h]}]})
 }
diff --git a/src/app/share.ts b/src/app/share.ts
index 08819721..93edbeb3 100644
--- a/src/app/share.ts
+++ b/src/app/share.ts
@@ -1,17 +1,15 @@
-import {get} from "svelte/store"
 import {goto} from "$app/navigation"
 import type {TrustedEvent} from "@welshman/util"
-import {relaysByUrl} from "@welshman/app"
 import {setKey} from "@lib/implicit"
-import EventShare from "@app/components/EventShare.svelte"
-import {hasNip29} from "@app/relays"
+import {relays} from "@app/core"
 import {pushModal} from "@app/modal"
 import {makeSpaceChatPath} from "@app/routes"
+import EventShare from "@app/components/EventShare.svelte"
 
 // Share an event to chat. On NIP-29 relays we prompt for a room to share into;
 // otherwise we stash the event and jump to the space chat composer, which quotes it.
 export const shareEventToChat = (url: string, noun: string, event: TrustedEvent) => {
-  if (hasNip29(get(relaysByUrl).get(url))) {
+  if (relays.get().get(url)?.hasNip(29)) {
     pushModal(EventShare, {url, noun, event})
   } else {
     setKey("share", event)
diff --git a/src/app/signer.ts b/src/app/signer.ts
new file mode 100644
index 00000000..d9b7707e
--- /dev/null
+++ b/src/app/signer.ts
@@ -0,0 +1,42 @@
+import {derived} from "svelte/store"
+import {Logger} from "@welshman/app"
+import type {LogMessage} from "@welshman/app"
+import {fromApp} from "@app/core"
+
+export type SignerRequest = {
+  id: string
+  method: string
+  startedAt: number
+  finishedAt?: number
+  ok?: boolean
+}
+
+// The logger records one entry per state transition, correlated by id. Fold them back into one
+// entry per request so callers can reason about how long each took and how it ended.
+export const signerRequests = derived(
+  fromApp($app => $app.use(Logger).messages.$),
+  ($messages: LogMessage[]) => {
+    const requestsById = new Map<string, SignerRequest>()
+
+    for (const message of $messages) {
+      if (message.source !== "signer") continue
+
+      if (message.status === "pending") {
+        requestsById.set(message.id, {
+          id: message.id,
+          method: String(message.method),
+          startedAt: message.at,
+        })
+      } else {
+        const request = requestsById.get(message.id)
+
+        if (request) {
+          request.finishedAt = message.at
+          request.ok = message.status === "success"
+        }
+      }
+    }
+
+    return Array.from(requestsById.values())
+  },
+)
diff --git a/src/app/social.ts b/src/app/social.ts
index bd2a3497..4e980b4b 100644
--- a/src/app/social.ts
+++ b/src/app/social.ts
@@ -1,54 +1,65 @@
 import {derived} from "svelte/store"
-import {displayProfileByPubkey, getProfile, userFollowList, userMuteList} from "@welshman/app"
-import {shuffle, tryCatch} from "@welshman/lib"
+import {shuffle} from "@welshman/lib"
 import {
+  COMMENT,
+  addressTags,
   getAddress,
-  getAddressTagValues,
-  getEventTagValues,
-  getListTags,
-  getParentAddrs,
-  getParentIds,
-  getPubkeyTagValues,
-  getTagValues,
+  hexTags,
+  tagSpec,
+  tagValues,
+  topicTags,
 } from "@welshman/util"
 import type {TrustedEvent} from "@welshman/util"
 import {withGetter} from "@welshman/store"
+import {getCommentTagValues, getReplyTagValues} from "@welshman/domain"
+import {followLists, muteLists, profiles, user} from "@app/core"
 import {DEFAULT_PUBKEYS} from "@app/env"
-export const bootstrapPubkeys = derived(userFollowList, $userFollowList => {
-  const appPubkeys = DEFAULT_PUBKEYS.split(",")
-  const userPubkeys = shuffle(getPubkeyTagValues(getListTags($userFollowList)))
 
-  return userPubkeys.length > 5 ? userPubkeys : [...userPubkeys, ...appPubkeys]
-})
+export const bootstrapPubkeys = derived(
+  [user, followLists.get().index.$],
+  ([$user, $followLists]) => {
+    const appPubkeys = DEFAULT_PUBKEYS.split(",")
+    const userPubkeys = shuffle($followLists.get($user.pubkey)?.pubkeys() ?? [])
+
+    return userPubkeys.length > 5 ? userPubkeys : [...userPubkeys, ...appPubkeys]
+  },
+)
+
+// Ids and addresses of an event's immediate parents, falling back to its thread roots.
+const getParents = ({kind, tags}: TrustedEvent) => {
+  const {roots, replies} = kind === COMMENT ? getCommentTagValues(tags) : getReplyTagValues(tags)
+
+  return replies.length > 0 ? replies : roots
+}
 
 export const isEventMuted = withGetter(
-  derived(userMuteList, $userMuteList => {
-    const pubkey = $userMuteList?.event.pubkey
-    const tags = getListTags($userMuteList)
-    const mutedEvents = new Set(getEventTagValues(tags))
-    const mutedPubkeys = new Set(getPubkeyTagValues(tags))
-    const mutedAddresses = new Set(getAddressTagValues(tags))
-    const mutedTopics = new Set(getTagValues("t", tags))
-    const mutedWords = getTagValues("word", tags)
+  derived([user, muteLists.get().index.$], ([$user, $muteLists]) => {
+    const muteList = $muteLists.get($user.pubkey)
+    const tags = muteList?.tags() ?? []
+    const mutedEvents = new Set(tagValues(hexTags("e"), tags))
+    const mutedPubkeys = new Set(tagValues(hexTags("p"), tags))
+    const mutedAddresses = new Set(tagValues(addressTags("a"), tags))
+    const mutedTopics = new Set(tagValues(topicTags("t"), tags))
+    const mutedWords = tagValues(tagSpec("word"), tags)
     const regex =
       mutedWords.length > 0
         ? new RegExp(`\\b(${mutedWords.map(w => w.toLowerCase().trim()).join("|")})\\b`)
         : undefined
 
     return (e: TrustedEvent) => {
-      if (!pubkey) return false
-      if (pubkey === e.pubkey) return false
+      if (!muteList) return false
+      if ($user.pubkey === e.pubkey) return false
       if (mutedPubkeys.has(e.pubkey)) return true
       if (mutedEvents.has(e.id)) return true
       if (mutedAddresses.has(getAddress(e))) return true
-      if (getParentIds(e).some(id => mutedEvents.has(id))) return true
-      if (getParentAddrs(e).some(address => mutedAddresses.has(address))) return true
-      if (getTagValues("t", e.tags).some(t => mutedTopics.has(t))) return true
+      if (getParents(e).some(v => mutedEvents.has(v) || mutedAddresses.has(v))) return true
+      if (tagValues(topicTags("t"), e.tags).some(t => mutedTopics.has(t))) return true
 
       if (regex) {
-        if (e.content?.toLowerCase().match(regex)) return true
-        if (displayProfileByPubkey(e.pubkey).toLowerCase().match(regex)) return true
-        if (tryCatch(() => getProfile(e.pubkey)?.nip05?.match(regex))) return true
+        const profile = profiles.get().get(e.pubkey)
+
+        if (profile?.display().toLowerCase().match(regex)) return true
+        if (profile?.nip05()?.match(regex)) return true
       }
 
       return false
diff --git a/src/app/storage.ts b/src/app/storage.ts
index 5609097f..c94ec31d 100644
--- a/src/app/storage.ts
+++ b/src/app/storage.ts
@@ -1,5 +1,10 @@
-import {on, throttle, indexBy, fromPairs, batch, call} from "@welshman/lib"
-import {throttled} from "@welshman/store"
+import {writable} from "svelte/store"
+import type {Unsubscriber} from "svelte/store"
+import {deleteDB} from "idb"
+import {SecureStorage} from "@aparajita/capacitor-secure-storage"
+import {Preferences} from "@capacitor/preferences"
+import {noop, on, throttle, batch, call} from "@welshman/lib"
+import type {Maybe} from "@welshman/lib"
 import {
   ALERT_ANDROID,
   ALERT_EMAIL,
@@ -23,33 +28,21 @@ import {
   ROOM_MEMBERS,
   ROOM_ADMINS,
   ROOM_META,
+  ROOM_PINS,
   ROOM_DELETE,
   ROOM_REMOVE_MEMBER,
   ROOMS,
   verifiedSymbol,
 } from "@welshman/util"
-import type {Zapper, TrustedEvent, RelayProfile} from "@welshman/util"
+import type {Handle, TrustedEvent} from "@welshman/util"
+import {withGetter} from "@welshman/store"
 import type {RepositoryUpdate, WrapItem} from "@welshman/net"
-import type {Handle, RelayStats} from "@welshman/app"
-import {
-  tracker,
-  plaintext,
-  repository,
-  relaysByUrl,
-  relayStatsByUrl,
-  onRelayStats,
-  handlesByNip05,
-  zappersByLnurl,
-  onZapper,
-  onHandle,
-  wrapManager,
-  onRelay,
-} from "@welshman/app"
-import type {Unsubscriber} from "svelte/store"
-import {SecureStorage} from "@aparajita/capacitor-secure-storage"
-import {Preferences} from "@capacitor/preferences"
+import {Relay, Zapper} from "@welshman/domain"
+import type {RelayInfo, ZapperValues} from "@welshman/domain"
+import {Handles, Plaintext, Relays, RelayStats, User, Zappers} from "@welshman/app"
+import type {AppPolicy, IApp, RelayStatsItem} from "@welshman/app"
 import {IDB} from "@lib/indexeddb"
-import {ROOM_PINS} from "@app/pins"
+import {appPolicies} from "@app/core"
 
 export const kv = call(() => {
   let p = Promise.resolve()
@@ -119,20 +112,16 @@ export const ss = call(() => {
   return {get, set, clear}
 })
 
-export const db = new IDB({
-  name: "flotilla-9gl",
-  version: 1,
-  stores: [
-    {name: "events", keyPath: "id"},
-    {name: "tracker", keyPath: "id"},
-    {name: "relays", keyPath: "url"},
-    {name: "relayStats", keyPath: "url"},
-    {name: "handles", keyPath: "nip05"},
-    {name: "zappers", keyPath: "lnurl"},
-    {name: "plaintext", keyPath: "key"},
-    {name: "wrapManager", keyPath: "id"},
-  ],
-})
+const TABLES = [
+  {name: "events", keyPath: "id"},
+  {name: "tracker", keyPath: "id"},
+  {name: "relays", keyPath: "url"},
+  {name: "relayStats", keyPath: "url"},
+  {name: "handles", keyPath: "nip05"},
+  {name: "zappers", keyPath: "lnurl"},
+  {name: "plaintext", keyPath: "key"},
+  {name: "wrapManager", keyPath: "id"},
+]
 
 const FLUSH_INTERVAL = 3000
 
@@ -170,255 +159,309 @@ type TrackerItem = {id: string; relays: string[]}
 
 type PlaintextItem = {key: string; value: string}
 
-const loadCriticalEvents = async () => {
-  const table = db.table<TrustedEvent>("events")
-  const initialEvents = await table.getAll()
-  const keep: TrustedEvent[] = []
-  const drop: string[] = []
+/**
+ * Caches an app's repository, tracker and local collections in indexeddb. Everything stored
+ * here belongs to a single identity, so each gets its own database, named for the pubkey the
+ * policy below requires before it builds one.
+ */
+class Storage {
+  ready: Promise<void>
 
-  for (const event of initialEvents) {
-    if (shouldPersistEvent(event)) {
-      event[verifiedSymbol] = true
-      keep.push(event)
+  private db: IDB
+  private unsubscribers: Unsubscriber[] = []
+  private timeouts: ReturnType<typeof setTimeout>[] = []
+  private stopped = false
+
+  constructor(private readonly app: IApp) {
+    // Every identity used to share one database; drop it rather than leave it on disk.
+    void deleteDB("flotilla-9gl")
+
+    this.db = new IDB({name: `flotilla-9gl-${User.require(app).pubkey}`, stores: TABLES})
+    this.ready = this.start()
+  }
+
+  close = () => this.db.close()
+
+  clear = () => this.db.clear()
+
+  cleanup = () => {
+    this.stopped = true
+    this.timeouts.forEach(clearTimeout)
+    this.unsubscribers.forEach(call)
+    this.close()
+  }
+
+  private start = async () => {
+    await this.db.connect()
+
+    const [, unsubscribeRelays] = await Promise.all([this.loadCriticalEvents(), this.initRelays()])
+
+    await this.loadCriticalTracker()
+
+    this.addUnsubscriber(this.syncEvents())
+    this.addUnsubscriber(this.syncTracker())
+    this.addUnsubscriber(unsubscribeRelays)
+
+    const defer = (init: () => Promise<Unsubscriber>) => {
+      this.timeouts.push(
+        setTimeout(async () => {
+          if (!this.stopped) {
+            this.addUnsubscriber(await init())
+          }
+        }, 0),
+      )
+    }
+
+    defer(this.initRelayStats)
+    defer(this.initHandles)
+    defer(this.initZappers)
+    defer(this.initPlaintext)
+    defer(this.initWrapManager)
+  }
+
+  private addUnsubscriber = (unsubscriber: Unsubscriber) => {
+    if (this.stopped) {
+      unsubscriber()
     } else {
-      drop.push(event.id)
+      this.unsubscribers.push(unsubscriber)
     }
   }
 
-  repository.load(keep)
+  private loadCriticalEvents = async () => {
+    const table = this.db.table<TrustedEvent>("events")
+    const initialEvents = await table.getAll()
+    const keep: TrustedEvent[] = []
+    const drop: string[] = []
 
-  if (drop.length > 0) {
-    void table.bulkDelete(drop)
+    for (const event of initialEvents) {
+      if (shouldPersistEvent(event)) {
+        event[verifiedSymbol] = true
+        keep.push(event)
+      } else {
+        drop.push(event.id)
+      }
+    }
+
+    this.app.repository.load(keep)
+
+    if (drop.length > 0) {
+      void table.bulkDelete(drop)
+    }
   }
-}
 
-const syncEvents = () => {
-  const table = db.table<TrustedEvent>("events")
+  private syncEvents = () => {
+    const table = this.db.table<TrustedEvent>("events")
 
-  return on(
-    repository,
-    "update",
-    batch(3000, async (updates: RepositoryUpdate[]) => {
-      const add: TrustedEvent[] = []
-      const remove = new Set<string>()
+    return on(
+      this.app.repository,
+      "update",
+      batch(3000, async (updates: RepositoryUpdate[]) => {
+        const add: TrustedEvent[] = []
+        const remove = new Set<string>()
 
-      for (const update of updates) {
-        for (const event of update.added) {
-          if (shouldPersistEvent(event)) {
-            add.push(event)
-            remove.delete(event.id)
+        for (const update of updates) {
+          for (const event of update.added) {
+            if (shouldPersistEvent(event)) {
+              add.push(event)
+              remove.delete(event.id)
+            }
+          }
+
+          for (const id of update.removed) {
+            remove.add(id)
           }
         }
 
-        for (const id of update.removed) {
-          remove.add(id)
+        if (add.length > 0) {
+          await table.bulkPut(add)
         }
+
+        if (remove.size > 0) {
+          await table.bulkDelete(remove)
+        }
+      }),
+    )
+  }
+
+  private loadCriticalTracker = async () => {
+    const table = this.db.table<TrackerItem>("tracker")
+    const relaysById = new Map<string, Set<string>>()
+    const stale: string[] = []
+
+    for (const {id, relays} of await table.getAll()) {
+      if (this.app.repository.getEvent(id)) {
+        relaysById.set(id, new Set(relays))
+      } else {
+        stale.push(id)
+      }
+    }
+
+    this.app.tracker.load(relaysById)
+
+    if (stale.length > 0) {
+      void table.bulkDelete(stale)
+    }
+  }
+
+  private syncTracker = () => {
+    const table = this.db.table<TrackerItem>("tracker")
+
+    const _onAdd = async (ids: Iterable<string>) => {
+      const items: TrackerItem[] = []
+
+      for (const id of ids) {
+        const event = this.app.repository.getEvent(id)
+
+        if (!event || !shouldPersistEvent(event)) continue
+
+        const relays = Array.from(this.app.tracker.getRelays(id))
+
+        if (relays.length === 0) continue
+
+        items.push({id, relays})
       }
 
-      if (add.length > 0) {
-        await table.bulkPut(add)
+      await table.bulkPut(items)
+    }
+
+    const _onRemove = async (ids: Iterable<string>) => {
+      await table.bulkDelete(Array.from(ids))
+    }
+
+    const onAdd = batch(3000, _onAdd)
+    const onRemove = batch(3000, _onRemove)
+    const onLoad = () => _onAdd(this.app.tracker.relaysById.keys())
+    const onClear = () => _onRemove(this.app.tracker.relaysById.keys())
+
+    this.app.tracker.on("add", onAdd)
+    this.app.tracker.on("remove", onRemove)
+    this.app.tracker.on("load", onLoad)
+    this.app.tracker.on("clear", onClear)
+
+    return () => {
+      this.app.tracker.off("add", onAdd)
+      this.app.tracker.off("remove", onRemove)
+      this.app.tracker.off("load", onLoad)
+      this.app.tracker.off("clear", onClear)
+    }
+  }
+
+  private initRelays = async () => {
+    const table = this.db.table<RelayInfo & {url: string}>("relays")
+
+    for (const row of await table.getAll()) {
+      this.app.use(Relays).set(row.url, new Relay(row.url, row))
+    }
+
+    const enqueue = batch(
+      FLUSH_INTERVAL,
+      idleWrite((relays: Relay[]) => table.bulkPut(relays.map(relay => ({...relay})))),
+    )
+
+    return this.app.use(Relays).onItem((_url, relay) => {
+      if (relay) enqueue(relay)
+    })
+  }
+
+  private initRelayStats = async () => {
+    const table = this.db.table<RelayStatsItem>("relayStats")
+
+    for (const row of await table.getAll()) {
+      this.app.use(RelayStats).set(row.url, row)
+    }
+
+    const enqueue = batch(FLUSH_INTERVAL, idleWrite(table.bulkPut))
+
+    return this.app.use(RelayStats).onItem((_url, stats) => {
+      if (stats) enqueue(stats)
+    })
+  }
+
+  private initHandles = async () => {
+    const table = this.db.table<Handle>("handles")
+
+    for (const row of await table.getAll()) {
+      this.app.use(Handles).set(row.nip05, row)
+    }
+
+    const enqueue = batch(FLUSH_INTERVAL, idleWrite(table.bulkPut))
+
+    return this.app.use(Handles).onItem((_nip05, handle) => {
+      if (handle) enqueue(handle)
+    })
+  }
+
+  private initZappers = async () => {
+    const table = this.db.table<ZapperValues>("zappers")
+
+    for (const row of await table.getAll()) {
+      // Validation is meaningless without these, and rows cached before they were required
+      // won't have them.
+      if (row.pubkey && row.nostrPubkey) {
+        this.app.use(Zappers).set(row.lnurl, new Zapper(row))
       }
-
-      if (remove.size > 0) {
-        await table.bulkDelete(remove)
-      }
-    }),
-  )
-}
-
-const loadCriticalTracker = async () => {
-  const table = db.table<TrackerItem>("tracker")
-  const relaysById = new Map<string, Set<string>>()
-  const stale: string[] = []
-
-  for (const {id, relays} of await table.getAll()) {
-    if (!repository.getEvent(id)) {
-      stale.push(id)
-      continue
     }
 
-    relaysById.set(id, new Set(relays))
+    const enqueue = batch(
+      FLUSH_INTERVAL,
+      idleWrite((zappers: Zapper[]) => table.bulkPut(zappers.map(zapper => ({...zapper})))),
+    )
+
+    return this.app.use(Zappers).onItem((_lnurl, zapper) => {
+      if (zapper) enqueue(zapper)
+    })
   }
 
-  tracker.load(relaysById)
+  private initPlaintext = async () => {
+    const table = this.db.table<PlaintextItem>("plaintext")
 
-  if (stale.length > 0) {
-    void table.bulkDelete(stale)
-  }
-}
-
-const syncTracker = () => {
-  const table = db.table<TrackerItem>("tracker")
-
-  const _onAdd = async (ids: Iterable<string>) => {
-    const items: TrackerItem[] = []
-
-    for (const id of ids) {
-      const event = repository.getEvent(id)
-
-      if (!event || !shouldPersistEvent(event)) continue
-
-      const relays = Array.from(tracker.getRelays(id))
-
-      if (relays.length === 0) continue
-
-      items.push({id, relays})
+    for (const {key, value} of await table.getAll()) {
+      this.app.use(Plaintext).set(key, value)
     }
 
-    await table.bulkPut(items)
+    const enqueue = batch(FLUSH_INTERVAL, idleWrite(table.bulkPut))
+
+    return this.app.use(Plaintext).onItem((key, value) => {
+      if (value) enqueue({key, value})
+    })
   }
 
-  const _onRemove = async (ids: Iterable<string>) => {
-    await table.bulkDelete(Array.from(ids))
-  }
+  private initWrapManager = async () => {
+    const table = this.db.table<WrapItem>("wrapManager")
 
-  const onAdd = batch(3000, _onAdd)
-  const onRemove = batch(3000, _onRemove)
-  const onLoad = () => _onAdd(tracker.relaysById.keys())
-  const onClear = () => _onRemove(tracker.relaysById.keys())
+    this.app.wrapManager.load(await table.getAll())
 
-  tracker.on("add", onAdd)
-  tracker.on("remove", onRemove)
-  tracker.on("load", onLoad)
-  tracker.on("clear", onClear)
+    const addOne = batch(3000, table.bulkPut)
+    const removeOne = throttle(3000, table.bulkDelete)
 
-  return () => {
-    tracker.off("add", onAdd)
-    tracker.off("remove", onRemove)
-    tracker.off("load", onLoad)
-    tracker.off("clear", onClear)
+    this.app.wrapManager.on("add", addOne)
+    this.app.wrapManager.on("remove", removeOne)
+
+    return () => {
+      this.app.wrapManager.off("add", addOne)
+      this.app.wrapManager.off("remove", removeOne)
+    }
   }
 }
 
-const loadCriticalRelays = async () => {
-  const table = db.table<RelayProfile>("relays")
+// The current app's cache, which only exists once there's an identity to cache for.
+export const storage = withGetter(writable<Maybe<Storage>>(undefined))
 
-  relaysByUrl.set(indexBy(r => r.url, await table.getAll()))
-}
+// Storage is scoped to one app's repository, tracker and caches, so it's built and torn down
+// with the app rather than living on as a module-level singleton.
+export const storagePolicy: AppPolicy = $app => {
+  if ($app.user) {
+    const $storage = new Storage($app)
 
-const syncRelays = () =>
-  onRelay(batch(FLUSH_INTERVAL, idleWrite(db.table<RelayProfile>("relays").bulkPut)))
+    storage.set($storage)
 
-const initRelayStats = async () => {
-  const table = db.table<RelayStats>("relayStats")
-
-  relayStatsByUrl.set(indexBy(r => r.url, await table.getAll()))
-
-  return onRelayStats(batch(FLUSH_INTERVAL, idleWrite(table.bulkPut)))
-}
-
-const initHandles = async () => {
-  const table = db.table<Handle>("handles")
-
-  handlesByNip05.set(indexBy(r => r.nip05, await table.getAll()))
-
-  return onHandle(batch(FLUSH_INTERVAL, idleWrite(table.bulkPut)))
-}
-
-const initZappers = async () => {
-  const table = db.table<Zapper>("zappers")
-
-  zappersByLnurl.set(indexBy(z => z.lnurl, await table.getAll()))
-
-  return onZapper(batch(FLUSH_INTERVAL, idleWrite(table.bulkPut)))
-}
-
-const initPlaintext = async () => {
-  const table = db.table<PlaintextItem>("plaintext")
-  const initialRecords = await table.getAll()
-
-  plaintext.set(fromPairs(initialRecords.map(({key, value}) => [key, value])))
-
-  return throttled(3000, plaintext).subscribe($plaintext => {
-    table.bulkPut(Object.entries($plaintext).map(([key, value]) => ({key, value})))
-  })
-}
-
-const initWrapManager = async () => {
-  const table = db.table<WrapItem>("wrapManager")
-
-  wrapManager.load(await table.getAll())
-
-  const addOne = batch(3000, table.bulkPut)
-  const removeOne = throttle(3000, table.bulkDelete)
-
-  wrapManager.on("add", addOne)
-  wrapManager.on("remove", removeOne)
-
-  return () => {
-    wrapManager.off("add", addOne)
-    wrapManager.off("remove", removeOne)
-  }
-}
-
-type StorageSync = {
-  unsubscribe: Unsubscriber
-  ready: Promise<void>
-}
-
-export const sync = (): StorageSync => {
-  const unsubscribers: Unsubscriber[] = []
-  const deferredTimers: ReturnType<typeof setTimeout>[] = []
-  let stopped = false
-
-  const addUnsubscriber = (unsubscriber: Unsubscriber) => {
-    if (stopped) {
-      unsubscriber()
-    } else {
-      unsubscribers.push(unsubscriber)
+    return () => {
+      $storage.cleanup()
+      storage.set(undefined)
     }
   }
 
-  const scheduleDeferred = (task: () => Promise<void>) => {
-    const timeout = setTimeout(() => {
-      if (stopped) return
-
-      void task()
-    }, 0)
-
-    deferredTimers.push(timeout)
-  }
-
-  const ready = call(async () => {
-    await db.connect()
-
-    await Promise.all([loadCriticalEvents(), loadCriticalRelays()])
-    await loadCriticalTracker()
-
-    addUnsubscriber(syncEvents())
-    addUnsubscriber(syncTracker())
-    addUnsubscriber(syncRelays())
-
-    scheduleDeferred(async () => {
-      addUnsubscriber(await initRelayStats())
-    })
-
-    scheduleDeferred(async () => {
-      addUnsubscriber(await initHandles())
-    })
-
-    scheduleDeferred(async () => {
-      addUnsubscriber(await initZappers())
-    })
-
-    scheduleDeferred(async () => {
-      addUnsubscriber(await initPlaintext())
-    })
-
-    scheduleDeferred(async () => {
-      addUnsubscriber(await initWrapManager())
-    })
-  })
-
-  const unsubscribe = () => {
-    stopped = true
-
-    for (const timeout of deferredTimers) {
-      clearTimeout(timeout)
-    }
-
-    unsubscribers.forEach(unsubscriber => unsubscriber())
-  }
-
-  return {unsubscribe, ready}
+  return noop
 }
+
+appPolicies.push(storagePolicy)
diff --git a/src/app/sync.ts b/src/app/sync.ts
index 77f56a0d..334d0572 100644
--- a/src/app/sync.ts
+++ b/src/app/sync.ts
@@ -1,68 +1,78 @@
 import {page} from "$app/stores"
 import type {Unsubscriber} from "svelte/store"
-import {last, call, assoc, WEEK, MONTH, ago} from "@welshman/lib"
-import {merged} from "@welshman/store"
-import {Router} from "@welshman/router"
+import {ago, assoc, call, MONTH, WEEK} from "@welshman/lib"
+import type {Maybe} from "@welshman/lib"
 import {
-  getListTags,
-  getRelayTagValues,
-  WRAP,
-  MUTES,
+  APP_DATA,
   FOLLOWS,
-  ROOM_META,
-  ROOM_DELETE,
-  ROOM_ADMINS,
-  ROOM_MEMBERS,
+  MESSAGE,
+  MUTES,
+  PIN,
+  PINBOARD,
+  POLL_RESPONSE,
+  RELAY_ADD_MEMBER,
+  RELAY_MEMBERS,
+  RELAY_REMOVE_MEMBER,
+  RELAY_ROLE,
   ROOM_ADD_MEMBER,
-  ROOM_REMOVE_MEMBER,
+  ROOM_ADMINS,
+  ROOM_CREATE_PERMISSION,
+  ROOM_DELETE,
   ROOM_JOIN,
   ROOM_LEAVE,
-  ROOM_CREATE_PERMISSION,
-  RELAY_MEMBERS,
-  RELAY_ADD_MEMBER,
-  RELAY_REMOVE_MEMBER,
-  MESSAGE,
-  POLL_RESPONSE,
-  APP_DATA,
-  isSignedEvent,
+  ROOM_MEMBERS,
+  ROOM_META,
+  ROOM_PINS,
+  ROOM_REMOVE_MEMBER,
+  WRAP,
+  outbox,
   unionFilters,
 } from "@welshman/util"
-import type {Filter, List, PublishedList, TrustedEvent} from "@welshman/util"
-import {request, load} from "@welshman/net"
+import type {Filter} from "@welshman/util"
+import type {
+  FollowListReader,
+  MessagingRelayListReader,
+  RelayListReader,
+  RoomListReader,
+} from "@welshman/domain"
+import {merged, synced, withGetter} from "@welshman/store"
 import {
-  pubkey,
-  loadRelay,
-  userRelayList,
-  userMessagingRelayList,
-  loadRelayList,
-  loadMessagingRelayList,
-  loadBlossomServerList,
-  loadBlockedRelayList,
-  loadFollowList,
-  loadMuteList,
-  loadProfile,
-  userFollowList,
-  getFollows,
-  repository,
-  shouldUnwrap,
+  FollowLists,
+  MessagingRelayLists,
+  RelayLists,
+  RoomLists,
+  Sync,
+  makeRoomKey,
 } from "@welshman/app"
+import {
+  app,
+  blockedRelayLists,
+  blossomServerLists,
+  deriveUserItem,
+  followLists,
+  messagingRelayLists,
+  muteLists,
+  network,
+  profiles,
+  relayLists,
+  relays,
+  roomLists,
+  router,
+} from "@app/core"
+import {LIVEKIT_PARTICIPANTS} from "@app/call"
 import {REACTION_KINDS, CONTENT_KINDS, makeCommentFilter} from "@app/content"
 import {INDEXER_RELAYS, PLATFORM_RELAYS} from "@app/env"
-import {loadSettings} from "@app/settings"
-import {
-  loadGroupList,
-  userSpaceUrls,
-  userGroupList,
-  getSpaceUrlsFromGroupList,
-  getSpaceRoomsFromGroupList,
-} from "@app/groups"
-import {decodeRelay} from "@app/relays"
-import {RELAY_ROLE} from "@app/members"
 import {FEATURED_CONTENT_D} from "@app/featured"
-import {BOARD, PIN} from "@app/pinboards"
+import {decodeRelay} from "@app/relays"
+import {Settings} from "@app/settings"
+import {kv} from "@app/storage"
 import {hasBlossomSupport} from "@app/uploads"
-import {LIVEKIT_PARTICIPANTS} from "@app/call"
-import {ROOM_PINS} from "@app/pins"
+
+// Whether to sync gift wraps. Unwrapping itself is unconditional, so this is the only
+// thing keeping a signer from being asked to decrypt the user's entire DM history.
+export const shouldUnwrap = withGetter(
+  synced({key: "shouldUnwrap", storage: kv, defaultValue: false}),
+)
 
 // Utils
 
@@ -70,97 +80,52 @@ type SyncOpts = {
   url: string
   signal: AbortSignal
   filters: Filter[]
-  onEvent?: (event: TrustedEvent) => void
 }
 
-const pullOneWithFallback = async (
-  url: string,
-  filter: Filter,
-  signal: AbortSignal,
-  onEvent?: (event: TrustedEvent) => void,
-) => {
+const pullAndListen = ({url, signal, filters}: SyncOpts) => {
   if (signal.aborted) return
 
-  const cachedEvents = repository.query([filter]).filter(isSignedEvent)
-  const since = last(cachedEvents.slice(10))?.created_at || 0
-
-  if (onEvent) {
-    for (const event of cachedEvents) {
-      onEvent(event)
-    }
-  }
-
-  // Temporarily disable negentropy until the new welshman lands, which fixes
-  // error handling (neg-err with auth-required were never getting retried)
-  const shouldFallback = true
-  // !hasNegentropy(url) ||
-  // (await new Promise(resolve => {
-  //   if (signal.aborted) {
-  //     resolve(false)
-  //     return
-  //   }
-
-  //   // If teardown wins while the diff is opening, skip the fallback path and let cleanup stay in control.
-  //   const diff = new Difference({relay: url, filter, events: cachedEvents, signal})
-
-  //   diff.on(DifferenceEvent.Error, () => {
-  //     resolve(true)
-  //   })
-
-  //   diff.on(DifferenceEvent.Close, () => {
-  //     for (const ids of chunk(100, Array.from(diff.need))) {
-  //       requestOne({relay: url, signal, autoClose: true, filters: [{ids}], onEvent})
-  //     }
-
-  //     resolve(false)
-  //   })
-  // }))
-
-  if (shouldFallback && !signal.aborted) {
-    request({relays: [url], signal, autoClose: true, filters: [{since, ...filter}], onEvent})
-  }
+  app
+    .get()
+    .use(Sync)
+    .pull({relays: [url], filters})
+  network.get().request({
+    relays: [url],
+    signal,
+    filters: unionFilters(filters.map(assoc("limit", 0))),
+  })
 }
 
-export const pullWithFallback = async ({url, signal, filters, onEvent}: SyncOpts) => {
-  await loadRelay(url)
+const userRoomList = deriveUserItem($app => $app.use(RoomLists))
 
-  if (signal.aborted) return
+const userRelayList = deriveUserItem($app => $app.use(RelayLists))
 
-  await Promise.all(filters.map(filter => pullOneWithFallback(url, filter, signal, onEvent)))
-}
+const userFollowList = deriveUserItem($app => $app.use(FollowLists))
 
-const listen = ({url, signal, filters, onEvent}: SyncOpts) => {
-  const relays = [url]
+const userMessagingRelayList = deriveUserItem($app => $app.use(MessagingRelayLists))
 
-  request({relays, signal, filters: unionFilters(filters.map(assoc("limit", 0))), onEvent})
-}
-
-const pullAndListen = (options: SyncOpts) => {
-  if (options.signal.aborted) return
-
-  pullWithFallback(options)
-  listen(options)
-}
+const getSpaceUrls = ($roomList: Maybe<RoomListReader>) =>
+  PLATFORM_RELAYS.length > 0 ? PLATFORM_RELAYS : ($roomList?.urls() ?? [])
 
 // Relays
 
 const syncRelays = () => {
   for (const url of INDEXER_RELAYS) {
-    loadRelay(url)
+    relays.get().load(url)
   }
 
   const unsubscribePage = page.subscribe($page => {
     if ($page.params.relay) {
       const url = decodeRelay($page.params.relay)
 
-      loadRelay(url)
+      relays.get().load(url)
       hasBlossomSupport(url)
     }
   })
 
-  const unsubscribeSpaceUrls = userSpaceUrls.subscribe(urls => {
-    for (const url of urls) {
-      loadRelay(url)
+  const unsubscribeSpaceUrls = userRoomList.subscribe($roomList => {
+    for (const url of $roomList?.urls() ?? []) {
+      relays.get().load(url)
     }
   })
 
@@ -173,7 +138,7 @@ const syncRelays = () => {
 // User data
 
 const syncUserSpaceMembership = (url: string) => {
-  const $pubkey = pubkey.get()
+  const $pubkey = app.get().user?.pubkey
   const controller = new AbortController()
 
   if ($pubkey) {
@@ -192,7 +157,7 @@ const syncUserSpaceMembership = (url: string) => {
 }
 
 const syncUserRoomMembership = (url: string, h: string) => {
-  const $pubkey = pubkey.get()
+  const $pubkey = app.get().user?.pubkey
   const controller = new AbortController()
 
   if ($pubkey) {
@@ -212,21 +177,19 @@ const syncUserRoomMembership = (url: string, h: string) => {
 const syncUserData = () => {
   const unsubscribersByKey = new Map<string, Unsubscriber>()
 
-  const syncGroupList = ($userGroupList: List | undefined) => {
-    if ($userGroupList) {
+  const syncRoomList = ($roomList: Maybe<RoomListReader>) => {
+    if ($roomList) {
       const keys = new Set<string>()
-      const urls =
-        PLATFORM_RELAYS.length > 0 ? PLATFORM_RELAYS : getSpaceUrlsFromGroupList($userGroupList)
 
-      for (const url of urls) {
+      for (const url of getSpaceUrls($roomList)) {
         if (!unsubscribersByKey.has(url)) {
           unsubscribersByKey.set(url, syncUserSpaceMembership(url))
         }
 
         keys.add(url)
 
-        for (const h of getSpaceRoomsFromGroupList(url, $userGroupList)) {
-          const key = `${url}'${h}`
+        for (const h of $roomList.roomsForUrl(url)) {
+          const key = makeRoomKey(url, h)
 
           if (!unsubscribersByKey.has(key)) {
             unsubscribersByKey.set(key, syncUserRoomMembership(url, h))
@@ -245,46 +208,40 @@ const syncUserData = () => {
     }
   }
 
-  const syncRelayList = ($userRelayList: PublishedList | undefined) => {
-    const pubkey = $userRelayList?.event?.pubkey
+  const syncRelayList = ($relayList: Maybe<RelayListReader>) => {
+    const author = $relayList?.author()
 
-    if (pubkey) {
-      loadBlossomServerList(pubkey)
-      loadBlockedRelayList(pubkey)
-      loadFollowList(pubkey)
-      loadGroupList(pubkey)
-      loadMuteList(pubkey)
-      loadProfile(pubkey)
-      loadSettings(pubkey)
+    if (author) {
+      blossomServerLists.get().load(author)
+      blockedRelayLists.get().load(author)
+      followLists.get().load(author)
+      roomLists.get().load(author)
+      muteLists.get().load(author)
+      profiles.get().load(author)
+      app.get().use(Settings).load(author)
     }
   }
 
-  const syncFollowNetwork = ($userFollowList: List | undefined) => {
-    const author = $userFollowList?.event?.pubkey
+  const syncFollowNetwork = async ($followList: Maybe<FollowListReader>) => {
+    const authors = $followList?.pubkeys() ?? []
 
-    if (author) {
-      const authors = getFollows(author)
+    if (authors.length > 0) {
+      const scenario = await router.get().resolve(authors.map(author => outbox(author)))
 
-      load({
+      network.get().load({
         filters: [{kinds: [FOLLOWS, MUTES], authors}],
-        relays: Router.get().FromPubkeys(authors).limit(8).getUrls(),
+        relays: scenario.limit(8).getUrls(),
       })
     }
   }
 
-  const unsubscribeGroupList = merged([userGroupList]).subscribe(([$userGroupList]) => {
-    syncGroupList($userGroupList)
-  })
-
-  const unsubscribeRelayList = merged([userRelayList]).subscribe(([$userRelayList]) => {
-    syncRelayList($userRelayList)
-  })
-
+  const unsubscribeRoomList = userRoomList.subscribe(syncRoomList)
+  const unsubscribeRelayList = userRelayList.subscribe(syncRelayList)
   const unsubscribeFollowList = userFollowList.subscribe(syncFollowNetwork)
 
   return () => {
     unsubscribersByKey.forEach(call)
-    unsubscribeGroupList()
+    unsubscribeRoomList()
     unsubscribeRelayList()
     unsubscribeFollowList()
   }
@@ -317,7 +274,7 @@ const syncSpace = (url: string) => {
           ROOM_MEMBERS,
           ROOM_DELETE,
           LIVEKIT_PARTICIPANTS,
-          BOARD,
+          PINBOARD,
           ROOM_PINS,
         ],
       },
@@ -339,13 +296,10 @@ const syncSpace = (url: string) => {
 }
 
 const syncSpaces = () => {
-  const store = merged([userGroupList, page])
   const unsubscribersByUrl = new Map<string, Unsubscriber>()
 
-  const unsubscribe = store.subscribe(([$userGroupList, $page]) => {
-    const urls = new Set(
-      PLATFORM_RELAYS.length > 0 ? PLATFORM_RELAYS : getSpaceUrlsFromGroupList($userGroupList),
-    )
+  const unsubscribe = merged([userRoomList, page]).subscribe(([$roomList, $page]) => {
+    const urls = new Set(getSpaceUrls($roomList))
     const currentUrl = $page.params.relay ? decodeRelay($page.params.relay) : undefined
 
     if (currentUrl) {
@@ -404,34 +358,6 @@ const syncDMs = () => {
     }
   }
 
-  const syncPubkey = ($pubkey: string | undefined, $shouldUnwrap: boolean) => {
-    if ($pubkey !== currentPubkey) {
-      unsubscribeAll()
-    }
-
-    if ($pubkey && $shouldUnwrap) {
-      loadRelayList($pubkey)
-        .then(() => loadMessagingRelayList($pubkey))
-        .then($l => {
-          if ($l && currentPubkey === $pubkey && currentShouldUnwrap === $shouldUnwrap) {
-            subscribeAll($pubkey, getRelayTagValues(getListTags($l)))
-          }
-        })
-    }
-
-    currentPubkey = $pubkey
-    currentShouldUnwrap = $shouldUnwrap
-  }
-
-  const syncList = ($userMessagingRelayList: List | undefined) => {
-    const $pubkey = pubkey.get()
-    const $shouldUnwrap = shouldUnwrap.get()
-
-    if ($pubkey && $shouldUnwrap) {
-      subscribeAll($pubkey, getRelayTagValues(getListTags($userMessagingRelayList)))
-    }
-  }
-
   const subscribeAll = (pubkey: string, urls: string[]) => {
     // Start syncing newly added relays
     for (const url of urls) {
@@ -449,20 +375,44 @@ const syncDMs = () => {
     }
   }
 
-  const unsubscribePubkey = merged([pubkey, shouldUnwrap]).subscribe(([$pubkey, $shouldUnwrap]) => {
-    syncPubkey($pubkey, $shouldUnwrap)
+  const syncPubkey = ($pubkey: Maybe<string>, $shouldUnwrap: boolean) => {
+    if ($pubkey !== currentPubkey) {
+      unsubscribeAll()
+    }
+
+    if ($pubkey && $shouldUnwrap) {
+      relayLists
+        .get()
+        .load($pubkey)
+        .then(() => messagingRelayLists.get().load($pubkey))
+        .then($list => {
+          if ($list && currentPubkey === $pubkey && currentShouldUnwrap === $shouldUnwrap) {
+            subscribeAll($pubkey, $list.urls())
+          }
+        })
+    }
+
+    currentPubkey = $pubkey
+    currentShouldUnwrap = $shouldUnwrap
+  }
+
+  const syncList = ($list: Maybe<MessagingRelayListReader>) => {
+    const $pubkey = app.get().user?.pubkey
+
+    if ($pubkey && shouldUnwrap.get()) {
+      subscribeAll($pubkey, $list?.urls() ?? [])
+    }
+  }
+
+  const unsubscribeUser = merged([app, shouldUnwrap]).subscribe(([$app, $shouldUnwrap]) => {
+    syncPubkey($app.user?.pubkey, $shouldUnwrap)
   })
 
-  // When user messaging relays change, update synchronization
-  const unsubscribeList = merged([userMessagingRelayList]).subscribe(
-    ([$userMessagingRelayList]) => {
-      syncList($userMessagingRelayList)
-    },
-  )
+  const unsubscribeList = userMessagingRelayList.subscribe(syncList)
 
   return () => {
     unsubscribeAll()
-    unsubscribePubkey()
+    unsubscribeUser()
     unsubscribeList()
   }
 }
diff --git a/src/app/title.ts b/src/app/title.ts
index 4e605200..0af928a4 100644
--- a/src/app/title.ts
+++ b/src/app/title.ts
@@ -1,10 +1,11 @@
 import {append, identity, uniq} from "@welshman/lib"
-import {repository, displayProfileByPubkey} from "@welshman/app"
-import {displayPubkey, getTagValue} from "@welshman/util"
-import {PLATFORM_NAME} from "@app/env"
+import {tagSpec, tagValue} from "@welshman/util"
+import {displayPubkey} from "@welshman/domain"
+import {makeRoomKey} from "@welshman/app"
 import {decodePubkey} from "@lib/util"
+import {app, profiles, rooms} from "@app/core"
+import {PLATFORM_NAME} from "@app/env"
 import {decodeRelay} from "@app/relays"
-import {getRoom, makeRoomId} from "@app/groups"
 import {splitChatId} from "@app/chats"
 
 const FALLBACK_APP_NAME = "Flotilla"
@@ -65,9 +66,9 @@ const getRoomTitle = (params: RouteParams) => {
     return "Room"
   }
 
-  const url = decodeRelay(relay)
+  const room = rooms.get().get(makeRoomKey(decodeRelay(relay), h))
 
-  return getRoom(makeRoomId(url, h))?.name || "Room"
+  return room?.meta?.name() || "Room"
 }
 
 const getEventForTitle = (routeId: string, params: RouteParams) => {
@@ -81,7 +82,7 @@ const getEventForTitle = (routeId: string, params: RouteParams) => {
     return
   }
 
-  return repository.getEvent(eventId)
+  return app.get().repository.getEvent(eventId)
 }
 
 const getChatTitle = (chatId: string | undefined, pubkey: string | undefined) => {
@@ -127,7 +128,7 @@ export const getPageTitle = ({page, pubkey}: PageTitleContext) => {
     const profilePubkey = decodePubkey(page.params.npub!)
 
     if (profilePubkey) {
-      return makeTitle(displayProfileByPubkey(profilePubkey))
+      return makeTitle(profiles.get().display(profilePubkey).get())
     }
   }
 
@@ -138,19 +139,19 @@ export const getPageTitle = ({page, pubkey}: PageTitleContext) => {
   const event = getEventForTitle(routeId, page.params)
 
   if (routeId === "/spaces/[relay]/threads/[id]") {
-    return makeTitle(getTagValue("title", event?.tags || []) || "Thread")
+    return makeTitle(tagValue(tagSpec("title"), event?.tags || []) || "Thread")
   }
 
   if (routeId === "/spaces/[relay]/calendar/[address]") {
-    return makeTitle(getTagValue("title", event?.tags || []) || "Event")
+    return makeTitle(tagValue(tagSpec("title"), event?.tags || []) || "Event")
   }
 
   if (routeId === "/spaces/[relay]/classifieds/[address]") {
-    return makeTitle(getTagValue("title", event?.tags || []) || "Listing")
+    return makeTitle(tagValue(tagSpec("title"), event?.tags || []) || "Listing")
   }
 
   if (routeId === "/spaces/[relay]/goals/[id]") {
-    return makeTitle(event?.content || getTagValue("summary", event?.tags || []) || "Goal")
+    return makeTitle(event?.content || tagValue(tagSpec("summary"), event?.tags || []) || "Goal")
   }
 
   return makeTitle()
diff --git a/src/app/uploads.ts b/src/app/uploads.ts
index fd78d947..0afc1703 100644
--- a/src/app/uploads.ts
+++ b/src/app/uploads.ts
@@ -1,30 +1,20 @@
+import {first, normalizeUrl, parseJson, sha256, simpleCache} from "@welshman/lib"
+import {canUploadBlob, encryptFile, makeBlossomAuthEvent, uploadBlob} from "@welshman/util"
 import {Nip01Signer} from "@welshman/signer"
 import type {UploadTask} from "@welshman/editor"
-import {
-  canUploadBlob,
-  encryptFile,
-  getListTags,
-  getTagValues,
-  makeBlossomAuthEvent,
-  uploadBlob,
-} from "@welshman/util"
-import {getRelay, signer, userBlossomServerList} from "@welshman/app"
-import {first, normalizeUrl, parseJson, sha256, simpleCache} from "@welshman/lib"
-import {get} from "svelte/store"
 import {compressFile} from "@lib/html"
+import {app, blossomServerLists, relays} from "@app/core"
 import {DEFAULT_BLOSSOM_SERVERS} from "@app/env"
 
 export const normalizeBlossomUrl = (url: string) => normalizeUrl(url.replace(/^ws/, "http"))
 
 export const fetchHasBlossomSupport = async (url: string) => {
-  const relay = getRelay(url)
-
-  if (relay?.supported_nips?.map(String).includes("BUD-02")) {
+  if (relays.get().get(url)?.hasNip("BUD-02")) {
     return true
   }
 
   const server = normalizeBlossomUrl(url)
-  const $signer = signer.get() || Nip01Signer.ephemeral()
+  const $signer = app.get().user?.signer || Nip01Signer.ephemeral()
   const headers: Record<string, string> = {
     "X-Content-Type": "text/plain",
     "X-Content-Length": "1",
@@ -58,10 +48,14 @@ export const getBlossomServer = async (options: GetBlossomServerOptions = {}) =>
     }
   }
 
-  const userUrls = getTagValues("server", getListTags(get(userBlossomServerList)))
+  const $pubkey = app.get().user?.pubkey
 
-  for (const url of userUrls) {
-    return normalizeBlossomUrl(url)
+  if ($pubkey) {
+    const userUrl = first(blossomServerLists.get().urls($pubkey).get())
+
+    if (userUrl) {
+      return normalizeBlossomUrl(userUrl)
+    }
   }
 
   return first(DEFAULT_BLOSSOM_SERVERS)!
@@ -111,7 +105,7 @@ export const uploadFile = async (file: File, options: UploadFileOptions = {}) =>
     const ext = "." + type.split("/")[1]
     const server = await getBlossomServer(options)
     const hashes = [await sha256(await file.arrayBuffer())]
-    const $signer = signer.get() || Nip01Signer.ephemeral()
+    const $signer = app.get().user?.signer || Nip01Signer.ephemeral()
     const authTemplate = makeBlossomAuthEvent({action: "upload", server, hashes})
     const authEvent = await $signer.sign(authTemplate)
     const res = await uploadBlob(server, file, {authEvent})
diff --git a/src/lib/currency.ts b/src/lib/currency.ts
index 3add9efa..60581f7a 100644
--- a/src/lib/currency.ts
+++ b/src/lib/currency.ts
@@ -1,3 +1,5 @@
+import {spec} from "@welshman/lib"
+
 export type CurrencyOption = {
   code: string
   name: string
@@ -163,10 +165,10 @@ export const currencyOptions: CurrencyOption[] = [
   {name: "Zambian Kwacha", symbol: "K", code: "ZMW"},
 ]
 
-export const defaultCurrencyOption = currencyOptions.find(c => c.code === "SAT")
+export const defaultCurrencyOption = currencyOptions.find(spec({code: "SAT"}))
 
 export const getCurrencyOption = (code: string): CurrencyOption =>
-  currencyOptions.find(c => c.code === code) || {name: code, symbol: "$", code}
+  currencyOptions.find(spec({code})) || {name: code, symbol: "$", code}
 
 export const displayCurrency = ({code, name}: CurrencyOption) => `${code} (${name})`
 
diff --git a/src/lib/indexeddb.ts b/src/lib/indexeddb.ts
index f3427322..f34034fb 100644
--- a/src/lib/indexeddb.ts
+++ b/src/lib/indexeddb.ts
@@ -9,46 +9,50 @@ export type IDBStore = {
 
 export type IDBOptions = {
   name: string
-  version: number
   stores: IDBStore[]
 }
 
 export class IDB {
-  connection: Maybe<Promise<IDBPDatabase>>
+  connection: Maybe<Promise<Maybe<IDBPDatabase>>>
   failedToConnect = false
 
   constructor(readonly options: IDBOptions) {}
 
+  // Object stores can only be created during a version change, and which stores we need depends
+  // on who is logged in, so open at whatever version exists and bump it to add missing ones.
+  private open = async () => {
+    const {name, stores} = this.options
+    const db = await openDB(name)
+    const missing = stores.filter(store => !db.objectStoreNames.contains(store.name))
+
+    if (missing.length === 0) {
+      return db
+    }
+
+    const version = db.version + 1
+
+    db.close()
+
+    return openDB(name, version, {
+      upgrade(idbDb: IDBPDatabase) {
+        for (const {name, keyPath} of missing) {
+          idbDb.createObjectStore(name, {keyPath})
+        }
+      },
+      blocked() {},
+      blocking() {},
+    })
+  }
+
   async connect() {
     if (!this.failedToConnect && !this.connection) {
-      const {name, version, stores} = this.options
-
-      try {
-        this.connection = openDB(name, version, {
-          upgrade(idbDb: IDBPDatabase) {
-            const names = new Set(stores.map(store => store.name))
-
-            for (const table of idbDb.objectStoreNames) {
-              if (!names.has(table)) {
-                idbDb.deleteObjectStore(table)
-              }
-            }
-
-            for (const {name, keyPath} of stores) {
-              try {
-                idbDb.createObjectStore(name, {keyPath})
-              } catch (e) {
-                console.warn(e)
-              }
-            }
-          },
-          blocked() {},
-          blocking() {},
-        })
-      } catch (e) {
+      this.connection = this.open().catch(e => {
         console.error("Failed to connect to indexeddb", e)
+
         this.failedToConnect = true
-      }
+
+        return undefined
+      })
     }
 
     return this.connection
@@ -104,12 +108,12 @@ export class IDB {
   }
 
   close = () => {
-    this.connection?.then(c => c.close())
+    this.connection?.then(c => c?.close())
     this.connection = undefined
   }
 
   clear = async () => {
-    await this.connection?.then(c => c.close())
+    await this.connection?.then(c => c?.close())
     await deleteDB(this.options.name, {
       blocked() {},
     })
diff --git a/src/lib/livekit.ts b/src/lib/livekit.ts
index 431e282a..12f1f1ad 100644
--- a/src/lib/livekit.ts
+++ b/src/lib/livekit.ts
@@ -4,9 +4,9 @@ const toHttpUrl = (url: string) =>
     .replace(/^ws:\/\//, "http://")
     .replace(/\/$/, "")
 
-const livekitEndpoint = (url: string, groupId?: string) => {
+const livekitEndpoint = (url: string, roomId?: string) => {
   const base = `${toHttpUrl(url)}/.well-known/nip29/livekit`
-  return groupId ? `${base}/${groupId}` : base
+  return roomId ? `${base}/${roomId}` : base
 }
 
 export const checkRelayHasLivekit = async (url: string): Promise<boolean> => {
@@ -20,4 +20,4 @@ export const checkRelayHasLivekit = async (url: string): Promise<boolean> => {
   }
 }
 
-export const getLivekitEndpoint = (url: string, groupId: string) => livekitEndpoint(url, groupId)
+export const getLivekitEndpoint = (url: string, roomId: string) => livekitEndpoint(url, roomId)
diff --git a/src/lib/test/relayMocks.ts b/src/lib/test/relayMocks.ts
index 03b923f0..2d1a1514 100644
--- a/src/lib/test/relayMocks.ts
+++ b/src/lib/test/relayMocks.ts
@@ -1,8 +1,9 @@
 import {on} from "@welshman/lib"
+import type {Maybe} from "@welshman/lib"
 import {isRelayUrl, normalizeRelayUrl} from "@welshman/util"
 import type {TrustedEvent} from "@welshman/util"
-import {AbstractAdapter, AdapterEvent, LocalAdapter, Repository, netContext} from "@welshman/net"
-import type {ClientMessage, NetContext, RelayMessage} from "@welshman/net"
+import {AbstractAdapter, AdapterEvent, LocalAdapter, Repository} from "@welshman/net"
+import type {AdapterFactory, ClientMessage, RelayMessage} from "@welshman/net"
 
 // The window key Playwright writes the mock config to (see e2e/support/relayMocks.ts). Keep it in
 // sync with the literal duplicated there.
@@ -50,10 +51,10 @@ class FixtureAdapter extends AbstractAdapter {
   }
 }
 
-// Override netContext.getAdapter so every real relay url is served from memory and no websocket is
-// ever created for it. Non-relay urls (e.g. the local:// repository relay) fall through to
-// welshman's default handling.
-export const installRelayMocks = (config: RelayMockConfig) => {
+// An adapter factory serving every real relay url from memory, so no websocket is ever created for
+// one. Non-relay urls (e.g. the local:// repository relay) fall through to welshman's default
+// handling by returning undefined.
+export const makeRelayMockAdapter = (config: RelayMockConfig): AdapterFactory => {
   const reposByUrl = new Map<string, Repository>()
 
   for (const [url, events] of Object.entries(config.relays ?? {})) {
@@ -63,29 +64,20 @@ export const installRelayMocks = (config: RelayMockConfig) => {
   }
 
   const emptyRepository = new Repository()
-  const fallback = netContext.getAdapter
 
-  netContext.getAdapter = ((url: string, context: NetContext) => {
-    if (!isRelayUrl(url)) {
-      return fallback ? fallback(url, context) : undefined
+  return (url: string) => {
+    if (isRelayUrl(url)) {
+      return new FixtureAdapter(url, reposByUrl.get(normalizeRelayUrl(url)) ?? emptyRepository)
     }
-
-    const repository = reposByUrl.get(normalizeRelayUrl(url)) ?? emptyRepository
-
-    return new FixtureAdapter(url, repository)
-  }) as NetContext["getAdapter"]
+  }
 }
 
-// Called once on app startup. Installs the mocks only when Playwright has injected a config, so it
-// is a no-op for real users.
-export const maybeInstallRelayMocks = () => {
-  const config = (globalThis as Record<string, unknown>)[RELAY_MOCKS_KEY] as
-    | RelayMockConfig
-    | undefined
+// Called when the app is created. Yields an adapter factory only when Playwright has injected a
+// config, so it is a no-op for real users.
+export const maybeMakeRelayMockAdapter = (): Maybe<AdapterFactory> => {
+  const config = (globalThis as {[RELAY_MOCKS_KEY]?: RelayMockConfig})[RELAY_MOCKS_KEY]
 
   if (config) {
-    installRelayMocks(config)
+    return makeRelayMockAdapter(config)
   }
-
-  return Boolean(config)
 }
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
index 7ad2ada0..cc9f4249 100644
--- a/src/routes/+layout.svelte
+++ b/src/routes/+layout.svelte
@@ -9,131 +9,48 @@
   import {dev} from "$app/environment"
   import {goto} from "$app/navigation"
   import {page} from "$app/stores"
-  import {sync, throttled} from "@welshman/store"
-  import {always, call} from "@welshman/lib"
-  import {defaultSocketPolicies, netContext, Pool} from "@welshman/net"
-  import {appContext, pubkey, sessions, signerLog, shouldUnwrap} from "@welshman/app"
-  import {routerContext} from "@welshman/router"
-  import {verifyEvent} from "@welshman/util"
-  import type {TrustedEvent} from "@welshman/util"
   import {context as pomadeContext} from "@pomade/core"
-  import * as lib from "@welshman/lib"
+  import {sync, throttled} from "@welshman/store"
+  import * as domain from "@welshman/domain"
   import * as util from "@welshman/util"
-  import * as feeds from "@welshman/feeds"
-  import * as router from "@welshman/router"
-  import * as store from "@welshman/store"
-  import * as welshmanSigner from "@welshman/signer"
-  import * as net from "@welshman/net"
-  import * as app from "@welshman/app"
+  import * as lib from "@welshman/lib"
+  import {Logger} from "@welshman/app"
   import {isMobile} from "@lib/html"
-  import * as implicit from "@lib/implicit"
-  import {maybeInstallRelayMocks} from "@lib/test/relayMocks"
   import AppContainer from "@app/components/AppContainer.svelte"
   import ModalContainer from "@app/components/ModalContainer.svelte"
+  import {app} from "@app/core"
   import {setupHistory} from "@app/routes"
   import {setupAnalytics} from "@app/analytics"
-  import {authPolicy, blockPolicy, trustPolicy, mostlyRestrictedPolicy} from "@app/policies"
-  import {db, kv, ss} from "@app/storage"
+  import "@app/policies"
+  import {restoreSession} from "@app/session"
+  import {signerRequests} from "@app/signer"
+  import {wallet} from "@app/lightning"
+  import {kv, ss, storage} from "@app/storage"
   import {device} from "@app/device"
-  import {getSetting, userSettings, notificationSettings} from "@app/settings"
-  import {DUFFLEPUD_URL, DEFAULT_RELAYS, INDEXER_RELAYS, POMADE_SIGNERS} from "@app/env"
-  import {pushState} from "@app/push/adapters/common"
-  import {syncApplicationData} from "@app/sync"
-  import * as groups from "@app/groups"
-  import * as comments from "@app/comments"
-  import * as deletes from "@app/deletes"
-  import * as reactions from "@app/reactions"
-  import * as profiles from "@app/profiles"
-  import * as lightning from "@app/lightning"
-  import * as uploads from "@app/uploads"
-  import * as appPolls from "@app/polls"
-  import * as pinboards from "@app/pinboards"
-  import * as reports from "@app/reports"
-  import * as relays from "@app/relays"
-  import * as settings from "@app/settings"
-  import * as members from "@app/members"
-  import * as chats from "@app/chats"
-  import * as content from "@app/content"
+  import {userSettingsValues, notificationSettings} from "@app/settings"
+  import {shouldUnwrap, syncApplicationData} from "@app/sync"
   import * as env from "@app/env"
-  import * as repository from "@app/repository"
-  import * as social from "@app/social"
-  import * as appDevice from "@app/device"
-  import * as actionItems from "@app/actionItems"
-  import * as appFeeds from "@app/feeds"
-  import * as access from "@app/access"
-  import * as healthChecks from "@app/healthChecks"
   import {theme} from "@app/theme"
   import {toast, pushToast} from "@app/toast"
   import * as notifications from "@app/notifications"
   import {Push} from "@app/push"
-  import {onPushNotificationAction} from "@app/push/adapters/common"
-  import * as storage from "@app/storage"
+  import {onPushNotificationAction, pushState} from "@app/push/adapters/common"
   import {syncKeyboard} from "@app/keyboard"
   import {getPageTitle} from "@app/title"
   import NewNotificationSound from "@src/app/components/NewNotificationSound.svelte"
 
   const {children} = $props()
 
-  // Test-only: when Playwright has injected window.__RELAY_MOCKS__, serve relays from in-memory
-  // fixtures instead of the network. No-op for real users; stripped from production builds.
-  if (import.meta.env.DEV) {
-    maybeInstallRelayMocks()
-  }
-
   // Do this asap to avoid a font size flash
   // @ts-ignore
   document.documentElement.style["font-size"] = `${localStorage.getItem("font-size") || 1.1}rem`
 
-  const policies = [authPolicy, blockPolicy, trustPolicy, mostlyRestrictedPolicy]
-
   // Add stuff to window for convenience
-  Object.assign(window, {
-    get,
-    nip19,
-    theme,
-    ...lib,
-    ...implicit,
-    ...welshmanSigner,
-    ...router,
-    ...store,
-    ...util,
-    ...feeds,
-    ...net,
-    ...app,
-    ...groups,
-    ...relays,
-    ...settings,
-    ...members,
-    ...chats,
-    ...content,
-    ...env,
-    ...repository,
-    ...social,
-    ...appDevice,
-    ...actionItems,
-    ...appFeeds,
-    ...access,
-    ...healthChecks,
-    ...comments,
-    ...deletes,
-    ...reactions,
-    ...profiles,
-    ...lightning,
-    ...uploads,
-    ...appPolls,
-    ...pinboards,
-    ...reports,
-    ...notifications,
-  })
+  Object.assign(window, {get, nip19, theme, app, domain, Logger, ...lib, ...util})
 
   // Set up context for various modules
-  pomadeContext.setSignerUrls(POMADE_SIGNERS)
+  pomadeContext.setSignerUrls(env.POMADE_SIGNERS)
   pomadeContext.setArgonWorker(import("@pomade/core/argon-worker.js?worker"))
-  appContext.dufflepudUrl = DUFFLEPUD_URL
-  routerContext.getIndexerRelays = always(INDEXER_RELAYS)
-  routerContext.getDefaultRelays = always(DEFAULT_RELAYS)
-  netContext.isEventValid = (event: TrustedEvent, url: string) =>
-    getSetting<string[]>("trusted_relays").includes(url) || verifyEvent(event)
 
   // Handle a deep link (universal/app link or custom scheme). Used for both
   // warm-start links (via the appUrlOpen event) and cold-start links (via
@@ -182,12 +99,17 @@
     }
   })
 
-  // Cleanup on page close
-  window.addEventListener("beforeunload", () => db.close())
+  const closeStorage = () => storage.get()?.close()
 
-  const unsubscribe = call(async () => {
+  // Cleanup on page close
+  window.addEventListener("beforeunload", closeStorage)
+
+  const unsubscribe = lib.call(async () => {
     const unsubscribers: Unsubscriber[] = []
 
+    // Attach the user before anything reads or decrypts on their behalf
+    unsubscribers.push(await restoreSession())
+
     // Sync stuff to storage
     await Promise.all([
       sync({
@@ -195,21 +117,16 @@
         store: device,
         storage: kv,
       }),
-      sync({
-        key: "pubkey",
-        store: pubkey,
-        storage: kv,
-      }),
-      sync({
-        key: "sessions",
-        store: sessions,
-        storage: ss,
-      }),
       sync({
         key: "shouldUnwrap",
         store: shouldUnwrap,
         storage: kv,
       }),
+      sync({
+        key: "wallet",
+        store: wallet,
+        storage: ss,
+      }),
       sync({
         key: "notificationSettings",
         store: notificationSettings,
@@ -222,12 +139,8 @@
       }),
     ])
 
-    const storageSync = storage.sync()
-
-    unsubscribers.push(storageSync.unsubscribe)
-
     // Wait for critical storage data only
-    await storageSync.ready
+    await storage.get()?.ready
 
     // Handle cold-start deep links. When a link launches the app from a killed
     // state the intent arrives via onCreate, so Capacitor never emits
@@ -241,13 +154,7 @@
     }
 
     // Close the database connection on reload
-    unsubscribers.push(() => db.close())
-
-    // Add our extra policies now that we're set up
-    defaultSocketPolicies.push(...policies)
-
-    // Remove policies when we're done
-    unsubscribers.push(() => defaultSocketPolicies.splice(-policies.length))
+    unsubscribers.push(closeStorage)
 
     // History, navigation, application data
     unsubscribers.push(setupHistory(), setupAnalytics(), syncApplicationData())
@@ -267,14 +174,14 @@
     // Initialize background notifications
     unsubscribers.push(Push.sync())
 
-    // When the user logs in, drop connections opened anonymously and sync again
-    let lastPubkey = pubkey.get()
+    // Logging in swaps in a fresh app — its policies rebind themselves, we just have to sync
+    // application data against the new identity's relays.
+    let currentApp = app.get()
 
     unsubscribers.push(
-      pubkey.subscribe($pubkey => {
-        if ($pubkey !== lastPubkey) {
-          lastPubkey = $pubkey
-          Pool.get().clear()
+      app.subscribe($app => {
+        if ($app !== currentApp) {
+          currentApp = $app
           syncApplicationData()
         }
       }),
@@ -282,15 +189,15 @@
 
     // Listen for signer errors, report to user via toast
     unsubscribers.push(
-      throttled(10_000, signerLog).subscribe($log => {
+      throttled(10_000, signerRequests).subscribe($requests => {
         if ($toast) return
 
         const longCutoff = Date.now() - 30_000
         const shortCutoff = Date.now() - 10_000
-        const pending = $log.filter(x => !x.finished_at && x.started_at < longCutoff)
-        const completed = $log.filter(x => x.finished_at && x.finished_at > shortCutoff)
+        const pending = $requests.filter(r => !r.finishedAt && r.startedAt < longCutoff)
+        const completed = $requests.filter(r => r.finishedAt && r.finishedAt > shortCutoff)
         const showPendingError = pending.length > 10
-        const showCompletedError = completed.length > 5 && completed.filter(x => x.ok).length === 0
+        const showCompletedError = completed.length > 5 && completed.filter(r => r.ok).length === 0
 
         if (showPendingError || showCompletedError) {
           pushToast({
@@ -312,29 +219,27 @@
         document.body.setAttribute("data-theme", $theme)
         document.body.setAttribute("data-fl-theme", env.FL_THEME)
       }),
-      userSettings.subscribe(
-        debounce(100, $userSettings => {
-          if ($userSettings) {
-            localStorage.setItem("font-size", $userSettings.values.font_size)
+      userSettingsValues.subscribe(
+        debounce(100, $settings => {
+          localStorage.setItem("font-size", String($settings.font_size))
 
-            // @ts-ignore
-            document.documentElement.style["font-size"] = `${$userSettings.values.font_size}rem`
-          }
+          // @ts-ignore
+          document.documentElement.style["font-size"] = `${$settings.font_size}rem`
         }),
       ),
     )
 
-    return () => unsubscribers.forEach(call)
+    return () => unsubscribers.forEach(lib.call)
   })
 
   // Cleanup on hot reload
   import.meta.hot?.dispose(() => {
     App.removeAllListeners()
-    unsubscribe.then(call)
+    unsubscribe.then(lib.call)
   })
 
   $effect(() => {
-    document.title = getPageTitle({page: $page, pubkey: $pubkey})
+    document.title = getPageTitle({page: $page, pubkey: $app.user?.pubkey})
   })
 </script>
 
diff --git a/src/routes/chat/+layout.svelte b/src/routes/chat/+layout.svelte
index 8660201e..00da7ee4 100644
--- a/src/routes/chat/+layout.svelte
+++ b/src/routes/chat/+layout.svelte
@@ -3,7 +3,6 @@
   import {onMount} from "svelte"
   import {page} from "$app/stores"
   import {sleep} from "@welshman/lib"
-  import {shouldUnwrap} from "@welshman/app"
   import MenuDots from "@assets/icons/menu-dots.svg?dataurl"
   import ChatSquarePlus from "@assets/icons/chat-square-plus.svg?dataurl"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
@@ -20,6 +19,7 @@
   import ChatItem from "@app/components/ChatItem.svelte"
   import {chatSearch} from "@app/chats"
   import {pushModal} from "@app/modal"
+  import {shouldUnwrap} from "@app/sync"
 
   type Props = {
     children?: Snippet
diff --git a/src/routes/chat/[chat]/+page.svelte b/src/routes/chat/[chat]/+page.svelte
index cc0d51e2..37c02b5e 100644
--- a/src/routes/chat/[chat]/+page.svelte
+++ b/src/routes/chat/[chat]/+page.svelte
@@ -14,15 +14,15 @@
   import {page} from "$app/stores"
   import type {MakeNonOptional} from "@welshman/lib"
   import {append, uniq} from "@welshman/lib"
-  import {pubkey} from "@welshman/app"
   import Chat from "@app/components/Chat.svelte"
   import {splitChatId} from "@app/chats"
   import {notificationSettings} from "@app/settings"
   import {pushToast} from "@app/toast"
   import {Push} from "@app/push"
+  import {user} from "@app/core"
 
   const {chat} = $page.params as MakeNonOptional<typeof $page.params>
-  const pubkeys = uniq(append($pubkey!, splitChatId(chat)))
+  const pubkeys = uniq(append($user.pubkey, splitChatId(chat)))
 
   onMount(async () => {
     if (!$dmNotificationsPrompted) {
diff --git a/src/routes/people/+page.svelte b/src/routes/people/+page.svelte
index 4e8aef10..b3b55f60 100644
--- a/src/routes/people/+page.svelte
+++ b/src/routes/people/+page.svelte
@@ -1,14 +1,16 @@
 <script lang="ts">
   import {onMount} from "svelte"
   import {createScroller, isMobile} from "@lib/html"
-  import {profileSearch} from "@welshman/app"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Page from "@lib/components/Page.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
   import ContentSearch from "@lib/components/ContentSearch.svelte"
+  import {profiles} from "@app/core"
   import PeopleItem from "@app/components/PeopleItem.svelte"
 
+  const search = $profiles.profileSearch
+
   let term = $state("")
   let limit = $state(10)
   let element: Element | undefined = $state()
@@ -42,7 +44,7 @@
       {/snippet}
       {#snippet content()}
         <div class="flex flex-col gap-2 h-full" bind:this={element}>
-          {#each $profileSearch.searchValues(term).slice(0, limit) as pubkey (pubkey)}
+          {#each $search.searchValues(term).slice(0, limit) as pubkey (pubkey)}
             <PeopleItem {pubkey} />
           {/each}
         </div>
diff --git a/src/routes/people/[npub]/+page.svelte b/src/routes/people/[npub]/+page.svelte
index ed5bb6d1..0349ee65 100644
--- a/src/routes/people/[npub]/+page.svelte
+++ b/src/routes/people/[npub]/+page.svelte
@@ -1,27 +1,28 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {get} from "svelte/store"
   import {page} from "$app/stores"
   import {goto} from "$app/navigation"
   import type {MakeNonOptional} from "@welshman/lib"
   import type {Filter} from "@welshman/util"
   import {ROOMS, NOTE, FOLLOWS} from "@welshman/util"
-  import {
-    loadProfile,
-    loadRelayList,
-    loadFollowList,
-    loadMessagingRelayList,
-    loadPinList,
-    pubkey as sessionPubkey,
-  } from "@welshman/app"
-  import {load} from "@welshman/net"
-  import {Router} from "@welshman/router"
+  import {outbox} from "@welshman/util"
+  import {PinLists} from "@welshman/app"
   import {decodePubkey} from "@lib/util"
   import Page from "@lib/components/Page.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
   import ProfilePage from "@app/components/ProfilePage.svelte"
-  import {loadGroupList} from "@app/groups"
   import {pushToast} from "@app/toast"
+  import {
+    app,
+    followLists,
+    messagingRelayLists,
+    network,
+    profiles,
+    relayLists,
+    roomLists,
+    router,
+    user,
+  } from "@app/core"
 
   const {npub} = $page.params as MakeNonOptional<typeof $page.params>
 
@@ -33,17 +34,17 @@
     }
 
     try {
-      await loadProfile(pubkey)
-      await loadRelayList(pubkey)
+      await $profiles.load(pubkey)
+      await $relayLists.load(pubkey)
 
-      const viewer = get(sessionPubkey)
+      const viewer = user.get().pubkey
 
       await Promise.all([
-        loadFollowList(pubkey),
-        loadPinList(pubkey),
-        loadGroupList(pubkey),
-        loadMessagingRelayList(pubkey),
-        viewer && viewer !== pubkey ? loadFollowList(viewer) : undefined,
+        $followLists.load(pubkey),
+        $app.use(PinLists).load(pubkey),
+        $roomLists.load(pubkey),
+        $messagingRelayLists.load(pubkey),
+        viewer && viewer !== pubkey ? $followLists.load(viewer) : undefined,
       ])
 
       const filters: Filter[] = [
@@ -51,12 +52,12 @@
         {authors: [pubkey], kinds: [NOTE], limit: 1},
       ]
 
-      if (get(sessionPubkey) === pubkey) {
+      if (viewer === pubkey) {
         filters.push({kinds: [FOLLOWS], "#p": [pubkey], limit: 500})
       }
 
-      load({
-        relays: Router.get().FromPubkeys([pubkey]).getUrls(),
+      $network.load({
+        relays: await $router.resolver.relays([outbox(pubkey)]),
         filters,
       })
     } catch (e) {
diff --git a/src/routes/settings/about/+page.svelte b/src/routes/settings/about/+page.svelte
index 8664ef19..5e2dd294 100644
--- a/src/routes/settings/about/+page.svelte
+++ b/src/routes/settings/about/+page.svelte
@@ -1,20 +1,20 @@
 <script lang="ts">
-  import {session} from "@welshman/app"
   import {Capacitor} from "@capacitor/core"
   import Link from "@lib/components/Link.svelte"
   import Button from "@lib/components/Button.svelte"
-  import Zap from "@app/components/Zap.svelte"
-  import ZapInvoice from "@app/components/ZapInvoice.svelte"
   import Icon from "@lib/components/Icon.svelte"
   import Card from "@lib/components/Card.svelte"
-  import ProfileDetail from "@app/components/ProfileDetail.svelte"
-  import {PLATFORM_NAME} from "@app/env"
-  import {pushModal} from "@app/modal"
-  import {makeSpacePath} from "@app/routes"
   import Code from "@assets/icons/code-2.svg?dataurl"
   import Global from "@assets/icons/global.svg?dataurl"
   import Pen from "@assets/icons/pen.svg?dataurl"
   import HeadphonesRound from "@assets/icons/headphones-round.svg?dataurl"
+  import Zap from "@app/components/Zap.svelte"
+  import ZapInvoice from "@app/components/ZapInvoice.svelte"
+  import ProfileDetail from "@app/components/ProfileDetail.svelte"
+  import {PLATFORM_NAME} from "@app/env"
+  import {wallet} from "@app/lightning"
+  import {pushModal} from "@app/modal"
+  import {makeSpacePath} from "@app/routes"
 
   const hash = import.meta.env.VITE_BUILD_HASH
 
@@ -22,7 +22,7 @@
 
   const openProfile = () => pushModal(ProfileDetail, {pubkey})
 
-  const zap = () => pushModal($session?.wallet ? Zap : ZapInvoice, {pubkey})
+  const zap = () => pushModal($wallet ? Zap : ZapInvoice, {pubkey})
 </script>
 
 <div class="flex flex-col gap-6 p-8 max-w-2xl h-screen justify-center m-auto">
diff --git a/src/routes/settings/content/+page.svelte b/src/routes/settings/content/+page.svelte
index dbaeb72d..e8d01c0a 100644
--- a/src/routes/settings/content/+page.svelte
+++ b/src/routes/settings/content/+page.svelte
@@ -1,15 +1,5 @@
 <script lang="ts">
-  import {
-    getListTags,
-    tagger,
-    makeEvent,
-    getPubkeyTagValues,
-    getTagValues,
-    MUTES,
-    BLOSSOM_SERVERS,
-  } from "@welshman/util"
-  import {Router} from "@welshman/router"
-  import {userMuteList, tagPubkey, publishThunk, userBlossomServerList} from "@welshman/app"
+  import {publish} from "@welshman/app"
   import NotesMinimalistic from "@assets/icons/notes-minimalistic.svg?dataurl"
   import AddCircle from "@assets/icons/add-circle.svg?dataurl"
   import {preventDefault} from "@lib/html"
@@ -22,14 +12,18 @@
   import Button from "@lib/components/Button.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
   import ProfileMultiSelect from "@app/components/ProfileMultiSelect.svelte"
+  import {blossomServerLists, deriveUserItem, muteLists} from "@app/core"
   import {pushToast} from "@app/toast"
   import {PLATFORM_NAME} from "@app/env"
   import {userSettingsValues, publishSettings} from "@app/settings"
 
+  const userMuteList = deriveUserItem($app => $muteLists)
+  const userBlossomServerList = deriveUserItem($app => $blossomServerLists)
+
   const reset = () => {
     settings = {...$userSettingsValues}
-    mutedPubkeys = getPubkeyTagValues(getListTags($userMuteList))
-    blossomServers = getTagValues("server", getListTags($userBlossomServerList))
+    mutedPubkeys = $userMuteList?.pubkeys() ?? []
+    blossomServers = $userBlossomServerList?.urls() ?? []
   }
 
   const addServer = () => {
@@ -39,22 +33,16 @@
   const onsubmit = preventDefault(async () => {
     await publishSettings($state.snapshot(settings))
 
-    publishThunk({
-      event: makeEvent(MUTES, {tags: mutedPubkeys.map(tagPubkey)}),
-      relays: Router.get().FromUser().getUrls(),
-    })
+    await $muteLists.setMutes({publicTags: mutedPubkeys.map(pubkey => ["p", pubkey])}).then(publish)
 
-    publishThunk({
-      event: makeEvent(BLOSSOM_SERVERS, {tags: blossomServers.map(tagger("server"))}),
-      relays: Router.get().FromUser().getUrls(),
-    })
+    await $blossomServerLists.setUrls($state.snapshot(blossomServers)).then(publish)
 
     pushToast({message: "Your settings have been saved!"})
   })
 
   let settings = $state({...$userSettingsValues})
-  let mutedPubkeys = $state(getPubkeyTagValues(getListTags($userMuteList)))
-  let blossomServers = $state(getTagValues("server", getListTags($userBlossomServerList)))
+  let mutedPubkeys = $state($userMuteList?.pubkeys() ?? [])
+  let blossomServers = $state($userBlossomServerList?.urls() ?? [])
 </script>
 
 <form {onsubmit}>
diff --git a/src/routes/settings/hosting/+page.svelte b/src/routes/settings/hosting/+page.svelte
index 82cb2102..29d34450 100644
--- a/src/routes/settings/hosting/+page.svelte
+++ b/src/routes/settings/hosting/+page.svelte
@@ -1,9 +1,8 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import type {Maybe} from "@welshman/lib"
-  import {indexBy} from "@welshman/lib"
-  import {pubkey} from "@welshman/app"
   import {App} from "@capacitor/app"
+  import type {Maybe} from "@welshman/lib"
+  import {indexBy, spec} from "@welshman/lib"
   import Add from "@assets/icons/add.svg?dataurl"
   import Server from "@assets/icons/server.svg?dataurl"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
@@ -23,6 +22,7 @@
   import InvoiceListItem from "@app/components/hosting/InvoiceListItem.svelte"
   import PaymentDialog from "@app/components/hosting/PaymentDialog.svelte"
   import PaymentSetup from "@app/components/hosting/PaymentSetup.svelte"
+  import {user} from "@app/core"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
   import {
@@ -35,8 +35,8 @@
     derivePlans,
     reconcileTenant,
     selectPayableInvoice,
+    type HostedRelay,
     type Invoice,
-    type Relay,
     type Tenant,
   } from "@app/hosting"
 
@@ -48,7 +48,7 @@
 
   let tenant = $state<Maybe<Tenant>>()
   let invoices = $state<Invoice[]>([])
-  let relays = $state<Relay[]>([])
+  let relays = $state<HostedRelay[]>([])
   let draftInvoice = $state<Maybe<Invoice>>()
   let loading = $state(true)
   let error = $state("")
@@ -94,7 +94,7 @@
   )
 
   const refetch = async () => {
-    const pk = pubkey.get()
+    const pk = user.get().pubkey
     if (!pk) return
 
     const results = await Promise.allSettled([
@@ -111,7 +111,7 @@
     if (rel.status === "fulfilled") relays = rel.value
     if (draft.status === "fulfilled") draftInvoice = draft.value
 
-    if (results.some(r => r.status === "rejected")) {
+    if (results.some(spec({status: "rejected"}))) {
       pushToast({theme: "error", message: "Failed to refresh billing data"})
     }
   }
@@ -126,7 +126,7 @@
   // to settle a completed checkout and pick up a portal-added card. Charging open
   // invoices is left to the backend's dunning poll, which collects all of them.
   const reconcile = async () => {
-    const pk = pubkey.get()
+    const pk = user.get().pubkey
     if (!pk || reconciling) return
 
     reconciling = true
diff --git a/src/routes/settings/profile/+page.svelte b/src/routes/settings/profile/+page.svelte
index 62b4133f..946ab078 100644
--- a/src/routes/settings/profile/+page.svelte
+++ b/src/routes/settings/profile/+page.svelte
@@ -2,8 +2,8 @@
   import * as nip19 from "nostr-tools/nip19"
   import {Client} from "@pomade/core"
   import {hexToBytes} from "@welshman/lib"
-  import {displayPubkey, displayProfile} from "@welshman/util"
-  import {pubkey, session, SessionMethod, displayNip05, deriveProfile} from "@welshman/app"
+  import {displayNip05} from "@welshman/util"
+  import {displayPubkey} from "@welshman/domain"
   import {slideAndFade} from "@lib/transition"
   import PenNewSquare from "@assets/icons/pen-new-square.svg?dataurl"
   import UserRounded from "@assets/icons/user-rounded.svg?dataurl"
@@ -21,7 +21,7 @@
   import PageContent from "@lib/components/PageContent.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
-  import ContentMinimal from "@app/components/ContentMinimal.svelte"
+  import ProfileAbout from "@app/components/ProfileAbout.svelte"
   import ProfileEdit from "@app/components/ProfileEdit.svelte"
   import ProfileDelete from "@app/components/ProfileDelete.svelte"
   import SignerStatus from "@app/components/SignerStatus.svelte"
@@ -30,14 +30,20 @@
   import {pushModal} from "@app/modal"
   import {POMADE_NETWORK_ERROR_MESSAGE} from "@app/pomade"
   import {clip, pushToast} from "@app/toast"
+  import {profiles, session, user} from "@app/core"
+  import {isPomadeSession, requirePomadeSession} from "@app/pomade"
 
-  const npub = nip19.npubEncode($pubkey!)
-  const profile = deriveProfile($pubkey!)
-  const pubkeyDisplay = displayPubkey($pubkey!)
+  const npub = nip19.npubEncode($user.pubkey)
+  const profile = $profiles.one($user.pubkey)
+  const pomadeEmail = $derived(isPomadeSession($session) ? $session.data.email : undefined)
+  const nip01Secret = $derived(
+    $session?.method === "nip01" ? (($session.data as {secret: string}).secret ?? "") : undefined,
+  )
+  const pubkeyDisplay = displayPubkey($user.pubkey)
 
   const copyNpub = () => clip(npub)
 
-  const copyNsec = () => clip(nip19.nsecEncode(hexToBytes($session!.secret!)))
+  const copyNsec = () => clip(nip19.nsecEncode(hexToBytes(nip01Secret!)))
 
   const startEdit = () => pushModal(ProfileEdit)
 
@@ -47,7 +53,9 @@
     loading = true
 
     try {
-      const {ok, peersByPrefix} = await Client.requestChallenge($session!.email)
+      const {ok, peersByPrefix} = await Client.requestChallenge(
+        requirePomadeSession($session).data.email,
+      )
 
       if (!ok) {
         console.error("Pomade challenge request failed during password reset initiation")
@@ -84,16 +92,16 @@
     <div class="flex justify-between gap-2">
       <div class="flex max-w-full gap-3">
         <div class="py-1">
-          <ProfileCircle pubkey={$pubkey!} size={10} />
+          <ProfileCircle pubkey={$user.pubkey} size={10} />
         </div>
         <div class="flex min-w-0 flex-col">
           <div class="flex items-center gap-2">
             <div class="text-bold overflow-hidden text-ellipsis">
-              {displayProfile($profile, pubkeyDisplay)}
+              {$profile?.display(pubkeyDisplay) ?? pubkeyDisplay}
             </div>
           </div>
           <div class="overflow-hidden text-ellipsis text-sm opacity-75">
-            {$profile?.nip05 ? displayNip05($profile.nip05) : pubkeyDisplay}
+            {$profile?.nip05() ? displayNip05($profile.nip05()!) : pubkeyDisplay}
           </div>
         </div>
       </div>
@@ -103,12 +111,10 @@
         <Icon icon={PenNewSquare} />
       </Button>
     </div>
-    {#key $profile?.about}
-      <ContentMinimal event={{content: $profile?.about || "", tags: []}} />
-    {/key}
+    <ProfileAbout pubkey={$user.pubkey} />
   </div>
   <div class="card flex flex-col gap-4 shadow-md">
-    {#if $session?.method === SessionMethod.Pomade}
+    {#if pomadeEmail}
       <FieldInline>
         {#snippet label()}
           <Icon icon={Letter} />
@@ -117,7 +123,7 @@
         {#snippet input()}
           <label class="input flex w-full items-center gap-2">
             <Icon icon={UserRounded} />
-            <input readonly value={$session.email} class="grow" />
+            <input readonly value={pomadeEmail} class="grow" />
           </label>
         {/snippet}
       </FieldInline>
@@ -158,7 +164,7 @@
         {#snippet input()}
           <label class="input flex w-full items-center gap-2">
             <Icon icon={LinkRound} />
-            <input readonly value={$session.secret} class="grow" type="password" />
+            <input readonly value={nip01Secret} class="grow" type="password" />
             <Button class="flex items-center" onclick={copyNsec}>
               <Icon icon={Copy} />
             </Button>
@@ -170,7 +176,7 @@
       </FieldInline>
     {/if}
     <SignerStatus />
-    {#if $session?.method === SessionMethod.Pomade}
+    {#if pomadeEmail}
       <div class="flex flex-col lg:flex-row gap-4 lg:gap-2 justify-end">
         <Button class="button button-neutral" onclick={startPasswordReset}>
           <Spinner {loading}>Update your password</Spinner>
diff --git a/src/routes/settings/relays/+page.svelte b/src/routes/settings/relays/+page.svelte
index f802f40c..5f07ed6b 100644
--- a/src/routes/settings/relays/+page.svelte
+++ b/src/routes/settings/relays/+page.svelte
@@ -1,20 +1,8 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {
-    pubkey,
-    getRelayLists,
-    derivePubkeyRelays,
-    addRelay,
-    removeRelay,
-    addBlockedRelay,
-    removeBlockedRelay,
-    addMessagingRelay,
-    removeMessagingRelay,
-    addSearchRelay,
-    removeSearchRelay,
-    getRelay,
-  } from "@welshman/app"
-  import {RelayMode} from "@welshman/util"
+  import {uniq} from "@welshman/lib"
+  import {isShareableRelayUrl} from "@welshman/util"
+  import {publish} from "@welshman/app"
   import Plane from "@assets/icons/plane.svg?dataurl"
   import Inbox from "@assets/icons/inbox.svg?dataurl"
   import Server from "@assets/icons/server.svg?dataurl"
@@ -25,22 +13,46 @@
   import PageContent from "@lib/components/PageContent.svelte"
   import RelaySettingsItem from "@app/components/RelaySettingsItem.svelte"
   import RelaySettingsHealthChecks from "@app/components/RelaySettingsHealthChecks.svelte"
-  import {hasNip50} from "@app/relays"
-  import {discoverRelays} from "@app/relays"
+  import {
+    blockedRelayLists,
+    messagingRelayLists,
+    relayLists,
+    relays,
+    searchRelayLists,
+    user,
+  } from "@app/core"
 
-  const readRelayUrls = derivePubkeyRelays($pubkey!, RelayMode.Read)
-  const writeRelayUrls = derivePubkeyRelays($pubkey!, RelayMode.Write)
-  const searchRelayUrls = derivePubkeyRelays($pubkey!, RelayMode.Search)
-  const blockedRelayUrls = derivePubkeyRelays($pubkey!, RelayMode.Blocked)
-  const messagingRelayUrls = derivePubkeyRelays($pubkey!, RelayMode.Messaging)
+  const readRelayUrls = $relayLists.readUrls($user.pubkey).$
+  const writeRelayUrls = $relayLists.writeUrls($user.pubkey).$
+  const searchRelayUrls = $searchRelayLists.urls($user.pubkey).$
+  const blockedRelayUrls = $blockedRelayLists.urls($user.pubkey).$
+  const messagingRelayUrls = $messagingRelayLists.urls($user.pubkey).$
 
-  const addReadRelay = (url: string) => addRelay(url, RelayMode.Read)
-  const removeReadRelay = (url: string) => removeRelay(url, RelayMode.Read)
-  const addWriteRelay = (url: string) => addRelay(url, RelayMode.Write)
-  const removeWriteRelay = (url: string) => removeRelay(url, RelayMode.Write)
+  const addReadRelay = (url: string) => $relayLists.addReadUrl(url).then(publish)
+  const removeReadRelay = (url: string) => $relayLists.removeReadUrl(url).then(publish)
+  const addWriteRelay = (url: string) => $relayLists.addWriteUrl(url).then(publish)
+  const removeWriteRelay = (url: string) => $relayLists.removeWriteUrl(url).then(publish)
 
+  const addMessagingRelay = (url: string) => $messagingRelayLists.addUrl(url).then(publish)
+
+  const removeMessagingRelay = (url: string) => $messagingRelayLists.removeUrl(url).then(publish)
+
+  const addSearchRelay = (url: string) => $searchRelayLists.addUrl(url).then(publish)
+  const removeSearchRelay = (url: string) => $searchRelayLists.removeUrl(url).then(publish)
+  const addBlockedRelay = (url: string) => $blockedRelayLists.addUrl(url).then(publish)
+
+  const removeBlockedRelay = (url: string) => $blockedRelayLists.removeUrl(url).then(publish)
+
+  const relaySupportsSearch = (url: string) => Boolean($relays.get(url)?.hasNip(50))
+
+  // Suggestions come from relay search, which only knows about relays whose NIP-11
+  // document has been fetched — so seed it from everyone's relay lists.
   onMount(() => {
-    discoverRelays(getRelayLists())
+    const urls = uniq($relayLists.all.get().flatMap(list => list.urls()))
+
+    for (const url of urls.filter(isShareableRelayUrl)) {
+      $relays.load(url)
+    }
   })
 </script>
 
@@ -84,7 +96,7 @@
       relays={searchRelayUrls}
       addRelay={addSearchRelay}
       removeRelay={removeSearchRelay}
-      matchRelay={url => hasNip50(getRelay(url))} />
+      matchRelay={relaySupportsSearch} />
     <RelaySettingsItem
       icon={ForbiddenCircle}
       title="Blocked Relays"
diff --git a/src/routes/settings/wallet/+page.svelte b/src/routes/settings/wallet/+page.svelte
index 5c39b41d..23bdac7d 100644
--- a/src/routes/settings/wallet/+page.svelte
+++ b/src/routes/settings/wallet/+page.svelte
@@ -2,7 +2,6 @@
   import cx from "classnames"
   import {LOCALE, always, call, removeAt, replaceAt, sleep} from "@welshman/lib"
   import {WalletType, displayRelayUrl, isNWCWallet, fromMsats} from "@welshman/util"
-  import {session, pubkey, profilesByPubkey} from "@welshman/app"
   import DownloadMinimalistic from "@assets/icons/download-minimalistic.svg?dataurl"
   import UploadMinimalistic from "@assets/icons/upload-minimalistic.svg?dataurl"
   import Bolt from "@assets/icons/bolt.svg?dataurl"
@@ -13,19 +12,20 @@
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
+  import Wallet2 from "@assets/icons/wallet.svg?dataurl"
+  import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
+  import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
+  import InfoCircle from "@assets/icons/info-circle.svg?dataurl"
   import WalletPay from "@app/components/WalletPay.svelte"
   import WalletReceive from "@app/components/WalletReceive.svelte"
   import WalletConnect from "@app/components/WalletConnect.svelte"
   import WalletDisconnect from "@app/components/WalletDisconnect.svelte"
   import WalletUpdateReceivingAddress from "@app/components/WalletUpdateReceivingAddress.svelte"
   import {pushModal} from "@app/modal"
-  import {getNwcClient, getWebLn} from "@app/lightning"
+  import {getNwcClient, getWebLn, wallet} from "@app/lightning"
   import {userSettingsValues, publishSettings} from "@app/settings"
   import {pushToast} from "@app/toast"
-  import Wallet2 from "@assets/icons/wallet.svg?dataurl"
-  import CheckCircle from "@assets/icons/check-circle.svg?dataurl"
-  import CloseCircle from "@assets/icons/close-circle.svg?dataurl"
-  import InfoCircle from "@assets/icons/info-circle.svg?dataurl"
+  import {profiles, user} from "@app/core"
 
   const connect = () => pushModal(WalletConnect)
 
@@ -33,16 +33,14 @@
 
   const updateReceivingAddress = () => pushModal(WalletUpdateReceivingAddress)
 
-  const profile = $derived($profilesByPubkey.get($pubkey || ""))
-  const profileLightningAddress = $derived(profile?.lud16)
-  const walletLud16 = $derived(
-    $session?.wallet && isNWCWallet($session.wallet) ? $session.wallet.info.lud16 : undefined,
-  )
+  const profile = $derived($profiles.get($user.pubkey))
+  const profileLightningAddress = $derived(profile?.lnurl())
+  const walletLud16 = $derived($wallet && isNWCWallet($wallet) ? $wallet.info.lud16 : undefined)
 
   const pay = () => pushModal(WalletPay)
 
   const receive = () => {
-    if ($session?.wallet) {
+    if ($wallet) {
       pushModal(WalletReceive)
     } else {
       pushModal(WalletConnect)
@@ -51,7 +49,7 @@
 
   let walletStatus = $state("checking")
 
-  const isWalletAvailable = $derived(Boolean($session?.wallet) && walletStatus === "connected")
+  const isWalletAvailable = $derived(Boolean($wallet) && walletStatus === "connected")
   const statusClass = $derived(
     cx("flex items-center gap-2 text-sm", {
       "text-success": walletStatus === "connected",
@@ -60,12 +58,12 @@
   )
   const connectionVerb = $derived(walletStatus === "connected" ? "Connected to" : "Configured for")
 
-  const startWalletStatusCheck = async (wallet = $session?.wallet) => {
+  const startWalletStatusCheck = async (currentWallet = $wallet) => {
     walletStatus = "checking"
 
-    if (wallet) {
+    if (currentWallet) {
       const promise =
-        wallet.type === WalletType.NWC
+        currentWallet.type === WalletType.NWC
           ? getNwcClient().getInfo()
           : call(async () => {
               const client = getWebLn()
@@ -83,7 +81,7 @@
   }
 
   $effect(() => {
-    startWalletStatusCheck($session?.wallet)
+    startWalletStatusCheck($wallet)
   })
 
   const resetZapAmounts = () => {
@@ -144,7 +142,7 @@
         <Icon icon={Wallet2} />
         Your Wallet
       </strong>
-      {#if $session?.wallet}
+      {#if $wallet}
         <div class={statusClass}>
           {#if walletStatus === "checking"}
             <Spinner size="xs" />
@@ -165,13 +163,13 @@
       {/if}
     </div>
     <div class="flex flex-col gap-4">
-      {#if $session?.wallet}
-        {#if $session.wallet.type === "webln"}
-          {@const {node, version} = $session.wallet.info}
+      {#if $wallet}
+        {#if $wallet.type === "webln"}
+          {@const {node, version} = $wallet.info}
           <div class="flex flex-col justify-between gap-2 lg:flex-row">
             <p>
               {connectionVerb} <strong>{node?.alias || version || "unknown wallet"}</strong>
-              via <strong>{$session.wallet.type}</strong>
+              via <strong>{$wallet.type}</strong>
             </p>
             <p class="flex gap-2 whitespace-nowrap">
               {#if walletStatus === "connected"}
@@ -194,8 +192,8 @@
               {/if}
             </p>
           </div>
-        {:else if $session.wallet.type === "nwc"}
-          {@const {lud16, relayUrl} = $session.wallet.info}
+        {:else if $wallet.type === "nwc"}
+          {@const {lud16, relayUrl} = $wallet.info}
           <div class="flex flex-col justify-between gap-2 lg:flex-row">
             <p>
               {connectionVerb} <strong>{lud16}</strong> via
@@ -257,7 +255,7 @@
       <Button class="button button-neutral button-xs ml-3" onclick={updateReceivingAddress}
         >Update</Button>
     </div>
-    {#if profileLightningAddress && walletLud16 && profile?.lud16 !== walletLud16}
+    {#if profileLightningAddress && walletLud16 && profileLightningAddress !== walletLud16}
       <div class="card flex items-center gap-2 text-xs">
         <Icon icon={InfoCircle} size={4} />
         Your profile has a different lightning address than your connected wallet.
diff --git a/src/routes/spaces/+page.svelte b/src/routes/spaces/+page.svelte
index e0743ad2..6d787bea 100644
--- a/src/routes/spaces/+page.svelte
+++ b/src/routes/spaces/+page.svelte
@@ -3,11 +3,11 @@
   import {flip} from "svelte/animate"
   import {cubicOut} from "svelte/easing"
   import {derived as _derived} from "svelte/store"
-  import {dec, insertAt, removeAt, sleep} from "@welshman/lib"
-  import type {RelayProfile} from "@welshman/util"
+  import {addToMapKey, dec, insertAt, removeAt, sleep, spec} from "@welshman/lib"
   import {ROOMS} from "@welshman/util"
+  import type {Relay} from "@welshman/domain"
   import {throttled} from "@welshman/store"
-  import {pull, relays, createSearch} from "@welshman/app"
+  import {Sync, createSearch, publish} from "@welshman/app"
   import {createScroller, isMobile} from "@lib/html"
   import {fly} from "@lib/transition"
   import DragHandle from "@assets/icons/drag-handle.svg?dataurl"
@@ -26,7 +26,8 @@
   import SpaceAdd from "@app/components/SpaceAdd.svelte"
   import SpaceInviteAccept from "@app/components/SpaceInviteAccept.svelte"
   import SpaceJoin from "@app/components/SpaceJoin.svelte"
-  import {userSpaceUrls, loadUserGroupList, groupListPubkeysByUrl, setSpaces} from "@app/groups"
+  import {app, relays, roomLists, user} from "@app/core"
+  import {userSpaceUrls} from "@app/rooms"
   import {PLATFORM_RELAYS, DEFAULT_RELAYS} from "@app/env"
   import {bootstrapPubkeys} from "@app/social"
   import {parseInviteLink} from "@app/access"
@@ -36,25 +37,44 @@
 
   const addSpace = () => pushModal(SpaceAdd)
 
-  const relaySearch = _derived(throttled(1000, relays), $relays => {
-    const options = $relays.filter(r => $groupListPubkeysByUrl.has(r.url))
+  const userSpacesLoaded = $roomLists.load($user.pubkey)
 
-    return createSearch(options, {
-      getValue: (relay: RelayProfile) => relay.url,
-      sortFn: ({score, item}) => {
-        if (score && score > 0.1) return -score!
+  // How many people list each space, used both to limit search to spaces someone
+  // has joined and to rank them.
+  const spacePubkeysByUrl = _derived($roomLists.all.$, $roomLists => {
+    const result = new Map<string, Set<string>>()
 
-        const wotScore = $groupListPubkeysByUrl.get(item.url)?.size || 0
+    for (const roomList of $roomLists) {
+      for (const url of roomList.urls()) {
+        addToMapKey(result, url, roomList.author())
+      }
+    }
 
-        return score ? dec(score) * wotScore : -wotScore
-      },
-      fuseOptions: {
-        keys: ["url", "name", {name: "description", weight: 0.3}],
-        shouldSort: false,
-      },
-    })
+    return result
   })
 
+  const relaySearch = _derived(
+    [throttled(1000, $relays.all.$), spacePubkeysByUrl],
+    ([$relays, $spacePubkeysByUrl]) => {
+      const options = $relays.filter(r => $spacePubkeysByUrl.has(r.url))
+
+      return createSearch(options, {
+        getValue: (relay: Relay) => relay.url,
+        sortFn: ({score, item}) => {
+          if (score && score > 0.1) return -score!
+
+          const wotScore = $spacePubkeysByUrl.get(item.url)?.size || 0
+
+          return score ? dec(score) * wotScore : -wotScore
+        },
+        fuseOptions: {
+          keys: ["url", "name", {name: "description", weight: 0.3}],
+          shouldSort: false,
+        },
+      })
+    },
+  )
+
   const openSpace = (url: string, claim = "") => {
     if ($userSpaceUrls.includes(url)) {
       goToSpace(url)
@@ -128,7 +148,7 @@
     lastDragTarget = undefined
 
     if (dragStartOrder && !isSameOrder(dragStartOrder, orderedSpaceUrls)) {
-      void setSpaces(orderedSpaceUrls).catch(console.error)
+      void $roomLists.setRelays(orderedSpaceUrls).then(publish).catch(console.error)
     }
 
     dragStartOrder = undefined
@@ -166,9 +186,7 @@
   const searchResults = $derived($relaySearch.searchOptions(term))
   const userSpaceSet = $derived(new Set($userSpaceUrls))
   const filteredUserUrls = $derived(
-    term
-      ? orderedSpaceUrls.filter(url => searchResults.some(r => r.url === url))
-      : orderedSpaceUrls,
+    term ? orderedSpaceUrls.filter(url => searchResults.some(spec({url}))) : orderedSpaceUrls,
   )
   const otherSpaces = $derived(
     searchResults.filter(r => !userSpaceSet.has(r.url) && r.url !== inviteData?.url),
@@ -182,7 +200,7 @@
       },
     })
 
-    pull({
+    $app.use(Sync).pull({
       filters: [{kinds: [ROOMS], authors: $bootstrapPubkeys}],
       relays: DEFAULT_RELAYS,
     })
@@ -231,7 +249,7 @@
               <RelaySummary {url} />
             </Button>
           {:else}
-            {#await loadUserGroupList()}
+            {#await userSpacesLoaded}
               <div class="flex items-center justify-center py-20">
                 <Spinner size="sm" class="mr-3" />
                 Loading your spaces...
diff --git a/src/routes/spaces/[relay]/+layout.svelte b/src/routes/spaces/[relay]/+layout.svelte
index c54fb299..00e21d13 100644
--- a/src/routes/spaces/[relay]/+layout.svelte
+++ b/src/routes/spaces/[relay]/+layout.svelte
@@ -8,6 +8,7 @@
   import {page} from "$app/stores"
   import type {Maybe} from "@welshman/lib"
   import {once} from "@welshman/lib"
+  import {normalizeRelayUrl} from "@welshman/util"
   import Page from "@lib/components/Page.svelte"
   import SecondaryNav from "@lib/components/SecondaryNav.svelte"
   import SpaceMenu from "@app/components/SpaceMenu.svelte"
@@ -16,10 +17,11 @@
   import SpaceJoin from "@app/components/SpaceJoin.svelte"
   import SpaceRedirect from "@app/components/SpaceRedirect.svelte"
   import {deriveRelayAuthError} from "@app/access"
-  import {loadUserGroupList, userSpaceUrls} from "@app/groups"
+  import {relays, roomLists, user} from "@app/core"
+  import {userSpaceUrls} from "@app/rooms"
   import {modal, pushModal} from "@app/modal"
   import {relaysPendingTrust} from "@app/policies"
-  import {decodeRelay, fetchRelayRedirect} from "@app/relays"
+  import {decodeRelay} from "@app/relays"
   import {makeSpacePath} from "@app/routes"
 
   type Props = {
@@ -38,13 +40,27 @@
 
   const showPendingTrust = once(() => pushModal(SpaceTrustRelay, {url}, {noEscape: true}))
 
-  // Detect a moved custom domain (see fetchRelayRedirect)
+  // Detect a moved custom domain — the relay's nip-11 document answered with a redirect
   const checkRedirect = once(() => {
-    fetchRelayRedirect(url).then(next => {
-      redirectUrl = next
+    $relays.load(url).then($relay => {
+      const next = $relay?.redirect_to
+
+      if (next) {
+        redirectUrl = normalizeRelayUrl(next.replace(/^http/, "ws"))
+      }
     })
   })
 
+  const loadSpaces = async () => {
+    const currentPubkey = user.get().pubkey
+
+    if (currentPubkey) {
+      await $roomLists.load(currentPubkey, [url])
+    }
+
+    spacesLoaded = true
+  }
+
   // Track this manually since we want to avoid race conditions in which we show this prompt before we load
   let spacesLoaded = $state(false)
 
@@ -57,7 +73,7 @@
   $effect(() => {
     if ($modal) return
 
-    if (redirectUrl && !redirectPrompted.has(url)) {
+    if (redirectUrl && redirectUrl !== url && !redirectPrompted.has(url)) {
       redirectPrompted.add(url)
       pushModal(SpaceRedirect, {url, newUrl: redirectUrl})
     } else if (!$userSpaceUrls.includes(url) && !joinPrompted.has(url)) {
@@ -65,9 +81,7 @@
         joinPrompted.add(url)
         pushModal(SpaceJoin, {url})
       } else {
-        loadUserGroupList([url]).then(() => {
-          spacesLoaded = true
-        })
+        loadSpaces()
       }
     } else if ($authError) {
       showAuthError()
diff --git a/src/routes/spaces/[relay]/about/+page.svelte b/src/routes/spaces/[relay]/about/+page.svelte
index 463b3cb4..4b188d07 100644
--- a/src/routes/spaces/[relay]/about/+page.svelte
+++ b/src/routes/spaces/[relay]/about/+page.svelte
@@ -2,7 +2,6 @@
   import {page} from "$app/stores"
   import {goto} from "$app/navigation"
   import {displayRelayUrl} from "@welshman/util"
-  import {deriveRelay} from "@welshman/app"
   import ArrowLeft from "@assets/icons/arrow-left.svg?dataurl"
   import ShieldUser from "@assets/icons/shield-user.svg?dataurl"
   import BillList from "@assets/icons/bill-list.svg?dataurl"
@@ -16,11 +15,12 @@
   import ProfileLink from "@app/components/ProfileLink.svelte"
   import SpaceMembersSummary from "@app/components/SpaceMembersSummary.svelte"
   import SpaceFeaturedContent from "@app/components/SpaceFeaturedContent.svelte"
+  import {relays} from "@app/core"
   import {makeSpacePath} from "@app/routes"
   import {decodeRelay} from "@app/relays"
 
   const url = decodeRelay($page.params.relay!)
-  const relay = deriveRelay(url)
+  const relay = $relays.one(url)
   const showMenu = () => goto(makeSpacePath(url))
 </script>
 
diff --git a/src/routes/spaces/[relay]/calendar/+page.svelte b/src/routes/spaces/[relay]/calendar/+page.svelte
index 894abbaa..f0fab54e 100644
--- a/src/routes/spaces/[relay]/calendar/+page.svelte
+++ b/src/routes/spaces/[relay]/calendar/+page.svelte
@@ -5,7 +5,7 @@
   import {page} from "$app/stores"
   import {now, last, formatTimestampAsDate} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {EVENT_TIME, getTagValue} from "@welshman/util"
+  import {EVENT_TIME, tagValue, tagSpec} from "@welshman/util"
   import {fly} from "@lib/transition"
   import CalendarMinimalistic from "@assets/icons/calendar-minimalistic.svg?dataurl"
   import Add from "@assets/icons/add.svg?dataurl"
@@ -26,7 +26,7 @@
 
   const makeEvent = () => pushModal(CalendarEventCreate, {url})
 
-  const getStart = (event: TrustedEvent) => parseInt(getTagValue("start", event.tags) || "")
+  const getStart = (event: TrustedEvent) => parseInt(tagValue(tagSpec("start"), event.tags) || "")
 
   let element: HTMLElement | undefined = $state()
   let loading = $state(true)
diff --git a/src/routes/spaces/[relay]/calendar/[address]/+page.svelte b/src/routes/spaces/[relay]/calendar/[address]/+page.svelte
index 9d86d9ab..50a47ff5 100644
--- a/src/routes/spaces/[relay]/calendar/[address]/+page.svelte
+++ b/src/routes/spaces/[relay]/calendar/[address]/+page.svelte
@@ -1,12 +1,11 @@
 <script lang="ts">
+  import {derived} from "svelte/store"
   import {onMount} from "svelte"
   import {page} from "$app/stores"
   import {sortBy, sleep} from "@welshman/lib"
   import type {MakeNonOptional} from "@welshman/lib"
-  import {COMMENT, getTagValue} from "@welshman/util"
-  import {request} from "@welshman/net"
-  import {repository} from "@welshman/app"
-  import {deriveEventsById, deriveEventsAsc} from "@welshman/store"
+  import {COMMENT} from "@welshman/util"
+  import {TimeEvent} from "@welshman/domain"
   import SortVertical from "@assets/icons/sort-vertical.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -22,14 +21,16 @@
   import CalendarEventMeta from "@app/components/CalendarEventMeta.svelte"
   import CalendarEventDate from "@app/components/CalendarEventDate.svelte"
   import EventReply from "@app/components/EventReply.svelte"
-  import {deriveEvent} from "@app/repository"
+  import {network, reader} from "@app/core"
+  import {deriveEvent, deriveEvents} from "@app/repository"
   import {decodeRelay} from "@app/relays"
 
   const {relay, address} = $page.params as MakeNonOptional<typeof $page.params>
   const url = decodeRelay(relay)
   const event = deriveEvent(address, [url])
+  const timeEvent = derived(event, $event => ($event ? reader(TimeEvent)($event) : undefined))
   const filters = [{kinds: [COMMENT], "#A": [address]}]
-  const replies = deriveEventsAsc(deriveEventsById({filters, repository}))
+  const replies = deriveEvents(filters)
 
   const back = () => history.back()
 
@@ -51,7 +52,7 @@
   onMount(() => {
     const controller = new AbortController()
 
-    request({relays: [url], filters, signal: controller.signal})
+    $network.request({relays: [url], filters, signal: controller.signal})
 
     return () => {
       controller.abort()
@@ -61,7 +62,7 @@
 
 <SpaceBar {back}>
   {#snippet title()}
-    <h1 class="text-xl">{getTagValue("title", $event?.tags || []) || ""}</h1>
+    <h1 class="text-xl">{$timeEvent?.title() ?? ""}</h1>
   {/snippet}
 </SpaceBar>
 
diff --git a/src/routes/spaces/[relay]/classifieds/+page.svelte b/src/routes/spaces/[relay]/classifieds/+page.svelte
index 6292be45..0f79ecff 100644
--- a/src/routes/spaces/[relay]/classifieds/+page.svelte
+++ b/src/routes/spaces/[relay]/classifieds/+page.svelte
@@ -5,7 +5,7 @@
   import {page} from "$app/stores"
   import {sortBy, partition, spec, max, pushToMapKey} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {CLASSIFIED, getTagValue} from "@welshman/util"
+  import {CLASSIFIED, tagSpec, tagValue} from "@welshman/util"
   import {fly} from "@lib/transition"
   import CaseMinimalistic from "@assets/icons/case-minimalistic.svg?dataurl"
   import Add from "@assets/icons/add.svg?dataurl"
@@ -34,7 +34,7 @@
     const [goals, comments] = partition(spec({kind: CLASSIFIED}), $events)
 
     for (const comment of comments) {
-      const id = getTagValue("E", comment.tags)
+      const id = tagValue(tagSpec("E"), comment.tags)
 
       if (id) {
         pushToMapKey(scores, id, comment.created_at)
diff --git a/src/routes/spaces/[relay]/classifieds/[address]/+page.svelte b/src/routes/spaces/[relay]/classifieds/[address]/+page.svelte
index 8b4794dc..049bed8b 100644
--- a/src/routes/spaces/[relay]/classifieds/[address]/+page.svelte
+++ b/src/routes/spaces/[relay]/classifieds/[address]/+page.svelte
@@ -1,12 +1,12 @@
 <script lang="ts">
+  import {derived} from "svelte/store"
   import {onMount} from "svelte"
   import {page} from "$app/stores"
   import {sleep} from "@welshman/lib"
   import type {MakeNonOptional} from "@welshman/lib"
-  import {COMMENT, getTagValue} from "@welshman/util"
-  import {repository} from "@welshman/app"
-  import {request} from "@welshman/net"
-  import {deriveEventsById, deriveEventsAsc} from "@welshman/store"
+  import {COMMENT} from "@welshman/util"
+  import {deriveEventsAsc} from "@welshman/store"
+  import {Classified} from "@welshman/domain"
   import SortVertical from "@assets/icons/sort-vertical.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -19,14 +19,16 @@
   import ClassifiedActions from "@app/components/ClassifiedActions.svelte"
   import CommentActions from "@app/components/CommentActions.svelte"
   import EventReply from "@app/components/EventReply.svelte"
-  import {deriveEvent} from "@app/repository"
+  import {network, reader} from "@app/core"
+  import {deriveEvent, deriveEventsById} from "@app/repository"
   import {decodeRelay} from "@app/relays"
 
   const {relay, address} = $page.params as MakeNonOptional<typeof $page.params>
   const url = decodeRelay(relay)
   const event = deriveEvent(address, [url])
+  const classified = derived(event, $event => ($event ? reader(Classified)($event) : undefined))
   const filters = [{kinds: [COMMENT], "#A": [address]}]
-  const replies = deriveEventsAsc(deriveEventsById({filters, repository}))
+  const replies = deriveEventsAsc(deriveEventsById(filters))
 
   const back = () => history.back()
 
@@ -48,7 +50,7 @@
   onMount(() => {
     const controller = new AbortController()
 
-    request({relays: [url], filters, signal: controller.signal})
+    $network.request({relays: [url], filters, signal: controller.signal})
 
     return () => {
       controller.abort()
@@ -58,7 +60,7 @@
 
 <SpaceBar {back}>
   {#snippet title()}
-    <h1 class="text-xl">{getTagValue("title", $event?.tags || []) || ""}</h1>
+    <h1 class="text-xl">{$classified?.title() ?? ""}</h1>
   {/snippet}
 </SpaceBar>
 
diff --git a/src/routes/spaces/[relay]/directory/+page.svelte b/src/routes/spaces/[relay]/directory/+page.svelte
index f2122155..c5ef33d7 100644
--- a/src/routes/spaces/[relay]/directory/+page.svelte
+++ b/src/routes/spaces/[relay]/directory/+page.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
   import {derived} from "svelte/store"
   import {page} from "$app/stores"
-  import {displayProfileByPubkey} from "@welshman/app"
+  import {removeUndefined, sortBy} from "@welshman/lib"
   import UsersGroup from "@assets/icons/users-group-rounded.svg?dataurl"
   import AddCircle from "@assets/icons/add-circle.svg?dataurl"
   import MenuDots from "@assets/icons/menu-dots.svg?dataurl"
@@ -17,31 +17,28 @@
   import SpaceInvite from "@app/components/SpaceInvite.svelte"
   import SpaceRoles from "@app/components/SpaceRoles.svelte"
   import SpaceMembersBanned from "@app/components/SpaceMembersBanned.svelte"
-  import {
-    deriveSpaceRoles,
-    deriveSpaceMembers,
-    deriveSpaceMemberRoles,
-    deriveUserIsSpaceAdmin,
-    type SpaceRole,
-  } from "@app/members"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
+  import {deriveSpaceMemberRoles} from "@app/roles"
+  import {profiles, relayMemberLists, relayRoles} from "@app/core"
   import {decodeRelay} from "@app/relays"
   import {pushModal} from "@app/modal"
 
   const url = decodeRelay($page.params.relay!)
-  const roles = deriveSpaceRoles(url)
-  const members = deriveSpaceMembers(url)
+  const roles = $relayRoles.forUrl(url).$
+  const members = $relayMemberLists.forUrl(url)
   const memberRoles = deriveSpaceMemberRoles(url)
   const userIsAdmin = deriveUserIsSpaceAdmin(url)
 
   // Each member with their resolved roles (sorted by order).
   const memberList = derived([members, memberRoles, roles], ([$members, $memberRoles, $roles]) => {
-    const byId = new Map($roles.map(role => [role.id, role]))
+    const byId = new Map($roles.map(role => [role.identifier(), role]))
 
-    return $members.map(pubkey => ({
+    return ($members?.pubkeys() ?? []).map(pubkey => ({
       pubkey,
-      roleList: ($memberRoles.get(pubkey) ?? [])
-        .map(id => byId.get(id))
-        .filter((role): role is SpaceRole => Boolean(role)),
+      roleList: sortBy(
+        role => role.order(),
+        removeUndefined(($memberRoles.get(pubkey) ?? []).map(id => byId.get(id))),
+      ),
     }))
   })
 
@@ -67,7 +64,7 @@
   let term = $state("")
 
   const matchesTerm = (pubkey: string, t: string) =>
-    displayProfileByPubkey(pubkey).toLowerCase().includes(t) || pubkey.toLowerCase().includes(t)
+    $profiles.display(pubkey).get().toLowerCase().includes(t) || pubkey.toLowerCase().includes(t)
 
   // In-place search: match by member info or by the name of any role they hold.
   const visibleMembers = $derived.by(() => {
@@ -77,7 +74,8 @@
 
     return $memberList.filter(
       ({pubkey, roleList}) =>
-        matchesTerm(pubkey, t) || roleList.some(role => role.label.toLowerCase().includes(t)),
+        matchesTerm(pubkey, t) ||
+        roleList.some(role => (role.label() ?? "").toLowerCase().includes(t)),
     )
   })
 </script>
diff --git a/src/routes/spaces/[relay]/goals/+page.svelte b/src/routes/spaces/[relay]/goals/+page.svelte
index 063823bf..0e933b4f 100644
--- a/src/routes/spaces/[relay]/goals/+page.svelte
+++ b/src/routes/spaces/[relay]/goals/+page.svelte
@@ -5,7 +5,7 @@
   import {page} from "$app/stores"
   import {sortBy, partition, spec, pushToMapKey, max} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {ZAP_GOAL, getTagValue} from "@welshman/util"
+  import {ZAP_GOAL, tagSpec, tagValue} from "@welshman/util"
   import {fly} from "@lib/transition"
   import StarFallMinimalistic from "@assets/icons/star-fall-minimalistic.svg?dataurl"
   import Add from "@assets/icons/add.svg?dataurl"
@@ -34,7 +34,7 @@
     const [goals, comments] = partition(spec({kind: ZAP_GOAL}), $events)
 
     for (const comment of comments) {
-      const id = getTagValue("E", comment.tags)
+      const id = tagValue(tagSpec("E"), comment.tags)
 
       if (id) {
         pushToMapKey(scores, id, comment.created_at)
diff --git a/src/routes/spaces/[relay]/goals/[id]/+page.svelte b/src/routes/spaces/[relay]/goals/[id]/+page.svelte
index 6efee7ff..8ce2c71e 100644
--- a/src/routes/spaces/[relay]/goals/[id]/+page.svelte
+++ b/src/routes/spaces/[relay]/goals/[id]/+page.svelte
@@ -1,12 +1,12 @@
 <script lang="ts">
+  import {derived} from "svelte/store"
   import {onMount} from "svelte"
   import {page} from "$app/stores"
   import {sleep} from "@welshman/lib"
   import type {MakeNonOptional} from "@welshman/lib"
-  import {COMMENT, getTagValue} from "@welshman/util"
-  import {repository} from "@welshman/app"
-  import {request} from "@welshman/net"
-  import {deriveEventsById, deriveEventsAsc} from "@welshman/store"
+  import {COMMENT} from "@welshman/util"
+  import {deriveEventsAsc} from "@welshman/store"
+  import {ZapGoal} from "@welshman/domain"
   import SortVertical from "@assets/icons/sort-vertical.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -19,15 +19,17 @@
   import GoalActions from "@app/components/GoalActions.svelte"
   import CommentActions from "@app/components/CommentActions.svelte"
   import EventReply from "@app/components/EventReply.svelte"
-  import {deriveEvent} from "@app/repository"
+  import {network, reader} from "@app/core"
+  import {deriveEvent, deriveEventsById} from "@app/repository"
   import {decodeRelay} from "@app/relays"
 
   const {relay, id} = $page.params as MakeNonOptional<typeof $page.params>
   const url = decodeRelay(relay)
   const event = deriveEvent(id, [url])
   const filters = [{kinds: [COMMENT], "#E": [id]}]
-  const replies = deriveEventsAsc(deriveEventsById({repository, filters}))
-  const summary = getTagValue("summary", $event?.tags || [])
+  const replies = deriveEventsAsc(deriveEventsById(filters))
+  const goal = derived(event, $event => ($event ? reader(ZapGoal)($event) : undefined))
+  const summary = $derived($goal?.summary() ?? "")
 
   const back = () => history.back()
 
@@ -49,7 +51,7 @@
   onMount(() => {
     const controller = new AbortController()
 
-    request({relays: [url], filters, signal: controller.signal})
+    $network.request({relays: [url], filters, signal: controller.signal})
 
     return () => {
       controller.abort()
diff --git a/src/routes/spaces/[relay]/library/+page.svelte b/src/routes/spaces/[relay]/library/+page.svelte
index 2dc64010..003183dc 100644
--- a/src/routes/spaces/[relay]/library/+page.svelte
+++ b/src/routes/spaces/[relay]/library/+page.svelte
@@ -1,10 +1,8 @@
 <script lang="ts">
   import {onMount} from "svelte"
-  import {get} from "svelte/store"
   import {page} from "$app/stores"
-  import {randomId} from "@welshman/lib"
-  import {deriveRelay} from "@welshman/app"
-  import {load} from "@welshman/net"
+  import {PIN, PINBOARD} from "@welshman/util"
+  import {Pinboards} from "@welshman/app"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
   import GalleryWide from "@assets/icons/gallery-wide.svg?dataurl"
   import Add from "@assets/icons/add.svg?dataurl"
@@ -16,53 +14,48 @@
   import SpaceBar from "@app/components/SpaceBar.svelte"
   import PinboardItem from "@app/components/PinboardItem.svelte"
   import PinboardEdit from "@app/components/PinboardEdit.svelte"
-  import {decodeRelay, deriveSupportedMethods} from "@app/relays"
-  import {deriveBoards, BOARD, PIN, type Board} from "@app/pinboards"
+  import {app, network, relays} from "@app/core"
+  import {decodeRelay} from "@app/relays"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
   import {pushModal} from "@app/modal"
 
   const url = decodeRelay($page.params.relay!)
 
-  const boards = deriveBoards(url)
-  const supportedMethods = deriveSupportedMethods(url)
-  const canManage = $derived($supportedMethods.some(m => (m as string) === "signevent"))
+  const relay = $relays.one(url)
+
+  const canManage = deriveUserIsSpaceAdmin(url)
+
+  const createBoard = () => pushModal(PinboardEdit, {url})
 
   let term = $state("")
   let loading = $state(true)
 
+  // Shelves are signed by the relay itself, so the relay's own pubkey scopes them
+  // to this space.
+  const boards = $derived($app.use(Pinboards).forAuthor($relay?.self ?? "").$)
+
   const filtered = $derived.by(() => {
     const value = term.trim().toLowerCase()
 
-    if (!value) return $boards
-
-    return $boards.filter(board =>
-      [board.title, board.description, ...board.topics].some(field =>
-        field?.toLowerCase().includes(value),
-      ),
-    )
-  })
-
-  const createBoard = () => {
-    const self = get(deriveRelay(url))?.self ?? ""
-    const identifier = randomId()
-    const board: Board = {
-      address: `${BOARD}:${self}:${identifier}`,
-      identifier,
-      title: "",
-      description: "",
-      image: "",
-      topics: [],
-      collaborative: false,
+    if (value) {
+      return $boards.filter(board =>
+        [board.title(), board.description(), ...board.topics()].some(field =>
+          field?.toLowerCase().includes(value),
+        ),
+      )
     }
 
-    pushModal(PinboardEdit, {url, board, isNew: true})
-  }
+    return $boards
+  })
 
   onMount(() => {
     const controller = new AbortController()
 
-    load({relays: [url], filters: [{kinds: [BOARD, PIN]}], signal: controller.signal}).then(() => {
-      loading = false
-    })
+    $network
+      .load({relays: [url], filters: [{kinds: [PINBOARD, PIN]}], signal: controller.signal})
+      .then(() => {
+        loading = false
+      })
 
     return () => controller.abort()
   })
@@ -76,7 +69,7 @@
     <strong>Library</strong>
   {/snippet}
   {#snippet action()}
-    {#if canManage}
+    {#if $canManage}
       <Button class="button button-primary button-sm" onclick={createBoard}>
         <Icon icon={Add} />
         Create Shelf
@@ -90,7 +83,7 @@
     <Icon size={4} icon={Magnifier} />
     <input bind:value={term} class="min-w-0 grow" type="text" placeholder="Search library..." />
   </label>
-  <Masonry items={filtered} getKey={board => board.address} columnWidth={80} gap={4}>
+  <Masonry items={filtered} getKey={board => board.address()} columnWidth={80} gap={4}>
     {#snippet child(board)}
       <PinboardItem {url} {board} />
     {/snippet}
diff --git a/src/routes/spaces/[relay]/library/[address]/+page.svelte b/src/routes/spaces/[relay]/library/[address]/+page.svelte
index b68f2798..136a9e9d 100644
--- a/src/routes/spaces/[relay]/library/[address]/+page.svelte
+++ b/src/routes/spaces/[relay]/library/[address]/+page.svelte
@@ -3,8 +3,9 @@
   import {page} from "$app/stores"
   import {sleep} from "@welshman/lib"
   import type {MakeNonOptional} from "@welshman/lib"
-  import {getIdFilters} from "@welshman/util"
-  import {request} from "@welshman/net"
+  import {PIN, getIdFilters} from "@welshman/util"
+  import {Pinboards, Pins} from "@welshman/app"
+  import {errorMessage} from "@lib/util"
   import {fly} from "@lib/transition"
   import Magnifier from "@assets/icons/magnifier.svg?dataurl"
   import MenuDots from "@assets/icons/menu-dots.svg?dataurl"
@@ -25,8 +26,9 @@
   import EventInfo from "@app/components/EventInfo.svelte"
   import PinboardEdit from "@app/components/PinboardEdit.svelte"
   import PinAdd from "@app/components/PinAdd.svelte"
-  import {decodeRelay, deriveSupportedMethods} from "@app/relays"
-  import {deriveBoardByAddress, derivePins, deleteBoard, PIN} from "@app/pinboards"
+  import {app, deletes, network} from "@app/core"
+  import {deriveUserIsSpaceAdmin} from "@app/management"
+  import {decodeRelay} from "@app/relays"
   import {shareEventToChat} from "@app/share"
   import {pushModal} from "@app/modal"
   import {pushToast} from "@app/toast"
@@ -34,10 +36,9 @@
   const {relay, address} = $page.params as MakeNonOptional<typeof $page.params>
   const url = decodeRelay(relay)
 
-  const board = deriveBoardByAddress(url, address)
-  const pins = derivePins(url, address)
-  const supportedMethods = deriveSupportedMethods(url)
-  const canManage = $derived($supportedMethods.some(m => (m as string) === "signevent"))
+  const board = $app.use(Pinboards).one(address)
+  const pins = $app.use(Pins).forBoard(address).$
+  const canManage = deriveUserIsSpaceAdmin(url)
 
   let term = $state("")
   let menuOpen = $state(false)
@@ -47,11 +48,14 @@
 
     if (!value) return $pins
 
-    return $pins.filter(pin =>
-      [pin.title, pin.description, pin.value[0] === "i" ? pin.value[1] : "", ...pin.topics].some(
-        field => field?.toLowerCase().includes(value),
-      ),
-    )
+    return $pins.filter(pin => {
+      const reference = pin.reference()
+      const external = reference?.type === "external" ? reference.id : ""
+
+      return [pin.title(), pin.content(), external, ...pin.topics()].some(field =>
+        field?.toLowerCase().includes(value),
+      )
+    })
   })
 
   const back = () => history.back()
@@ -90,28 +94,37 @@
     pushModal(PinboardEdit, {url, board: $board})
   }
 
+  const deleteBoard = async () => {
+    try {
+      const command = await $deletes.deleteEvent($board!.event)
+      const thunk = await command.publishAsRelay(url)
+      const error = await thunk.waitForError()
+
+      if (error) {
+        return pushToast({theme: "error", message: error})
+      }
+
+      pushToast({message: "Shelf deleted!"})
+      back()
+    } catch (e) {
+      console.error(e)
+      pushToast({theme: "error", message: errorMessage(e)})
+    }
+  }
+
   const confirmDelete = () => {
     menuOpen = false
     pushModal(Confirm, {
       title: "Delete Shelf",
-      message: `Delete "${$board?.title || "this shelf"}"?`,
-      confirm: async () => {
-        const error = await deleteBoard(url, address)
-
-        if (error) {
-          pushToast({theme: "error", message: error})
-        } else {
-          pushToast({message: "Shelf deleted!"})
-          back()
-        }
-      },
+      message: `Delete "${$board?.title() || "this shelf"}"?`,
+      confirm: deleteBoard,
     })
   }
 
   onMount(() => {
     const controller = new AbortController()
 
-    request({
+    $network.request({
       relays: [url],
       filters: [...getIdFilters([address]), {kinds: [PIN], "#A": [address]}],
       signal: controller.signal,
@@ -123,7 +136,7 @@
 
 <SpaceBar {back}>
   {#snippet title()}
-    <h1 class="truncate text-xl">{$board?.title || "Shelf"}</h1>
+    <h1 class="truncate text-xl">{$board?.title() || "Shelf"}</h1>
   {/snippet}
   {#snippet action()}
     <div class="relative">
@@ -150,7 +163,7 @@
                 Share to chat
               </Button>
             </li>
-            {#if canManage}
+            {#if $canManage}
               <li>
                 <Button onclick={addLink}>
                   <Icon icon={AddCircle} />
@@ -182,7 +195,7 @@
     {#if $pins.length === 0}
       <div class="flex flex-col items-center gap-4 py-20 text-center">
         <p class="opacity-70">This shelf doesn't have any links yet.</p>
-        {#if canManage}
+        {#if $canManage}
           <Button class="button button-primary" onclick={addLink}>
             <Icon icon={AddCircle} />
             Add a link
@@ -197,7 +210,7 @@
       {#if filtered.length === 0}
         <p class="py-20 text-center opacity-70">No links found.</p>
       {:else}
-        <Masonry items={filtered} getKey={pin => pin.id} columnWidth={60} gap={3}>
+        <Masonry items={filtered} getKey={pin => pin.id()} columnWidth={60} gap={3}>
           {#snippet child(pin)}
             <PinItem {url} {pin} />
           {/snippet}
diff --git a/src/routes/spaces/[relay]/polls/+page.svelte b/src/routes/spaces/[relay]/polls/+page.svelte
index 13fffe84..e9b5f605 100644
--- a/src/routes/spaces/[relay]/polls/+page.svelte
+++ b/src/routes/spaces/[relay]/polls/+page.svelte
@@ -5,7 +5,7 @@
   import {page} from "$app/stores"
   import {sortBy, partition, spec, pushToMapKey, max} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue, POLL} from "@welshman/util"
+  import {POLL, tagValue, tagSpec} from "@welshman/util"
   import {fly} from "@lib/transition"
   import PollIcon from "@assets/icons/revote.svg?dataurl"
   import Add from "@assets/icons/add.svg?dataurl"
@@ -34,7 +34,7 @@
     const [polls, comments] = partition(spec({kind: POLL}), $events)
 
     for (const comment of comments) {
-      const id = getTagValue("E", comment.tags)
+      const id = tagValue(tagSpec("E"), comment.tags)
 
       if (id) {
         pushToMapKey(scores, id, comment.created_at)
diff --git a/src/routes/spaces/[relay]/polls/[id]/+page.svelte b/src/routes/spaces/[relay]/polls/[id]/+page.svelte
index d788a93a..fa593438 100644
--- a/src/routes/spaces/[relay]/polls/[id]/+page.svelte
+++ b/src/routes/spaces/[relay]/polls/[id]/+page.svelte
@@ -4,9 +4,7 @@
   import {sleep} from "@welshman/lib"
   import type {MakeNonOptional} from "@welshman/lib"
   import {COMMENT, POLL, POLL_RESPONSE} from "@welshman/util"
-  import {repository} from "@welshman/app"
-  import {request} from "@welshman/net"
-  import {deriveEventsById, deriveEventsAsc} from "@welshman/store"
+  import {deriveEventsAsc} from "@welshman/store"
   import SortVertical from "@assets/icons/sort-vertical.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
@@ -17,14 +15,15 @@
   import NoteContent from "@app/components/NoteContent.svelte"
   import CommentActions from "@app/components/CommentActions.svelte"
   import EventReply from "@app/components/EventReply.svelte"
-  import {deriveEvent} from "@app/repository"
+  import {network} from "@app/core"
+  import {deriveEvent, deriveEventsById} from "@app/repository"
   import {decodeRelay} from "@app/relays"
 
   const {relay, id} = $page.params as MakeNonOptional<typeof $page.params>
   const url = decodeRelay(relay)
   const event = deriveEvent(id, [url])
   const filters = [{kinds: [COMMENT], "#E": [id]}]
-  const comments = deriveEventsAsc(deriveEventsById({repository, filters}))
+  const comments = deriveEventsAsc(deriveEventsById(filters))
 
   const back = () => history.back()
 
@@ -46,7 +45,7 @@
   onMount(() => {
     const controller = new AbortController()
 
-    request({
+    $network.request({
       relays: [url],
       filters: [{kinds: [POLL], ids: [id]}, {kinds: [POLL_RESPONSE], "#e": [id]}, ...filters],
       signal: controller.signal,
diff --git a/src/routes/spaces/[relay]/threads/+page.svelte b/src/routes/spaces/[relay]/threads/+page.svelte
index 026c2f12..cf935291 100644
--- a/src/routes/spaces/[relay]/threads/+page.svelte
+++ b/src/routes/spaces/[relay]/threads/+page.svelte
@@ -5,7 +5,7 @@
   import {page} from "$app/stores"
   import {sortBy, partition, spec, max, pushToMapKey, groupBy} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {THREAD, getTagValue} from "@welshman/util"
+  import {THREAD, tagValue, tagSpec} from "@welshman/util"
   import NotesMinimalistic from "@assets/icons/notes-minimalistic.svg?dataurl"
   import Add from "@assets/icons/add.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
@@ -16,7 +16,7 @@
   import ThreadBoard from "@app/components/ThreadBoard.svelte"
   import ThreadCreate from "@app/components/ThreadCreate.svelte"
   import {decodeRelay} from "@app/relays"
-  import {displayRoom} from "@app/groups"
+  import {displayRoom} from "@app/rooms"
   import {makeCommentFilter} from "@app/content"
   import {makeFeed} from "@app/feeds"
   import {pushModal} from "@app/modal"
@@ -34,7 +34,7 @@
     const [threads, comments] = partition(spec({kind: THREAD}), $events)
 
     for (const comment of comments) {
-      const id = getTagValue("E", comment.tags)
+      const id = tagValue(tagSpec("E"), comment.tags)
 
       if (id) {
         pushToMapKey(scores, id, comment.created_at)
@@ -43,7 +43,7 @@
 
     const items = sortBy(e => -max([...(scores.get(e.id) || []), e.created_at]), threads)
 
-    const byRoom = groupBy(e => getTagValue("h", e.tags) || "", items)
+    const byRoom = groupBy(e => tagValue(tagSpec("h"), e.tags) || "", items)
     const roomName = (h: string) => (h ? displayRoom(url, h) : "general").toLowerCase()
     const boards = sortBy(([h]) => roomName(h), Array.from(byRoom.entries()))
 
diff --git a/src/routes/spaces/[relay]/threads/[id]/+page.svelte b/src/routes/spaces/[relay]/threads/[id]/+page.svelte
index 8ae064dd..78dd5cf6 100644
--- a/src/routes/spaces/[relay]/threads/[id]/+page.svelte
+++ b/src/routes/spaces/[relay]/threads/[id]/+page.svelte
@@ -3,13 +3,12 @@
   import * as nip19 from "nostr-tools/nip19"
   import {page} from "$app/stores"
   import {goto} from "$app/navigation"
-  import {sleep} from "@welshman/lib"
+  import {sleep, spec} from "@welshman/lib"
   import type {MakeNonOptional} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {COMMENT, getTagValue} from "@welshman/util"
-  import {repository} from "@welshman/app"
+  import {deriveEventsAsc} from "@welshman/store"
+  import {COMMENT, tagValue, tagSpec} from "@welshman/util"
   import {request} from "@welshman/net"
-  import {deriveEventsById, deriveEventsAsc} from "@welshman/store"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
@@ -21,7 +20,7 @@
   import ThreadPagination from "@app/components/ThreadPagination.svelte"
   import EventReply from "@app/components/EventReply.svelte"
   import RoomName from "@app/components/RoomName.svelte"
-  import {deriveEvent} from "@app/repository"
+  import {deriveEvent, deriveEventsById} from "@app/repository"
   import {decodeRelay} from "@app/relays"
   import {makeSpacePath, scrollToEvent} from "@app/routes"
 
@@ -31,7 +30,7 @@
   const url = decodeRelay(relay)
   const event = deriveEvent(id, [url])
   const filters = [{kinds: [COMMENT], "#E": [id]}]
-  const replies = deriveEventsAsc(deriveEventsById({filters, repository}))
+  const replies = deriveEventsAsc(deriveEventsById(filters))
 
   const back = () => history.back()
 
@@ -42,7 +41,7 @@
   })
 
   const replyCount = $derived(Math.max(0, posts.length - 1))
-  const h = $derived(getTagValue("h", $event?.tags || []))
+  const h = $derived(tagValue(tagSpec("h"), $event?.tags || []))
 
   const pageCount = $derived(Math.max(1, Math.ceil(posts.length / POSTS_PER_PAGE)))
 
@@ -121,7 +120,7 @@
       return
     }
 
-    const index = posts.findIndex(post => post.id === eventId)
+    const index = posts.findIndex(spec({id: eventId}))
 
     if (index < 0) return
 
@@ -151,7 +150,7 @@
   {#snippet title()}
     <div class="flex min-w-0 flex-col gap-0.5">
       <h1 class="truncate min-w-0 font-bold sm:text-xl">
-        {getTagValue("title", $event?.tags || []) || ""}
+        {tagValue(tagSpec("title"), $event?.tags || []) || ""}
       </h1>
       <p class="text-xs opacity-75">
         {replyCount}