fix: deleted rooms persisting in navigation

Co-authored-by: userAdityaa <aditya.chaudhary1558@gmail.com>
Co-committed-by: userAdityaa <aditya.chaudhary1558@gmail.com>

.ackrc

@@ -1,8 +1,10 @@
 --ignore-dir=.svelte-kit
 --ignore-dir=android
+--ignore-dir=target
 --ignore-dir=build
 --ignore-dir=ios/DerivedData
 --ignore-dir=ios/App/App/public
+--ignore-dir=ios/App/Pods
 --ignore-file=match:.svg
 --ignore-file=match:package-lock.json
 

.dockerignore

@@ -2,3 +2,10 @@ node_modules
 android
 ios
 build
+
+# Git
+.gitignore
+
+# Env files (keep .env for build; exclude local overrides)
+.env.local
+.env.*.local

.env

@@ -1,6 +1,6 @@
 VITE_DEFAULT_PUBKEYS=06639a386c9c1014217622ccbcf40908c4f1a0c33e23f8d6d68f4abf655f8f71,266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5,391819e2f2f13b90cac7209419eb574ef7c0d1f4e81867fc24c47a3ce5e8a248,3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d,3f770d65d3a764a9c5cb503ae123e62ec7598ad035d836e2a810f3877a745b24,55f04590674f3648f4cdc9dc8ce32da2a282074cd0b020596ee033d12d385185,58c741aa630c2da35a56a77c1d05381908bd10504fdd2d8b43f725efa6d23196,61066504617ee79387021e18c89fb79d1ddbc3e7bff19cf2298f40466f8715e9,6389be6491e7b693e9f368ece88fcd145f07c068d2c1bbae4247b9b5ef439d32,63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed,6e75f7972397ca3295e0f4ca0fbc6eb9cc79be85bafdd56bd378220ca8eee74e,76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa,7fa56f5d6962ab1e3cd424e758c3002b8665f7b0d8dcee9fe9e288d7751ac194,82341f882b6eabcd2ba7f1ef90aad961cf074af15b9ef44a09f9d2a8fbfbe6a2,84dee6e676e5bb67b4ad4e042cf70cbd8681155db535942fcc6a0533858a7240,97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322,b676ded7c768d66a757aa3967b1243d90bf57afb09d1044d3219d8d424e4aea0,dace63b00c42e6e017d00dd190a9328386002ff597b841eb5ef91de4f1ce8491,eeb11961b25442b16389fe6c7ebea9adf0ac36dd596816ea7119e521b8821b9e,fe7f6bc6f7338b76bbf80db402ade65953e20b2f23e66e898204b63cc42539a3
 VITE_DEFAULT_BLOSSOM_SERVERS=https://blossom.primal.net/
-VITE_BURROW_URL=
+VITE_POMADE_SIGNERS=https://pomade.coracle.social,https://pomade.fiatjaf.com,https://pomade.nostrver.se,https://pomade.scuttle.works
 VITE_PLATFORM_URL=https://app.flotilla.social
 VITE_PLATFORM_TERMS=https://flotilla.social/terms
 VITE_PLATFORM_PRIVACY=https://flotilla.social/privacy
@@ -10,10 +10,15 @@ VITE_PLATFORM_RELAYS=
 VITE_PLATFORM_ACCENT="#7161FF"
 VITE_PLATFORM_SECONDARY="#EB5E28"
 VITE_PLATFORM_DESCRIPTION="Flotilla is nostr — for communities."
-VITE_INDEXER_RELAYS=wss://purplepag.es/,wss://relay.damus.io/,wss://relay.nostr.band/,wss://indexer.coracle.social/
-VITE_SIGNER_RELAYS=wss://relay.nsec.app/,wss://offchain.pub/
-VITE_NOTIFIER_PUBKEY=27b7c2ed89ef78322114225ea3ebf5f72c7767c2528d4d0c1854d039c00085df
-VITE_NOTIFIER_RELAY=wss://anchor.coracle.social/
+VITE_PUSH_SERVER=https://nps.flotilla.social/
+VITE_PUSH_BRIDGE=wss://npb.coracle.social/
+VITE_BLOCKED_RELAYS=brb.io,relay.nostr.band,nostr.mutinywallet.com,feeds.nostr.band,nostr.zbd.gg,wot.utxo.one,blastr.f7z.xyz,relay.current.fyi
+VITE_INDEXER_RELAYS=purplepag.es,relay.damus.io,indexer.coracle.social
+VITE_DEFAULT_RELAYS=relay.damus.io,relay.primal.net,nostr.mom
+VITE_DEFAULT_SEARCH_RELAYS=relay.ditto.pub,antiprimal.net,relay.vertexlab.io
+VITE_DEFAULT_MESSAGING_RELAYS=auth.nostr1.com,relay.keychat.io,relay.ditto.pub
+VITE_SIGNER_RELAYS=relay.nsec.app,ephemeral.snowflare.cc,bucket.coracle.social
 VITE_VAPID_PUBLIC_KEY=BIt2D4BdgdbCowD_0d3Np6GbrIGHxd7aIEUeZNe3hQuRlHz02OhzvDaai0XSFoJYVzSzdMjdyW-QhvW9_yq8j4Y
+VITE_THUMBNAIL_URL=https://vthumbs.coracle.social
 VITE_GLITCHTIP_API_KEY=
 GLITCHTIP_AUTH_TOKEN=

.fdignore

@@ -1,4 +1,6 @@
 src/assets
+.claude
+target
 build
 .idea
 .gradle
@@ -12,4 +14,4 @@ ios/App/Pods/
 android/capacitor-cordova-android-plugins
 android/app/src/androidTest
 android/app/src/test
-
+node_modules

.gitea/workflows/container-publish.yml

@@ -1,12 +1,17 @@
-name: Docker
+name: Container Image Build and Publish
 
 on:
   push:
-    branches: ['master']
+    branches: [master]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
 env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}
+  REGISTRY: gitea.coracle.social
+  IMAGE_NAME: coracle/flotilla
 
 jobs:
   build-and-push-image:
@@ -14,8 +19,6 @@ jobs:
     permissions:
       contents: read
       packages: write
-      attestations: write
-      id-token: write
 
     steps:
       - name: Checkout repository
@@ -25,8 +28,8 @@ jobs:
         uses: docker/login-action@v3
         with:
           registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+          username: hodlbod
+          password: ${{ secrets.PACKAGE_TOKEN }}
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
@@ -34,6 +37,7 @@ jobs:
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
           tags: |
+            type=sha
             type=raw,value=latest,enable=${{ github.ref == 'refs/heads/master' }}
 
       - name: Set up Docker Buildx
@@ -47,13 +51,7 @@ jobs:
         with:
           context: .
           push: true
+          target: production
           platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-
-      - name: Generate artifact attestation
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
-          subject-digest: ${{ steps.push.outputs.digest }}
-          push-to-registry: true

.gitignore

@@ -1,5 +1,6 @@
 # Env
-.env
+.env.local
+.env.*.local
 
 # Vite
 vite.config.js.timestamp-*
@@ -24,8 +25,11 @@ android/app/src/main/assets/public/
 
 # Web/JavaScript
 node_modules/
+.pnpm-store/
 build/
+build-server/
 .svelte-kit/
+.next/
 
 # iOS
 ios/App/App/public
@@ -63,7 +67,9 @@ GoogleService-Info.plist
 .roo
 .idea/
 .vscode/
+.claude/
 
 # OS generated
 .DS_Store
 Thumbs.db
+package-lock.json

.prettierrc

@@ -5,6 +5,6 @@
   "svelteSortOrder": "options-styles-scripts-markup",
   "arrowParens": "avoid",
   "bracketSpacing": false,
-  "plugins": ["prettier-plugin-svelte", "prettier-plugin-tailwindcss"],
+  "plugins": ["prettier-plugin-tailwindcss", "prettier-plugin-svelte"],
   "overrides": [{"files": "*.svelte", "options": {"parser": "svelte"}}]
 }

AGENTS.md

@@ -0,0 +1,268 @@
+## Project Overview
+
+Flotilla is a Nostr "relays as groups" community chat client. It implements NIP-29 (relay-based groups) to create Discord-like spaces (servers) and rooms (channels).
+
+**Tech Stack:**
+
+- SvelteKit 5.48+ with TypeScript 5.9+
+- Capacitor for cross-platform (Web/PWA, Android, iOS)
+- TailwindCSS + DaisyUI for styling
+- Welshman library suite for Nostr protocol
+- IndexedDB for local storage
+- Vite for building
+
+**Key Concepts:**
+
+- **Spaces** - Relays used as community groups (like Discord servers)
+- **Rooms** - NIP-29 groups within spaces (like Discord channels), identified by `h`
+- **Chats** - Direct message conversations (NIP-04/NIP-44 encrypted)
+
+## Architecture & Dependency Graph
+
+The project follows a **strict acyclic dependency hierarchy**:
+
+```
+routes/                    (top layer - can depend on anything)
+  ↓
+app/components/            (can depend on app/* and lib/*)
+  ↓
+app/core/ & app/util/      (can only depend on lib/*)
+  ↓
+lib/                       (can only depend on external libraries)
+  ↓
+external libraries         (bottom layer)
+```
+
+**Import Ordering Convention (CRITICAL):**
+Always sort imports by dependency level:
+
+1. Third-party libraries first
+2. Then `lib/` imports
+3. Then `app/` imports
+
+Example:
+
+```typescript
+import {derived} from "svelte/store"
+import {throttle} from "throttle-debounce"
+import {Dialog} from "$lib/components"
+import {repository} from "$app/core/state"
+```
+
+## File Structure
+
+```
+src/
+├── lib/                          # Generic reusable code
+│   ├── components/               # 38 UI components (Button, Dialog, etc.)
+│   ├── html.ts                   # DOM utilities
+│   ├── indexeddb.ts              # IndexedDB helpers
+│   └── util.ts                   # Generic utilities
+│
+├── app/
+│   ├── core/
+│   │   ├── state.ts              # State management, stores, constants (687 lines)
+│   │   ├── commands.ts           # Publishing events and other write operations (440+ lines)
+│   │   ├── requests.ts           # Loading data from network (191 lines)
+│   │   ├── sync.ts               # Data synchronization (296 lines)
+│   │   └── storage.ts            # IndexedDB setup
+│   │
+│   ├── util/
+│   │   ├── notifications.ts      # Push notifications (731 lines)
+│   │   ├── policies.ts           # Relay policies
+│   │   ├── routes.ts             # Routing helpers
+│   │   ├── modal.ts              # Modal management
+│   │   ├── toast.ts              # Toast notifications
+│   │   ├── theme.ts              # Theme switching
+│   │   └── keyboard.ts           # Keyboard handling
+│   │
+│   ├── editor/                   # Rich text editor config
+│   │   ├── index.ts              # TipTap setup with Nostr integration
+│   │   ├── EditorContent.svelte
+│   │   └── MentionNodeView.ts
+│   │
+│   └── components/               # 188 app-specific components
+│       ├── Space*.svelte         # Space/relay management
+│       ├── Room*.svelte          # Room/channel management
+│       ├── Chat*.svelte          # Direct messaging
+│       ├── Profile*.svelte       # User profiles
+│       ├── Thread*.svelte        # Threaded posts
+│       └── ...
+│
+├── routes/                       # SvelteKit file-based routing
+│   ├── +layout.svelte            # Root layout (sync logic here)
+│   ├── spaces/                   # Space management
+│   │   └── [relay]/              # Specific space
+│   │       ├── chat/             # Space chat
+│   │       ├── threads/          # Thread posts
+│   │       ├── calendar/         # Events
+│   │       └── [h]/              # Specific room (h = room id)
+│   ├── chat/                     # Direct messages
+│   ├── settings/                 # User settings
+│   └── [bech32]/                 # Bech32 entity viewer
+│
+├── assets/icons/                 # ~1,277 SVG icons
+├── app.html                      # HTML template
+├── app.css                       # Global styles
+└── types.d.ts                    # Type definitions
+```
+
+## State Management
+
+**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`
+
+**Thunks:**
+
+- Reduce UI latency by handling signatures and sending in background
+- Return status that should be displayed to user
+- Allow cancellation and error handling
+- Immediately publish to local repository for optimistic updates
+
+## Nostr Integration
+
+**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/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
+
+**Key NIPs Implemented:**
+
+- NIP-01: Basic protocol
+- NIP-44/59/17: Encrypted DMs
+- NIP-07: Browser extension signing
+- NIP-19: Bech32 encoding
+- NIP-29: Relay-based Groups
+- NIP-42: Relay authentication
+- NIP-43: Relay membership
+- NIP-46: Nostr Connect (remote signing)
+- NIP-57: Lightning Zaps
+
+## Development Conventions
+
+**Component Parameterization:**
+
+- Only pass entity identifiers (`url` for spaces, `h` for rooms)
+- Derive all other data inside the component from identifiers
+- Example: Don't pass `members` prop, derive it from `h` inside component
+
+**CRITICAL Code Style Guidelines:**
+
+- **No `null`** - only use `undefined`
+- Svelte 5 runes (`$state`, `$derived`, `$effect`) only in UI components
+- TailwindCSS and DaisyUI styling
+- Only add comments for really weird stuff
+- Do not call functions in components unless a parameter is reactive. Instead, use a svelte store or rune to make it reactive.
+- Do not use `any`. If there are type errors related to `unknown`, they are likely because the upstream definition of the data is incorrect.
+- When dynamically building classes, use `cx` from `classnames` rather than embedded ternaries or svelte 4's old `class:` syntax.
+- When creating forms, use `FieldInline` or `Field` instead of custom elements/tailwindcss
+- Do not define svelte event handlers inline, instead name them and put them in the script section of templates
+- Avoid using `as`, except where necessary. Instead, annotate function parameters, and ensure upstream values are typed correctly.
+- Instead of `getTag(tagName, event.tags)?.[1] || ""`, use `getTagValue(tagName, event.tags)`
+
+**Human-First Simplicity (Jon Staab Style):**
+
+- Prefer direct, readable code over layered abstractions.
+- Do not add indirection (extra helpers, wrappers, stores, or derived state) unless it removes real repeated complexity.
+- Reuse existing Welshman and Flotilla primitives before introducing new utilities or dependencies.
+- Favor linear control flow and explicit naming over clever patterns.
+- Remove defensive checks that do not apply in this runtime model.
+- When two approaches work, pick the one that feels more human and easier to maintain.
+
+## Common Tasks
+
+### Adding a New Component
+
+1. Determine if it's generic (`lib/components/`) or app-specific (`app/components/`)
+2. Follow naming convention: `PascalCase.svelte`
+3. Import in dependency order (3rd party → lib → app)
+4. Use stores for state, runes only for UI reactivity
+
+### Creating a New Route
+
+1. Add to `src/routes/` following SvelteKit conventions
+2. Use `+page.svelte` for page component
+3. Use `+layout.svelte` for shared layouts
+4. Top-level sync logic goes in root `+layout.svelte`
+
+### 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`
+
+### 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`
+
+### Managing Modals/Toasts
+
+- Import from `app/util/modal.ts` or `app/util/toast.ts`
+- Pass component objects with parameters
+- Use `$state.snapshot` if calling component might unmount
+
+## Development Workflow
+
+Agents should not run the dev server or build the app. Instead, use the following commands:
+
+```bash
+pnpm run format           # Format changed files
+pnpm run lint             # Check formatting and linting
+pnpm run check            # Type check
+```
+
+**Welshman Development:**
+
+- Clone welshman to parent directory
+- Use `./link_deps` script to link local welshman packages
+- Avoid committing `pnpm.overrides` changes
+
+**Git Workflow:**
+
+- `master` branch auto-deploys to production
+- Work on feature branches based on `dev` branch
+- Pre-commit hooks run lint/typecheck automatically
+
+## Environment Variables
+
+See `.env.template` for all options.
+
+## Important Files to Reference
+
+- **src/app/core/state.ts** - All stores and constants
+- **src/app/core/sync.ts** - Data synchronization
+- **src/app/core/requests.ts** - Utilities for requesting data
+- **src/app/core/commands.ts** - Publishing patterns
+- **src/app/util/notifications.ts** - Notification badges and push notifications
+- **src/routes/+layout.svelte** - Top-level sync logic
+
+## Mobile Development
+
+**Capacitor Integration:**
+
+- Android: Full support, APK builds via `pnpm run release:android`
+- iOS: Full support (zaps disabled due to App Store policy)
+- PWA: Progressive Web App with service worker
+
+**Native Features:**
+
+- Push notifications (FCM/APNs)
+- Deep linking (nostr: and https: URLs)
+- Native signing plugin
+- Keyboard management
+- Safe area handling
+- Badge management

CHANGELOG.md

@@ -1,5 +1,209 @@
 # Changelog
 
+# 1.8.0
+
+* Fix relay badge overflow
+* Suppress programmatic scroll when user is scrolling
+* Fix vertical alignment of emoji and overflow buttons in shared event action row
+* Use type=email for signup/login email inputs, validate password
+* Improve toggle switch placement on settings screens
+* Fix relay auth privacy toggle
+* Improve field layout
+* Add progress bar to signup flow
+* Bundle emojis properly
+* Rework hosting page
+* Fix padding on pages on small screens
+* Add richer link preview support
+* Fix pasting into event summary
+* Publish fewer join/claim requests
+* Fix new messages not rendering in safari
+* Avoid capturing stale cleanup function in chat
+* Hide keyboard on app resume
+* Add email rendering support
+* Fix bunker login
+* Fix undefined chat draft key
+* Allow sharing to chat without a message
+* Make sure to show date on calendar events when embedded
+* Improve space search
+
+# 1.7.4
+
+* Fix safe area inset for FAB
+
+# 1.7.3
+
+* Add native share support for space invites
+* Stop sending duplicate requests per room
+* Add more robust thumbnail url generation
+* Make space reordering discoverable with smoother drag animation
+* Improve relay member list
+* Add room mentions and clickable room/relay refs
+* Support native clipboard image paste on mobile
+* publish kind 9 quote after room content creation for cross-client interoperability
+* Improve feed pagination logic and performance
+* Support Aegis URL scheme for NIP-46 login
+* Various UI and bug fixes
+* Raise message size limit in chat
+* Fix realtime updates for room members and admins
+* Add video to calls
+* Remove follow graph building
+* Add start chat FAB
+* Add drafts
+* Redesign toast notifications
+* Remove room/space leave indications
+* Hide report badge for non-admin users
+* Add polls
+* Add search to recent activity page
+* Fix notification badge on mobile nav
+* Change audio devices in call
+
+# 1.7.2
+
+* Fix race condition in nip 46
+* Remove duplicate spaces button
+* Combine discover and space list pages
+* Fix some chat related bugs
+* Fix bug with joining spaces
+
+# 1.7.1
+
+* Fix pomade registration fallback in case of offline signer
+
+# 1.7.0
+
+* Enable email/password login
+* Add up/edit to direct messages
+* Fix a number of UI bugs
+* Improve navigation on mobile
+* Improve performance and syncing reliability
+* Add proof of work to DMs
+* Detect blossom support using supported_nips
+* Improve notification badges
+* Add voice rooms (@mplorentz)
+* Re-design relay onboarding and settings
+* Add android fallback for push notifications
+* Fix file uploads on android
+
+# 1.6.5
+
+* Attempt to fix permission grant for notifications
+* Make sync logic more robust
+* Add unban/unallow support
+* Improve support for downloading/opening protected images
+* Add manual send/receive to wallet
+* Show wallet status when wallet is unreachable
+* Update nostr signer capacitor plugin
+* Fix some safe area insets
+* Update NIP 55 signer plugin (fixes Primal login)
+* Refine space join dialogs and discover page
+* Reopen the last DM that was open when navigating back to chat
+* Get rid of ChatEnable interstitial
+* Enable auth for relays we're publishing to
+* Drag and drop space icons
+* Add better muting support
+* Add back button to settings menu
+* Add page titles
+* Improve scroll to event behavior
+* Add in-memory search to rooms
+* Fix editing messages with html tags
+* Fix DM media detection
+* Clean up reporting dialogs
+* Improve room detail
+
+# 1.6.4
+
+* Clean up modal design
+* Fix overflowing popovers
+* Use space urls for relay hints
+* Re-work notification badges
+* Add push notification support via NIP 9a
+* Optimistically load messaging relays to avoid unnecessary warning
+* Recover from indexeddb not being available
+* Fix safe area inset support
+* Show space URL in top bar on mobile
+* Fix calendar detail page
+* Improve relay synchronization, especially for pyramid and relay29
+* Improve invite code error handling
+* Add wallet receive flow
+* Fix safari image uploads
+* Re-work recent activity page
+* Add classified listing content type
+* Use address for page param for replaceable events
+* Refine discover page to avoid slowness
+* Upgrade som dependencies
+* Tag event author when tagging parent event
+* Disable macos build
+* Add room muting
+
+# 1.6.3
+
+* Fix scroll down button z index
+* Hide tooltips on mobile
+* Sort comments ascending
+* Make video embeds rounded
+* Fix ProfileMultiSelect styling
+* Accept hex pubkeys/npubs/nprofiles in ProfileMultiSelect
+* Tweak room edit form design
+* Report pending signer to user
+* Update default relays
+* Fix chat list responsiveness
+* Fix memory leak, notification badge not showing
+* Improve space join flow
+* Fix opening images in fullscreen dialog
+* Add support for blocked relays
+* Add authentication policy setting
+* Add login with key if no signer is detected
+* Publish default relay selections on signup
+
+# 1.6.2
+
+* Fix modal scrolling and style
+
+# 1.6.1
+
+* Fix skinny profile images
+* Custom handler for relay urls
+* Improve time based chat partitioning
+* Improve authenticated image access interop
+* Fix image detail dialog
+* Fix zapper loading
+* Fix recent events missing in feeds
+
+# 1.6.0
+
+* Switch back to indexeddb to fix memory and performance
+* Add pay invoice functionality
+* Add space membership management and bans
+* Add event info to profile dialog
+* Add better room membership management
+* Refactor stores for performance
+* Hide nav when keyboard is open
+* Handle flotilla links in-app
+* Fix new messages indicator z-index
+* Fix some display bugs
+* Add date to chat items
+* Refine data synchronization
+* Hide nav when keyboard is open on mobile
+
+# 1.5.3
+
+* Add space edit form
+* Improve room syncing
+* Return better blossom errors
+* Fix access restricted bugs
+* Add room detail dialog
+* Fix broken link to self hosting
+* Tweak shadows
+* Always join spaces when visiting them
+
+# 1.5.2
+
+* Fix negentropy room syncing
+
+# 1.5.1
+
+* Fix chat path link
+
 # 1.5.0
 
 * Restyle mobile dialogs

CONTRIBUTING.md

@@ -1,96 +1,56 @@
-# Contributing guidelines
-
 ## Project Overview
 
-Flotilla is a svelte/typescript/capacitor project. It's intended to be an alternative to Discord for Nostr users. A high-quality UX is a priority, with an emphasis on well-tested, intuitive designs, and robust implementations.
+Flotilla is a Nostr "relays as groups" community chat client. It implements NIP-29 (relay-based groups) to create Discord-like spaces (servers) and rooms (channels).
 
-## Getting Started
+Please visit our [issue tracker](https://gitea.coracle.social/coracle/flotilla/issues) to contribute. Any new issues should be opened without a milestone, label, or project and the project owners will triage them.
 
-Run `pnpm run dev` to get a dev server, and `pnpm run check:watch` to watch for typescript errors. When you're ready to commit, a pre-commit hook will run to lint and typecheck your work. To run the project on Android or iOS, use Android Studio or Xcode.
+### Milestones
 
-The `master` branch is automatically deployed to production, so always work on feature branches based on the `dev` branch. This project frequently uses unreleased versions of [welshman](https://welshman.coracle.social), using `pnpm` link to hotlink a local copy of the code. To set that up, clone welshman to the parent directory of your `coracle` client, then add `link:../welshman/packages/packagename` to the `pnpm.overrides` section of your `package.json`. Below is a nodejs script that will do that automatically for you:
+Milestones indicate how soon a given task should be tackled.
 
-```javascript
-#!/usr/bin/env node
+- [Current](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&milestone=1) issues are immediately actionable.
+- [Next](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&milestone=2) means an issue is blocked.
+- [Future](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&milestone=3) means we're deferring work until a later date.
 
-import fs from 'fs'
-import path from 'path'
+### Labels
 
-const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'))
+- [Design](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&labels=15) issues need design work before being implemented. This might take the form of a high-quality mockup, wireframes, user flows, or just a couple notes about where things go, depending on the nature of the task.
+- [Dev](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&labels=16) issues are ready to be implemented. Most of the work will be related to architecting and writing code.
+- [Easy](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&labels=14) issues have no dependencies, and are scoped quite narrowly.
+- [Priority](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&labels=6) issues include bugs and urgent feature requests. These should get attention first if possible, although sometimes long-standing performance issues or subtle bugs might end up here for a while.
+- [Ideas](https://gitea.coracle.social/coracle/flotilla/issues?type=all&state=open&labels=13) are for things that aren't scoped out yet, or which need protocol work before getting designed or implemented.
 
-packageJson.pnpm.overrides = Object.keys(packageJson.dependencies)
-  .filter(pkg => pkg.startsWith('@welshman/'))
-  .reduce((acc, pkg) => {
-    const packageName = pkg.split('/')[1]
-    acc[pkg] = `link:../welshman/packages/${packageName}`
-    return acc
-  }, {})
+### Projects
 
-fs.writeFileSync('./package.json', JSON.stringify(packageJson, null, 2) + '\n')
+Issues may or may not have a project. Projects are used to group issues thematically just for organization.
 
-console.log('Added welshman package overrides.')
-```
+## Coding conventions
 
-Be sure to avoid committing overrides to either `package.json` or `pnpm-lock.yaml`. These overrides can generally be added, installed, and removed, and will persist until another `pnpm install` command gets run.
+There are a few conventions that are helpful to know right out of the gate.
 
-## File Structure
+- Most nostr protocol functionality is implemented via the [welshman library](https://welshman.coracle.social/)
+- Use Svelte 4 **stores** rather than runes for all state outside UI components
+- Most global state flows through Welshman's `repository` (unidirectional)
+- Query state using `deriveEventsMapped` or `deriveProfile` etc
+- Events are published via `publishThunk`, which allows for optimistic UI updates during signing/pow generation.
+- Components should have minimal props - e.g. instead of passing a whole `relay` through, pass its `url`.
+- Use `AbortController` when possible instead of request ids
+- Use `undefined` or optional properties instead of `null`
+- Do not use `any`. If there are type errors related to `unknown`, they are likely because the upstream definition of the data is incorrect.
+- Avoid using `as`, except where necessary. Instead, annotate function parameters, and ensure upstream values are typed correctly.
+- When dynamically building classes, use `cx` from `classnames`.
+- Do not define svelte event handlers inline, instead name them and put them in the script section of templates.
 
-The main parts of the application are as follows:
+## Contributing Workflow
 
-- `static` - static assets like fonts, images, etc.
-- `src/assets` - svgs for use as icons.
-- `src/lib` - general purpose components and utilities.
-- `src/app/core/state` - environment variables, constants, custom stores, and some utilities derived from them.
-- `src/app/core/requests` - utilities related to loading data from the nostr network.
-- `src/app/core/commands` - utilities related to publishing nostr events and uploading media to blossom servers.
-- `src/app/utils` - other application logic, including stuff related to modals, routing, etc.
-- `src/app/editor` - configuration for `@welshman/editor` for use in various app views.
-- `src/app/components` - reusable components that depend on other `app` stuff.
-- `src/routes` - file-based routing interpreted by sveltekit.
-
-Application organization is based on an acyclic dependency graph:
-
-- `routes` can depend on anything
-- `app/components` can depend on anything in `app` or `lib`
-- `app/utils` and `app/core` can only depend on `lib`
-- `lib` (and everything else) can depend only on external libraries
-
-The main stylistic/organizational rule when working in this project is that imports should be sorted based on the dependency graph. Third-party libraries should come first, then `lib`, then `app`.
-
-## System Architecture
-
-Flotilla's architecture generally mirrors the file structure. State is stored using Svelte `store`s provided either by `@welshman/app` or by `app/core/state`, allowing for idiomatic svelte 4 usage (svelte 5 runes are [ghey](https://habla.news/u/hodlbod@coracle.social/1739830562159) and not allowed outside of UI components).
-
-State is then synchronized to local storage or indexeddb using storage helpers provided by welshman in `routes/+layout.svelte`. Other top level synchronization logic generally belongs there.
-
-`app/core/state` contains all environment variables, constants, custom stores, and utilities derived from them. Most stores are `derived` from our event `repository` using `deriveEventsMapped`, which efficiently queries the repository and maps events to custom data structures. Some of these data structures are provided by `welshman`, and some are defined in `app/core/state`. In either case, they can always be mapped back to an event, which is important for updating replaceables without dropping unknown data.
-
-Here are a few important domain objects:
-
-- Spaces are relays used as community groups. Their `url`s are core to a lot of data and components, and are frequently passed around from place to place.
-- Chats are direct message conversations. There is currently some ambiguity in routing, since relays that don't support NIP 29 also have a "chat" tab, which uses vanilla NIP-C7.
-- NIP 29 groups are called "rooms". Conventionally, "h" is a group id, while a "room" as an object representing the group's metadata.
-- "Alerts" are records of requests the user has made to be notified, following [this NIP](https://github.com/nostr-protocol/nips/pull/1796)
-
-`app/core/requests` contains utilities related to loading data from the nostr network. This might include feed manager utilities, loaders, or listeners.
-
-`app/core/commands` contains utilities related to publishing nostr events and uploading media to blossom servers. This also includes utilities related to sending lighting payments, authenticating with relays, or probing relay policy. Event creation should generally be split into `make` functions which build the event, and `publish` functions which publish the event using `publishThunk`.
-
-Any of these utilities can be included either in `app/components` or `routes`. Crucial to keep in mind is that nearly all global state runs through welshman's `repository` in a unidirectional way. To update state, run `publishThunk`, which immediately publishes the event to the local repository. State can be read from the repository using `deriveEventsMapped` or other utilities provided by welshman like `deriveProfile`.
-
-Thunks are designed to reduce UI latency, handling signatures and delayed sending the background. In most cases, thunk status should be displayed to the user so that they can cancel sending or address errors.
-
-Toast, modals, and sidebar dialogs are controlled in `app/util/modal` and `app/util/toast`. In both cases, component objects can be passed along with parameters, but care has to be taken that the calling component either doesn't unmount before the modal (as when one modal replaces another), or that `$state.snapshot` is appropriately called on any state runes. These components frequently run into weird svelte compiler bugs too, in which case you may have to do some silly things to cope.
-
-## Issues and Pull Requests
-
-All work by contributors should be done against an issue. If there is no issue for the work you're doing, please open one or ask the project owner to open one. All PRs should be opened against the `dev` branch (unless for hotfixes).
-
-## Communication
-
-Discussion about development is done [on Flotilla](https://app.flotilla.social/spaces/internal.coracle.social). The group is currently closed, so please let me know if you'd like access.
-
-## Project License
-
-This project is licensed under the MIT license. By contributing, you agree to waive all intellectual property rights to your contributions to this project.
+To contribute, do the following:
 
+- Find or create an issue and assign yourself (comment instead if you're not able to self-assign)
+- If the issue is a design task, attach or link out to any mockups/wireframes/flowcharts
+- Once a design task is completed, a maintainer will remove the `design` label and add the `dev` label
+- If the issue is a development task, fork the repository and create a branch prefixed by the issue number, e.g. `105-deep-links`
+- Before requesting a review, be sure to review any agent-generated code, run the pre-commit hooks, and test the changes.
+- Open a PR and request a review. A maintainer will get back to you with requested changes, or will merge the PR.
+- Keep your PR up-to-date by rebasing frequently on `dev`. Avoid force-pushing to `dev`.
+- PRs are rebased, squashed, and merged to keep commit history simple.
+- An issue may have multiple PRs. Once complete, it can be closed.

Dockerfile

@@ -1,24 +1,31 @@
-FROM node:20-slim
+# Build and run the Flotilla web server.
+#
+#   docker build -t flotilla .
+#   docker run -p 3000:3000 flotilla
+#
+# Pass --build-arg VITE_BUILD_HASH=$(git rev-parse --short HEAD) to stamp the build.
+# A .env in the build context is picked up by build.sh for branding config.
 
-# Install pnpm
-RUN npm install -g pnpm@latest
+# https://pnpm.io/docker#example-3-build-on-cicd
+FROM node:24-slim AS builder
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable
 
-# Set working directory
 WORKDIR /app
-
-# Copy package files
-COPY package.json pnpm-lock.yaml ./
-
-# Install dependencies
-RUN pnpm i
-
-# Copy the rest of the application
-COPY . .
-
-# Build the application
 ENV NODE_OPTIONS=--max_old_space_size=16384
+COPY package.json pnpm-lock.yaml ./
+RUN pnpm i --frozen-lockfile
+COPY . .
+ARG VITE_BUILD_HASH
 RUN pnpm run build
+RUN pnpm run build:server
 
-# Default to serving the build directory
-CMD ["npx", "serve", "build"]
-
+FROM node:24-slim AS production
+ENV NODE_ENV=production
+WORKDIR /app
+COPY --from=builder /app/build /app/build
+COPY --from=builder /app/build-server/server.js /app/server.js
+EXPOSE 3000
+USER node
+CMD ["node", "server.js"]

README.md

@@ -6,23 +6,23 @@ If you would like to be interoperable with Flotilla, please check out this guide
 
 ## Environment
 
-You can also optionally create an `.env` file and populate it with the following environment variables (see `.env` for examples):
+You can also optionally create an `.env.local` file and populate it with the following environment variables (see `.env.template` for examples):
 
 - `VITE_DEFAULT_PUBKEYS` - A comma-separated list of hex pubkeys for bootstrapping web of trust
 - `VITE_PLATFORM_URL` - The url where the app will be hosted
 - `VITE_PLATFORM_NAME` - The name of the app
-- `VITE_PLATFORM_LOGO` - A logo url for the app
+- `VITE_PLATFORM_LOGO` - A logo url for the app. Can be a local path or https link. Must be a PNG file.
 - `VITE_PLATFORM_RELAYS` - A list of comma-separated relay urls that will make flotilla operate in "platform mode". Disables all space browse/add/select functionality and makes the first platform relay the home page.
 - `VITE_PLATFORM_ACCENT` - A hex color for the app's accent color
 - `VITE_PLATFORM_DESCRIPTION` - A description of the app
-- `VITE_GLITCHTIP_API_KEY` - A Sentry DSN for use with glitchtip (error reporting)
-- `GLITCHTIP_AUTH_TOKEN` - A glitchtip auth token for error reporting
+
+These values **won't** be used for a built version. Instead, env variables should be provided to `build.sh` directly or to the built container.
 
 If you're deploying a custom version of flotilla, be sure to remove the `plausible.coracle.social` script from `app.html`. This sends analytics to a server hosted by the developer.
 
 ## Development
 
-See [./CONTRIBUTING.md](CONTRIBUTING.md).
+See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Deployment
 
@@ -31,18 +31,18 @@ To run your own Flotilla, it's as simple as:
 ```sh
 pnpm install
 pnpm run build
-npx serve build
+pnpm run start
 ```
 
 Or, if you prefer to use a container:
 
 ```sh
-podman run -d -p 3000:3000 ghcr.io/coracle-social/flotilla:latest
+docker run -d -p 3000:3000 gitea.coracle.social/coracle/flotilla:latest
 ```
 
 Alternatively, you can copy the build files into a directory of your choice and serve it yourself:
 
 ```sh
 mkdir ./mount
-podman run -v ./mount:/app/mount ghcr.io/coracle-social/flotilla:latest bash -c 'cp -r build/* mount'
+docker run -v ./mount:/app/mount gitea.coracle.social/coracle/flotilla:latest bash -c 'cp -r build/* mount'
 ```

android/app/build.gradle

@@ -1,19 +1,20 @@
 apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
 
 android {
-    namespace "social.flotilla"
-    compileSdk rootProject.ext.compileSdkVersion
+    namespace = "social.flotilla"
+    compileSdk = rootProject.ext.compileSdkVersion
     defaultConfig {
         applicationId "social.flotilla"
         minSdk rootProject.ext.minSdkVersion
         targetSdk rootProject.ext.targetSdkVersion
-        versionCode 31
-        versionName "1.5.0"
+        versionCode 47
+        versionName "1.8.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
              // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61
-            ignoreAssetsPattern '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~'
+            ignoreAssetsPattern = '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~'
         }
     }
     buildTypes {
@@ -35,6 +36,10 @@ dependencies {
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"
     implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion"
+    implementation "androidx.work:work-runtime:2.10.3"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "com.squareup.okhttp3:okhttp:4.12.0"
+    implementation "fr.acinq.secp256k1:secp256k1-kmp-jni-android:0.22.0"
     implementation project(':capacitor-android')
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"

android/app/capacitor.build.gradle

@@ -9,12 +9,15 @@ android {
 
 apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle"
 dependencies {
+    implementation project(':aparajita-capacitor-secure-storage')
     implementation project(':capacitor-community-safe-area')
     implementation project(':capacitor-app')
+    implementation project(':capacitor-clipboard')
     implementation project(':capacitor-filesystem')
     implementation project(':capacitor-keyboard')
     implementation project(':capacitor-preferences')
     implementation project(':capacitor-push-notifications')
+    implementation project(':capacitor-share')
     implementation project(':capawesome-capacitor-android-dark-mode-support')
     implementation project(':capawesome-capacitor-badge')
     implementation project(':nostr-signer-capacitor-plugin')

android/app/src/main/AndroidManifest.xml

@@ -9,7 +9,7 @@
         android:theme="@style/AppTheme"
         android:usesCleartextTraffic="true">
         <activity
-            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode|navigation|density"
             android:name=".MainActivity"
             android:label="@string/title_activity_main"
             android:theme="@style/AppTheme.NoActionBarLaunch"
@@ -42,4 +42,9 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.CAMERA" />
+
+    <uses-feature android:name="android.hardware.camera.any" android:required="false" />
 </manifest>

android/app/src/main/java/social/flotilla/MainActivity.java

@@ -1,5 +1,15 @@
 package social.flotilla;
 
+import android.os.Bundle;
+
 import com.getcapacitor.BridgeActivity;
 
-public class MainActivity extends BridgeActivity {}
+import social.flotilla.notifications.AndroidPushFallbackPlugin;
+
+public class MainActivity extends BridgeActivity {
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    registerPlugin(AndroidPushFallbackPlugin.class);
+    super.onCreate(savedInstanceState);
+  }
+}

android/app/src/main/java/social/flotilla/notifications/AndroidPushFallbackPlugin.kt

@@ -0,0 +1,101 @@
+package social.flotilla.notifications
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequest
+import androidx.work.OutOfQuotaPolicy
+import androidx.work.PeriodicWorkRequest
+import androidx.work.WorkManager
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+
+@CapacitorPlugin(name = "AndroidPushFallback")
+class AndroidPushFallbackPlugin : Plugin() {
+  companion object {
+    const val PREFS_NAME = "CapacitorStorage"
+    const val KEY_STATE = "androidPushFallback.state"
+    const val UNIQUE_PERIODIC_WORK = "androidPushFallback.periodic"
+    const val UNIQUE_IMMEDIATE_WORK = "androidPushFallback.immediate"
+  }
+
+  private fun getPrefs(): SharedPreferences {
+    return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+  }
+
+  @PluginMethod
+  fun syncState(call: PluginCall) {
+    val state: JSObject? = call.getObject("state")
+
+    if (state != null) {
+      getPrefs().edit().putString(KEY_STATE, state.toString()).apply()
+
+      if (isEnabled(state.toString())) {
+        scheduleWork()
+      } else {
+        cancelWork()
+      }
+    }
+
+    call.resolve()
+  }
+
+  private fun isEnabled(rawState: String?): Boolean {
+    if (rawState == null || rawState.isEmpty()) {
+      return false
+    }
+
+    return try {
+      val state = JSONObject(rawState)
+      val subscriptions: JSONArray? = state.optJSONArray("subscriptions")
+      subscriptions != null && subscriptions.length() > 0
+    } catch (_: JSONException) {
+      false
+    }
+  }
+
+  private fun scheduleWork() {
+    val constraints = Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()
+
+    val workManager = WorkManager.getInstance(context)
+
+    val periodic = PeriodicWorkRequest.Builder(
+      AndroidPushFallbackWorker::class.java,
+      15,
+      TimeUnit.MINUTES,
+    ).setConstraints(constraints).build()
+
+    val immediate = OneTimeWorkRequest.Builder(AndroidPushFallbackWorker::class.java)
+      .setConstraints(constraints)
+      .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
+      .build()
+
+    workManager.enqueueUniquePeriodicWork(
+      UNIQUE_PERIODIC_WORK,
+      ExistingPeriodicWorkPolicy.UPDATE,
+      periodic,
+    )
+
+    workManager.enqueueUniqueWork(
+      UNIQUE_IMMEDIATE_WORK,
+      ExistingWorkPolicy.REPLACE,
+      immediate,
+    )
+  }
+
+  private fun cancelWork() {
+    val workManager = WorkManager.getInstance(context)
+    workManager.cancelUniqueWork(UNIQUE_IMMEDIATE_WORK)
+    workManager.cancelUniqueWork(UNIQUE_PERIODIC_WORK)
+  }
+}

android/app/src/main/java/social/flotilla/notifications/AndroidPushFallbackWorker.kt

@@ -0,0 +1,861 @@
+package social.flotilla.notifications
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.util.Log
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.app.ActivityManager
+import android.content.SharedPreferences
+import android.content.pm.PackageManager
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import fr.acinq.secp256k1.Secp256k1
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.json.JSONArray
+import org.json.JSONObject
+import social.flotilla.notifications.AndroidPushFallbackPlugin.Companion.KEY_STATE
+import social.flotilla.notifications.AndroidPushFallbackPlugin.Companion.PREFS_NAME
+import java.nio.charset.StandardCharsets
+import java.security.MessageDigest
+import java.security.SecureRandom
+import java.util.Arrays
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import android.util.Base64
+
+class AndroidPushFallbackWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
+  companion object {
+    private const val TAG = "PushFallback"
+    private const val CHANNEL_ID = "flotilla_fallback"
+    private const val CURSOR_PREFIX = "androidPushFallback.cursor."
+    private const val SOCKET_TIMEOUT_SECONDS = 30L
+    private const val REJECTED = "__REJECTED__"
+    private const val KIND_RELAY_AUTH = 22242
+    private const val KIND_NIP46_RPC = 24133
+    private val SECP = Secp256k1.get()
+  }
+
+  private val prefs: SharedPreferences =
+    context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+  private val client: OkHttpClient = OkHttpClient.Builder().build()
+
+  // ---- Socket pool ----
+
+  // Opens each relay URL at most once; caller must invoke closeAll() when done.
+  private inner class SocketPool {
+    private val sockets = ConcurrentHashMap<String, WebSocket>()
+
+    fun open(url: String, listener: WebSocketListener): WebSocket =
+      sockets.getOrPut(url) {
+        client.newWebSocket(Request.Builder().url(url).build(), listener)
+      }
+
+    fun closeAll() {
+      for ((_, ws) in sockets) ws.close(1000, "done")
+      sockets.clear()
+    }
+  }
+
+  override fun doWork(): Result {
+    Log.i(TAG, "doWork() started")
+
+    if (isAppInForeground()) {
+      return Result.success()
+    }
+
+    val pool = SocketPool()
+    try {
+      val rawState = prefs.getString(KEY_STATE, "") ?: ""
+      if (rawState.isEmpty()) return Result.success()
+
+      val state = JSONObject(rawState)
+      val sessionInfo = getSessionInfo(state)
+      val subscriptions = parseSubscriptions(state)
+      if (subscriptions.isEmpty()) return Result.success()
+
+      val activeSince = state.optLong("activeSince", 0L)
+      val seen = mutableSetOf<String>()
+      val newEvents = mutableListOf<Pair<String, JSONObject>>()
+
+      for (sub in subscriptions) {
+        val cursorKey = CURSOR_PREFIX + sub.relay + ":" + sub.key
+        val since = maxOf(prefs.getLong(cursorKey, 0L), activeSince)
+        val result = pollRelay(sub, since, sessionInfo, pool)
+
+        if (result.lastCursor > prefs.getLong(cursorKey, 0L)) {
+          prefs.edit().putLong(cursorKey, result.lastCursor).apply()
+        }
+
+        for (event in result.events) {
+          val id = event.optString("id", "")
+          if (id.isNotEmpty() && seen.add(id)) {
+            newEvents.add(Pair(sub.relay, event))
+          }
+        }
+      }
+
+      for ((relay, event) in newEvents) {
+        postNotification(relay, event)
+      }
+
+      return Result.success()
+    } catch (e: Exception) {
+      Log.e(TAG, "Worker failed", e)
+      return Result.retry()
+    } finally {
+      pool.closeAll()
+      client.dispatcher.executorService.shutdown()
+    }
+  }
+
+  private fun isAppInForeground(): Boolean {
+    val am = applicationContext.getSystemService(ActivityManager::class.java) ?: return false
+    val tasks = am.getRunningAppProcesses() ?: return false
+    val pkg = applicationContext.packageName
+    return tasks.any { it.processName == pkg && it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND }
+  }
+
+  private fun getSessionInfo(state: JSONObject): SessionInfo {
+    val session = state.optJSONObject("session") ?: return SessionInfo("anonymous", "", JSONObject())
+    return SessionInfo(
+      session.optString("method", "anonymous"),
+      session.optString("pubkey", ""),
+      session,
+    )
+  }
+
+  private fun parseSubscriptions(state: JSONObject): List<Subscription> {
+    val result = mutableListOf<Subscription>()
+    val arr = state.optJSONArray("subscriptions") ?: return result
+
+    for (i in 0 until arr.length()) {
+      val item = arr.optJSONObject(i) ?: continue
+      val relay = item.optString("relay", "").trim()
+
+      if (!relay.startsWith("wss://") && !relay.startsWith("ws://")) continue
+
+      val filters = item.optJSONArray("filters")
+      if (filters == null || filters.length() == 0) continue
+
+      val key = item.optString("key", "").trim()
+      result.add(Subscription(relay, key, filters, item.optJSONArray("ignore")))
+    }
+
+    return result
+  }
+
+  private fun pollRelay(sub: Subscription, since: Long, sessionInfo: SessionInfo, pool: SocketPool): RelayResult {
+    val result = RelayResult()
+    val latch = CountDownLatch(1)
+
+    val listener = RelayListener(sub, since, sessionInfo, result, latch, pool)
+    pool.open(sub.relay, listener)
+
+    if (!latch.await(SOCKET_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+      Log.d(TAG, "Relay ${sub.relay} timed out")
+    }
+
+    return result
+  }
+
+  private fun postNotification(relay: String, event: JSONObject) {
+    val context = applicationContext
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
+      ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED
+    ) return
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val manager = context.getSystemService(NotificationManager::class.java)
+      if (manager != null && manager.getNotificationChannel(CHANNEL_ID) == null) {
+        val channel = NotificationChannel(CHANNEL_ID, "Fallback Notifications", NotificationManager.IMPORTANCE_DEFAULT)
+        channel.description = "Notifications delivered by Android background fallback"
+        manager.createNotificationChannel(channel)
+      }
+    }
+
+    val id = event.optString("id", "")
+    val encodedRelay = Uri.encode(relay)
+    val url = "https://app.flotilla.social/?relay=$encodedRelay&id=$id"
+    val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+    intent.setPackage(context.packageName)
+    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+
+    val pendingIntent = PendingIntent.getActivity(
+      context, 0, intent,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+
+    val body = "New activity"
+
+    val notification = NotificationCompat.Builder(context, CHANNEL_ID)
+      .setSmallIcon(android.R.drawable.stat_notify_chat)
+      .setContentTitle("Flotilla")
+      .setContentText(body)
+      .setAutoCancel(true)
+      .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+      .setContentIntent(pendingIntent)
+      .build()
+
+    val notificationId = id.hashCode().let { if (it == 0) 1 else it }
+    NotificationManagerCompat.from(context).notify(notificationId, notification)
+  }
+
+  private fun matchesFilter(filter: JSONObject, event: JSONObject): Boolean {
+    val kinds = filter.optJSONArray("kinds")
+    if (kinds != null && kinds.length() > 0) {
+      val kind = event.optInt("kind", -1)
+      var found = false
+      for (i in 0 until kinds.length()) {
+        if (kinds.optInt(i, -1) == kind) { found = true; break }
+      }
+      if (!found) return false
+    }
+
+    val tags = event.optJSONArray("tags")
+    val iter = filter.keys()
+    while (iter.hasNext()) {
+      val key = iter.next()
+      if (!key.startsWith("#")) continue
+      val tagName = key.substring(1)
+      val allowed = filter.optJSONArray(key) ?: continue
+      if (allowed.length() == 0) continue
+
+      val allowedValues = mutableSetOf<String>()
+      for (i in 0 until allowed.length()) {
+        val v = allowed.optString(i, "")
+        if (v.isNotEmpty()) allowedValues.add(v)
+      }
+
+      var matched = false
+      if (tags != null) {
+        for (i in 0 until tags.length()) {
+          val tag = tags.optJSONArray(i) ?: continue
+          if (tag.optString(0, "") == tagName && allowedValues.contains(tag.optString(1, ""))) {
+            matched = true; break
+          }
+        }
+      }
+      if (!matched) return false
+    }
+
+    return true
+  }
+
+  // ---- Crypto helpers ----
+
+  private fun computeEventId(event: JSONObject): String {
+    return try {
+      val serialized = JSONArray()
+      serialized.put(0)
+      serialized.put(event.optString("pubkey", ""))
+      serialized.put(event.optLong("created_at", 0))
+      serialized.put(event.optInt("kind", 0))
+      serialized.put(event.optJSONArray("tags") ?: JSONArray())
+      serialized.put(event.optString("content", ""))
+      // JSONObject escapes forward slashes (/ -> \/), but NIP-01 event ID hashing
+      // requires unescaped slashes. Replace them before hashing.
+      val serializedStr = serialized.toString().replace("\\/", "/")
+      bytesToHex(sha256(serializedStr.toByteArray(StandardCharsets.UTF_8)))
+    } catch (_: Exception) {
+      ""
+    }
+  }
+
+  private fun deriveXOnlyPubkey(secretHex: String): String {
+    val secret = hexToBytes(secretHex)
+    if (secret.size != 32 || !SECP.secKeyVerify(secret)) return ""
+    val pubkey65 = try { SECP.pubkeyCreate(secret) } catch (_: Exception) { return "" }
+    if (pubkey65.size != 65) return ""
+    return bytesToHex(Arrays.copyOfRange(pubkey65, 1, 33))
+  }
+
+  private fun schnorrSign(secretHex: String, messageHex: String): String {
+    val sk = hexToBytes(secretHex)
+    val msg = hexToBytes(messageHex)
+    if (sk.size != 32 || msg.size != 32 || !SECP.secKeyVerify(sk)) return ""
+    val aux = ByteArray(32).also { SecureRandom().nextBytes(it) }
+    val sig = try { SECP.signSchnorr(msg, sk, aux) } catch (_: Exception) { return "" }
+    if (sig.size != 64) return ""
+    return bytesToHex(sig)
+  }
+
+  private fun sha256(input: ByteArray): ByteArray =
+    try { MessageDigest.getInstance("SHA-256").digest(input) } catch (_: Exception) { ByteArray(32) }
+
+  private fun hexToBytes(hex: String?): ByteArray {
+    var s = hex?.trim()?.lowercase() ?: ""
+    if (s.startsWith("0x")) s = s.substring(2)
+    if (s.length % 2 == 1) s = "0$s"
+    val bytes = ByteArray(s.length / 2)
+    var i = 0
+    while (i < s.length) {
+      val hi = Character.digit(s[i], 16)
+      val lo = Character.digit(s[i + 1], 16)
+      if (hi < 0 || lo < 0) return ByteArray(0)
+      bytes[i / 2] = ((hi shl 4) + lo).toByte()
+      i += 2
+    }
+    return bytes
+  }
+
+  private fun bytesToHex(bytes: ByteArray): String {
+    val hex = "0123456789abcdef".toCharArray()
+    val chars = CharArray(bytes.size * 2)
+    for (i in bytes.indices) {
+      val v = bytes[i].toInt() and 0xFF
+      chars[i * 2] = hex[v ushr 4]
+      chars[i * 2 + 1] = hex[v and 0x0F]
+    }
+    return String(chars)
+  }
+
+  // ---- NIP-44 encryption (v2: ECDH + HKDF + ChaCha20 + HMAC-SHA256) ----
+
+  private fun nip44ConversationKey(clientSecret: String, theirPubkey: String): ByteArray {
+    val sk = hexToBytes(clientSecret)
+    val pk = hexToBytes("02$theirPubkey")
+    if (sk.size != 32 || pk.size != 33) return ByteArray(0)
+    val shared = try { SECP.pubKeyTweakMul(pk, sk) } catch (_: Exception) { return ByteArray(0) }
+    if (shared.size != 65) return ByteArray(0)
+    val sharedX = Arrays.copyOfRange(shared, 1, 33)
+    return hkdfExtract(sharedX, "nip44-v2".toByteArray(StandardCharsets.UTF_8))
+  }
+
+  private fun hkdfExtract(ikm: ByteArray, salt: ByteArray): ByteArray {
+    val mac = javax.crypto.Mac.getInstance("HmacSHA256")
+    mac.init(javax.crypto.spec.SecretKeySpec(salt, "HmacSHA256"))
+    return mac.doFinal(ikm)
+  }
+
+  private fun hkdfExpand(prk: ByteArray, info: ByteArray, length: Int): ByteArray {
+    val mac = javax.crypto.Mac.getInstance("HmacSHA256")
+    val result = ByteArray(length)
+    var prev = ByteArray(0)
+    var offset = 0
+    var counter = 1
+    while (offset < length) {
+      mac.init(javax.crypto.spec.SecretKeySpec(prk, "HmacSHA256"))
+      mac.update(prev)
+      mac.update(info)
+      mac.update(counter.toByte())
+      prev = mac.doFinal()
+      val toCopy = minOf(prev.size, length - offset)
+      System.arraycopy(prev, 0, result, offset, toCopy)
+      offset += toCopy
+      counter++
+    }
+    return result
+  }
+
+  private fun hmacSha256(key: ByteArray, vararg parts: ByteArray): ByteArray {
+    val mac = javax.crypto.Mac.getInstance("HmacSHA256")
+    mac.init(javax.crypto.spec.SecretKeySpec(key, "HmacSHA256"))
+    for (part in parts) mac.update(part)
+    return mac.doFinal()
+  }
+
+  // ChaCha20 block function per RFC 8439
+  private fun chacha20Block(key: ByteArray, counter: Int, nonce: ByteArray): ByteArray {
+    fun Int.rotl(n: Int) = (this shl n) or (this ushr (32 - n))
+    val state = IntArray(16)
+    state[0] = 0x61707865; state[1] = 0x3320646e; state[2] = 0x79622d32; state[3] = 0x6b206574
+    for (i in 0..7) state[4 + i] = (key[i*4].toInt() and 0xFF) or
+      ((key[i*4+1].toInt() and 0xFF) shl 8) or
+      ((key[i*4+2].toInt() and 0xFF) shl 16) or
+      ((key[i*4+3].toInt() and 0xFF) shl 24)
+    state[12] = counter
+    for (i in 0..2) state[13 + i] = (nonce[i*4].toInt() and 0xFF) or
+      ((nonce[i*4+1].toInt() and 0xFF) shl 8) or
+      ((nonce[i*4+2].toInt() and 0xFF) shl 16) or
+      ((nonce[i*4+3].toInt() and 0xFF) shl 24)
+    val working = state.copyOf()
+    repeat(10) {
+      fun quarterRound(a: Int, b: Int, c: Int, d: Int) {
+        working[a] += working[b]; working[d] = (working[d] xor working[a]).rotl(16)
+        working[c] += working[d]; working[b] = (working[b] xor working[c]).rotl(12)
+        working[a] += working[b]; working[d] = (working[d] xor working[a]).rotl(8)
+        working[c] += working[d]; working[b] = (working[b] xor working[c]).rotl(7)
+      }
+      quarterRound(0,4,8,12); quarterRound(1,5,9,13); quarterRound(2,6,10,14); quarterRound(3,7,11,15)
+      quarterRound(0,5,10,15); quarterRound(1,6,11,12); quarterRound(2,7,8,13); quarterRound(3,4,9,14)
+    }
+    val out = ByteArray(64)
+    for (i in 0..15) {
+      val v = working[i] + state[i]
+      out[i*4]   = v.toByte()
+      out[i*4+1] = (v ushr 8).toByte()
+      out[i*4+2] = (v ushr 16).toByte()
+      out[i*4+3] = (v ushr 24).toByte()
+    }
+    return out
+  }
+
+  private fun chacha20(key: ByteArray, nonce: ByteArray, data: ByteArray): ByteArray {
+    val out = ByteArray(data.size)
+    var counter = 0
+    var offset = 0
+    while (offset < data.size) {
+      val block = chacha20Block(key, counter, nonce)
+      val len = minOf(64, data.size - offset)
+      for (i in 0 until len) out[offset + i] = (data[offset + i].toInt() xor block[i].toInt()).toByte()
+      offset += len
+      counter++
+    }
+    return out
+  }
+
+  private fun nip44CalcPaddedLen(len: Int): Int {
+    if (len <= 32) return 32
+    val nextPower = 1 shl (Math.floor(Math.log((len - 1).toDouble()) / Math.log(2.0)).toInt() + 1)
+    val chunk = if (nextPower <= 256) 32 else nextPower / 8
+    return chunk * ((len - 1) / chunk + 1)
+  }
+
+  private fun nip44Pad(plaintext: String): ByteArray {
+    val unpadded = plaintext.toByteArray(StandardCharsets.UTF_8)
+    val len = unpadded.size
+    val padded = ByteArray(2 + nip44CalcPaddedLen(len))
+    padded[0] = (len ushr 8).toByte()
+    padded[1] = len.toByte()
+    System.arraycopy(unpadded, 0, padded, 2, len)
+    return padded
+  }
+
+  private fun nip44Unpad(padded: ByteArray): String {
+    val len = ((padded[0].toInt() and 0xFF) shl 8) or (padded[1].toInt() and 0xFF)
+    if (len == 0 || len > padded.size - 2) return ""
+    return String(padded, 2, len, StandardCharsets.UTF_8)
+  }
+
+  private fun encryptNip44(plaintext: String, conversationKey: ByteArray): String {
+    return try {
+      val nonce = ByteArray(32).also { SecureRandom().nextBytes(it) }
+      val keys = hkdfExpand(conversationKey, nonce, 76)
+      val chachaKey = keys.sliceArray(0 until 32)
+      val chachaNonce = keys.sliceArray(32 until 44)
+      val hmacKey = keys.sliceArray(44 until 76)
+      val padded = nip44Pad(plaintext)
+      val ciphertext = chacha20(chachaKey, chachaNonce, padded)
+      val mac = hmacSha256(hmacKey, nonce, ciphertext)
+      val payload = ByteArray(1 + 32 + ciphertext.size + 32)
+      payload[0] = 2
+      System.arraycopy(nonce, 0, payload, 1, 32)
+      System.arraycopy(ciphertext, 0, payload, 33, ciphertext.size)
+      System.arraycopy(mac, 0, payload, 33 + ciphertext.size, 32)
+      Base64.encodeToString(payload, Base64.NO_WRAP)
+    } catch (_: Exception) {
+      ""
+    }
+  }
+
+  private fun decryptNip44(payload: String, conversationKey: ByteArray): String {
+    return try {
+      if (payload.isEmpty() || payload[0] == '#') return ""
+      val data = Base64.decode(payload, Base64.NO_WRAP)
+      if (data.size < 99 || data[0] != 2.toByte()) return ""
+      val nonce = data.sliceArray(1 until 33)
+      val ciphertext = data.sliceArray(33 until data.size - 32)
+      val mac = data.sliceArray(data.size - 32 until data.size)
+      val keys = hkdfExpand(conversationKey, nonce, 76)
+      val chachaKey = keys.sliceArray(0 until 32)
+      val chachaNonce = keys.sliceArray(32 until 44)
+      val hmacKey = keys.sliceArray(44 until 76)
+      val expectedMac = hmacSha256(hmacKey, nonce, ciphertext)
+      if (!expectedMac.contentEquals(mac)) return ""
+      val padded = chacha20(chachaKey, chachaNonce, ciphertext)
+      nip44Unpad(padded)
+    } catch (_: Exception) {
+      ""
+    }
+  }
+
+  // ---- Signing ----
+
+  private fun signWithNip01Secret(secretHex: String, eventJson: String, expectedPubkey: String): String {
+    return try {
+      val secret = hexToBytes(secretHex)
+      if (secret.size != 32) return ""
+
+      val event = JSONObject(eventJson)
+      var pubkey = event.optString("pubkey", expectedPubkey)
+      if (pubkey.isEmpty()) pubkey = deriveXOnlyPubkey(secretHex)
+      if (pubkey.isEmpty()) return ""
+
+      event.put("pubkey", pubkey)
+      val id = computeEventId(event)
+      if (id.isEmpty()) return ""
+
+      val sig = schnorrSign(secretHex, id)
+      if (sig.isEmpty()) return ""
+
+      event.put("id", id)
+      event.put("sig", sig)
+      event.toString()
+    } catch (_: Exception) {
+      ""
+    }
+  }
+
+  private fun signWithNip55ContentResolver(packageName: String, eventJson: String, pubkey: String): String {
+    val uri = Uri.parse("content://$packageName.SIGN_EVENT")
+    var cursor: Cursor? = null
+    return try {
+      cursor = applicationContext.contentResolver.query(uri, arrayOf(eventJson, "", pubkey), "1", null, null)
+      if (cursor == null || !cursor.moveToFirst()) return ""
+      val rejIdx = cursor.getColumnIndex("rejected")
+      if (rejIdx >= 0) {
+        val v = cursor.getString(rejIdx)
+        if (v == "1" || v.equals("true", ignoreCase = true)) return REJECTED
+      }
+      val eventIdx = cursor.getColumnIndex("event")
+      if (eventIdx >= 0) cursor.getString(eventIdx) ?: "" else ""
+    } catch (_: Exception) {
+      ""
+    } finally {
+      cursor?.close()
+    }
+  }
+
+  // ---- Data types ----
+
+  private data class SessionInfo(
+    val method: String,
+    val pubkey: String,
+    val session: JSONObject,
+  )
+
+  private data class Subscription(
+    val relay: String,
+    val key: String,
+    val filters: JSONArray,
+    val ignore: JSONArray?,
+  )
+
+  private class RelayResult {
+    val events = mutableListOf<JSONObject>()
+    var lastCursor = 0L
+  }
+
+  // ---- Relay listener ----
+
+  private inner class RelayListener(
+    private val sub: Subscription,
+    private val since: Long,
+    private val sessionInfo: SessionInfo,
+    private val result: RelayResult,
+    private val latch: CountDownLatch,
+    private val pool: SocketPool,
+  ) : WebSocketListener() {
+    private val subId = UUID.randomUUID().toString().replace("-", "")
+    private var done = false
+    private var authed = false
+    private var authEventId = ""
+    private var nip46InFlight = false
+    private var pendingDone = false
+
+    override fun onOpen(webSocket: WebSocket, response: Response) {
+      sendReq(webSocket)
+    }
+
+    private fun sendReq(webSocket: WebSocket) {
+      val req = JSONArray()
+      req.put("REQ")
+      req.put(subId)
+
+      for (i in 0 until sub.filters.length()) {
+        val filter = sub.filters.optJSONObject(i) ?: continue
+        val shaped = JSONObject(filter.toString())
+        if (since > 0) shaped.put("since", since + 1)
+        shaped.put("limit", 1)
+        req.put(shaped)
+      }
+
+      if (req.length() <= 2) { finish(); return }
+
+      send(webSocket, req.toString())
+    }
+
+    override fun onMessage(webSocket: WebSocket, text: String) {
+      try {
+        val message = JSONArray(text)
+        Log.d(TAG, "Received message from ${sub.relay}: $text")
+        when (message.optString(0, "")) {
+          "EVENT" -> {
+            val event = message.optJSONObject(2) ?: return
+            if (!matchesAnyFilter(sub.filters, event)) return
+            if (isIgnored(event)) return
+            result.events.add(event)
+            val createdAt = event.optLong("created_at", 0L)
+            if (createdAt > result.lastCursor) result.lastCursor = createdAt
+          }
+          "AUTH" -> {
+            // Only auth once per connection
+            if (!authed) {
+              authed = true
+              tryAuth(webSocket, message.optString(1, ""))
+            }
+          }
+          "OK" -> {
+            val okId = message.optString(1, "")
+            val accepted = message.optBoolean(2, false)
+            if (accepted && okId == authEventId) sendReq(webSocket)
+          }
+          "EOSE" -> {
+            send(webSocket, JSONArray().apply { put("CLOSE"); put(subId) }.toString())
+            finish()
+          }
+        }
+      } catch (_: Exception) {
+        finish()
+      }
+    }
+
+    override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) = finish()
+    override fun onClosed(webSocket: WebSocket, code: Int, reason: String) = finish()
+
+    private fun finish() {
+      if (done) return
+      if (nip46InFlight) { pendingDone = true; return }
+      done = true
+      latch.countDown()
+    }
+
+    private fun isIgnored(event: JSONObject): Boolean {
+      val ignore = sub.ignore ?: return false
+      for (i in 0 until ignore.length()) {
+        val filter = ignore.optJSONObject(i) ?: continue
+        if (matchesFilter(filter, event)) return true
+      }
+      return false
+    }
+
+    private fun matchesAnyFilter(filters: JSONArray, event: JSONObject): Boolean {
+      for (i in 0 until filters.length()) {
+        val filter = filters.optJSONObject(i) ?: continue
+        if (matchesFilter(filter, event)) return true
+      }
+      return false
+    }
+
+    // ---- NIP-42 auth ----
+
+    private fun tryAuth(webSocket: WebSocket, challenge: String) {
+      if (challenge.isEmpty()) return
+      when (sessionInfo.method) {
+        "nip01" -> tryNip01Auth(webSocket, challenge)
+        "nip55" -> tryNip55Auth(webSocket, challenge)
+        "nip46" -> tryNip46Auth(webSocket, challenge)
+        // Pomade background auth is not supported: properly delegating to the Pomade signer
+        // from a background worker is complex, usage is rare, and relays that require auth
+        // may still be readable without it.
+      }
+    }
+
+    private fun buildAuthEvent(challenge: String): JSONObject {
+      return JSONObject().apply {
+        put("kind", KIND_RELAY_AUTH)
+        put("pubkey", sessionInfo.pubkey)
+        put("created_at", System.currentTimeMillis() / 1000L)
+        put("content", "")
+        put("id", "")
+        put("sig", "")
+        put("tags", JSONArray().apply {
+          put(JSONArray().apply { put("relay"); put(sub.relay) })
+          put(JSONArray().apply { put("challenge"); put(challenge) })
+        })
+      }
+    }
+
+    private fun sendAuthMessage(webSocket: WebSocket, signedEventJson: String): Boolean {
+      if (signedEventJson.isEmpty() || signedEventJson == REJECTED) return false
+      return try {
+        val event = JSONObject(signedEventJson)
+        authEventId = event.optString("id", "")
+        send(webSocket, JSONArray().apply { put("AUTH"); put(event) }.toString())
+      } catch (_: Exception) {
+        false
+      }
+    }
+
+    private fun send(webSocket: WebSocket, message: String): Boolean {
+      Log.d(TAG, "Sending message to ${webSocket.request().url}: $message")
+      return webSocket.send(message)
+    }
+
+    private fun tryNip01Auth(webSocket: WebSocket, challenge: String): Boolean {
+      val secret = sessionInfo.session.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", "")
+      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")
+
+      if (clientSecret.isEmpty() || signerPubkey.isEmpty() || relays == null || relays.length() == 0) return false
+
+      val clientPubkey = deriveXOnlyPubkey(clientSecret)
+      if (clientPubkey.isEmpty()) return false
+
+      val authEventJson = buildAuthEvent(challenge).toString()
+
+      nip46InFlight = true
+      var success = false
+      try {
+        for (i in 0 until relays.length()) {
+          val signerRelay = relays.optString(i, "").trim()
+          if (!signerRelay.startsWith("wss://") && !signerRelay.startsWith("ws://")) continue
+          if (tryNip46ViaRelay(webSocket, signerRelay, clientSecret, clientPubkey, signerPubkey, authEventJson)) { success = true; break }
+        }
+      } finally {
+        nip46InFlight = false
+        if (pendingDone) finish()
+      }
+
+      return success
+    }
+
+    private fun tryNip46ViaRelay(
+      relaySocket: WebSocket,
+      signerRelay: String,
+      clientSecret: String,
+      clientPubkey: String,
+      signerPubkey: String,
+      authEventJson: String,
+    ): Boolean {
+      val localLatch = CountDownLatch(1)
+      val signedEvent = StringBuilder()
+      val requestId = UUID.randomUUID().toString().replace("-", "")
+
+      val signerSocket = pool.open(signerRelay, object : WebSocketListener() {
+        private var done = false
+
+        override fun onOpen(webSocket: WebSocket, response: Response) {
+          try {
+            val rpcEnvelope = JSONObject().apply {
+              put("kind", KIND_NIP46_RPC)
+              put("pubkey", clientPubkey)
+              put("created_at", System.currentTimeMillis() / 1000L)
+              put("content", encryptNip44(
+                JSONObject().apply {
+                  put("id", requestId)
+                  put("method", "sign_event")
+                  put("params", JSONArray().apply { put(authEventJson) })
+                }.toString(),
+                nip44ConversationKey(clientSecret, signerPubkey),
+              ))
+              put("id", "")
+              put("sig", "")
+              put("tags", JSONArray().apply { put(JSONArray().apply { put("p"); put(signerPubkey) }) })
+            }
+
+            val signedEnvelope = signWithNip01Secret(clientSecret, rpcEnvelope.toString(), clientPubkey)
+            if (signedEnvelope.isEmpty()) { finish(); return }
+
+            val sentAt = System.currentTimeMillis() / 1000L
+            send(webSocket, JSONArray().apply { put("EVENT"); put(JSONObject(signedEnvelope)) }.toString())
+            send(webSocket, JSONArray().apply {
+              put("REQ")
+              put(requestId)
+              put(JSONObject().apply {
+                put("#p", JSONArray().apply { put(clientPubkey) })
+                put("kinds", JSONArray().apply { put(KIND_NIP46_RPC) })
+                put("since", sentAt)
+                put("limit", 10)
+              })
+            }.toString())
+          } catch (_: Exception) {
+            finish()
+          }
+        }
+
+        override fun onMessage(webSocket: WebSocket, text: String) {
+          try {
+            val message = JSONArray(text)
+            val msgType = message.optString(0, "")
+            Log.d(TAG, "NIP-46 signer message: $msgType from ${webSocket.request().url}")
+            if (msgType != "EVENT") return
+            val event = message.optJSONObject(2) ?: return
+
+            val tags = event.optJSONArray("tags")
+            var hasP = false
+            if (tags != null) {
+              for (i in 0 until tags.length()) {
+                val tag = tags.optJSONArray(i) ?: continue
+                if (tag.optString(0, "") == "p" && tag.optString(1, "") == clientPubkey) { hasP = true; break }
+              }
+            }
+            if (!hasP) { Log.d(TAG, "NIP-46 event missing p tag for client"); return }
+
+            val decryptedContent = decryptNip44(event.optString("content", ""), nip44ConversationKey(clientSecret, signerPubkey))
+            Log.d(TAG, "NIP-46 decrypted response: $decryptedContent")
+            if (decryptedContent.isEmpty()) return
+            val payload = JSONObject(decryptedContent)
+            if (requestId == payload.optString("id", "")) {
+              val result = payload.optString("result", "")
+              if (result.isNotEmpty()) {
+                signedEvent.setLength(0)
+                signedEvent.append(result)
+                finish()
+              }
+            }
+          } catch (e: Exception) {
+            Log.e(TAG, "NIP-46 signer message error", e)
+          }
+        }
+
+        override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) = finish()
+        override fun onClosed(webSocket: WebSocket, code: Int, reason: String) = finish()
+
+        private fun finish() {
+          if (!done) { done = true; localLatch.countDown() }
+        }
+      })
+
+      try {
+        localLatch.await(5, TimeUnit.SECONDS)
+      } catch (_: InterruptedException) {
+        return false
+      }
+
+      if (signedEvent.isEmpty()) return false
+
+      val authEvent = JSONObject(signedEvent.toString())
+      authEventId = authEvent.optString("id", "")
+      val authMessage = JSONArray().apply { put("AUTH"); put(authEvent) }.toString()
+      Log.d(TAG, "NIP-46 sending AUTH to relay ${relaySocket.request().url}: $authMessage")
+      return try {
+        relaySocket.send(authMessage)
+      } catch (e: Exception) {
+        Log.e(TAG, "NIP-46 failed to send AUTH", e)
+        false
+      }
+    }
+  }
+}

android/build.gradle

@@ -1,14 +1,16 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
+    ext.kotlin_version = '2.2.20'
     
     repositories {
         google()
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.8.0'
-        classpath 'com.google.gms:google-services:4.4.2'
+        classpath 'com.android.tools.build:gradle:8.13.2'
+        classpath 'com.google.gms:google-services:4.4.4'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files

android/capacitor.settings.gradle

@@ -1,30 +1,39 @@
 // DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN
 include ':capacitor-android'
-project(':capacitor-android').projectDir = new File('../node_modules/.pnpm/@capacitor+android@7.4.3_@capacitor+core@7.4.3/node_modules/@capacitor/android/capacitor')
+project(':capacitor-android').projectDir = new File('../node_modules/.pnpm/@capacitor+android@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/android/capacitor')
+
+include ':aparajita-capacitor-secure-storage'
+project(':aparajita-capacitor-secure-storage').projectDir = new File('../node_modules/.pnpm/@aparajita+capacitor-secure-storage@8.0.0/node_modules/@aparajita/capacitor-secure-storage/android')
 
 include ':capacitor-community-safe-area'
-project(':capacitor-community-safe-area').projectDir = new File('../node_modules/.pnpm/@capacitor-community+safe-area@7.0.0-alpha.1_@capacitor+core@7.4.3/node_modules/@capacitor-community/safe-area/android')
+project(':capacitor-community-safe-area').projectDir = new File('../node_modules/.pnpm/@capacitor-community+safe-area@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor-community/safe-area/android')
 
 include ':capacitor-app'
-project(':capacitor-app').projectDir = new File('../node_modules/.pnpm/@capacitor+app@7.1.0_@capacitor+core@7.4.3/node_modules/@capacitor/app/android')
+project(':capacitor-app').projectDir = new File('../node_modules/.pnpm/@capacitor+app@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/app/android')
+
+include ':capacitor-clipboard'
+project(':capacitor-clipboard').projectDir = new File('../node_modules/.pnpm/@capacitor+clipboard@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/clipboard/android')
 
 include ':capacitor-filesystem'
-project(':capacitor-filesystem').projectDir = new File('../node_modules/.pnpm/@capacitor+filesystem@7.1.4_@capacitor+core@7.4.3/node_modules/@capacitor/filesystem/android')
+project(':capacitor-filesystem').projectDir = new File('../node_modules/.pnpm/@capacitor+filesystem@8.1.0_@capacitor+core@8.0.1/node_modules/@capacitor/filesystem/android')
 
 include ':capacitor-keyboard'
-project(':capacitor-keyboard').projectDir = new File('../node_modules/.pnpm/@capacitor+keyboard@7.0.3_@capacitor+core@7.4.3/node_modules/@capacitor/keyboard/android')
+project(':capacitor-keyboard').projectDir = new File('../node_modules/.pnpm/@capacitor+keyboard@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/keyboard/android')
 
 include ':capacitor-preferences'
-project(':capacitor-preferences').projectDir = new File('../node_modules/.pnpm/@capacitor+preferences@7.0.2_@capacitor+core@7.4.3/node_modules/@capacitor/preferences/android')
+project(':capacitor-preferences').projectDir = new File('../node_modules/.pnpm/@capacitor+preferences@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/preferences/android')
 
 include ':capacitor-push-notifications'
-project(':capacitor-push-notifications').projectDir = new File('../node_modules/.pnpm/@capacitor+push-notifications@7.0.3_@capacitor+core@7.4.3/node_modules/@capacitor/push-notifications/android')
+project(':capacitor-push-notifications').projectDir = new File('../node_modules/.pnpm/@capacitor+push-notifications@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/push-notifications/android')
+
+include ':capacitor-share'
+project(':capacitor-share').projectDir = new File('../node_modules/.pnpm/@capacitor+share@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/share/android')
 
 include ':capawesome-capacitor-android-dark-mode-support'
-project(':capawesome-capacitor-android-dark-mode-support').projectDir = new File('../node_modules/.pnpm/@capawesome+capacitor-android-dark-mode-support@7.0.0_@capacitor+core@7.4.3/node_modules/@capawesome/capacitor-android-dark-mode-support/android')
+project(':capawesome-capacitor-android-dark-mode-support').projectDir = new File('../node_modules/.pnpm/@capawesome+capacitor-android-dark-mode-support@8.0.0_@capacitor+core@8.0.1/node_modules/@capawesome/capacitor-android-dark-mode-support/android')
 
 include ':capawesome-capacitor-badge'
-project(':capawesome-capacitor-badge').projectDir = new File('../node_modules/.pnpm/@capawesome+capacitor-badge@7.0.1_@capacitor+core@7.4.3/node_modules/@capawesome/capacitor-badge/android')
+project(':capawesome-capacitor-badge').projectDir = new File('../node_modules/.pnpm/@capawesome+capacitor-badge@8.0.0_@capacitor+core@8.0.1/node_modules/@capawesome/capacitor-badge/android')
 
 include ':nostr-signer-capacitor-plugin'
-project(':nostr-signer-capacitor-plugin').projectDir = new File('../node_modules/.pnpm/nostr-signer-capacitor-plugin@0.0.4_@capacitor+core@7.4.3/node_modules/nostr-signer-capacitor-plugin/android')
+project(':nostr-signer-capacitor-plugin').projectDir = new File('../node_modules/.pnpm/nostr-signer-capacitor-plugin@https+++codeload.github.com+coracle-social+nostr-signer-c_a3c0fb15d5bfa83f24d0070ca2583fc9/node_modules/nostr-signer-capacitor-plugin/android')

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-all.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

android/gradlew

@@ -86,8 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
-' "$PWD" ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -115,7 +114,7 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+CLASSPATH="\\\"\\\""
 
 
 # Determine the Java command to use to start the JVM.
@@ -206,7 +205,7 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
@@ -214,7 +213,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
         -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
 # Stop when "xargs" is not available.

android/gradlew.bat

@@ -70,11 +70,11 @@ goto fail
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+set CLASSPATH=
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell

android/variables.gradle

@@ -1,18 +1,18 @@
 ext {
-    minSdkVersion = 23
-    compileSdkVersion = 35
-    targetSdkVersion = 35
-    androidxActivityVersion = '1.9.2'
+    minSdkVersion = 24
+    compileSdkVersion = 36
+    targetSdkVersion = 36
+    androidxActivityVersion = '1.11.0'
     //https://github.com/ionic-team/capacitor/issues/7866
-    // androidxAppCompatVersion = '1.7.0'
-    androidxAppCompatVersion = '1.6.1'
-    androidxCoordinatorLayoutVersion = '1.2.0'
-    androidxCoreVersion = '1.15.0'
-    androidxFragmentVersion = '1.8.4'
-    coreSplashScreenVersion = '1.0.1'
-    androidxWebkitVersion = '1.12.1'
+    // androidxAppCompatVersion = '1.7.1'
+    androidxAppCompatVersion = '1.7.1'
+    androidxCoordinatorLayoutVersion = '1.3.0'
+    androidxCoreVersion = '1.17.0'
+    androidxFragmentVersion = '1.8.9'
+    coreSplashScreenVersion = '1.2.0'
+    androidxWebkitVersion = '1.14.0'
     junitVersion = '4.13.2'
-    androidxJunitVersion = '1.2.1'
-    androidxEspressoCoreVersion = '3.6.1'
-    cordovaAndroidVersion = '10.1.1'
+    androidxJunitVersion = '1.3.0'
+    androidxEspressoCoreVersion = '3.7.0'
+    cordovaAndroidVersion = '14.0.1'
 }

build.sh

@@ -2,8 +2,8 @@
 
 temp_env=$(declare -p -x)
 
-if [ -f .env.template ]; then
-  source .env.template
+if [ -f .env ]; then
+  source .env
 fi
 
 # Avoid overwriting env vars provided directly
@@ -14,12 +14,13 @@ if [[ -z $VITE_BUILD_HASH ]]; then
   export VITE_BUILD_HASH=$(git rev-parse --short HEAD)
 fi
 
-if [[ $VITE_PLATFORM_LOGO =~ ^https://* ]]; then
-  curl $VITE_PLATFORM_LOGO > static/logo.png
+if [[ $VITE_PLATFORM_LOGO =~ ^https:// ]]; then
+  curl -fSL "$VITE_PLATFORM_LOGO" -o static/logo.png
   export VITE_PLATFORM_LOGO=static/logo.png
 fi
 
-npx pwa-assets-generator
+# Ensure generator uses local path (dotenv may have loaded URL from .env)
+VITE_PLATFORM_LOGO="${VITE_PLATFORM_LOGO}" npx pwa-assets-generator
 npx vite build
 
 # Replace index.html variables with stuff from our env

capacitor.config.ts

@@ -1,18 +1,24 @@
-import type { CapacitorConfig } from '@capacitor/cli';
+import type {CapacitorConfig} from "@capacitor/cli"
 
 const config: CapacitorConfig = {
-  appId: 'social.flotilla',
-  appName: 'Flotilla',
-  webDir: 'build'
-  server: {
-    androidScheme: "https"
+  appId: "social.flotilla",
+  appName: "Flotilla",
+  webDir: "build",
+  ios: {
+    scheme: "Flotilla Chat",
   },
   android: {
-    adjustMarginsForEdgeToEdge: false,
+    adjustMarginsForEdgeToEdge: true,
   },
   plugins: {
+    CapacitorHttp: {
+      enabled: true,
+    },
+    SystemBars: {
+      insetsHandling: "enable",
+    },
     SplashScreen: {
-      androidSplashResourceName: "splash"
+      androidSplashResourceName: "splash",
     },
     Keyboard: {
       style: "DARK",
@@ -20,14 +26,14 @@ const config: CapacitorConfig = {
     },
     Badge: {
       persist: true,
-      autoClear: true
+      autoClear: true,
     },
   },
-  // Use this for live reload https://capacitorjs.com/docs/guides/live-reload
-  // server: {
-  //   url: "http://192.168.1.115:1847",
-  //   cleartext: true
-  // },
-};
+  server: {
+    // Use this for live reload https://capacitorjs.com/docs/guides/live-reload
+    // url: "http://192.168.1.17:1847",
+    // cleartext: true,
+  },
+}
 
-export default config;
+export default config

ios/App/App.xcodeproj/project.pbxproj

@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 48;
+	objectVersion = 54;
 	objects = {
 
 /* Begin PBXBuildFile section */
@@ -131,8 +131,9 @@
 		504EC2FC1FED79650016851F /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
+				BuildIndependentTargetsInParallel = YES;
 				LastSwiftUpdateCheck = 920;
-				LastUpgradeCheck = 920;
+				LastUpgradeCheck = 2630;
 				TargetAttributes = {
 					504EC3031FED79650016851F = {
 						CreatedOnToolsVersion = 9.2;
@@ -257,6 +258,7 @@
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -264,8 +266,10 @@
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
 				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
@@ -275,8 +279,10 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
+				DEVELOPMENT_TEAM = S26U9DYW3A;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_NO_COMMON_BLOCKS = YES;
@@ -291,10 +297,11 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
 			};
@@ -314,6 +321,7 @@
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -321,8 +329,10 @@
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
 				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
 				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
 				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
 				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
@@ -332,8 +342,10 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DEVELOPMENT_TEAM = S26U9DYW3A;
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
@@ -342,10 +354,12 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = iphoneos;
-				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
 				VALIDATE_PRODUCT = YES;
 			};
 			name = Release;
@@ -358,18 +372,21 @@
 				CODE_SIGN_ENTITLEMENTS = "Flotilla Chat.entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 22;
-				DEVELOPMENT_TEAM = S26U9DYW3A;
+				CURRENT_PROJECT_VERSION = 38;
 				INFOPLIST_FILE = App/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = "Flotilla Chat";
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
-				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				MARKETING_VERSION = 1.5.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				MARKETING_VERSION = 1.8.0;
 				OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" \"-DDEBUG\"";
 				PRODUCT_BUNDLE_IDENTIFIER = social.flotilla;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
+				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
@@ -384,17 +401,20 @@
 				CODE_SIGN_ENTITLEMENTS = "Flotilla Chat.entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 22;
-				DEVELOPMENT_TEAM = S26U9DYW3A;
+				CURRENT_PROJECT_VERSION = 38;
 				INFOPLIST_FILE = App/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = "Flotilla Chat";
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
-				IPHONEOS_DEPLOYMENT_TARGET = 14.0;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				MARKETING_VERSION = 1.5.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				MARKETING_VERSION = 1.8.0;
 				PRODUCT_BUNDLE_IDENTIFIER = social.flotilla;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
+				SUPPORTS_MAC_DESIGNED_FOR_IPHONE_IPAD = NO;
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "";
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";

ios/App/App/Info.plist

@@ -20,8 +20,18 @@
 	<string>$(MARKETING_VERSION)</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>ITSAppUsesNonExemptEncryption</key>
+	<false/>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
+	<key>NSCameraUsageDescription</key>
+	<string>Flotilla uses the camera when you enable it in a voice room.</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>Flotilla uses the microphone when you enable it in a voice room.</string>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>remote-notification</string>
+	</array>
 	<key>UILaunchStoryboardName</key>
 	<string>LaunchScreen</string>
 	<key>UIMainStoryboardFile</key>
@@ -47,11 +57,5 @@
 	</array>
 	<key>UIViewControllerBasedStatusBarAppearance</key>
 	<true/>
-	<key>ITSAppUsesNonExemptEncryption</key>
-	<false/>
-	<key>UIBackgroundModes</key>
-	<array>
-		<string>remote-notification</string>
-	</array>
 </dict>
 </plist>

ios/App/Podfile

@@ -1,6 +1,6 @@
-require_relative '../../node_modules/.pnpm/@capacitor+ios@7.4.3_@capacitor+core@7.4.3/node_modules/@capacitor/ios/scripts/pods_helpers'
+require_relative '../../node_modules/.pnpm/@capacitor+ios@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/ios/scripts/pods_helpers'
 
-platform :ios, '14.0'
+platform :ios, '15.0'
 use_frameworks!
 
 # workaround to avoid Xcode caching of Pods that requires
@@ -9,16 +9,19 @@ use_frameworks!
 install! 'cocoapods', :disable_input_output_paths => true
 
 def capacitor_pods
-  pod 'Capacitor', :path => '../../node_modules/.pnpm/@capacitor+ios@7.4.3_@capacitor+core@7.4.3/node_modules/@capacitor/ios'
-  pod 'CapacitorCordova', :path => '../../node_modules/.pnpm/@capacitor+ios@7.4.3_@capacitor+core@7.4.3/node_modules/@capacitor/ios'
-  pod 'CapacitorCommunitySafeArea', :path => '../../node_modules/.pnpm/@capacitor-community+safe-area@7.0.0-alpha.1_@capacitor+core@7.4.3/node_modules/@capacitor-community/safe-area'
-  pod 'CapacitorApp', :path => '../../node_modules/.pnpm/@capacitor+app@7.1.0_@capacitor+core@7.4.3/node_modules/@capacitor/app'
-  pod 'CapacitorFilesystem', :path => '../../node_modules/.pnpm/@capacitor+filesystem@7.1.4_@capacitor+core@7.4.3/node_modules/@capacitor/filesystem'
-  pod 'CapacitorKeyboard', :path => '../../node_modules/.pnpm/@capacitor+keyboard@7.0.3_@capacitor+core@7.4.3/node_modules/@capacitor/keyboard'
-  pod 'CapacitorPreferences', :path => '../../node_modules/.pnpm/@capacitor+preferences@7.0.2_@capacitor+core@7.4.3/node_modules/@capacitor/preferences'
-  pod 'CapacitorPushNotifications', :path => '../../node_modules/.pnpm/@capacitor+push-notifications@7.0.3_@capacitor+core@7.4.3/node_modules/@capacitor/push-notifications'
-  pod 'CapawesomeCapacitorBadge', :path => '../../node_modules/.pnpm/@capawesome+capacitor-badge@7.0.1_@capacitor+core@7.4.3/node_modules/@capawesome/capacitor-badge'
-  pod 'NostrSignerCapacitorPlugin', :path => '../../node_modules/.pnpm/nostr-signer-capacitor-plugin@0.0.4_@capacitor+core@7.4.3/node_modules/nostr-signer-capacitor-plugin'
+  pod 'Capacitor', :path => '../../node_modules/.pnpm/@capacitor+ios@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/ios'
+  pod 'CapacitorCordova', :path => '../../node_modules/.pnpm/@capacitor+ios@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/ios'
+  pod 'AparajitaCapacitorSecureStorage', :path => '../../node_modules/.pnpm/@aparajita+capacitor-secure-storage@8.0.0/node_modules/@aparajita/capacitor-secure-storage'
+  pod 'CapacitorCommunitySafeArea', :path => '../../node_modules/.pnpm/@capacitor-community+safe-area@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor-community/safe-area'
+  pod 'CapacitorApp', :path => '../../node_modules/.pnpm/@capacitor+app@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/app'
+  pod 'CapacitorClipboard', :path => '../../node_modules/.pnpm/@capacitor+clipboard@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/clipboard'
+  pod 'CapacitorFilesystem', :path => '../../node_modules/.pnpm/@capacitor+filesystem@8.1.0_@capacitor+core@8.0.1/node_modules/@capacitor/filesystem'
+  pod 'CapacitorKeyboard', :path => '../../node_modules/.pnpm/@capacitor+keyboard@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/keyboard'
+  pod 'CapacitorPreferences', :path => '../../node_modules/.pnpm/@capacitor+preferences@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/preferences'
+  pod 'CapacitorPushNotifications', :path => '../../node_modules/.pnpm/@capacitor+push-notifications@8.0.0_@capacitor+core@8.0.1/node_modules/@capacitor/push-notifications'
+  pod 'CapacitorShare', :path => '../../node_modules/.pnpm/@capacitor+share@8.0.1_@capacitor+core@8.0.1/node_modules/@capacitor/share'
+  pod 'CapawesomeCapacitorBadge', :path => '../../node_modules/.pnpm/@capawesome+capacitor-badge@8.0.0_@capacitor+core@8.0.1/node_modules/@capawesome/capacitor-badge'
+  pod 'NostrSignerCapacitorPlugin', :path => '../../node_modules/.pnpm/nostr-signer-capacitor-plugin@https+++codeload.github.com+coracle-social+nostr-signer-c_a3c0fb15d5bfa83f24d0070ca2583fc9/node_modules/nostr-signer-capacitor-plugin'
 end
 
 target 'Flotilla Chat' do

link_deps

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import fs from 'fs'
+import { execSync } from 'child_process'
+
+const force = process.argv.includes('--force')
+
+if (execSync('git status --porcelain', { encoding: 'utf8' }).trim() && !force) {
+  console.error('Error: Git working tree is dirty. Please commit or stash your changes first, or re-run with --force.')
+  process.exit(1)
+}
+
+const pkg = JSON.parse(fs.readFileSync('./package.json', 'utf8'))
+
+pkg.pnpm.overrides = pkg.pnpm.overrides || {}
+pkg.pnpm.overrides["@welshman/app"] = "link:../welshman/packages/app"
+pkg.pnpm.overrides["@welshman/content"] = "link:../welshman/packages/content"
+pkg.pnpm.overrides["@welshman/editor"] = "link:../welshman/packages/editor"
+pkg.pnpm.overrides["@welshman/feeds"] = "link:../welshman/packages/feeds"
+pkg.pnpm.overrides["@welshman/lib"] = "link:../welshman/packages/lib"
+pkg.pnpm.overrides["@welshman/net"] = "link:../welshman/packages/net"
+pkg.pnpm.overrides["@welshman/router"] = "link:../welshman/packages/router"
+pkg.pnpm.overrides["@welshman/signer"] = "link:../welshman/packages/signer"
+pkg.pnpm.overrides["@welshman/store"] = "link:../welshman/packages/store"
+pkg.pnpm.overrides["@welshman/util"] = "link:../welshman/packages/util"
+// pkg.pnpm.overrides["nostr-editor"] = "link:../nostr-editor"
+// pkg.pnpm.overrides["@pomade/core"] = "link:../pomade/packages/core"
+// pkg.pnpm.overrides["nostr-signer-capacitor-plugin"] = "link:../nostr-signer-capacitor-plugin"
+
+fs.writeFileSync('./package.json', JSON.stringify(pkg, null, 2) + '\n')
+
+execSync('pnpm i', { stdio: 'inherit' })
+
+execSync('git checkout -f pnpm-lock.yaml', { stdio: 'inherit' })
+execSync('git checkout -f package.json', { stdio: 'inherit' })

package.json

@@ -1,86 +1,98 @@
 {
   "name": "flotilla",
-  "version": "1.5.0",
+  "version": "1.8.0",
   "private": true,
   "scripts": {
     "dev": "vite dev",
     "build": "./build.sh",
-    "sourcemaps": "./build.sh && ./sourcemaps.sh",
+    "build:server": "vite build --config vite.config.server.ts",
+    "start": "node server.js",
     "release:android": "./build.sh && cap build android --androidreleasetype APK --signing-type apksigner",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
     "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "lint": "prettier --check src && eslint src",
-    "format": "git diff head --name-only --diff-filter d | grep -E '(js|ts|svelte)$' | xargs -r prettier --write",
+    "format": "git diff head --name-only --diff-filter d | grep -E '(js|ts|svelte|css)$' | xargs -r prettier --write",
     "format:all": "prettier --write src",
     "prepare": "husky"
   },
   "devDependencies": {
     "@capacitor/assets": "^3.0.5",
-    "@eslint/js": "^9.37.0",
-    "@sentry/cli": "^2.56.1",
-    "@sveltejs/kit": "^2.46.5",
-    "@sveltejs/vite-plugin-svelte": "^4.0.4",
+    "@eslint/js": "^9.39.2",
+    "@sveltejs/kit": "^2.61.1",
+    "@sveltejs/vite-plugin-svelte": "^5.1.1",
+    "@tailwindcss/postcss": "^4.2.2",
     "@types/eslint": "^9.6.1",
-    "autoprefixer": "^10.4.21",
+    "autoprefixer": "^10.4.23",
     "classnames": "^2.5.1",
-    "eslint": "^9.37.0",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^9.1.2",
     "eslint-plugin-svelte": "^2.46.1",
     "globals": "^15.15.0",
-    "postcss": "^8.5.6",
-    "prettier": "^3.6.2",
-    "prettier-plugin-svelte": "^3.4.0",
-    "svelte": "^5.39.12",
-    "svelte-check": "^4.3.3",
-    "tailwindcss": "^3.4.18",
+    "postcss": "^8.5.15",
+    "prettier": "^3.8.1",
+    "prettier-plugin-svelte": "^3.4.1",
+    "svelte": "^5.55.9",
+    "svelte-check": "^4.3.5",
+    "tailwindcss": "^4.2.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.1",
-    "vite": "^5.4.20"
+    "typescript-eslint": "^8.53.1",
+    "vite": "^6.4.2"
   },
   "type": "module",
   "dependencies": {
-    "@capacitor-community/safe-area": "7.0.0-alpha.1",
-    "@capacitor/android": "^7.4.3",
-    "@capacitor/app": "^7.1.0",
-    "@capacitor/cli": "^7.4.3",
-    "@capacitor/core": "^7.4.3",
-    "@capacitor/filesystem": "^7.1.4",
-    "@capacitor/ios": "^7.4.3",
-    "@capacitor/keyboard": "^7.0.3",
-    "@capacitor/preferences": "^7.0.2",
-    "@capacitor/push-notifications": "^7.0.3",
-    "@capawesome/capacitor-android-dark-mode-support": "^7.0.0",
-    "@capawesome/capacitor-badge": "^7.0.1",
+    "@aparajita/capacitor-secure-storage": "^8.0.0",
+    "@capacitor-community/safe-area": "^8.0.1",
+    "@capacitor/android": "^8.0.1",
+    "@capacitor/app": "^8.0.0",
+    "@capacitor/cli": "^8.0.1",
+    "@capacitor/clipboard": "^8.0.1",
+    "@capacitor/core": "^8.0.1",
+    "@capacitor/filesystem": "^8.1.0",
+    "@capacitor/ios": "^8.0.1",
+    "@capacitor/keyboard": "^8.0.0",
+    "@capacitor/preferences": "^8.0.0",
+    "@capacitor/push-notifications": "^8.0.0",
+    "@capacitor/share": "^8.0.1",
+    "@capawesome/capacitor-android-dark-mode-support": "^8.0.0",
+    "@capawesome/capacitor-badge": "^8.0.0",
+    "@getalby/lightning-tools": "^6.1.0",
     "@getalby/sdk": "^5.1.2",
-    "@poppanator/sveltekit-svg": "^4.2.1",
-    "@sentry/browser": "^8.55.0",
+    "@hono/node-server": "^2.0.0",
+    "@noble/curves": "^1.9.7",
+    "@pomade/core": "^0.2.3",
+    "@poppanator/sveltekit-svg": "^7.0.0",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@tiptap/core": "^2.26.3",
-    "@types/qrcode": "^1.5.5",
+    "@tiptap/core": "^2.27.2",
+    "@tiptap/pm": "^2.27.2",
+    "@types/qrcode": "^1.5.6",
     "@types/throttle-debounce": "^5.0.2",
-    "@vite-pwa/assets-generator": "^0.2.6",
-    "@vite-pwa/sveltekit": "^0.6.8",
-    "@welshman/app": "^0.6.4",
-    "@welshman/content": "^0.6.4",
-    "@welshman/editor": "^0.6.4",
-    "@welshman/feeds": "^0.6.4",
-    "@welshman/lib": "^0.6.4",
-    "@welshman/net": "^0.6.4",
-    "@welshman/router": "^0.6.4",
-    "@welshman/signer": "^0.6.4",
-    "@welshman/store": "^0.6.4",
-    "@welshman/util": "^0.6.4",
-    "compressorjs": "^1.2.1",
-    "daisyui": "^4.12.24",
-    "date-picker-svelte": "^2.16.0",
+    "@vite-pwa/assets-generator": "^1.0.2",
+    "@vite-pwa/sveltekit": "^1.1.0",
+    "@welshman/app": "^0.8.15",
+    "@welshman/content": "^0.8.15",
+    "@welshman/editor": "^0.8.15",
+    "@welshman/feeds": "^0.8.15",
+    "@welshman/lib": "^0.8.15",
+    "@welshman/net": "^0.8.15",
+    "@welshman/router": "^0.8.15",
+    "@welshman/signer": "^0.8.15",
+    "@welshman/store": "^0.8.15",
+    "@welshman/util": "^0.8.15",
+    "cheerio": "^1.2.0",
+    "compressorjs-next": "^1.1.2",
+    "daisyui": "^5.5.19",
+    "date-picker-svelte": "^2.17.0",
     "dotenv": "^16.6.1",
-    "emoji-picker-element": "^1.27.0",
+    "emoji-picker-element": "^1.28.1",
+    "emoji-picker-element-data": "^1.8.0",
     "fuse.js": "^7.1.0",
+    "hono": "^4.12.23",
     "husky": "^9.1.7",
     "idb": "^8.0.3",
-    "nostr-signer-capacitor-plugin": "^0.0.4",
-    "nostr-tools": "^2.14.2",
-    "prettier-plugin-tailwindcss": "^0.6.14",
+    "livekit-client": "^2.17.2",
+    "nostr-signer-capacitor-plugin": "github:coracle-social/nostr-signer-capacitor-plugin#main",
+    "nostr-tools": "^2.19.4",
+    "prettier-plugin-tailwindcss": "^0.7.2",
     "qr-scanner": "^1.4.2",
     "qrcode": "^1.5.4",
     "throttle-debounce": "^5.0.2",
@@ -88,11 +100,15 @@
   },
   "pnpm": {
     "ignoredBuiltDependencies": [
-      "@sentry/cli",
       "esbuild"
     ],
     "onlyBuiltDependencies": [
-      "sharp"
-    ]
-  }
+      "sharp",
+      "nostr-signer-capacitor-plugin"
+    ],
+    "overrides": {
+      "sharp": "0.35.0-rc.0"
+    }
+  },
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
 }

postcss.config.js

@@ -1,6 +1,5 @@
 export default {
   plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
+    "@tailwindcss/postcss": {},
   },
 }

pwa-assets.config.js

@@ -1,8 +1,8 @@
 import dotenv from "dotenv"
 import {defineConfig, minimalPreset as preset} from "@vite-pwa/assets-generator/config"
 
+dotenv.config({path: ".env.local"})
 dotenv.config({path: ".env"})
-dotenv.config({path: ".env.template"})
 
 export default defineConfig({
   preset,

server.js

@@ -0,0 +1,288 @@
+import path from "node:path"
+import {promises as fs} from "node:fs"
+import {fileURLToPath} from "node:url"
+
+import "dotenv/config"
+import {serve} from "@hono/node-server"
+import {serveStatic} from "@hono/node-server/serve-static"
+import {loadRelay} from "@welshman/app"
+import {displayRelayUrl, normalizeRelayUrl} from "@welshman/util"
+import {load} from "cheerio"
+import {Hono} from "hono"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const BUILD_DIR = path.join(__dirname, "build")
+const INDEX_PATH = path.join(BUILD_DIR, "index.html")
+
+const PORT = parseInt(process.env.PORT || "", 10) || 3000
+const HOST = process.env.HOST || "0.0.0.0"
+
+let TEMPLATE_HTML = ""
+try {
+  TEMPLATE_HTML = await fs.readFile(INDEX_PATH, "utf8")
+} catch (error) {
+  console.error(`Unable to read ${INDEX_PATH}. Run "pnpm run build" first.`)
+  process.exit(1)
+}
+
+const PLATFORM_NAME = process.env.VITE_PLATFORM_NAME
+const PLATFORM_DESCRIPTION = process.env.VITE_PLATFORM_DESCRIPTION
+
+// Match client-side decode logic
+const decodeRelay = url => {
+  try {
+    return normalizeRelayUrl(decodeURIComponent(url))
+  } catch {
+    return undefined
+  }
+}
+
+const requestUrlFromContext = context => {
+  const requestUrl = new URL(context.req.url)
+  const forwardedProto = context.req.header("x-forwarded-proto")?.split(",")[0]?.trim()
+  const forwardedHost = context.req.header("x-forwarded-host")?.split(",")[0]?.trim()
+
+  if (forwardedProto === "http" || forwardedProto === "https") {
+    requestUrl.protocol = `${forwardedProto}:`
+  }
+
+  if (forwardedHost) {
+    requestUrl.host = forwardedHost
+  }
+
+  return requestUrl
+}
+
+const fetchRelayMeta = async relayUrl => {
+  if (!relayUrl) return undefined
+  try {
+    return await loadRelay(normalizeRelayUrl(relayUrl))
+  } catch (err) {
+    console.error(`Failed to fetch relay metadata for ${relayUrl}:`, err)
+    return undefined
+  }
+}
+
+const buildDefaultImage = requestUrl => {
+  return new URL("/maskable-icon-512x512.png", requestUrl.origin).toString()
+}
+
+const getMetadataForInvite = async (url, match) => {
+  const relayParam = url.searchParams.get("r")
+  if (!relayParam) return undefined
+
+  const relayMetadata = await fetchRelayMeta(relayParam)
+  if (!relayMetadata) return undefined
+
+  const relayDisplay = displayRelayUrl(relayParam)
+  const spaceName = relayMetadata.name
+  const relayDescription = relayMetadata.description
+
+  const title = spaceName
+    ? `Invite to ${spaceName} on ${PLATFORM_NAME}`
+    : `Invite to a Space on ${PLATFORM_NAME}`
+
+  const parts = []
+  if (spaceName) {
+    parts.push(`You are invited to join ${spaceName} on ${PLATFORM_NAME}.`)
+  } else {
+    parts.push(`You are invited to join a space on ${PLATFORM_NAME}.`)
+  }
+
+  if (relayDisplay) parts.push(`Relay: ${relayDisplay}.`)
+  if (relayDescription) parts.push(relayDescription)
+  else parts.push(PLATFORM_DESCRIPTION)
+
+  const description = parts.join(" ")
+  const image =
+    relayMetadata.icon ||
+    relayMetadata.picture ||
+    relayMetadata.image ||
+    buildDefaultImage(url)
+
+  return {
+    title,
+    description,
+    image,
+    url: url.toString(),
+    site: url.origin,
+  }
+}
+
+const getMetadataForSpace = async (url, match) => {
+  const relayParam = decodeRelay(match[1])
+  if (!relayParam) return undefined
+
+  const relayMetadata = await fetchRelayMeta(relayParam)
+  if (!relayMetadata) return undefined
+
+  const spaceName = relayMetadata.name || displayRelayUrl(relayParam)
+
+  return {
+    title: `${spaceName} on ${PLATFORM_NAME}`,
+    description: relayMetadata.description || PLATFORM_DESCRIPTION,
+    image:
+      relayMetadata.icon ||
+      relayMetadata.picture ||
+      relayMetadata.image ||
+      buildDefaultImage(url),
+    url: url.toString(),
+    site: url.origin,
+  }
+}
+
+const getMetadataForSpaceSection = async (url, match) => {
+  const spaceMeta = await getMetadataForSpace(url, match)
+  if (!spaceMeta) return undefined
+
+  const section = match[2]
+  const sectionName = section.charAt(0).toUpperCase() + section.slice(1)
+  spaceMeta.title = `${sectionName} on ${spaceMeta.title}`
+  return spaceMeta
+}
+
+const getMetadataForSpaceItem = async (url, match) => {
+  const spaceMeta = await getMetadataForSpace(url, match)
+  if (!spaceMeta) return undefined
+
+  const section = match[2]
+  let itemType = "Item"
+  if (section === "calendar") itemType = "Event"
+  if (section === "threads") itemType = "Thread"
+  if (section === "polls") itemType = "Poll"
+  if (section === "goals") itemType = "Goal"
+  if (section === "classifieds") itemType = "Listing"
+
+  spaceMeta.title = `${itemType} on ${spaceMeta.title}`
+  return spaceMeta
+}
+
+const getMetadataForRoom = async (url, match) => {
+  const spaceMeta = await getMetadataForSpace(url, match)
+  if (!spaceMeta) return undefined
+
+  // Room metadata requires fetching from Nostr, which can be added later.
+  spaceMeta.title = `Room on ${spaceMeta.title}`
+  return spaceMeta
+}
+
+const routes = [
+  [/^\/join\/?$/, getMetadataForInvite],
+  [/^\/spaces\/([^/]+)\/(calendar|chat|threads|polls|goals|classifieds|recent)\/?$/, getMetadataForSpaceSection],
+  [/^\/spaces\/([^/]+)\/(calendar|threads|polls|goals|classifieds)\/([^/]+)\/?$/, getMetadataForSpaceItem],
+  [/^\/spaces\/([^/]+)\/([^/]+)\/?$/, getMetadataForRoom],
+  [/^\/spaces\/([^/]+)\/?$/, getMetadataForSpace],
+]
+
+const getMetadataForRoute = async url => {
+  for (const [regex, getMetadata] of routes) {
+    const match = url.pathname.match(regex)
+    if (match) {
+      try {
+        return await getMetadata(url, match)
+      } catch (err) {
+        console.error(`Error generating metadata for route ${url.pathname}:`, err)
+        return undefined
+      }
+    }
+  }
+  return undefined
+}
+
+const injectMeta = metadata => {
+  const $ = load(TEMPLATE_HTML)
+
+  if (metadata.title) {
+    $("title").text(metadata.title)
+    $('meta[property="og:title"]').attr("content", metadata.title)
+    $('meta[name="twitter:title"]').attr("content", metadata.title)
+  }
+
+  if (metadata.description) {
+    $('meta[name="description"]').attr("content", metadata.description)
+    $('meta[property="og:description"]').attr("content", metadata.description)
+    $('meta[name="twitter:description"]').attr("content", metadata.description)
+  }
+
+  if (metadata.image) {
+    $('meta[property="og:image"]').attr("content", metadata.image)
+    $('meta[name="twitter:image"]').attr("content", metadata.image)
+  }
+
+  if (metadata.url) {
+    $('meta[property="og:url"]').attr("content", metadata.url)
+    $('meta[name="twitter:site"]').attr("content", metadata.site)
+    $('meta[name="twitter:url"]').attr("content", metadata.url)
+    $('link[rel="canonical"]').attr("href", metadata.url)
+  }
+
+  return $.html()
+}
+
+const app = new Hono()
+
+// Only allow GET and HEAD requests
+app.use("*", async (context, next) => {
+  const method = context.req.method
+  if (method !== "GET" && method !== "HEAD") {
+    return context.text("Method Not Allowed", 405, {Allow: "GET, HEAD"})
+  }
+  await next()
+})
+
+// Serve static assets with appropriate caching
+app.use(
+  "*",
+  serveStatic({
+    root: BUILD_DIR,
+    onFound: (filePath, context) => {
+      const isImmutable = filePath.split(path.sep).join("/").includes("/_app/immutable/")
+      const cacheControl =
+        path.basename(filePath) === "index.html"
+          ? "no-cache"
+          : isImmutable
+            ? "public, max-age=31536000, immutable"
+            : "public, max-age=3600"
+
+      context.header("Cache-Control", cacheControl)
+
+      // Immutable assets are content-hashed by Vite, so the filename is itself a
+      // stable content identifier. Exposing it as an ETag lets clients that
+      // revalidate explicitly (e.g. emoji-picker-element checks its data source
+      // on every load) skip re-downloading large files when nothing changed.
+      if (isImmutable) {
+        context.header("ETag", `"${path.basename(filePath)}"`)
+      }
+    },
+  }),
+)
+
+// SPA fallback for routes that don't match static files
+app.get("*", async context => {
+  const requestUrl = requestUrlFromContext(context)
+
+  // If the path has an extension, it's likely a missing static asset, not an SPA route
+  if (path.extname(requestUrl.pathname)) {
+    return context.text("Not found", 404)
+  }
+
+  const metadata = await getMetadataForRoute(requestUrl)
+  const html = metadata ? injectMeta(metadata) : TEMPLATE_HTML
+
+  return context.html(html, 200, {
+    "Cache-Control": metadata ? "no-store" : "no-cache",
+  })
+})
+
+serve(
+  {
+    fetch: app.fetch,
+    hostname: HOST,
+    port: PORT,
+  },
+  () => {
+    console.log(`Flotilla server running on http://${HOST}:${PORT}`)
+  },
+)

sourcemaps.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-hash=$(find build -type f -print0 | sort -z | xargs -0 sha1sum | sha1sum | awk '{print $1}')
-
-sentry-cli \
-  --url https://glitchtip.coracle.social \
-  --auth-token $GLITCHTIP_AUTH_TOKEN \
-  --api-key $VITE_GLITCHTIP_API_KEY \
-  sourcemaps \
-  --org coracle \
-  --project flotilla \
-  --release $hash \
-  upload \
-  --url-prefix /_app/immutable/ \
-  build/_app/immutable

src/app.css

@@ -1,46 +1,6 @@
-@import "@welshman/editor/index.css";
+@import "tailwindcss";
 
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-/* Fonts */
-
-@font-face {
-  font-family: "Satoshis";
-  font-style: normal;
-  font-weight: 400;
-  src:
-    local(""),
-    url("/fonts/Satoshi Symbol.ttf") format("truetype");
-}
-
-@font-face {
-  font-family: "Lato";
-  font-style: normal;
-  font-weight: 400;
-  src:
-    local(""),
-    url("/fonts/Lato-Regular.ttf") format("truetype");
-}
-
-@font-face {
-  font-family: "Lato";
-  font-style: bold;
-  font-weight: 600;
-  src:
-    local(""),
-    url("/fonts/Lato-Bold.ttf") format("truetype");
-}
-
-@font-face {
-  font-family: "Lato";
-  font-style: italic;
-  font-weight: 400;
-  src:
-    local(""),
-    url("/fonts/Italic.ttf") format("truetype");
-}
+@config "../tailwind.config.js";
 
 /* root */
 
@@ -52,94 +12,245 @@
   --sair: var(--safe-area-inset-right, env(safe-area-inset-right));
 }
 
-[data-theme] {
-  @apply bg-base-300;
-  --base-100: oklch(var(--b1));
-  --base-200: oklch(var(--b2));
-  --base-300: oklch(var(--b3));
-  --base-content: oklch(var(--bc));
-  --primary: oklch(var(--p));
-  --primary-content: oklch(var(--pc));
-  --secondary: oklch(var(--s));
-  --secondary-content: oklch(var(--sc));
-  --neutral: oklch(var(--n));
-  --neutral-content: oklch(var(--nc));
+@utility pt-sai {
+  padding-top: var(--sait);
 }
 
-/* safe area insets */
+@utility pr-sai {
+  padding-right: var(--sair);
+}
 
-@layer components {
-  .pt-sai {
-    padding-top: var(--sait);
+@utility pb-sai {
+  padding-bottom: var(--saib);
+}
+
+@utility pl-sai {
+  padding-left: var(--sail);
+}
+
+@utility px-sai {
+  @apply pl-sai pr-sai;
+}
+
+@utility py-sai {
+  @apply pt-sai pb-sai;
+}
+
+@utility p-sai {
+  @apply py-sai px-sai;
+}
+
+@utility mt-sai {
+  margin-top: var(--sait);
+}
+
+@utility mr-sai {
+  margin-right: var(--sair);
+}
+
+@utility mb-sai {
+  margin-bottom: var(--saib);
+}
+
+@utility ml-sai {
+  margin-left: var(--sail);
+}
+
+@utility mx-sai {
+  @apply ml-sai mr-sai;
+}
+
+@utility my-sai {
+  @apply mt-sai mb-sai;
+}
+
+@utility m-sai {
+  @apply my-sai mx-sai;
+}
+
+@utility top-sai {
+  top: var(--sait);
+}
+
+@utility right-sai {
+  right: var(--sair);
+}
+
+@utility bottom-sai {
+  bottom: var(--saib);
+}
+
+@utility left-sai {
+  left: var(--sail);
+}
+
+@utility card2 {
+  @apply rounded-box text-base-content p-4 sm:p-6;
+}
+
+@utility column {
+  @apply flex flex-col;
+}
+
+@utility center {
+  @apply flex items-center justify-center;
+}
+
+@utility row-2 {
+  @apply flex items-center gap-2;
+}
+
+@utility row-3 {
+  @apply flex items-center gap-3;
+}
+
+@utility row-4 {
+  @apply flex items-center gap-4;
+}
+
+@utility col-2 {
+  @apply flex flex-col gap-2;
+}
+
+@utility col-3 {
+  @apply flex flex-col gap-3;
+}
+
+@utility col-4 {
+  @apply flex flex-col gap-4;
+}
+
+@utility col-8 {
+  @apply flex flex-col gap-8;
+}
+
+@utility ellipsize {
+  @apply overflow-hidden text-ellipsis;
+}
+
+@utility content-padding-x {
+  @apply px-4 sm:px-8 md:px-12;
+}
+
+@utility content-padding-t {
+  @apply pt-4 sm:pt-8 md:pt-12;
+}
+
+@utility content-padding-b {
+  @apply pb-4 sm:pb-8 md:pb-12;
+}
+
+@utility content-padding-y {
+  @apply pt-4 pb-4 sm:pt-8 sm:pb-8 md:pt-12 md:pb-12;
+}
+
+@utility content-sizing {
+  @apply m-auto w-full max-w-3xl;
+}
+
+@utility content {
+  @apply m-auto w-full max-w-3xl px-4 pt-4 pb-4 sm:px-8 sm:pt-8 sm:pb-8 md:px-12 md:pt-12 md:pb-12;
+}
+
+@utility heading {
+  @apply text-center text-2xl;
+}
+
+@utility subheading {
+  @apply text-center text-xl;
+}
+
+@utility superheading {
+  @apply text-center text-4xl;
+}
+
+@utility link {
+  @apply text-primary cursor-pointer underline;
+}
+
+/* content visibility */
+
+@utility cv {
+  content-visibility: auto;
+}
+
+/*
+  The default border color has changed to `currentcolor` in Tailwind CSS v4,
+  so we've added these compatibility styles to make sure everything still
+  looks the same as it did with Tailwind CSS v3.
+
+  If we ever want to remove these styles, we need to add an explicit border
+  color utility to any element that depends on these defaults.
+*/
+@layer base {
+  *,
+  ::after,
+  ::before,
+  ::backdrop,
+  ::file-selector-button {
+    border-color: var(--color-gray-200, currentcolor);
+  }
+}
+
+@layer utilities {
+  /* Fonts */
+
+  @font-face {
+    font-family: "Satoshis";
+    font-style: normal;
+    font-weight: 400;
+    src:
+      local(""),
+      url("/fonts/Satoshi Symbol.ttf") format("truetype");
   }
 
-  .pr-sai {
-    padding-right: var(--sair);
+  @font-face {
+    font-family: "Lato";
+    font-style: normal;
+    font-weight: 400;
+    src:
+      local(""),
+      url("/fonts/Lato-Regular.ttf") format("truetype");
   }
 
-  .pb-sai {
-    padding-bottom: var(--saib);
+  @font-face {
+    font-family: "Lato";
+    font-style: bold;
+    font-weight: 600;
+    src:
+      local(""),
+      url("/fonts/Lato-Bold.ttf") format("truetype");
   }
 
-  .pl-sai {
-    padding-left: var(--sail);
+  @font-face {
+    font-family: "Lato";
+    font-style: italic;
+    font-weight: 400;
+    src:
+      local(""),
+      url("/fonts/Italic.ttf") format("truetype");
   }
 
-  .px-sai {
-    @apply pl-sai pr-sai;
+  /* root */
+
+  :root {
+    font-family: Lato;
+    text-size-adjust: 100%;
+    --sait: var(--safe-area-inset-top, env(safe-area-inset-top));
+    --saib: var(--safe-area-inset-bottom, env(safe-area-inset-bottom));
+    --sail: var(--safe-area-inset-left, env(safe-area-inset-left));
+    --sair: var(--safe-area-inset-right, env(safe-area-inset-right));
   }
 
-  .py-sai {
-    @apply pt-sai pb-sai;
+  [data-theme] {
+    @apply bg-base-300;
   }
 
-  .p-sai {
-    @apply py-sai px-sai;
+  .mobile [data-tip]::before {
+    display: none !important;
   }
 
-  .mt-sai {
-    padding-top: var(--sait);
-  }
-
-  .mr-sai {
-    padding-right: var(--sair);
-  }
-
-  .mb-sai {
-    padding-bottom: var(--saib);
-  }
-
-  .ml-sai {
-    padding-left: var(--sail);
-  }
-
-  .mx-sai {
-    @apply ml-sai mr-sai;
-  }
-
-  .my-sai {
-    @apply mt-sai mb-sai;
-  }
-
-  .m-sai {
-    @apply my-sai mx-sai;
-  }
-
-  .top-sai {
-    top: var(--sait);
-  }
-
-  .right-sai {
-    right: var(--sair);
-  }
-
-  .bottom-sai {
-    bottom: var(--saib);
-  }
-
-  .left-sai {
-    left: var(--sail);
-  }
+  /* safe area insets */
 }
 
 /* utilities */
@@ -161,134 +272,42 @@
   @apply bg-base-300 text-base-content transition-colors;
 }
 
-.card2 {
-  @apply rounded-box p-4 text-base-content sm:p-6;
-}
-
 .card2.card2-sm {
-  @apply p-2 text-base-content sm:p-4;
-}
-
-.column {
-  @apply flex flex-col;
-}
-
-.center {
-  @apply flex items-center justify-center;
-}
-
-.row-2 {
-  @apply flex items-center gap-2;
-}
-
-.row-3 {
-  @apply flex items-center gap-3;
-}
-
-.row-4 {
-  @apply flex items-center gap-4;
-}
-
-.col-2 {
-  @apply flex flex-col gap-2;
-}
-
-.col-3 {
-  @apply flex flex-col gap-3;
-}
-
-.col-4 {
-  @apply flex flex-col gap-4;
-}
-
-.col-8 {
-  @apply flex flex-col gap-8;
-}
-
-.badge {
-  @apply justify-start overflow-hidden text-ellipsis whitespace-nowrap;
-}
-
-.ellipsize {
-  @apply overflow-hidden text-ellipsis;
+  @apply text-base-content p-2 sm:p-4;
 }
 
 [data-tip]::before {
-  @apply ellipsize;
-}
-
-.content-padding-x {
-  @apply px-4 sm:px-8 md:px-12;
-}
-
-.content-padding-t {
-  @apply pt-4 sm:pt-8 md:pt-12;
-}
-
-.content-padding-b {
-  @apply pb-4 sm:pb-8 md:pb-12;
-}
-
-.content-padding-y {
-  @apply content-padding-t content-padding-b;
-}
-
-.content-sizing {
-  @apply m-auto w-full max-w-3xl;
-}
-
-.content {
-  @apply content-sizing content-padding-x content-padding-y;
-}
-
-.heading {
-  @apply text-center text-2xl;
-}
-
-.subheading {
-  @apply text-center text-xl;
-}
-
-.superheading {
-  @apply text-center text-4xl;
-}
-
-.link {
-  @apply cursor-pointer text-primary underline;
+  @apply overflow-hidden text-ellipsis;
 }
 
 .input input::placeholder {
   opacity: 0.5;
 }
 
-.shadow-top-xl {
-  @apply shadow-[0_20px_25px_-5px_rgb(0,0,0,0.1)_0_8px_10px_-6px_rgb(0,0,0,0.1)];
-}
-
 /* tiptap */
 
 .input-editor,
 .chat-editor,
 .note-editor {
-  @apply -m-1 min-h-12 p-1;
+  @apply -m-1 p-1;
 }
 
 .tiptap {
-  --tiptap-object-bg: var(--neutral);
-  --tiptap-object-fg: var(--neutral-content);
-  --tiptap-active-bg: var(--primary);
-  --tiptap-active-fg: var(--primary-content);
+  --tiptap-object-bg: var(--color-neutral);
+  --tiptap-object-fg: var(--color-neutral-content);
+  --tiptap-active-bg: var(--color-primary);
+  --tiptap-active-fg: var(--color-primary-content);
 }
 
 .tiptap-suggestions {
-  --tiptap-object-bg: var(--base-100);
-  --tiptap-object-fg: var(--base-content);
-  --tiptap-active-bg: var(--base-300);
-  --tiptap-active-fg: var(--base-content);
+  --tiptap-object-bg: var(--color-base-100);
+  --tiptap-object-fg: var(--color-base-content);
+  --tiptap-active-bg: var(--color-base-300);
+  --tiptap-active-fg: var(--color-base-content);
 }
 
 .tiptap-suggestions__item {
-  @apply border-l-2 border-solid border-base-100;
+  @apply border-base-100 border-l-2 border-solid;
 }
 
 .tiptap-suggestions__selected {
@@ -296,7 +315,7 @@
 }
 
 .tiptap {
-  @apply max-h-[350px] overflow-y-auto p-2 px-4;
+  @apply max-h-[350px] min-h-10 overflow-y-auto p-2 px-4;
 }
 
 .tiptap p.is-editor-empty:first-child::before {
@@ -308,13 +327,13 @@
 }
 
 .note-editor .tiptap {
-  --tiptap-object-bg: var(--base-200);
-  @apply input input-bordered h-auto min-h-32 rounded-box p-[.65rem] pb-6;
+  --tiptap-object-bg: var(--color-base-200);
+  @apply input rounded-box block h-auto min-h-32 w-full p-[.65rem] pb-6;
 }
 
 .input-editor .tiptap {
-  --tiptap-object-bg: var(--base-200);
-  @apply input input-bordered h-auto p-[.65rem];
+  --tiptap-object-bg: var(--color-base-200);
+  @apply input block h-auto p-[.65rem];
 }
 
 /* link-content, based on tiptap */
@@ -326,8 +345,8 @@
   white-space: nowrap;
   border-radius: 3px;
   padding: 0 0.25rem;
-  background-color: var(--base-100);
-  color: var(--base-content);
+  background-color: var(--color-base-100);
+  color: var(--color-base-content);
 }
 
 /* content rendered by welshman/content */
@@ -343,33 +362,47 @@
 /* date input */
 
 .picker {
-  --date-picker-foreground: var(--base-content);
-  --date-picker-background: var(--base-300);
-  --date-picker-highlight-border: var(--primary);
-  --date-picker-selected-color: var(--primary-content);
-  --date-picker-selected-background: var(--primary);
+  --date-picker-foreground: var(--color-base-content);
+  --date-picker-background: var(--color-base-300);
+  --date-picker-highlight-border: var(--color-primary);
+  --date-picker-selected-color: var(--color-primary-content);
+  --date-picker-selected-background: var(--color-primary);
 }
 
 .date-time-field {
-  @apply input input-bordered rounded-lg px-0;
+  @apply input rounded-lg px-0;
 }
 
 .date-time-field input {
-  @apply !h-full !w-full !rounded-lg !border-none !bg-inherit !px-4 !text-inherit;
+  @apply h-full! w-full! rounded-lg! border-none! bg-inherit! px-4! text-inherit!;
+}
+
+/* tippy popover */
+
+.tippy-target {
+  @apply z-tooltip pointer-events-none fixed inset-0;
+}
+
+.tippy-target > * {
+  pointer-events: auto;
+}
+
+.tippy-box {
+  @apply rounded-box shadow-xl;
 }
 
 /* emoji picker */
 
 emoji-picker {
-  --background: var(--base-100);
-  --border-color: var(--base-100);
+  --background: var(--color-base-100);
+  --border-color: var(--color-base-100);
   --border-radius: var(--rounded-box);
-  --button-active-background: var(--base-content);
-  --button-hover-background: var(--base-content);
-  --indicator-color: var(--base-content);
-  --input-border-color: var(--base-100);
-  --input-font-color: var(--base-content);
-  --outline-color: var(--base-100);
+  --button-active-background: var(--color-base-content);
+  --button-hover-background: var(--color-base-content);
+  --indicator-color: var(--color-base-content);
+  --input-border-color: var(--color-base-100);
+  --input-font-color: var(--color-base-content);
+  --outline-color: var(--color-base-100);
 }
 
 /* progress */
@@ -380,24 +413,38 @@ progress[value]::-webkit-progress-value {
 
 /* content width for fixed elements */
 
-.cw {
-  @apply w-full md:left-[18.5rem] md:w-[calc(100%-18.5rem-var(--sair))];
+.left-content {
+  @apply md:left-[calc(18.5rem+var(--sail))];
 }
 
-.cw-full {
-  @apply w-full md:left-[4rem] md:w-[calc(100%-4rem-var(--sair))];
+.left-content-full {
+  @apply md:left-[calc(3.5rem+var(--sail))];
 }
 
-.cb {
-  @apply md:bottom-sai bottom-[calc(var(--saib)+3.5rem)];
+/* Keyboard open state adjustments */
+
+body.keyboard-open {
+  --saib: 0px;
+}
+
+body.keyboard-open .hide-on-keyboard {
+  display: none;
+}
+
+body.keyboard-open .chat__compose {
+  margin-bottom: 0;
 }
 
 /* chat view */
 
 .chat__compose {
-  @apply cb cw fixed z-compose;
+  @apply z-compose relative mb-14 shrink-0 md:mb-0;
+}
+
+.chat__compose .chat__compose-inner {
+  @apply min-w-0;
 }
 
 .chat__scroll-down {
-  @apply fixed bottom-28 right-4 md:bottom-16;
+  @apply pb-sai z-feature fixed right-4 bottom-28 md:bottom-16;
 }

src/app.html

@@ -2,15 +2,18 @@
 <html lang="en">
   <head>
     <meta charset="utf-8" />
+    <title>{NAME}</title>
+    <link rel="canonical" href="{URL}" />
     <meta
       name="viewport"
       content="width=device-width, initial-scale=1.0, viewport-fit=cover, interactive-widget=resizes-content" />
     <meta name="theme-color" content="{ACCENT}" />
     <meta name="description" content="{DESCRIPTION}" />
-    <meta name="og:url" content="{URL}" />
-    <meta name="og:type" content="website" />
-    <meta name="og:title" content="{NAME}" />
-    <meta name="og:description" content="{DESCRIPTION}" />
+    <meta property="og:url" content="{URL}" />
+    <meta property="og:type" content="website" />
+    <meta property="og:title" content="{NAME}" />
+    <meta property="og:description" content="{DESCRIPTION}" />
+    <meta property="og:image" content="" />
     <meta name="twitter:card" content="summary" />
     <meta name="twitter:site" content="{URL}" />
     <meta name="twitter:title" content="{NAME}" />
@@ -26,7 +29,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/icons/apple-touch-icon-180x180.png" />
     %sveltekit.head%
   </head>
-  <body data-sveltekit-preload-data="hover">
+  <body data-sveltekit-preload-data="hover" data-sveltekit-preload-code="eager">
     <div style="display: contents">%sveltekit.body%</div>
     <script
       defer

src/app/call/stores.ts

@@ -0,0 +1,72 @@
+import {Room as LiveKitRoom} from "livekit-client"
+import {derived, writable} from "svelte/store"
+import {type Room} from "@app/core/state"
+
+export type VoiceSession = {
+  url: string
+  h: string
+  room: LiveKitRoom
+  cameraOn: boolean
+  screenShareOn: boolean
+}
+
+/** Mic mute state is separate so toggling it does not re-render video tiles. */
+export const voiceMicMuted = writable(true)
+
+export type Pubkey = string
+
+export type VoiceParticipant = {pubkey?: Pubkey; identity: string}
+
+export enum VoiceState {
+  Joining = "joining",
+  Connected = "connected",
+  Disconnected = "disconnected",
+}
+
+export const currentVoiceSession = writable<VoiceSession | undefined>(undefined)
+
+export const voiceState = writable<VoiceState>(VoiceState.Disconnected)
+
+export const currentVoiceRoom = writable<Room | undefined>(undefined)
+
+export const pubkeyFromLiveKitIdentity = (identity: string): string | undefined =>
+  /^[a-f0-9]{64}$/.test(identity.slice(0, 64)) ? identity.slice(0, 64) : undefined
+
+export const participantFromLiveKitIdentity = (identity: string): VoiceParticipant => {
+  const pk = pubkeyFromLiveKitIdentity(identity)
+  return pk ? {pubkey: pk, identity} : {identity}
+}
+
+export const participantKey = (p: VoiceParticipant) => p.pubkey ?? p.identity
+
+export const speakingParticipants = writable<VoiceParticipant[]>([])
+
+export const participantMediaState = writable(
+  new Map<string, {muted: boolean; cameraOn: boolean}>(),
+)
+
+export const mediaStateByIdentity = derived(
+  [participantMediaState, currentVoiceSession, voiceMicMuted],
+  ([$media, $session, $micMuted]) =>
+    (identity: string) => {
+      if ($session?.room.localParticipant.identity === identity) {
+        return {muted: $micMuted, cameraOn: $session.cameraOn}
+      }
+      return $media.get(identity) ?? {muted: true, cameraOn: false}
+    },
+)
+
+export const isParticipantSpeaking = derived(
+  speakingParticipants,
+  $participants => (p: VoiceParticipant) =>
+    $participants.some(sp => participantKey(sp) === participantKey(p)),
+)
+
+export const isLocalSpeaking = derived(
+  [currentVoiceSession, speakingParticipants],
+  ([$session, $speaking]) => {
+    if (!$session?.room) return false
+    const local = participantFromLiveKitIdentity($session.room.localParticipant.identity)
+    return $speaking.some(sp => participantKey(sp) === participantKey(local))
+  },
+)

src/app/call/video.ts

@@ -0,0 +1,99 @@
+import {Track} from "livekit-client"
+import {MediaQuery} from "svelte/reactivity"
+import {derived, get, writable} from "svelte/store"
+import {currentVoiceSession, VoiceState, type VoiceSession, voiceState} from "@app/call/stores"
+import {pushToast} from "@app/util/toast"
+
+export enum VideoCallLayout {
+  Chat = "chat",
+  Video = "video",
+  Split = "split",
+}
+
+export const isDesktopLayout = new MediaQuery("min-width: 768px", false)
+
+export enum ViewportSize {
+  Desktop = "desktop",
+  Mobile = "mobile",
+}
+
+export const videoCallViewportSync = {
+  previousLayout: undefined as ViewportSize | undefined,
+}
+
+export const videoCallLayout = writable<VideoCallLayout>(VideoCallLayout.Split)
+
+export const resetVideoCallLayout = () => {
+  videoCallViewportSync.previousLayout = undefined
+  videoCallLayout.set(VideoCallLayout.Chat)
+}
+
+export const videoPrimaryTileKey = writable<string | undefined>(undefined)
+
+export const toggleVideoPrimaryTile = (key: string) => {
+  videoPrimaryTileKey.update(k => (k === key ? undefined : key))
+}
+
+const VISUAL_SOURCES = [Track.Source.Camera, Track.Source.ScreenShare] as const
+
+const countLiveVisualFeeds = (session: VoiceSession): number => {
+  const room = session.room
+  let n = 0
+  const lp = room.localParticipant
+  if (session.cameraOn) {
+    const pub = lp.getTrackPublication(Track.Source.Camera)
+    if (pub?.track) n += 1
+  }
+  if (session.screenShareOn) {
+    const pub = lp.getTrackPublication(Track.Source.ScreenShare)
+    if (pub?.track) n += 1
+  }
+  for (const rp of room.remoteParticipants.values()) {
+    for (const source of VISUAL_SOURCES) {
+      const pub = rp.getTrackPublication(source)
+      if (pub?.isSubscribed && pub.track) n += 1
+    }
+  }
+  return n
+}
+
+export const triggerVideoFeedCount = () => {
+  currentVoiceSession.update(s => (s ? {...s} : s))
+}
+
+export const videoTileCount = derived([currentVoiceSession, voiceState], ([$session, $state]) => {
+  if ($state !== VoiceState.Connected || !$session) return 0
+  return countLiveVisualFeeds($session)
+})
+
+export const toggleCamera = async () => {
+  const session = get(currentVoiceSession)
+  if (!session) return
+
+  const cameraOn = !session.cameraOn
+  try {
+    await session.room.localParticipant.setCameraEnabled(cameraOn)
+    currentVoiceSession.set({...session, cameraOn})
+  } catch {
+    pushToast({
+      theme: "error",
+      message: cameraOn ? "Could not access camera" : "Could not turn off camera",
+    })
+  }
+}
+
+export const toggleScreenShare = async () => {
+  const session = get(currentVoiceSession)
+  if (!session) return
+
+  const screenShareOn = !session.screenShareOn
+  try {
+    await session.room.localParticipant.setScreenShareEnabled(screenShareOn)
+    currentVoiceSession.set({...session, screenShareOn})
+  } catch {
+    pushToast({
+      theme: "error",
+      message: screenShareOn ? "Could not start screen sharing" : "Could not stop screen sharing",
+    })
+  }
+}

src/app/call/voice.ts

@@ -0,0 +1,384 @@
+/**
+ * Voice rooms via LiveKit. Note: Voice does not work on localhost in Firefox
+ * (ICE candidate gathering fails). Use Chrome or test from deployed HTTPS.
+ */
+import {
+  DisconnectReason,
+  LocalParticipant,
+  LocalTrackPublication,
+  Participant,
+  Room as LiveKitRoom,
+  RoomEvent,
+  Track,
+  TrackPublication,
+  supportsAudioOutputSelection,
+  type AudioCaptureOptions,
+} from "livekit-client"
+import {derived, get} 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 {getLivekitEndpoint} from "$lib/livekit"
+import {AbortError, whenAborted, whenTimeout} from "$lib/util"
+import {
+  currentVoiceRoom,
+  currentVoiceSession,
+  voiceMicMuted,
+  participantFromLiveKitIdentity,
+  participantKey,
+  participantMediaState,
+  speakingParticipants,
+  VoiceState,
+  type VoiceParticipant,
+  voiceState,
+} from "@app/call/stores"
+import {resetVideoCallLayout, triggerVideoFeedCount, videoPrimaryTileKey} from "@app/call/video"
+import {deriveLatestEventForUrl, deriveRoom, makeRoomId} from "@app/core/state"
+import {pushToast} from "@app/util/toast"
+
+export const LIVEKIT_PARTICIPANTS = 39004
+
+export {checkRelayHasLivekit} from "$lib/livekit"
+
+export {supportsAudioOutputSelection}
+
+const LIVEKIT_DEFAULT_DEVICE_ID = "default"
+
+export enum DeviceKind {
+  AudioInput = "audioinput",
+  AudioOutput = "audiooutput",
+  VideoInput = "videoinput",
+}
+
+export const switchVoiceActiveDevice = async (
+  kind: DeviceKind,
+  targetDeviceId: string,
+): Promise<void> => {
+  const session = get(currentVoiceSession)
+  if (!session) return
+  const id = targetDeviceId === "" ? LIVEKIT_DEFAULT_DEVICE_ID : targetDeviceId
+  try {
+    await session.room.switchActiveDevice(kind, id)
+  } catch {
+    let label: string
+    switch (kind) {
+      case DeviceKind.AudioInput:
+        label = "microphone"
+        break
+      case DeviceKind.AudioOutput:
+        label = "speaker"
+        break
+      case DeviceKind.VideoInput:
+        label = "camera"
+        break
+    }
+    pushToast({theme: "error", message: `Error changing ${label}`})
+  }
+}
+
+const deleteParticipant = (identity: string) => {
+  participantMediaState.update(m => new Map(reject(nthEq(0, identity), [...m])))
+}
+
+const syncParticipantMedia = (participant: Participant) => {
+  const state = {muted: !participant.isMicrophoneEnabled, cameraOn: participant.isCameraEnabled}
+  participantMediaState.update(m => {
+    const prev = m.get(participant.identity)
+    if (prev?.muted === state.muted && prev?.cameraOn === state.cameraOn) return m
+    const next = new Map(m)
+    next.set(participant.identity, state)
+    return next
+  })
+}
+
+const onParticipantMediaChanged = (_publication: TrackPublication, participant: Participant) => {
+  syncParticipantMedia(participant)
+}
+
+const fetchLivekitToken = async (
+  url: string,
+  groupId: 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")
+
+  if (signal?.aborted) throw new DOMException("Aborted", "AbortError")
+
+  const template = await makeHttpAuth(endpoint, "GET")
+  const signedEvent = await $signer.sign(template)
+  const authHeader = makeHttpAuthHeader(signedEvent)
+
+  const response = await fetch(endpoint, {
+    headers: {Authorization: authHeader},
+    signal,
+  })
+
+  if (!response.ok) {
+    const text = await response.text()
+    throw new Error(`Token request failed (${response.status}): ${text}`)
+  }
+
+  return response.json()
+}
+
+export const deriveVoiceParticipants = (url: string, h: string) =>
+  // We use the livekit identity list while in a call, and fall back to the list in kind 39004.
+  derived(
+    [
+      participantMediaState,
+      currentVoiceRoom,
+      deriveLatestEventForUrl(url, [{kinds: [LIVEKIT_PARTICIPANTS], "#d": [h]}]),
+    ],
+    ([$participantMediaState, $currentVoiceRoom, $publishedParticipantList]) => {
+      const inCall = $participantMediaState.size > 0 && $currentVoiceRoom?.id === makeRoomId(url, h)
+
+      if (inCall) {
+        const participants = [...$participantMediaState.keys()].map(participantFromLiveKitIdentity)
+        return uniqBy((p: VoiceParticipant) => participantKey(p), participants)
+      } else {
+        const latestEvent = $publishedParticipantList as TrustedEvent | undefined
+        if (!latestEvent) return []
+        const participants = removeUndefined(
+          map(
+            (tag: string[]) => (tag[1] ? {pubkey: tag[1], identity: tag[1]} : undefined),
+            getTags("participant", latestEvent.tags),
+          ),
+        )
+        return uniqBy((p: VoiceParticipant) => participantKey(p), participants)
+      }
+    },
+  )
+
+const setUpMicrophone = async (
+  startMuted: boolean,
+  preferredMicId: string | undefined,
+  participant: LocalParticipant,
+): Promise<boolean> => {
+  if (startMuted) {
+    return true
+  }
+
+  let muted = true
+  let capture: AudioCaptureOptions | undefined = undefined
+  if (preferredMicId) {
+    capture = {deviceId: preferredMicId}
+  }
+  try {
+    await participant.setMicrophoneEnabled(true, capture)
+    muted = false
+  } catch (e) {
+    pushToast({theme: "error", message: "Could not access microphone"})
+  }
+  return muted
+}
+
+const onRoomDisconnected = (reason?: DisconnectReason) => {
+  videoPrimaryTileKey.set(undefined)
+  voiceMicMuted.set(true)
+  currentVoiceSession.set(undefined)
+  resetVideoCallLayout()
+  if (reason !== undefined && reason !== DisconnectReason.CLIENT_INITIATED) {
+    voiceState.set(VoiceState.Disconnected)
+    const message =
+      reason === DisconnectReason.JOIN_FAILURE
+        ? "Could not connect to voice room. Please try again."
+        : "Voice connection lost."
+    pushToast({theme: "error", message})
+  }
+  speakingParticipants.set([])
+  participantMediaState.set(new Map())
+}
+
+const onTrackSubscribed = (track: Track) => {
+  if (track.kind === Track.Kind.Audio) {
+    const element = track.attach()
+    element.style.display = "none"
+    document.body.appendChild(element)
+    element.play().catch(() => {})
+  } else if (track.kind === Track.Kind.Video) {
+    triggerVideoFeedCount()
+  }
+}
+
+const onTrackUnsubscribed = (track: Track) => {
+  track.detach().forEach(el => el.remove())
+  if (track.kind === Track.Kind.Video) {
+    triggerVideoFeedCount()
+  }
+}
+
+const onActiveSpeakersChanged = (participants: {identity: string}[]) => {
+  speakingParticipants.set(participants.map(p => participantFromLiveKitIdentity(p.identity)))
+}
+
+const playJoinSound = () => {
+  const audio = new Audio("/join-voice-room.mp3")
+  audio.play().catch(() => {})
+}
+
+const onParticipantConnected = (participant: Participant) => {
+  syncParticipantMedia(participant)
+  playJoinSound()
+}
+
+const onParticipantDisconnected = (participant: {identity: string}) => {
+  deleteParticipant(participant.identity)
+}
+
+const onLocalTrackUnpublished = (
+  publication: LocalTrackPublication,
+  participant: LocalParticipant,
+) => {
+  if (publication.source !== Track.Source.ScreenShare) return
+  const session = get(currentVoiceSession)
+  if (!session || participant.identity !== session.room.localParticipant.identity) return
+  if (!session.screenShareOn) return
+  currentVoiceSession.set({...session, screenShareOn: false})
+}
+
+let joinAbortController: AbortController | undefined
+
+export const cancelJoinVoiceRoom = () => {
+  joinAbortController?.abort()
+}
+
+export const joinVoiceRoom = async (
+  url: string,
+  h: string,
+  startMuted = true,
+  preferredMicId?: string,
+): Promise<void> => {
+  cancelJoinVoiceRoom()
+
+  const session = get(currentVoiceSession)
+  if (session) await leaveVoiceRoom()
+
+  currentVoiceRoom.set(get(deriveRoom(url, h)))
+  voiceState.set(VoiceState.Joining)
+
+  const controller = new AbortController()
+  joinAbortController = controller
+  const signal = controller.signal
+  const isActive = () => joinAbortController === controller
+
+  try {
+    const {server_url, participant_token} = await fetchLivekitToken(url, h, signal)
+
+    if (signal.aborted) throw new AbortError()
+
+    const liveKitRoom = new LiveKitRoom({adaptiveStream: true, dynacast: true})
+
+    liveKitRoom.on(RoomEvent.Disconnected, onRoomDisconnected)
+    liveKitRoom.on(RoomEvent.ParticipantConnected, onParticipantConnected)
+    liveKitRoom.on(RoomEvent.ParticipantDisconnected, onParticipantDisconnected)
+    liveKitRoom.on(RoomEvent.TrackSubscribed, onTrackSubscribed)
+    liveKitRoom.on(RoomEvent.TrackUnsubscribed, onTrackUnsubscribed)
+    liveKitRoom.on(RoomEvent.LocalTrackUnpublished, onLocalTrackUnpublished)
+    liveKitRoom.on(RoomEvent.ActiveSpeakersChanged, onActiveSpeakersChanged)
+    liveKitRoom.on(RoomEvent.TrackMuted, onParticipantMediaChanged)
+    liveKitRoom.on(RoomEvent.TrackUnmuted, onParticipantMediaChanged)
+    liveKitRoom.on(RoomEvent.TrackPublished, onParticipantMediaChanged)
+    liveKitRoom.on(RoomEvent.TrackUnpublished, onParticipantMediaChanged)
+    liveKitRoom.on(RoomEvent.LocalTrackPublished, onParticipantMediaChanged)
+
+    try {
+      await Promise.race([
+        liveKitRoom.connect(server_url, participant_token, {maxRetries: 0}),
+        whenTimeout(15_000, {
+          message: "Connection timed out. Please check your network and try again.",
+        }),
+        whenAborted(signal),
+      ])
+    } catch (e) {
+      liveKitRoom.disconnect()
+      throw e
+    }
+
+    participantMediaState.set(new Map())
+    syncParticipantMedia(liveKitRoom.localParticipant)
+    for (const p of liveKitRoom.remoteParticipants.values()) {
+      syncParticipantMedia(p)
+    }
+
+    const muted = await setUpMicrophone(startMuted, preferredMicId, liveKitRoom.localParticipant)
+
+    voiceMicMuted.set(muted)
+    currentVoiceSession.set({
+      url,
+      h,
+      room: liveKitRoom,
+      cameraOn: false,
+      screenShareOn: false,
+    })
+    voiceState.set(VoiceState.Connected)
+    playJoinSound()
+  } catch (e) {
+    if (isActive()) voiceState.set(VoiceState.Disconnected)
+    if (e instanceof AbortError) return
+    throw e
+  } finally {
+    if (isActive()) joinAbortController = undefined
+  }
+}
+
+export const leaveVoiceRoom = async () => {
+  const session = get(currentVoiceSession)
+  if (!session) return
+
+  const audio = new Audio("/leave-voice-room.mp3")
+  audio.play().catch(() => {})
+
+  if (session.cameraOn) {
+    try {
+      await session.room.localParticipant.setCameraEnabled(false)
+    } catch {
+      pushToast({theme: "error", message: "Error turning off camera."})
+    }
+  }
+
+  if (session.screenShareOn) {
+    try {
+      await session.room.localParticipant.setScreenShareEnabled(false)
+    } catch {
+      pushToast({theme: "error", message: "Error turning off screen sharing."})
+    }
+  }
+
+  voiceState.set(VoiceState.Disconnected)
+  videoPrimaryTileKey.set(undefined)
+  voiceMicMuted.set(true)
+  currentVoiceSession.set(undefined)
+  resetVideoCallLayout()
+  session.room.disconnect()
+  speakingParticipants.set([])
+  participantMediaState.set(new Map())
+}
+
+export const rejoinVoiceRoom = async (): Promise<void> => {
+  const target = get(currentVoiceRoom)
+  if (!target) return
+  return joinVoiceRoom(target.url, target.h)
+}
+
+export const toggleMute = async () => {
+  const session = get(currentVoiceSession)
+  if (!session) return
+
+  voiceMicMuted.update(not)
+  if (get(voiceMicMuted)) {
+    // Disable and re-enable microphone to trigger permission prompt
+    session.room.localParticipant.setMicrophoneEnabled(false)
+    return
+  }
+
+  try {
+    await session.room.localParticipant.setMicrophoneEnabled(true)
+  } catch (e) {
+    voiceMicMuted.set(true)
+    pushToast({theme: "error", message: "Could not access microphone"})
+  }
+}

src/app/components/AlertAdd.svelte

@@ -1,215 +0,0 @@
-<script lang="ts">
-  import {onMount} from "svelte"
-  import {preventDefault} from "@lib/html"
-  import {randomInt, displayList, TIMEZONE, identity} from "@welshman/lib"
-  import {displayRelayUrl, getTagValue, THREAD, MESSAGE, EVENT_TIME, COMMENT} from "@welshman/util"
-  import type {Filter} from "@welshman/util"
-  import {makeIntersectionFeed, makeRelayFeed, feedFromFilters} from "@welshman/feeds"
-  import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
-  import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
-  import Icon from "@lib/components/Icon.svelte"
-  import Button from "@lib/components/Button.svelte"
-  import FieldInline from "@lib/components/FieldInline.svelte"
-  import Spinner from "@lib/components/Spinner.svelte"
-  import ModalHeader from "@lib/components/ModalHeader.svelte"
-  import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {alerts, userSpaceUrls} from "@app/core/state"
-  import {requestRelayClaim} from "@app/core/requests"
-  import {createAlert} from "@app/core/commands"
-  import {canSendPushNotifications} from "@app/util/push"
-  import {pushToast} from "@app/util/toast"
-
-  type Props = {
-    url?: string
-    channel?: string
-    notifyChat?: boolean
-    notifyThreads?: boolean
-    notifyCalendar?: boolean
-    hideSpaceField?: boolean
-  }
-
-  let {
-    url = "",
-    channel = "email",
-    notifyChat = true,
-    notifyThreads = true,
-    notifyCalendar = true,
-    hideSpaceField = false,
-  }: Props = $props()
-
-  const timezoneOffset = parseInt(TIMEZONE.slice(3)) / 100
-  const minute = randomInt(0, 59)
-  const hour = (17 - timezoneOffset) % 24
-  const WEEKLY = `0 ${minute} ${hour} * * 1`
-  const DAILY = `0 ${minute} ${hour} * * *`
-
-  let loading = $state(false)
-  let cron = $state(WEEKLY)
-  let email = $state($alerts.map(a => getTagValue("email", a.tags)).filter(identity)[0] || "")
-
-  const back = () => history.back()
-
-  const submit = async () => {
-    if (channel === "email" && !email.includes("@")) {
-      return pushToast({
-        theme: "error",
-        message: "Please provide an email address",
-      })
-    }
-
-    if (!url) {
-      return pushToast({
-        theme: "error",
-        message: "Please select a space",
-      })
-    }
-
-    if (!notifyThreads && !notifyCalendar && !notifyChat) {
-      return pushToast({
-        theme: "error",
-        message: "Please select something to be notified about",
-      })
-    }
-
-    const filters: Filter[] = []
-    const display: string[] = []
-
-    if (notifyThreads) {
-      display.push("threads")
-      filters.push({kinds: [THREAD]})
-      filters.push({kinds: [COMMENT], "#k": [String(THREAD)]})
-    }
-
-    if (notifyCalendar) {
-      display.push("calendar events")
-      filters.push({kinds: [EVENT_TIME]})
-      filters.push({kinds: [COMMENT], "#k": [String(EVENT_TIME)]})
-    }
-
-    if (notifyChat) {
-      display.push("chat")
-      filters.push({kinds: [MESSAGE]})
-    }
-
-    loading = true
-
-    try {
-      const claim = url ? await requestRelayClaim(url) : undefined
-
-      const {error} = await createAlert({
-        feed: makeIntersectionFeed(feedFromFilters(filters), makeRelayFeed(url)),
-        claims: claim ? {[url]: claim} : {},
-        description: `for ${displayList(display)} on ${displayRelayUrl(url)}`,
-        email: channel === "email" ? {cron, email} : undefined,
-      })
-
-      if (error) {
-        pushToast({theme: "error", message: error})
-      } else {
-        pushToast({message: "Your alert has been successfully created!"})
-        back()
-      }
-    } finally {
-      loading = false
-    }
-  }
-
-  onMount(() => {
-    if (!canSendPushNotifications()) {
-      channel = "email"
-    }
-  })
-</script>
-
-<form class="column gap-4" onsubmit={preventDefault(submit)}>
-  <ModalHeader>
-    {#snippet title()}
-      Add an Alert
-    {/snippet}
-    {#snippet info()}
-      Enable notifications to keep up to date on activity you care about.
-    {/snippet}
-  </ModalHeader>
-  {#if canSendPushNotifications()}
-    <FieldInline>
-      {#snippet label()}
-        <p>Alert Type*</p>
-      {/snippet}
-      {#snippet input()}
-        <select bind:value={channel} class="select select-bordered">
-          <option value="email">Email Digest</option>
-          <option value="push">Push Notification</option>
-        </select>
-      {/snippet}
-    </FieldInline>
-  {/if}
-  {#if channel === "email"}
-    <FieldInline>
-      {#snippet label()}
-        <p>Email Address*</p>
-      {/snippet}
-      {#snippet input()}
-        <label class="input input-bordered flex w-full items-center gap-2">
-          <input placeholder="email@example.com" bind:value={email} />
-        </label>
-      {/snippet}
-    </FieldInline>
-    <FieldInline>
-      {#snippet label()}
-        <p>Frequency*</p>
-      {/snippet}
-      {#snippet input()}
-        <select bind:value={cron} class="select select-bordered">
-          <option value={WEEKLY}>Weekly</option>
-          <option value={DAILY}>Daily</option>
-        </select>
-      {/snippet}
-    </FieldInline>
-  {/if}
-  {#if !hideSpaceField}
-    <FieldInline>
-      {#snippet label()}
-        <p>Space*</p>
-      {/snippet}
-      {#snippet input()}
-        <select bind:value={url} class="select select-bordered">
-          <option value="" disabled selected>Choose a space URL</option>
-          {#each $userSpaceUrls as url (url)}
-            <option value={url}>{displayRelayUrl(url)}</option>
-          {/each}
-        </select>
-      {/snippet}
-    </FieldInline>
-  {/if}
-  <FieldInline>
-    {#snippet label()}
-      <p>Notifications*</p>
-    {/snippet}
-    {#snippet input()}
-      <div class="flex items-center justify-end gap-4">
-        <span class="flex gap-3">
-          <input type="checkbox" class="checkbox" bind:checked={notifyThreads} />
-          Threads
-        </span>
-        <span class="flex gap-3">
-          <input type="checkbox" class="checkbox" bind:checked={notifyCalendar} />
-          Calendar
-        </span>
-        <span class="flex gap-3">
-          <input type="checkbox" class="checkbox" bind:checked={notifyChat} />
-          Chat
-        </span>
-      </div>
-    {/snippet}
-  </FieldInline>
-  <ModalFooter>
-    <Button class="btn btn-link" onclick={back}>
-      <Icon icon={AltArrowLeft} />
-      Go back
-    </Button>
-    <Button type="submit" class="btn btn-primary" disabled={loading}>
-      <Spinner {loading}>Confirm</Spinner>
-      <Icon icon={AltArrowRight} />
-    </Button>
-  </ModalFooter>
-</form>

src/app/components/AlertDelete.svelte

@@ -1,20 +0,0 @@
-<script lang="ts">
-  import Confirm from "@lib/components/Confirm.svelte"
-  import type {Alert} from "@app/core/state"
-  import {deleteAlert} from "@app/core/commands"
-  import {pushToast} from "@app/util/toast"
-
-  type Props = {
-    alert: Alert
-  }
-
-  const {alert}: Props = $props()
-
-  const confirm = () => {
-    deleteAlert(alert)
-    pushToast({message: "Your alert has been deleted!"})
-    history.back()
-  }
-</script>
-
-<Confirm {confirm} message="You'll no longer receive messages for this alert." />

src/app/components/AlertItem.svelte

@@ -1,42 +0,0 @@
-<script lang="ts">
-  import {parseJson} from "@welshman/lib"
-  import {displayFeeds} from "@welshman/feeds"
-  import {getTagValue, getTagValues} from "@welshman/util"
-  import TrashBin2 from "@assets/icons/trash-bin-2.svg?dataurl"
-  import Icon from "@lib/components/Icon.svelte"
-  import Button from "@lib/components/Button.svelte"
-  import AlertDelete from "@app/components/AlertDelete.svelte"
-  import AlertStatus from "@app/components/AlertStatus.svelte"
-  import type {Alert} from "@app/core/state"
-  import {pushModal} from "@app/util/modal"
-
-  type Props = {
-    alert: Alert
-  }
-
-  const {alert}: Props = $props()
-
-  const cron = $derived(getTagValue("cron", alert.tags))
-  const channel = $derived(getTagValue("channel", alert.tags))
-  const feeds = $derived(getTagValues("feed", alert.tags))
-  const description = $derived(
-    getTagValue("description", alert.tags) ||
-      [
-        `${cron?.endsWith("1") ? "Weekly" : "Daily"} alert for events`,
-        displayFeeds(feeds.map(parseJson)),
-        `sent via ${channel}.`,
-      ].join(" "),
-  )
-
-  const startDelete = () => pushModal(AlertDelete, {alert})
-</script>
-
-<div class="flex items-start justify-between gap-4">
-  <div class="flex items-start gap-4">
-    <Button class="py-1" onclick={startDelete}>
-      <Icon icon={TrashBin2} />
-    </Button>
-    <div class="flex-inline gap-1">{description}</div>
-  </div>
-  <AlertStatus {alert} />
-</div>

src/app/components/AlertStatus.svelte

@@ -1,42 +0,0 @@
-<script lang="ts">
-  import {getAddress, getTagValue} from "@welshman/util"
-  import type {Alert} from "@app/core/state"
-  import {deriveAlertStatus} from "@app/core/state"
-
-  type Props = {
-    alert: Alert
-  }
-
-  const {alert}: Props = $props()
-
-  const status = deriveAlertStatus(getAddress(alert.event))
-</script>
-
-{#if $status}
-  {@const statusText = getTagValue("status", $status.tags) || "error"}
-  {#if statusText === "ok"}
-    <span
-      class="tooltip tooltip-left cursor-pointer rounded-full border border-solid border-base-content px-3 py-1 text-sm"
-      data-tip={getTagValue("message", $status.tags)}>
-      Active
-    </span>
-  {:else if statusText === "pending"}
-    <span
-      class="tooltip tooltip-left cursor-pointer rounded-full border border-solid border-base-content border-yellow-500 px-3 py-1 text-sm text-yellow-500"
-      data-tip={getTagValue("message", $status.tags)}>
-      Pending
-    </span>
-  {:else}
-    <span
-      class="tooltip tooltip-left cursor-pointer rounded-full border border-solid border-error px-3 py-1 text-sm text-error"
-      data-tip={getTagValue("message", $status.tags)}>
-      {statusText.replace("-", " ").replace(/^(.)/, x => x.toUpperCase())}
-    </span>
-  {/if}
-{:else}
-  <span
-    class="tooltip tooltip-left cursor-pointer rounded-full border border-solid border-error px-3 py-1 text-sm text-error"
-    data-tip="The notification server did not respond to your request.">
-    Inactive
-  </span>
-{/if}

src/app/components/Alerts.svelte

@@ -1,155 +0,0 @@
-<script lang="ts">
-  import {sleep} from "@welshman/lib"
-  import {getTagValue, getAddress} from "@welshman/util"
-  import {isRelayFeed, findFeed} from "@welshman/feeds"
-  import Inbox from "@assets/icons/inbox.svg?dataurl"
-  import Bell from "@assets/icons/bell.svg?dataurl"
-  import AddCircle from "@assets/icons/add-circle.svg?dataurl"
-  import Icon from "@lib/components/Icon.svelte"
-  import Button from "@lib/components/Button.svelte"
-  import AlertAdd from "@app/components/AlertAdd.svelte"
-  import AlertItem from "@app/components/AlertItem.svelte"
-  import {pushModal} from "@app/util/modal"
-  import {pushToast} from "@app/util/toast"
-  import {
-    alerts,
-    dmAlert,
-    deriveAlertStatus,
-    userInboxRelays,
-    getAlertFeed,
-    userSettingsValues,
-  } from "@app/core/state"
-  import {deleteAlert, createDmAlert} from "@app/core/commands"
-  import {clearBadges} from "../util/notifications"
-
-  type Props = {
-    url?: string
-    channel?: string
-    hideSpaceField?: boolean
-  }
-
-  const {url = "", channel = "push", hideSpaceField = false}: Props = $props()
-
-  const dmStatus = $derived($dmAlert ? deriveAlertStatus(getAddress($dmAlert.event)) : undefined)
-
-  const filteredAlerts = $derived(
-    $alerts.filter(alert => {
-      const feed = getAlertFeed(alert)
-
-      // Skip non-feeds and DM alerts
-      if (!feed || alert === $dmAlert) return false
-
-      // If we have a space url, only match feeds for this space
-      if (url) return findFeed(feed, f => isRelayFeed(f) && f.includes(url))
-
-      return true
-    }),
-  )
-
-  const startAlert = () => pushModal(AlertAdd, {url, channel, hideSpaceField})
-
-  const uncheckDmAlert = async (message: string) => {
-    await sleep(100)
-
-    directMessagesNotificationToggle.checked = false
-    pushToast({theme: "error", message})
-  }
-
-  const onDirectMessagesNotificationToggle = async () => {
-    if ($dmAlert) {
-      deleteAlert($dmAlert)
-    } else {
-      if ($userInboxRelays.length === 0) {
-        return uncheckDmAlert("Please set up your messaging relays before enabling alerts.")
-      }
-
-      const {error} = await createDmAlert()
-
-      if (error) {
-        return uncheckDmAlert(error)
-      }
-
-      pushToast({message: "Your alert has been successfully created!"})
-    }
-  }
-
-  const onShowBadgeOnUnreadToggle = async () => {
-    $userSettingsValues.show_notifications_badge = !$userSettingsValues.show_notifications_badge
-
-    if (!$userSettingsValues.show_notifications_badge) {
-      await clearBadges()
-    }
-  }
-
-  const onDirectMessagesNotificationSoundToggle = async () => {
-    $userSettingsValues.play_notification_sound = !$userSettingsValues.play_notification_sound
-  }
-
-  let directMessagesNotificationToggle: HTMLInputElement
-</script>
-
-<div class="col-4">
-  <div class="card2 bg-alt flex flex-col gap-6 shadow-xl">
-    <div class="flex items-center justify-between">
-      <strong class="flex items-center gap-3">
-        <Icon icon={Inbox} />
-        Alerts
-      </strong>
-      <Button class="btn btn-primary btn-sm" onclick={startAlert}>
-        <Icon icon={AddCircle} />
-        Add Alert
-      </Button>
-    </div>
-    <div class="col-4">
-      {#each filteredAlerts as alert (alert.event.id)}
-        <AlertItem {alert} />
-      {:else}
-        <p class="text-center opacity-75 py-12">Nothing here yet!</p>
-      {/each}
-    </div>
-  </div>
-  <div class="card2 bg-alt flex flex-col gap-4 shadow-xl">
-    <div class="flex items-center justify-between">
-      <strong class="flex items-center gap-3">
-        <Icon icon={Bell} />
-        Notifications
-      </strong>
-    </div>
-    <div class="flex justify-between">
-      <p>Notify me about new direct messages</p>
-      <input
-        type="checkbox"
-        class="toggle toggle-primary"
-        bind:this={directMessagesNotificationToggle}
-        checked={Boolean($dmAlert)}
-        oninput={onDirectMessagesNotificationToggle} />
-    </div>
-    <div class="flex justify-between">
-      <p>Show badge for unread direct messages</p>
-      <input
-        type="checkbox"
-        class="toggle toggle-primary"
-        checked={Boolean($userSettingsValues.show_notifications_badge)}
-        oninput={onShowBadgeOnUnreadToggle} />
-    </div>
-    <div class="flex justify-between">
-      <p>Play sound for new direct messages</p>
-      <input
-        type="checkbox"
-        class="toggle toggle-primary"
-        checked={Boolean($userSettingsValues.play_notification_sound)}
-        oninput={onDirectMessagesNotificationSoundToggle} />
-    </div>
-    {#if $dmStatus}
-      {@const status = getTagValue("status", $dmStatus.tags) || "error"}
-      {#if status !== "ok"}
-        <div class="alert alert-error border border-solid border-error bg-transparent text-error">
-          <p>
-            {getTagValue("message", $dmStatus.tags) ||
-              "The notification server did not respond to your request."}
-          </p>
-        </div>
-      {/if}
-    {/if}
-  </div>
-</div>

src/app/components/AppContainer.svelte

@@ -1,36 +1,17 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
-  import {page} from "$app/stores"
   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 EmailConfirm from "@app/components/EmailConfirm.svelte"
-  import PasswordReset from "@app/components/PasswordReset.svelte"
-  import {BURROW_URL} from "@app/core/state"
-  import {modals, pushModal} from "@app/util/modal"
+  import {modal} from "@app/util/modal"
 
   interface Props {
     children: Snippet
   }
 
   const {children}: Props = $props()
-
-  if (BURROW_URL && !$pubkey) {
-    if ($page.url.pathname === "/confirm-email") {
-      pushModal(EmailConfirm, {
-        email: $page.url.searchParams.get("email"),
-        confirm_token: $page.url.searchParams.get("confirm_token"),
-      })
-    }
-
-    if ($page.url.pathname === "/reset-password") {
-      pushModal(PasswordReset, {
-        email: $page.url.searchParams.get("email"),
-        reset_token: $page.url.searchParams.get("reset_token"),
-      })
-    }
-  }
 </script>
 
 <div class="flex h-screen overflow-hidden">
@@ -38,8 +19,8 @@
     <PrimaryNav>
       {@render children?.()}
     </PrimaryNav>
-  {:else if !$modals[$page.url.hash.slice(1)]}
-    <Landing />
+  {:else if !$modal}
+    <Dialog noEscape children={{component: Landing, props: {}}} />
   {/if}
 </div>
 <Toast />

src/app/components/CalendarEventActions.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {getTagValue, getAddress} from "@welshman/util"
   import {pubkey} from "@welshman/app"
+  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"
@@ -14,7 +15,6 @@
   import {publishDelete, publishReaction, canEnforceNip70} from "@app/core/commands"
   import {makeCalendarPath, makeSpacePath} from "@app/util/routes"
   import {pushModal} from "@app/util/modal"
-  import Pen2 from "@assets/icons/pen-2.svg?dataurl"
 
   type Props = {
     url: string
@@ -26,7 +26,7 @@
   const {url, event, showRoom, showActivity}: Props = $props()
 
   const h = getTagValue("h", event.tags)
-  const path = makeCalendarPath(url, event.id)
+  const path = makeCalendarPath(url, getAddress(event))
   const shouldProtect = canEnforceNip70(url)
 
   const editEvent = () => pushModal(CalendarEventEdit, {url, event})
@@ -38,7 +38,7 @@
     publishReaction({...template, event, relays: [url], protect: await shouldProtect})
 </script>
 
-<div class="flex flex-grow flex-wrap justify-end gap-2">
+<div class="flex grow flex-wrap justify-end gap-2">
   {#if h && showRoom}
     <Link href={makeSpacePath(url, h)} class="btn btn-neutral btn-xs rounded-full">
       Posted in #<RoomName {h} {url} />

src/app/components/CalendarEventCreate.svelte

@@ -1,24 +1,23 @@
 <script lang="ts">
   import ModalHeader from "@lib/components/ModalHeader.svelte"
+  import ModalTitle from "@lib/components/ModalTitle.svelte"
+  import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import CalendarEventForm from "@app/components/CalendarEventForm.svelte"
 
   type Props = {
     url: string
     h?: string
+    shareToChat?: boolean
   }
 
-  const {url, h}: Props = $props()
+  const {url, h, shareToChat = false}: Props = $props()
 </script>
 
-<CalendarEventForm {url} {h}>
+<CalendarEventForm {url} {h} {shareToChat}>
   {#snippet header()}
     <ModalHeader>
-      {#snippet title()}
-        <div>Create an Event</div>
-      {/snippet}
-      {#snippet info()}
-        <div>Invite other group members to events online or in real life.</div>
-      {/snippet}
+      <ModalTitle>Create an Event</ModalTitle>
+      <ModalSubtitle>Invite other group members to events online or in real life.</ModalSubtitle>
     </ModalHeader>
   {/snippet}
 </CalendarEventForm>

src/app/components/CalendarEventEdit.svelte

@@ -2,6 +2,8 @@
   import type {TrustedEvent} from "@welshman/util"
   import {getTagValue} from "@welshman/util"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
+  import ModalTitle from "@lib/components/ModalTitle.svelte"
+  import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import CalendarEventForm from "@app/components/CalendarEventForm.svelte"
 
   type Props = {
@@ -24,12 +26,8 @@
 <CalendarEventForm {url} {initialValues}>
   {#snippet header()}
     <ModalHeader>
-      {#snippet title()}
-        <div>Edit this Event</div>
-      {/snippet}
-      {#snippet info()}
-        <div>Invite other group members to events online or in real life.</div>
-      {/snippet}
+      <ModalTitle>Edit this Event</ModalTitle>
+      <ModalSubtitle>Invite other group members to events online or in real life.</ModalSubtitle>
     </ModalHeader>
   {/snippet}
 </CalendarEventForm>

src/app/components/CalendarEventForm.svelte

@@ -3,7 +3,7 @@
   import {writable} from "svelte/store"
   import {randomId, HOUR} from "@welshman/lib"
   import {makeEvent, EVENT_TIME} from "@welshman/util"
-  import {publishThunk} from "@welshman/app"
+  import {publishThunk, waitForThunkError} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import {daysBetween} from "@lib/util"
   import GallerySend from "@assets/icons/gallery-send.svg?dataurl"
@@ -14,28 +14,40 @@
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import Modal from "@lib/components/Modal.svelte"
+  import ModalBody from "@lib/components/ModalBody.svelte"
   import DateTimeInput from "@lib/components/DateTimeInput.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
   import {PROTECTED} from "@app/core/state"
   import {makeEditor} from "@app/editor"
+  import {DraftKey} from "@app/util/drafts"
   import {pushToast} from "@app/util/toast"
-  import {canEnforceNip70} from "@app/core/commands"
+  import {canEnforceNip70, publishRoomQuote} from "@app/core/commands"
+
+  type Values = {
+    d: string
+    title: string
+    content: string | object
+    location: string
+    start?: number
+    end?: number
+  }
 
   type Props = {
     url: string
     h?: string
+    shareToChat?: boolean
     header: Snippet
-    initialValues?: {
-      d: string
-      title: string
-      content: string
-      location: string
-      start: number
-      end: number
-    }
+    initialValues?: Values
   }
 
-  const {url, h, header, initialValues}: Props = $props()
+  let {url, h, shareToChat = false, header, initialValues}: Props = $props()
+
+  const draftKey = new DraftKey<Values>(`calendar:${url}:${h ?? ""}`)
+
+  if (!initialValues) {
+    initialValues = draftKey.get()
+  }
 
   const shouldProtect = canEnforceNip70(url)
 
@@ -46,7 +58,7 @@
   const selectFiles = () => editor.then(ed => ed.chain().selectFiles().run())
 
   const submit = async () => {
-    if ($uploading) return
+    if ($uploading || loading) return
 
     if (!title) {
       return pushToast({
@@ -72,38 +84,68 @@
     const ed = await editor
     const content = ed.getText({blockSeparator: "\n"}).trim()
     const tags = [
-      ["d", initialValues?.d || randomId()],
+      ["d", d],
       ["title", title],
-      ["location", location || ""],
+      ["location", location],
       ["start", start.toString()],
       ["end", end.toString()],
       ...daysBetween(start, end).map(D => ["D", D.toString()]),
       ...ed.storage.nostr.getEditorTags(),
     ]
 
-    if (await shouldProtect) {
-      tags.push(PROTECTED)
+    loading = true
+
+    try {
+      const protect = await shouldProtect
+
+      if (protect) {
+        tags.push(PROTECTED)
+      }
+
+      if (h) {
+        tags.push(["h", h])
+      }
+
+      const event = makeEvent(EVENT_TIME, {content, tags})
+      const calendarThunk = publishThunk({event, relays: [url]})
+      const error = await waitForThunkError(calendarThunk)
+
+      if (error) {
+        return pushToast({theme: "error", message: error})
+      }
+
+      draftKey.clear()
+      history.back()
+
+      if (shareToChat) {
+        publishRoomQuote({url, h, parent: calendarThunk.event, protect})
+      }
+
+      pushToast({message: "Your event has been saved!"})
+    } finally {
+      loading = false
     }
-
-    if (h) {
-      tags.push(["h", h])
-    }
-
-    const event = makeEvent(EVENT_TIME, {content, tags})
-
-    pushToast({message: "Your event has been saved!"})
-    publishThunk({event, relays: [url]})
-    history.back()
   }
 
-  const content = initialValues?.content || ""
-  const editor = makeEditor({url, submit, uploading, content})
+  let loading = $state(false)
 
-  let title = $state(initialValues?.title || "")
-  let location = $state(initialValues?.location || "")
+  const d = $state(initialValues?.d ?? randomId())
+  let title = $state(initialValues?.title ?? "")
+  let location = $state(initialValues?.location ?? "")
   let start: number | undefined = $state(initialValues?.start)
   let end: number | undefined = $state(initialValues?.end)
-  let endDirty = Boolean(initialValues?.end)
+  let endDirty = $state(Boolean(initialValues?.end))
+  let content = $state(initialValues?.content ?? "")
+
+  const onChange = (json: object) => {
+    content = json
+  }
+
+  const editor = makeEditor({url, submit, uploading, onChange, content})
+
+  $effect(() => {
+    draftKey.set({d, title, location, start, end, content})
+  })
 
   $effect(() => {
     if (!endDirty && start) {
@@ -114,71 +156,78 @@
   })
 </script>
 
-<form novalidate class="column gap-4" onsubmit={preventDefault(submit)}>
-  {@render header()}
-  <Field>
-    {#snippet label()}
-      <p>Title*</p>
-    {/snippet}
-    {#snippet input()}
-      <label class="input input-bordered flex w-full items-center gap-2">
-        <input bind:value={title} class="grow" type="text" />
-      </label>
-    {/snippet}
-  </Field>
-  <Field>
-    {#snippet label()}
-      <p>Summary</p>
-    {/snippet}
-    {#snippet input()}
-      <div class="relative z-feature flex gap-2 border-t border-solid border-base-100 bg-base-100">
-        <div class="input-editor flex-grow overflow-hidden">
-          <EditorContent {editor} />
+<Modal tag="form" novalidate onsubmit={preventDefault(submit)}>
+  <ModalBody>
+    {@render header()}
+    <Field>
+      {#snippet label()}
+        <p>Title*</p>
+      {/snippet}
+      {#snippet input()}
+        <label class="input input-bordered flex w-full items-center gap-2">
+          <input bind:value={title} class="grow" type="text" />
+        </label>
+      {/snippet}
+    </Field>
+    <Field>
+      {#snippet label()}
+        <p>Summary</p>
+      {/snippet}
+      {#snippet input()}
+        <div
+          class="relative z-feature flex gap-2 border-t border-solid border-base-100 bg-base-100">
+          <div class="input-editor grow overflow-hidden">
+            <EditorContent {editor} />
+          </div>
+          <Button
+            data-tip="Add an image"
+            class="center btn tooltip"
+            onclick={selectFiles}
+            disabled={loading}>
+            {#if $uploading}
+              <span class="loading loading-spinner loading-xs"></span>
+            {:else}
+              <Icon icon={GallerySend} />
+            {/if}
+          </Button>
         </div>
-        <Button data-tip="Add an image" class="center btn tooltip" onclick={selectFiles}>
-          {#if $uploading}
-            <span class="loading loading-spinner loading-xs"></span>
-          {:else}
-            <Icon icon={GallerySend} />
-          {/if}
-        </Button>
-      </div>
-    {/snippet}
-  </Field>
-  <Field>
-    {#snippet label()}
-      Start*
-    {/snippet}
-    {#snippet input()}
-      <DateTimeInput bind:value={start} />
-    {/snippet}
-  </Field>
-  <Field>
-    {#snippet label()}
-      End*
-    {/snippet}
-    {#snippet input()}
-      <DateTimeInput bind:value={end} />
-    {/snippet}
-  </Field>
-  <Field>
-    {#snippet label()}
-      <p>Location (optional)</p>
-    {/snippet}
-    {#snippet input()}
-      <label class="input input-bordered flex w-full items-center gap-2">
-        <Icon icon={MapPoint} />
-        <input bind:value={location} class="grow" type="text" />
-      </label>
-    {/snippet}
-  </Field>
+      {/snippet}
+    </Field>
+    <Field>
+      {#snippet label()}
+        Start*
+      {/snippet}
+      {#snippet input()}
+        <DateTimeInput bind:value={start} />
+      {/snippet}
+    </Field>
+    <Field>
+      {#snippet label()}
+        End*
+      {/snippet}
+      {#snippet input()}
+        <DateTimeInput bind:value={end} />
+      {/snippet}
+    </Field>
+    <Field>
+      {#snippet label()}
+        <p>Location (optional)</p>
+      {/snippet}
+      {#snippet input()}
+        <label class="input input-bordered flex w-full items-center gap-2">
+          <Icon icon={MapPoint} />
+          <input bind:value={location} class="grow" type="text" />
+        </label>
+      {/snippet}
+    </Field>
+  </ModalBody>
   <ModalFooter>
-    <Button class="btn btn-link" onclick={back}>
+    <Button class="btn btn-link" onclick={back} disabled={loading}>
       <Icon icon={AltArrowLeft} />
       Go back
     </Button>
-    <Button type="submit" class="btn btn-primary" disabled={$uploading}>
-      <Spinner loading={$uploading}>Save Event</Spinner>
+    <Button type="submit" class="btn btn-primary" disabled={$uploading || loading}>
+      <Spinner loading={$uploading || loading}>Save Event</Spinner>
     </Button>
   </ModalFooter>
-</form>
+</Modal>

src/app/components/CalendarEventHeader.svelte

@@ -19,15 +19,17 @@
   const end = $derived(parseInt(meta.end))
 </script>
 
-<div class="flex flex-grow flex-wrap justify-between gap-2">
-  <p class="text-xl">{meta.title || meta.name}</p>
+<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}
-    <div class="flex items-center gap-2 text-sm">
-      <Icon icon={ClockCircle} size={4} />
-      <span class="hidden sm:block">{formatTimestampAsDate(start)}</span>
+    <div class="flex flex-wrap gap-2 text-xs">
+      <div class="flex items-center gap-2">
+        <Icon icon={ClockCircle} size={4} />
+        {formatTimestampAsDate(start)}
+      </div>
       {formatTimestampAsTime(start)} — {isSingleDay
         ? formatTimestampAsTime(end)
         : formatTimestamp(end)}

src/app/components/CalendarEventItem.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
   import type {TrustedEvent} from "@welshman/util"
-  import {getTagValue} from "@welshman/util"
+  import {getTagValue, getAddress} from "@welshman/util"
   import Link from "@lib/components/Link.svelte"
   import CalendarEventActions from "@app/components/CalendarEventActions.svelte"
   import CalendarEventHeader from "@app/components/CalendarEventHeader.svelte"
@@ -19,8 +19,8 @@
 </script>
 
 <Link
-  class="col-3 card2 bg-alt w-full cursor-pointer shadow-xl"
-  href={makeCalendarPath(url, event.id)}>
+  class="cv col-3 card2 bg-alt w-full cursor-pointer shadow-md"
+  href={makeCalendarPath(url, getAddress(event))}>
   <CalendarEventHeader {event} />
   <div class="flex w-full flex-col items-end justify-between gap-2 sm:flex-row">
     <span class="whitespace-nowrap py-1 text-sm opacity-75">

src/app/components/CalendarEventMeta.svelte

@@ -23,7 +23,7 @@
   {#if meta.location}
     <span class="flex items-start gap-1">
       <Icon icon={MapPoint} class="mt-[2px]" size={4} />
-      <span class="break-words">{meta.location}</span>
+      <span class="wrap-break-word">{meta.location}</span>
     </span>
   {/if}
 </div>

src/app/components/Chat.svelte

@@ -1,10 +1,13 @@
 <script lang="ts">
   import type {Snippet} from "svelte"
   import {onMount} from "svelte"
+  import {goto} from "$app/navigation"
   import {
+    ago,
     int,
     ms,
     partition,
+    ifLet,
     spec,
     nthEq,
     nthNe,
@@ -28,51 +31,53 @@
     tagPubkey,
     sendWrapped,
     mergeThunks,
-    loadInboxRelaySelections,
-    inboxRelaySelectionsByPubkey,
+    loadMessagingRelayList,
+    messagingRelayListsByPubkey,
   } 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"
-  import Link from "@lib/components/Link.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
   import PageBar from "@lib/components/PageBar.svelte"
   import PageContent from "@lib/components/PageContent.svelte"
   import Divider from "@lib/components/Divider.svelte"
   import Button from "@lib/components/Button.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
+  import ProfileLink from "@app/components/ProfileLink.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import ProfileCircles from "@app/components/ProfileCircles.svelte"
   import ProfileDetail from "@app/components/ProfileDetail.svelte"
-  import ProfileList from "@app/components/ProfileList.svelte"
+  import ChatMembers from "@app/components/ChatMembers.svelte"
   import ChatMessage from "@app/components/ChatMessage.svelte"
   import ChatCompose from "@app/components/ChatCompose.svelte"
+  import ChatComposeEdit from "@app/components/ChatComposeEdit.svelte"
   import ChatComposeParent from "@app/components/ChatComposeParent.svelte"
   import ThunkToast from "@app/components/ThunkToast.svelte"
-  import {
-    INDEXER_RELAYS,
-    userSettingsValues,
-    deriveChat,
-    splitChatId,
-    PLATFORM_NAME,
-  } from "@app/core/state"
+  import {userSettingsValues, deriveChat, makeChatId} from "@app/core/state"
   import {pushModal} from "@app/util/modal"
-  import {prependParent} from "@app/core/commands"
+  import {DraftKey} from "@app/util/drafts"
+  import {makeDelete, prependParent} from "@app/core/commands"
   import {pushToast} from "@app/util/toast"
 
   type Props = {
-    id: string
+    pubkeys: string[]
     info?: Snippet
   }
 
-  const {id, info}: Props = $props()
+  const {pubkeys, info}: Props = $props()
 
-  const chat = deriveChat(id)
-  const pubkeys = splitChatId(id)
+  const chatId = makeChatId(pubkeys)
+  const chat = deriveChat(chatId)
+  const draftKey = new DraftKey<{content?: string | object}>(`dm:${chatId}`)
   const others = remove($pubkey!, pubkeys)
-  const missingInboxes = $derived(pubkeys.filter(pk => !$inboxRelaySelectionsByPubkey.has(pk)))
+  const missingRelayLists = $derived(others.filter(pk => !$messagingRelayListsByPubkey.has(pk)))
 
   const showMembers = () =>
-    pushModal(ProfileList, {pubkeys: others, title: `People in this conversation`})
+    others.length === 1
+      ? pushModal(ProfileDetail, {pubkey: others[0]})
+      : pushModal(ChatMembers, {pubkeys: others})
+
+  const back = () => goto("/chat")
 
   const replyTo = (event: TrustedEvent) => {
     parent = event
@@ -83,73 +88,117 @@
     parent = undefined
   }
 
-  const onSubmit = async (params: EventContent) => {
-    const ptags = remove($pubkey!, pubkeys).map(tagPubkey)
-
-    // 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)
-
-    const [imetaTags, tags] = partition(nthEq(0, "imeta"), params.tags)
-    const imetas = getTags("imeta", imetaTags).map(tagsFromIMeta)
-    const templates: EventTemplate[] = []
-    const buffer = []
-
-    const addTemplate = (kind: number, content: string, tags: string[][]) => {
-      content = content.trim()
-
-      if (content) {
-        templates.push(makeEvent(kind, {content, tags: [...tags, ...ptags]}))
-      }
-    }
-
-    for (const p of parse(params)) {
-      const imeta = isLink(p)
-        ? imetas.find(tags => tags.find(spec(["url", p.value.url.toString()])))
-        : undefined
-
-      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")),
-        )
-      } else {
-        buffer.push(p.raw)
-      }
-    }
-
-    addTemplate(DIRECT_MESSAGE, buffer.splice(0).join(""), tags)
-
-    // Split the message into multiple pieces so that we can use kind 15 to send images per nip 17
-    // Sleep 1 second between each one to make sure timestamps are distinct
-    const thunks = Array.from(enumerate(templates)).map(([i, event]) =>
-      sendWrapped({
-        event,
-        recipients: pubkeys,
-        delay: $userSettingsValues.send_delay + ms(i),
-      }),
-    )
-
-    pushToast({
-      timeout: 30_000,
-      children: {
-        component: ThunkToast,
-        props: {thunk: mergeThunks(thunks)},
-      },
-    })
-
-    clearParent()
+  const clearEventToEdit = () => {
+    eventToEdit = undefined
   }
 
+  const onSubmit = async (params: EventContent) => {
+    try {
+      const ptags = remove($pubkey!, pubkeys).map(tagPubkey)
+
+      // 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)
+
+      if (eventToEdit) {
+        if (eventToEdit.content === params.content) {
+          return
+        }
+
+        await sendWrapped({
+          event: makeDelete({event: eventToEdit, protect: false}),
+          recipients: pubkeys,
+          pow: 16,
+        })
+      }
+
+      const [imetaTags, tags] = partition(nthEq(0, "imeta"), params.tags)
+      const imetas = getTags("imeta", imetaTags).map(tagsFromIMeta)
+      const templates: EventTemplate[] = []
+      const buffer = []
+
+      const addTemplate = (kind: number, content: string, tags: string[][]) => {
+        content = content.trim()
+
+        if (content) {
+          templates.push(
+            makeEvent(kind, {
+              content,
+              tags: [...tags, ...ptags],
+              created_at: eventToEdit?.created_at,
+            }),
+          )
+        }
+      }
+
+      for (const p of parse(params)) {
+        const imeta = isLink(p)
+          ? imetas.find(tags => tags.find(spec(["url", p.value.url.toString()])))
+          : undefined
+
+        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")),
+          )
+        } else {
+          buffer.push(p.raw)
+        }
+      }
+
+      addTemplate(DIRECT_MESSAGE, buffer.splice(0).join(""), tags)
+
+      // Split the message into multiple pieces so that we can use kind 15 to send images per nip 17
+      // 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({
+            event,
+            recipients: pubkeys,
+            delay: $userSettingsValues.send_delay + ms(i),
+            pow: 16,
+          }),
+        ),
+      )
+
+      pushToast({
+        timeout: 30_000,
+        children: {
+          component: ThunkToast,
+          props: {thunk: mergeThunks(thunks)},
+        },
+      })
+    } finally {
+      clearParent()
+      clearEventToEdit()
+    }
+  }
+
+  const onEscape = () => {
+    clearParent()
+    clearEventToEdit()
+  }
+
+  const canEditEvent = (event: TrustedEvent) =>
+    event.pubkey === $pubkey &&
+    event.kind === DIRECT_MESSAGE &&
+    event.created_at >= ago(500, MINUTE)
+
+  const onEditEvent = (event: TrustedEvent) => {
+    clearParent()
+    eventToEdit = event
+  }
+
+  const onEditPrevious = () => ifLet($chat?.messages.toReversed().find(canEditEvent), onEditEvent)
+
   let loading = $state(true)
   let compose: ChatCompose | undefined = $state()
   let parent: TrustedEvent | undefined = $state()
-  let chatCompose: HTMLElement | undefined = $state()
-  let dynamicPadding: HTMLElement | undefined = $state()
+  let eventToEdit: TrustedEvent | undefined = $state()
 
   const elements = $derived.by(() => {
     const elements = []
@@ -183,21 +232,7 @@
 
   onMount(() => {
     for (const pubkey of others) {
-      loadInboxRelaySelections(pubkey, INDEXER_RELAYS, true)
-    }
-
-    const observer = new ResizeObserver(() => {
-      if (dynamicPadding && chatCompose) {
-        dynamicPadding.style.minHeight = `${chatCompose.offsetHeight}px`
-      }
-    })
-
-    observer.observe(chatCompose!)
-    observer.observe(dynamicPadding!)
-
-    return () => {
-      observer.unobserve(chatCompose!)
-      observer.unobserve(dynamicPadding!)
+      loadMessagingRelayList(pubkey)
     }
   })
 
@@ -207,83 +242,58 @@
 </script>
 
 <PageBar>
-  {#snippet title()}
-    <div class="flex flex-col gap-1 sm:flex-row sm:gap-2">
-      {#if others.length === 0}
-        <div class="row-2">
-          <ProfileCircle pubkey={$pubkey!} size={5} />
-          <ProfileName pubkey={$pubkey!} />
-        </div>
-      {:else if others.length === 1}
-        {@const pubkey = others[0]}
-        {@const onClick = () => pushModal(ProfileDetail, {pubkey})}
-        <Button onclick={onClick} class="row-2">
-          <ProfileCircle {pubkey} size={5} />
-          <ProfileName {pubkey} />
+  <div class="flex">
+    <Button onclick={back} class="place-self-start pr-3 md:hidden flex items-center">
+      <Icon icon={ArrowLeft} size={7} />
+    </Button>
+    <div class="flex items-center justify-between gap-4">
+      <div class="ellipsize flex items-center gap-4 whitespace-nowrap">
+        <Button class="flex flex-col gap-1 sm:flex-row sm:gap-2" onclick={showMembers}>
+          {#if others.length === 0}
+            <div class="row-2">
+              <ProfileCircle pubkey={$pubkey!} size={5} />
+              <ProfileName pubkey={$pubkey!} />
+            </div>
+          {:else if others.length === 1}
+            <div class="row-2">
+              <ProfileCircle pubkey={others[0]} size={5} />
+              <ProfileName pubkey={others[0]} />
+            </div>
+          {:else}
+            <div class="flex items-center gap-2">
+              <ProfileCircles pubkeys={others} size={5} />
+              <p class="overflow-hidden text-ellipsis whitespace-nowrap">
+                <ProfileName pubkey={others[0]} />
+                and
+                {#if others.length === 2}
+                  <ProfileName pubkey={others[1]} />
+                {:else}
+                  {others.length - 1}
+                  {others.length > 2 ? "others" : "other"}
+                {/if}
+              </p>
+            </div>
+          {/if}
         </Button>
-      {:else}
-        <div class="flex items-center gap-2">
-          <ProfileCircles pubkeys={others} size={5} />
-          <p class="overflow-hidden text-ellipsis whitespace-nowrap">
-            <ProfileName pubkey={others[0]} />
-            and
-            {#if others.length === 2}
-              <ProfileName pubkey={others[1]} />
-            {:else}
-              {others.length - 1}
-              {others.length > 2 ? "others" : "other"}
-            {/if}
-          </p>
-        </div>
-        {#if others.length > 2}
-          <Button onclick={showMembers} class="btn btn-link hidden sm:block"
-            >Show all members</Button>
-        {/if}
-      {/if}
-    </div>
-  {/snippet}
-  {#snippet action()}
-    <div>
-      {#if remove($pubkey, missingInboxes).length > 0}
-        {@const count = remove($pubkey, missingInboxes).length}
-        {@const label = count > 1 ? "inboxes are" : "inbox is"}
-        <div
-          class="row-2 badge badge-error badge-lg tooltip tooltip-left cursor-pointer"
-          data-tip="{count} {label} not configured.">
-          <Icon icon={Danger} />
-          {count}
-        </div>
-      {/if}
-    </div>
-  {/snippet}
-</PageBar>
-
-<PageContent class="flex flex-col-reverse gap-2 pt-4">
-  <div bind:this={dynamicPadding}></div>
-  {#if missingInboxes.includes($pubkey!)}
-    <div class="py-12">
-      <div class="card2 col-2 m-auto max-w-md items-center text-center">
-        <p class="row-2 text-lg text-error">
-          <Icon icon={Danger} />
-          Your inbox is not configured.
-        </p>
-        <p>
-          In order to deliver messages, {PLATFORM_NAME} needs to know where to send them. Please visit
-          your <Link class="link" href="/settings/relays">relay settings page</Link> to set up your inbox.
-        </p>
       </div>
     </div>
-  {:else if missingInboxes.length > 0}
+  </div>
+</PageBar>
+
+<PageContent class="flex flex-col-reverse gap-2 py-4">
+  {#if missingRelayLists.length > 0}
     <div class="py-12">
       <div class="card2 col-2 m-auto max-w-md items-center text-center">
         <p class="row-2 text-lg text-error">
           <Icon icon={Danger} />
-          {missingInboxes.length}
-          {missingInboxes.length > 1 ? "inboxes are" : "inbox is"} not configured.
+          Direct messages are not enabled
         </p>
         <p>
-          In order to deliver messages, {PLATFORM_NAME} needs to know where to send them. Please make
-          sure everyone in this conversation has set up their inbox relays.
+          Ask
+          {#each missingRelayLists as pubkey (pubkey)}
+            <ProfileLink {pubkey} />
+          {/each}
+          to enable direct messaging by opening this conversation in their app.
         </p>
       </div>
     </div>
@@ -296,7 +306,9 @@
         event={$state.snapshot(value as TrustedEvent)}
         {pubkeys}
         {showPubkey}
-        {replyTo} />
+        {replyTo}
+        canEdit={canEditEvent}
+        onEdit={onEditEvent} />
     {/if}
   {/each}
   <p class="m-auto flex h-10 max-w-sm flex-col items-center justify-center gap-4 py-20 text-center">
@@ -309,13 +321,26 @@
     </Spinner>
     {@render info?.()}
   </p>
+  <div class="h-screen"></div>
 </PageContent>
 
-<div class="chat__compose bg-base-200" bind:this={chatCompose}>
+<div class="chat__compose bg-base-200">
   <div>
     {#if parent}
       <ChatComposeParent event={parent} clear={clearParent} verb="Replying to" />
     {/if}
+    {#if eventToEdit}
+      <ChatComposeEdit clear={clearEventToEdit} />
+    {/if}
   </div>
-  <ChatCompose bind:this={compose} {onSubmit} />
+  {#key eventToEdit}
+    <ChatCompose
+      bind:this={compose}
+      {onSubmit}
+      {onEscape}
+      {onEditPrevious}
+      initialValues={eventToEdit}
+      draftKey={eventToEdit ? undefined : draftKey}
+      disabled={Boolean(missingRelayLists.length)} />
+  {/key}
 </div>

src/app/components/ChatCompose.svelte

@@ -1,5 +1,7 @@
 <script lang="ts">
+  import {onDestroy, onMount} from "svelte"
   import {writable} from "svelte/store"
+  import cx from "classnames"
   import type {EventContent} from "@welshman/util"
   import {isMobile, preventDefault} from "@lib/html"
   import GallerySend from "@assets/icons/gallery-send.svg?dataurl"
@@ -8,23 +10,63 @@
   import Button from "@lib/components/Button.svelte"
   import EditorContent from "@app/editor/EditorContent.svelte"
   import {makeEditor} from "@app/editor"
+  import {type DraftKey} from "@app/util/drafts"
 
-  type Props = {
-    onSubmit: (event: EventContent) => void
+  type Values = {
+    content?: string | object
   }
 
-  const {onSubmit}: Props = $props()
+  type Props = {
+    disabled?: boolean
+    draftKey?: DraftKey<Values>
+    onEscape?: () => void
+    onEditPrevious?: () => void
+    onSubmit: (event: EventContent) => void
+    initialValues?: Values
+  }
 
-  const autofocus = !isMobile
+  let {
+    initialValues,
+    disabled = false,
+    draftKey,
+    onEscape,
+    onEditPrevious,
+    onSubmit,
+  }: Props = $props()
+
+  if (!initialValues) {
+    initialValues = draftKey?.get()
+  }
+
+  const autofocus = !isMobile && !disabled
 
   const uploading = writable(false)
 
+  const editorClass = $derived(
+    cx("chat-editor grow overflow-hidden", {
+      "pointer-events-none opacity-50": disabled,
+    }),
+  )
+
   export const focus = () => editor.then(ed => ed.chain().focus().run())
 
+  export const canEnterEditPrevious = () =>
+    editor.then(ed => ed.getText({blockSeparator: "\n"}) === "")
+
+  const handleKeyDown = async (event: KeyboardEvent) => {
+    if (event.key === "Escape") {
+      onEscape?.()
+    }
+
+    if (event.key === "ArrowUp" && (await canEnterEditPrevious())) {
+      onEditPrevious?.()
+    }
+  }
+
   const uploadFiles = () => editor.then(ed => ed.chain().selectFiles().run())
 
   const submit = async () => {
-    if ($uploading) return
+    if ($uploading || disabled) return
 
     const ed = await editor
     const content = ed.getText({blockSeparator: "\n"}).trim()
@@ -34,23 +76,45 @@
 
     onSubmit({content, tags})
 
+    draftKey?.clear()
     ed.chain().clearContent().run()
   }
 
+  let content = $state(initialValues?.content ?? "")
+
+  const onChange = (json: object) => {
+    content = json
+  }
+
   const editor = makeEditor({
-    autofocus,
+    content,
     submit,
     uploading,
+    onChange,
     aggressive: true,
     encryptFiles: true,
   })
+
+  $effect(() => {
+    draftKey?.set({content})
+  })
+
+  onMount(async () => {
+    const ed = await editor
+    ed.view.dom.addEventListener("keydown", handleKeyDown)
+  })
+
+  onDestroy(async () => {
+    const ed = await editor
+    ed?.view?.dom.removeEventListener("keydown", handleKeyDown)
+  })
 </script>
 
 <form class="relative z-feature flex gap-2 p-2" onsubmit={preventDefault(submit)}>
   <Button
     data-tip="Add an image"
     class="center tooltip tooltip-right h-10 w-10 min-w-10 rounded-box bg-base-300 transition-colors hover:bg-base-200"
-    disabled={$uploading}
+    disabled={$uploading || disabled}
     onclick={uploadFiles}>
     {#if $uploading}
       <span class="loading loading-spinner loading-xs"></span>
@@ -58,13 +122,13 @@
       <Icon icon={GallerySend} />
     {/if}
   </Button>
-  <div class="chat-editor flex-grow overflow-hidden">
-    <EditorContent {editor} />
+  <div class={editorClass} aria-disabled={disabled}>
+    <EditorContent {autofocus} {editor} />
   </div>
   <Button
     data-tip="{window.navigator.platform.includes('Mac') ? 'cmd' : 'ctrl'}+enter to send"
     class="center tooltip tooltip-left absolute right-4 h-10 w-10 min-w-10 rounded-full"
-    disabled={$uploading}
+    disabled={$uploading || disabled}
     onclick={submit}>
     <Icon icon={Plane} />
   </Button>

src/app/components/ChatComposeEdit.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+  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"
+
+  const {
+    clear,
+  }: {
+    clear: () => void
+  } = $props()
+</script>
+
+<div
+  class="relative flex h-8 items-center justify-between border-l-2 border-solid border-primary bg-base-300 px-2 pr-7 text-xs"
+  transition:slide>
+  <p class="text-primary">Editing message</p>
+  <Button onclick={clear} class="flex items-center">
+    <Icon icon={CloseCircle} />
+  </Button>
+</div>

src/app/components/ChatEnable.svelte

@@ -1,63 +1,72 @@
 <script lang="ts">
-  import {goto} from "$app/navigation"
+  import {getRelaysFromList} from "@welshman/util"
+  import {waitForThunkError, setMessagingRelays, userRelayList, setRelays} from "@welshman/app"
   import {preventDefault} from "@lib/html"
-  import {shouldUnwrap} from "@welshman/app"
   import AltArrowLeft from "@assets/icons/alt-arrow-left.svg?dataurl"
   import AltArrowRight from "@assets/icons/alt-arrow-right.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Spinner from "@lib/components/Spinner.svelte"
+  import Modal from "@lib/components/Modal.svelte"
+  import ModalBody from "@lib/components/ModalBody.svelte"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
+  import ModalTitle from "@lib/components/ModalTitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
-  import {PLATFORM_NAME} from "@app/core/state"
-  import {clearModals} from "@app/util/modal"
+  import {DEFAULT_RELAYS, DEFAULT_MESSAGING_RELAYS} from "@app/core/state"
+  import {pushToast} from "@app/util/toast"
 
-  const {next} = $props()
+  type Props = {
+    next: () => void
+  }
 
-  const nextUrl = $state.snapshot(next)
+  const {next}: Props = $props()
 
   let loading = $state(false)
 
-  const submit = async () => {
+  const back = () => history.back()
+
+  const enable = async () => {
     loading = true
 
     try {
-      shouldUnwrap.set(true)
-      clearModals()
-      goto(nextUrl)
+      if (getRelaysFromList($userRelayList).length === 0) {
+        const error = await waitForThunkError(await setRelays(DEFAULT_RELAYS.map(r => ["r", r])))
+
+        if (error) {
+          pushToast({theme: "error", message: error})
+          return
+        }
+      }
+
+      const error = await waitForThunkError(await setMessagingRelays(DEFAULT_MESSAGING_RELAYS))
+
+      if (error) {
+        pushToast({theme: "error", message: error})
+        return
+      }
+
+      await next()
     } finally {
       loading = false
     }
   }
-
-  const back = () => history.back()
 </script>
 
-<form class="column gap-4" onsubmit={preventDefault(submit)}>
-  <ModalHeader>
-    {#snippet title()}
-      <div>Enable Messages</div>
-    {/snippet}
-    {#snippet info()}
-      <div>Do you want to enable direct messages?</div>
-    {/snippet}
-  </ModalHeader>
-  <p>
-    By default, direct messages are disabled, since loading them requires
-    {PLATFORM_NAME} to download and decrypt a lot of data.
-  </p>
-  <p>
-    If you'd like to enable them, please make sure your signer is set up to to auto-approve requests
-    to decrypt data.
-  </p>
+<Modal tag="form" onsubmit={preventDefault(enable)}>
+  <ModalBody>
+    <ModalHeader>
+      <ModalTitle>Enable direct messaging?</ModalTitle>
+    </ModalHeader>
+    <p>Direct messaging isn't currently enabled. Would you like to turn it on?</p>
+  </ModalBody>
   <ModalFooter>
     <Button class="btn btn-link" onclick={back}>
       <Icon icon={AltArrowLeft} />
       Go back
     </Button>
     <Button type="submit" class="btn btn-primary" disabled={loading}>
-      <Spinner {loading}>Enable Messages</Spinner>
+      <Spinner {loading}>Enable direct messaging</Spinner>
       <Icon icon={AltArrowRight} />
     </Button>
   </ModalFooter>
-</form>
+</Modal>

src/app/components/ChatItem.svelte

@@ -1,15 +1,15 @@
 <script lang="ts">
   import {onMount} from "svelte"
   import {page} from "$app/stores"
-  import {remove} from "@welshman/lib"
+  import {remove, uniq, formatTimestamp} from "@welshman/lib"
   import type {TrustedEvent} from "@welshman/util"
-  import {pubkey, loadInboxRelaySelections} from "@welshman/app"
+  import {pubkey, loadMessagingRelayList} from "@welshman/app"
   import {fade} from "@lib/transition"
-  import Link from "@lib/components/Link.svelte"
+  import Button from "@lib/components/Button.svelte"
   import ProfileName from "@app/components/ProfileName.svelte"
   import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import ProfileCircles from "@app/components/ProfileCircles.svelte"
-  import {makeChatPath} from "@app/util/routes"
+  import {makeChatPath, goToChat} from "@app/util/routes"
   import {notifications} from "@app/util/notifications"
 
   interface Props {
@@ -21,20 +21,21 @@
 
   const {...props}: Props = $props()
 
-  const others = remove($pubkey!, props.pubkeys)
+  const others = uniq(remove($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) {
-      loadInboxRelaySelections(pk)
+      loadMessagingRelayList(pk)
     }
   })
 </script>
 
-<Link class="flex flex-col justify-start gap-1" href={makeChatPath(props.pubkeys)}>
+<Button class="flex flex-col justify-start gap-1 w-full" onclick={openChat}>
   <div
-    class="cursor-pointer border-t border-solid border-base-100 px-6 py-2 transition-colors hover:bg-base-100 {props.class}"
+    class="cursor-pointer border-t border-solid border-base-100 px-3 py-2 transition-colors hover:bg-base-100 {props.class}"
     class:bg-base-100={active}>
     <div class="flex flex-col justify-start gap-1">
       <div class="flex items-center justify-between gap-2">
@@ -59,13 +60,16 @@
         {/if}
       </div>
       <p class="overflow-hidden text-ellipsis whitespace-nowrap text-sm">
-        <span class="opacity-50">
+        <span class="opacity-70">
           {#if props.messages[0].pubkey === $pubkey}
             You:
           {/if}
         </span>
         {props.messages[0].content}
       </p>
+      <p class="text-xs opacity-70">
+        {formatTimestamp(props.messages[0].created_at)}
+      </p>
     </div>
   </div>
-</Link>
+</Button>

src/app/components/ChatMembers.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+  import Button from "@lib/components/Button.svelte"
+  import ModalHeader from "@lib/components/ModalHeader.svelte"
+  import ModalTitle from "@lib/components/ModalTitle.svelte"
+  import ModalFooter from "@lib/components/ModalFooter.svelte"
+  import Modal from "@lib/components/Modal.svelte"
+  import ModalBody from "@lib/components/ModalBody.svelte"
+  import Profile from "@app/components/Profile.svelte"
+
+  interface Props {
+    pubkeys: string[]
+  }
+
+  const {pubkeys}: Props = $props()
+</script>
+
+<Modal>
+  <ModalBody>
+    <ModalHeader>
+      <ModalTitle>People in this conversation</ModalTitle>
+    </ModalHeader>
+    <div class="flex flex-col gap-2">
+      {#each pubkeys as pubkey (pubkey)}
+        <div class="card2 bg-alt">
+          <Profile {pubkey} />
+        </div>
+      {/each}
+    </div>
+  </ModalBody>
+  <ModalFooter>
+    <Button class="btn btn-primary" onclick={() => history.back()}>Got it</Button>
+  </ModalFooter>
+</Modal>

src/app/components/ChatMenu.svelte

@@ -1,83 +1,43 @@
 <script lang="ts">
-  import {waitForThunkCompletion} from "@welshman/app"
-  import ChatSquare from "@assets/icons/chat-square.svg?dataurl"
+  import {assoc} from "@welshman/lib"
   import Check from "@assets/icons/check.svg?dataurl"
   import Bell from "@assets/icons/bell.svg?dataurl"
   import BellOff from "@assets/icons/bell-off.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
-  import Spinner from "@lib/components/Spinner.svelte"
-  import ChatStart from "@app/components/ChatStart.svelte"
+  import Modal from "@lib/components/Modal.svelte"
+  import ModalBody from "@lib/components/ModalBody.svelte"
   import {setChecked} from "@app/util/notifications"
-  import {pushModal} from "@app/util/modal"
-  import {pushToast} from "@app/util/toast"
-  import {dmAlert, userInboxRelays} from "@app/core/state"
-  import {deleteAlert, createDmAlert} from "@app/core/commands"
-
-  const startChat = () => pushModal(ChatStart, {}, {replaceState: true})
+  import {notificationSettings} from "@app/core/state"
 
   const markAsRead = () => {
     setChecked("/chat/*")
     history.back()
   }
 
-  const enableAlerts = async () => {
-    if ($userInboxRelays.length === 0) {
-      return pushToast({
-        theme: "error",
-        message: "Please set up your messaging relays before enabling alerts.",
-      })
-    }
+  const enableAlerts = () => notificationSettings.update(assoc("messages", true))
 
-    enablingAlert = true
-
-    try {
-      const {error} = await createDmAlert()
-
-      if (error) {
-        return pushToast({theme: "error", message: error})
-      }
-    } finally {
-      enablingAlert = false
-    }
-  }
-
-  const disableAlerts = async () => {
-    disablingAlert = true
-
-    try {
-      await waitForThunkCompletion(deleteAlert($dmAlert!))
-    } finally {
-      disablingAlert = false
-    }
-  }
-
-  let enablingAlert = $state(false)
-  let disablingAlert = $state(false)
+  const disableAlerts = () => notificationSettings.update(assoc("messages", false))
 </script>
 
-<div class="col-2">
-  <Button class="btn btn-primary" onclick={startChat}>
-    <Icon size={5} icon={ChatSquare} />
-    Start chat
-  </Button>
-  <Button class="btn btn-neutral" onclick={markAsRead}>
-    <Icon size={5} icon={Check} />
-    Mark all read
-  </Button>
-  {#if (!enablingAlert && $dmAlert) || disablingAlert}
-    <Button class="btn btn-neutral" onclick={disableAlerts} disabled={disablingAlert}>
-      {#if !disablingAlert}
-        <Icon size={4} icon={BellOff} />
+<Modal>
+  <ModalBody>
+    <div class="flex flex-col gap-2">
+      <Button class="btn btn-neutral" onclick={markAsRead}>
+        <Icon size={5} icon={Check} />
+        Mark all read
+      </Button>
+      {#if $notificationSettings.messages}
+        <Button class="btn btn-neutral" onclick={disableAlerts}>
+          <Icon size={4} icon={BellOff} />
+          Disable alerts
+        </Button>
+      {:else}
+        <Button class="btn btn-neutral" onclick={enableAlerts}>
+          <Icon size={4} icon={Bell} />
+          Enable alerts
+        </Button>
       {/if}
-      <Spinner loading={disablingAlert}>Disable alerts</Spinner>
-    </Button>
-  {:else}
-    <Button class="btn btn-neutral" onclick={enableAlerts} disabled={enablingAlert}>
-      {#if !enablingAlert}
-        <Icon size={4} icon={Bell} />
-      {/if}
-      <Spinner loading={enablingAlert}>Enable alerts</Spinner>
-    </Button>
-  {/if}
-</div>
+    </div>
+  </ModalBody>
+</Modal>

src/app/components/ChatMessage.svelte

@@ -2,21 +2,14 @@
   import {type Instance} from "tippy.js"
   import {hash, formatTimestampAsTime} from "@welshman/lib"
   import type {TrustedEvent, EventContent} from "@welshman/util"
-  import {
-    thunks,
-    mergeThunks,
-    pubkey,
-    deriveProfile,
-    deriveProfileDisplay,
-    sendWrapped,
-  } from "@welshman/app"
+  import {thunks, mergeThunks, pubkey, deriveProfileDisplay, sendWrapped} from "@welshman/app"
   import {isMobile} from "@lib/html"
   import MenuDots from "@assets/icons/menu-dots.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
   import Button from "@lib/components/Button.svelte"
   import Tippy from "@lib/components/Tippy.svelte"
   import TapTarget from "@lib/components/TapTarget.svelte"
-  import Avatar from "@lib/components/Avatar.svelte"
+  import ProfileCircle from "@app/components/ProfileCircle.svelte"
   import Content from "@app/components/Content.svelte"
   import ReactionSummary from "@app/components/ReactionSummary.svelte"
   import ThunkFailure from "@app/components/ThunkFailure.svelte"
@@ -30,29 +23,35 @@
   interface Props {
     event: TrustedEvent
     replyTo: (event: TrustedEvent) => void
+    canEdit?: (event: TrustedEvent) => boolean
+    onEdit?: (event: TrustedEvent) => void
     pubkeys: string[]
     showPubkey?: boolean
   }
 
-  const {event, replyTo, pubkeys, showPubkey = false}: Props = $props()
+  const {event, replyTo, canEdit, onEdit, pubkeys, showPubkey = false}: Props = $props()
 
   const isOwn = event.pubkey === $pubkey
-  const profile = deriveProfile(event.pubkey)
   const profileDisplay = deriveProfileDisplay(event.pubkey)
   const thunk = mergeThunks($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})
+    sendWrapped({event: makeDelete({event, protect: false}), recipients: pubkeys, pow: 16})
 
   const createReaction = (template: EventContent) =>
-    sendWrapped({event: makeReaction({event, protect: false, ...template}), recipients: pubkeys})
+    sendWrapped({
+      event: makeReaction({event, protect: false, ...template}),
+      recipients: pubkeys,
+      pow: 16,
+    })
 
   const openProfile = () => pushModal(ProfileDetail, {pubkey: event.pubkey})
 
-  const showMobileMenu = () => pushModal(ChatMessageMenuMobile, {event, pubkeys, reply})
+  const showMobileMenu = () => pushModal(ChatMessageMenuMobile, {event, pubkeys, reply, edit})
 
   const togglePopover = () => {
     if (popoverIsVisible) {
@@ -79,7 +78,7 @@
     <Tippy
       bind:popover
       component={ChatMessageMenu}
-      props={{event, pubkeys, popover, replyTo}}
+      props={{event, pubkeys, popover, replyTo, edit}}
       params={{
         interactive: true,
         trigger: "manual",
@@ -101,14 +100,14 @@
   {/if}
   <div class="flex min-w-0 flex-col" class:items-end={isOwn}>
     <TapTarget
-      class="bg-alt chat-bubble mx-1 mb-2 flex cursor-auto flex-col gap-1 text-left lg:max-w-2xl"
+      class="bg-alt chat-bubble mx-1 mb-2 flex cursor-auto flex-col gap-1 text-left lg:max-w-2xl min-w-[100px]"
       onTap={showMobileMenu}>
       {#if showPubkey}
         <div class="flex items-center gap-2">
           {#if !isOwn}
             <Button onclick={openProfile} class="flex items-center gap-1">
-              <Avatar
-                src={$profile?.picture}
+              <ProfileCircle
+                pubkey={event.pubkey}
                 class="border border-solid border-base-content"
                 size={4} />
               <div class="flex items-center gap-2">

src/app/components/ChatMessageEmojiButton.svelte

@@ -18,6 +18,7 @@
     sendWrapped({
       event: makeReaction({event, content: emoji.unicode, protect: false}),
       recipients: pubkeys,
+      pow: 16,
     })
 </script>
 

src/app/components/ChatMessageMenu.svelte

@@ -4,12 +4,14 @@
   import ChatMessageEmojiButton from "@app/components/ChatMessageEmojiButton.svelte"
   import EventInfo from "@app/components/EventInfo.svelte"
   import {pushModal} from "@app/util/modal"
+  import Pen from "@assets/icons/pen.svg?dataurl"
   import Reply from "@assets/icons/reply-2.svg?dataurl"
   import Code2 from "@assets/icons/code-2.svg?dataurl"
 
-  const {event, pubkeys, popover, replyTo} = $props()
+  const {event, pubkeys, popover, replyTo, edit} = $props()
 
   const reply = () => replyTo(event)
+  const onEdit = () => edit?.()
 
   const showInfo = () => {
     popover.hide()
@@ -24,6 +26,11 @@
       <Icon size={4} icon={Reply} />
     </Button>
   {/if}
+  {#if edit}
+    <Button class="btn join-item btn-xs" onclick={onEdit}>
+      <Icon size={4} icon={Pen} />
+    </Button>
+  {/if}
   <Button class="btn join-item btn-xs" onclick={showInfo}>
     <Icon size={4} icon={Code2} />
   </Button>

src/app/components/ChatMessageMenuMobile.svelte

@@ -2,31 +2,36 @@
   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"
+  import Copy from "@assets/icons/copy.svg?dataurl"
+  import Code2 from "@assets/icons/code-2.svg?dataurl"
   import Icon from "@lib/components/Icon.svelte"
+  import Modal from "@lib/components/Modal.svelte"
+  import ModalBody from "@lib/components/ModalBody.svelte"
   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/core/commands"
   import {pushModal} from "@app/util/modal"
   import {clip} from "@app/util/toast"
-  import SmileCircle from "@assets/icons/smile-circle.svg?dataurl"
-  import Reply from "@assets/icons/reply-2.svg?dataurl"
-  import Copy from "@assets/icons/copy.svg?dataurl"
-  import Code2 from "@assets/icons/code-2.svg?dataurl"
 
   type Props = {
     pubkeys: string[]
     event: TrustedEvent
     reply: () => void
+    edit?: () => void
   }
 
-  const {event, pubkeys, reply}: Props = $props()
+  const {event, pubkeys, reply, edit}: Props = $props()
 
   const onEmoji = ((event: TrustedEvent, pubkeys: string[], emoji: NativeEmoji) => {
     history.back()
     sendWrapped({
       event: makeReaction({event, content: emoji.unicode, protect: false}),
       recipients: pubkeys,
+      pow: 16,
     })
   }).bind(undefined, event, pubkeys)
 
@@ -37,6 +42,11 @@
     reply()
   }
 
+  const sendEdit = () => {
+    history.back()
+    edit?.()
+  }
+
   const copyText = () => {
     history.back()
     clip(event.content)
@@ -45,21 +55,31 @@
   const showInfo = () => pushModal(EventInfo, {event}, {replaceState: true})
 </script>
 
-<div class="col-2">
-  <Button class="btn btn-primary w-full" onclick={showEmojiPicker}>
-    <Icon size={4} icon={SmileCircle} />
-    Send Reaction
-  </Button>
-  <Button class="btn btn-neutral w-full" onclick={sendReply}>
-    <Icon size={4} icon={Reply} />
-    Send Reply
-  </Button>
-  <Button class="btn btn-neutral w-full" onclick={copyText}>
-    <Icon size={4} icon={Copy} />
-    Copy Text
-  </Button>
-  <Button class="btn btn-neutral" onclick={showInfo}>
-    <Icon size={4} icon={Code2} />
-    Message Details
-  </Button>
-</div>
+<Modal>
+  <ModalBody>
+    <div class="flex flex-col gap-2">
+      <Button class="btn btn-neutral" onclick={showInfo}>
+        <Icon size={4} icon={Code2} />
+        Message Info
+      </Button>
+      <Button class="btn btn-neutral w-full" onclick={copyText}>
+        <Icon size={4} icon={Copy} />
+        Copy Text
+      </Button>
+      <Button class="btn btn-neutral w-full" onclick={sendReply}>
+        <Icon size={4} icon={Reply} />
+        Send Reply
+      </Button>
+      {#if edit}
+        <Button class="btn btn-neutral w-full" onclick={sendEdit}>
+          <Icon size={4} icon={Pen} />
+          Edit Message
+        </Button>
+      {/if}
+      <Button class="btn btn-primary w-full" onclick={showEmojiPicker}>
+        <Icon size={4} icon={SmileCircle} />
+        Send Reaction
+      </Button>
+    </div>
+  </ModalBody>
+</Modal>

src/app/components/ChatStart.svelte

@@ -2,24 +2,27 @@
   import * as nip19 from "nostr-tools/nip19"
   import {onMount} from "svelte"
   import {writable} from "svelte/store"
-  import {goto} from "$app/navigation"
   import {tryCatch, uniq} from "@welshman/lib"
   import {fromNostrURI} from "@welshman/util"
-  import {pubkey} from "@welshman/app"
+  import {loadMessagingRelayList} from "@welshman/app"
   import {preventDefault} from "@lib/html"
   import Field from "@lib/components/Field.svelte"
   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"
   import Icon from "@lib/components/Icon.svelte"
+  import Modal from "@lib/components/Modal.svelte"
+  import ModalBody from "@lib/components/ModalBody.svelte"
   import ModalHeader from "@lib/components/ModalHeader.svelte"
+  import ModalTitle from "@lib/components/ModalTitle.svelte"
+  import ModalSubtitle from "@lib/components/ModalSubtitle.svelte"
   import ModalFooter from "@lib/components/ModalFooter.svelte"
   import ProfileMultiSelect from "@app/components/ProfileMultiSelect.svelte"
-  import {makeChatPath} from "@app/util/routes"
+  import {goToChat} from "@app/util/routes"
 
   const back = () => history.back()
 
-  const onSubmit = () => goto(makeChatPath([...pubkeys, $pubkey!]))
+  const onSubmit = () => goToChat(pubkeys)
 
   const addPubkey = (pubkey: string) => {
     pubkeys = uniq([...pubkeys, pubkey])
@@ -30,6 +33,10 @@
 
   let pubkeys: string[] = $state([])
 
+  $effect(() => {
+    pubkeys.forEach(pubkey => loadMessagingRelayList(pubkey))
+  })
+
   onMount(() => {
     return term.subscribe(t => {
       if (t.match(/^[0-9a-f]{64}$/)) {
@@ -53,20 +60,18 @@
   })
 </script>
 
-<form class="column gap-4" onsubmit={preventDefault(onSubmit)}>
-  <ModalHeader>
-    {#snippet title()}
-      <div>Start a Chat</div>
-    {/snippet}
-    {#snippet info()}
-      <div>Create an encrypted chat room for private conversations.</div>
-    {/snippet}
-  </ModalHeader>
-  <Field>
-    {#snippet input()}
-      <ProfileMultiSelect autofocus bind:value={pubkeys} {term} />
-    {/snippet}
-  </Field>
+<Modal tag="form" onsubmit={preventDefault(onSubmit)}>
+  <ModalBody>
+    <ModalHeader>
+      <ModalTitle>Start a Chat</ModalTitle>
+      <ModalSubtitle>Create an encrypted chat room for private conversations.</ModalSubtitle>
+    </ModalHeader>
+    <Field>
+      {#snippet input()}
+        <ProfileMultiSelect autofocus bind:value={pubkeys} {term} />
+      {/snippet}
+    </Field>
+  </ModalBody>
   <ModalFooter>
     <Button class="btn btn-link" onclick={back}>
       <Icon icon={AltArrowLeft} />
@@ -77,4 +82,4 @@
       <Icon icon={AltArrowRight} />
     </Button>
   </ModalFooter>
-</form>
+</Modal>