feat: implement federation post/connections backfill schedulers

schedule_actor_posts_fetch now spawns backfill_outbox in background,
fetching all pages of a remote outbox and persisting via accept_note.
schedule_connections_fetch follows AP collection next-links, resolves
profiles, and caches them in the DB. Both were no-ops ("deferred").

Add connections_repo field to ActivityPubService; wire both factories.

.cargo/config.toml

@@ -1,9 +0,0 @@
-[registry]
-default = "gitea"
-
-[registries.gitea]
-index = "sparse+https://git.gabrielkaszewski.dev/api/packages/GKaszewski/cargo/" # Sparse index
-# index = "https://git.gabrielkaszewski.dev/GKaszewski/_cargo-index.git" # Git
-
-[net]
-git-fetch-with-cli = true

.claude/settings.json

@@ -1,18 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "if": "Bash(git commit*)",
-            "command": "cargo fmt --all 2>&1 && cargo clippy --workspace 2>&1 || echo '{\"continue\": false, \"stopReason\": \"cargo fmt or clippy failed — fix before committing\"}'",
-            "timeout": 120,
-            "statusMessage": "Running cargo fmt + clippy..."
-          }
-        ]
-      }
-    ]
-  }
-}

.env.example

@@ -9,7 +9,7 @@ BASE_URL=http://localhost:3000
 
 # Optional
 HOST=0.0.0.0
-PORT=8000
+PORT=3000
 
 # CORS — comma-separated allowed origins, or * for permissive (default: *)
 CORS_ORIGINS=*
@@ -24,21 +24,5 @@ RUST_ENV=development      # set to "production" to disable AP debug mode
 # but events will not be delivered to the worker)
 # NATS_URL=nats://localhost:4222
 
-# Media storage — local filesystem (default) or S3/MinIO
-STORAGE_BACKEND=local
-STORAGE_PATH=./media            # required when STORAGE_BACKEND=local
-# STORAGE_PREFIX=               # optional key prefix
-
-# S3/MinIO (set STORAGE_BACKEND=s3 to use)
-# S3_ENDPOINT=http://localhost:9000
-# S3_ACCESS_KEY_ID=minioadmin
-# S3_SECRET_ACCESS_KEY=minioadmin
-# S3_BUCKET=thoughts
-# S3_REGION=us-east-1
-
-# Upload limits (optional, defaults shown)
-# UPLOAD_MAX_BYTES=5242880
-# UPLOAD_ALLOWED_TYPES=image/jpeg,image/png,image/gif,image/webp,image/avif
-
 # Logging
 RUST_LOG=info

.gitea/workflows/test.yml

@@ -21,3 +21,32 @@ jobs:
             --exclude postgres-federation \
             --exclude postgres-search
 
+  # Integration tests — require a real PostgreSQL instance.
+  # These test that the SQL queries in the adapter crates are correct.
+  integration:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: thoughts_test
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+    env:
+      DATABASE_URL: postgres://postgres:postgres@localhost:5432/thoughts_test
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: integration tests
+        run: |
+          cargo test \
+            -p postgres \
+            -p postgres-federation \
+            -p postgres-search

.gitignore

@@ -1,6 +1,3 @@
 .env
-/.superpowers/
 
 /target
-/docs/superpowers/
-/media

ARCHITECTURE.md

@@ -1,164 +0,0 @@
-# Architecture
-
-Hexagonal (ports & adapters) architecture. Dependencies point inward — adapters implement domain ports, application orchestrates use cases, presentation handles HTTP.
-
-## Crate dependency graph
-
-```mermaid
-graph TD
-    subgraph Entry Points
-        bootstrap["bootstrap<br/><small>HTTP server, DI wiring</small>"]
-        worker["worker<br/><small>background job consumer</small>"]
-    end
-
-    subgraph Interface Layer
-        presentation["presentation<br/><small>axum handlers, extractors, AppState</small>"]
-        api_types["api-types<br/><small>DTOs, OpenAPI</small>"]
-    end
-
-    subgraph Application Layer
-        application["application<br/><small>use cases, FederationEventService</small>"]
-    end
-
-    subgraph Domain Layer
-        domain["domain<br/><small>models, value objects, events, port traits</small>"]
-    end
-
-    subgraph Adapters
-        postgres["postgres<br/><small>UserRepo, ThoughtRepo, LikeRepo,<br/>BoostRepo, FollowRepo, BlockRepo,<br/>TagRepo, FeedRepo, FederationContentRepo, ...</small>"]
-        activitypub["activitypub<br/><small>FederationActionPort,<br/>FederationBroadcastPort,<br/>FederationSchedulerPort<br/>(wraps k-ap)</small>"]
-        postgres_fed["postgres-federation<br/><small>k-ap DB traits</small>"]
-        postgres_search["postgres-search<br/><small>SearchPort</small>"]
-        auth["auth<br/><small>AuthService, ApiKeyService</small>"]
-        nats["nats<br/><small>EventPublisher, EventConsumer</small>"]
-        storage["storage<br/><small>MediaStore</small>"]
-        event_transport["event-transport<br/><small>event delivery</small>"]
-        event_payload["event-payload<br/><small>event serialization</small>"]
-    end
-
-    bootstrap --> presentation
-    bootstrap --> application
-    bootstrap --> postgres
-    bootstrap --> postgres_fed
-    bootstrap --> postgres_search
-    bootstrap --> activitypub
-    bootstrap --> auth
-    bootstrap --> nats
-    bootstrap --> storage
-    bootstrap --> event_transport
-    bootstrap --> event_payload
-
-    worker --> application
-    worker --> activitypub
-    worker --> postgres
-    worker --> postgres_fed
-    worker --> nats
-    worker --> event_transport
-    worker --> event_payload
-
-    presentation --> application
-    presentation --> api_types
-    presentation --> domain
-
-    application --> domain
-
-    postgres --> domain
-    activitypub --> domain
-    postgres_fed -.-> domain
-    postgres_search --> domain
-    postgres_search --> postgres
-    auth --> domain
-    nats --> domain
-    storage --> domain
-    event_transport --> domain
-    event_payload --> domain
-```
-
-## Domain ports
-
-```mermaid
-classDiagram
-    class domain {
-        <<core>>
-    }
-
-    namespace Data Ports {
-        class UserRepository {
-            <<trait>>
-            find_by_id()
-            find_by_username()
-            save()
-            update_profile()
-        }
-        class ThoughtRepository {
-            <<trait>>
-            save()
-            find_by_id()
-            delete()
-            update_content()
-        }
-        class LikeRepository { <<trait>> }
-        class BoostRepository { <<trait>> }
-        class FollowRepository { <<trait>> }
-        class BlockRepository { <<trait>> }
-        class TagRepository { <<trait>> }
-        class FeedRepository { <<trait>> }
-        class NotificationRepository { <<trait>> }
-        class EngagementRepository { <<trait>> }
-        class SearchPort { <<trait>> }
-    }
-
-    namespace Federation Ports {
-        class FederationContentRepository {
-            <<trait>>
-            outbox_entries_for_actor()
-            find_remote_actor_id()
-            intern_remote_actor()
-            accept_note()
-            retract_note()
-        }
-        class FederationBroadcastPort {
-            <<trait>>
-            broadcast_create()
-            broadcast_delete()
-            broadcast_update()
-            broadcast_announce()
-            broadcast_like()
-        }
-        class FederationActionPort {
-            <<supertrait>>
-        }
-        class FederationLookupPort { <<trait>> }
-        class FederationFollowPort { <<trait>> }
-        class FederationFollowRequestPort { <<trait>> }
-        class FederationFetchPort { <<trait>> }
-        class FederationBlockPort { <<trait>> }
-        class FederationSchedulerPort { <<trait>> }
-    }
-
-    namespace Infra Ports {
-        class EventPublisher { <<trait>> }
-        class EventConsumer { <<trait>> }
-        class AuthService { <<trait>> }
-        class PasswordHasher { <<trait>> }
-        class MediaStore { <<trait>> }
-    }
-
-    FederationActionPort --|> FederationLookupPort
-    FederationActionPort --|> FederationFollowPort
-    FederationActionPort --|> FederationFollowRequestPort
-    FederationActionPort --|> FederationFetchPort
-    FederationActionPort --|> FederationBlockPort
-```
-
-## Dependency rule
-
-```
-bootstrap/worker ──► presentation ──► application ──► domain ◄── adapters
-```
-
-- **domain** — zero framework deps, pure business logic, defines all port traits
-- **application** — orchestrates use cases, depends only on domain
-- **presentation** — HTTP handlers (axum), depends on domain + application
-- **adapters** — implement domain ports, depend inward on domain only
-- **bootstrap/worker** — composition roots, wire adapters into ports

Cargo.toml

@@ -9,12 +9,12 @@ members = [
     "crates/adapters/postgres",
     "crates/adapters/postgres-search",
     "crates/adapters/postgres-federation",
+    "crates/adapters/activitypub-base",
     "crates/adapters/activitypub",
     "crates/adapters/auth",
     "crates/adapters/nats",
     "crates/adapters/event-payload",
     "crates/adapters/event-transport",
-    "crates/adapters/storage",
 ]
 resolver = "2"
 
@@ -30,10 +30,9 @@ async-trait = "0.1"
 uuid = { version = "1.0", features = ["v4", "v5", "serde"] }
 chrono = { version = "0.4", features = ["serde"] }
 sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "uuid", "chrono", "macros"] }
-axum = { version = "0.8", features = ["macros", "multipart"] }
+axum = { version = "0.8", features = ["macros"] }
 tower-http = { version = "0.6", features = ["cors", "trace"] }
 futures = "0.3"
-bytes = "1.0"
 dotenvy = "0.15"
 async-nats = "0.48"
 async-stream = "0.3"
@@ -47,9 +46,9 @@ api-types        = { path = "crates/api-types" }
 postgres         = { path = "crates/adapters/postgres" }
 postgres-search  = { path = "crates/adapters/postgres-search" }
 postgres-federation = { path = "crates/adapters/postgres-federation" }
+activitypub-base = { path = "crates/adapters/activitypub-base" }
 activitypub      = { path = "crates/adapters/activitypub" }
 auth             = { path = "crates/adapters/auth" }
 nats             = { path = "crates/adapters/nats" }
 event-payload    = { path = "crates/adapters/event-payload" }
 event-transport  = { path = "crates/adapters/event-transport" }
-storage          = { path = "crates/adapters/storage" }

Dockerfile

@@ -4,11 +4,10 @@ FROM rust:slim-bookworm AS builder
 WORKDIR /build
 
 # Cache dependency compilation separately from source
-COPY .cargo/ .cargo/
 COPY Cargo.toml Cargo.lock ./
 COPY crates/adapters/activitypub/Cargo.toml       crates/adapters/activitypub/Cargo.toml
+COPY crates/adapters/activitypub-base/Cargo.toml  crates/adapters/activitypub-base/Cargo.toml
 COPY crates/adapters/auth/Cargo.toml              crates/adapters/auth/Cargo.toml
-COPY crates/adapters/storage/Cargo.toml           crates/adapters/storage/Cargo.toml
 COPY crates/adapters/event-payload/Cargo.toml     crates/adapters/event-payload/Cargo.toml
 COPY crates/adapters/event-transport/Cargo.toml   crates/adapters/event-transport/Cargo.toml
 COPY crates/adapters/nats/Cargo.toml              crates/adapters/nats/Cargo.toml
@@ -36,7 +35,7 @@ RUN cargo fetch
 # Now copy real source and build
 COPY crates ./crates
 
-RUN cargo build --release -p bootstrap -p worker --features storage/s3
+RUN cargo build --release -p bootstrap -p worker
 
 # ----- runtime -----
 FROM debian:bookworm-slim
@@ -52,7 +51,7 @@ WORKDIR /app
 COPY --from=builder /build/target/release/thoughts        ./thoughts
 COPY --from=builder /build/target/release/thoughts-worker ./thoughts-worker
 
-EXPOSE 8000
+EXPOSE 3000
 
 ENV RUST_LOG=info
 

Makefile

@@ -1,48 +0,0 @@
-.DEFAULT_GOAL := check
-
-# Run the full local check suite — same order as CI would.
-check: fmt-check clippy test
-	@echo "✅ All checks passed"
-
-# Apply rustfmt to all files.
-fmt:
-	cargo fmt
-
-# Check formatting without modifying files (CI-safe).
-fmt-check:
-	cargo fmt --check
-
-# Run Clippy and treat warnings as errors.
-clippy:
-	cargo clippy -- -D warnings
-
-# Run the full test suite (requires DATABASE_URL).
-test:
-	cargo test
-
-# Unit tests only — no database required.
-test-unit:
-	cargo test -p domain -p application -p api-types -p activitypub
-
-# Integration tests only — requires DATABASE_URL.
-test-integration:
-	cargo test -p postgres -p postgres-federation -p postgres-search -p presentation
-
-# Apply fmt + clippy auto-fixes in one shot.
-fix:
-	cargo fmt
-	cargo clippy --fix --allow-dirty --allow-staged
-
-# Start infra (Postgres + NATS) for local development.
-dev-infra:
-	docker compose up postgres nats -d
-
-# Stop infra.
-dev-infra-down:
-	docker compose down
-
-# Full Docker stack.
-up:
-	docker compose up --build
-
-.PHONY: check fmt fmt-check clippy test test-unit test-integration fix dev-infra dev-infra-down up

README.md

@@ -14,14 +14,7 @@ A self-hosted microblogging server with full ActivityPub federation. Write short
 - JWT authentication (Bearer token) with API key support for third-party clients
 - OpenAPI documentation at `/docs` (Swagger UI) and `/scalar` (Scalar)
 - Full-text search over thoughts and users via PostgreSQL trigram indexes
-- **Profile fields** — up to 4 custom key/value fields (Website, Pronouns, etc.), federated as AP `PropertyValue` attachment
+- Top friends — pin up to 5 users as highlighted contacts
-- **Custom CSS** — per-user stylesheet applied to their profile page
-- **Visibility levels** — public, followers-only, unlisted, and direct posts
-- **Content warnings** — optional CW label and sensitive flag on posts
-- **Feed controls** — sort by newest, oldest, most liked, most boosted, or most discussed; filter to originals only, replies only, local only, or hide sensitive
-- **Popular tags** — trending hashtag discovery
-- Top friends — pin up to 8 users as highlighted contacts
-- Account migration — set `alsoKnownAs` for Fediverse actor moves
 - Home feed, public feed, and per-user thought timelines
 - Rate limiting and registration control
 
@@ -70,11 +63,10 @@ bootstrap           — binary: thoughts (API server)
 worker              — binary: thoughts-worker (event consumer — notifications, AP fan-out)
 adapters/
   auth                 — JWT issuance and validation, Argon2 password hashing
-  storage              — object storage adapter (local filesystem + S3/MinIO) implementing the MediaStore port
   postgres             — PostgreSQL repositories for all domain entities
   postgres-search      — PostgreSQL trigram full-text search
   postgres-federation  — PostgreSQL-backed federation repository
-  k-ap (external)      — generic AP protocol layer (ActivityPubService, actor management, inbox/outbox routing, follower tracking, WebFinger, NodeInfo, HTTP signatures)
+  activitypub-base     — core ActivityPub protocol types, ActivityPubService, federation middleware
   activitypub          — project-specific AP wiring (ThoughtsObjectHandler, inbox/outbox)
   nats                 — NATS transport implementing Transport + MessageSource ports
   event-payload        — shared event serialization DTOs
@@ -83,20 +75,11 @@ adapters/
 
 The `domain` and `application` crates have zero concrete adapter dependencies. All I/O goes through `&dyn Port` traits, keeping business logic fully testable with in-memory fakes.
 
-## Media Storage
-
-Users can upload avatar and banner images via `PUT /users/me/avatar` and `PUT /users/me/banner` (multipart/form-data). Uploaded images are served at `GET /media/*path` (public, no auth required). Set `STORAGE_BACKEND` to configure the backend.
-
 ## Prerequisites
 
 - Rust stable (1.80+)
 - PostgreSQL 15+
 - NATS with JetStream (optional — see [Without NATS](#without-nats))
-- Docker & Docker Compose (for the easiest local setup)
-
-### Private cargo registry
-
-The `k-ap` crate (ActivityPub protocol library) is hosted on a private Gitea registry configured in `.cargo/config.toml`. To build the project you need read access to `git.gabrielkaszewski.dev`. If you're contributing and don't have access, open an issue and I'll sort it out.
 
 ## Environment Variables
 
@@ -115,60 +98,16 @@ Copy `.env.example` to `.env` and fill in your values.
 | Variable | Default | Description |
 |---|---|---|
 | `HOST` | `0.0.0.0` | Interface to bind |
-| `PORT` | `8000` | Port to listen on |
+| `PORT` | `3000` | Port to listen on |
 | `NATS_URL` | — | NATS connection string. If unset, a no-op publisher is used and events are not delivered to the worker |
 | `CORS_ORIGINS` | `*` | Comma-separated allowed origins for CORS, e.g. `https://app.example.com` |
 | `RATE_LIMIT` | disabled | Max requests per minute per IP |
 | `ALLOW_REGISTRATION` | `true` | Set to `false` to close sign-ups |
 | `RUST_ENV` | `development` | Set to `production` to disable ActivityPub debug logging |
 | `RUST_LOG` | `info` | Log level filter (`error`, `warn`, `info`, `debug`, `trace`) |
-| `STORAGE_BACKEND` | `local` | Storage backend: `local` or `s3` |
-| `STORAGE_PATH` | — | Local filesystem path for media (required when `STORAGE_BACKEND=local`) |
-| `STORAGE_PREFIX` | — | Optional key prefix for all stored objects |
-| `S3_ENDPOINT` | — | S3/MinIO endpoint URL (required when `STORAGE_BACKEND=s3`) |
-| `S3_ACCESS_KEY_ID` | — | S3 access key (required when `STORAGE_BACKEND=s3`) |
-| `S3_SECRET_ACCESS_KEY` | — | S3 secret key (required when `STORAGE_BACKEND=s3`) |
-| `S3_BUCKET` | — | S3 bucket name (required when `STORAGE_BACKEND=s3`) |
-| `S3_REGION` | `us-east-1` | S3 region |
-| `UPLOAD_MAX_BYTES` | `5242880` | Max upload size in bytes (default 5 MiB) |
-| `UPLOAD_ALLOWED_TYPES` | `image/jpeg,image/png,image/gif,image/webp,image/avif` | Comma-separated allowed MIME types |
-
-### Frontend environment
-
-Copy `thoughts-frontend/.env.example` to `thoughts-frontend/.env.local` and adjust:
-
-| Variable | Description |
-|---|---|
-| `NEXT_PUBLIC_API_URL` | API URL for client-side (browser) requests, e.g. `http://localhost:8000` |
-| `NEXT_PUBLIC_SERVER_SIDE_API_URL` | API URL for SSR requests — same as above locally, or `http://api:8000` inside Docker |
-| `NEXT_PUBLIC_FEDIVERSE_DOMAIN` | (Optional) Domain shown on profile fediverse handles, e.g. `yourinstance.example.com` |
 
 ## Run
 
-### Local development (recommended)
-
-Start only the infrastructure containers (Postgres + NATS), then run the Rust backend and Next.js frontend natively for fast iteration:
-
-```bash
-# 1. Start Postgres + NATS
-make dev-infra
-
-# 2. Copy and fill in env files
-cp .env.example .env
-cp thoughts-frontend/.env.example thoughts-frontend/.env.local
-
-# 3. API server (runs migrations automatically on startup)
-cargo run -p bootstrap
-
-# 4. Event worker (separate terminal, optional)
-cargo run -p worker
-
-# 5. Frontend (separate terminal)
-cd thoughts-frontend && bun install && bun dev
-```
-
-### Bare metal
-
 ```bash
 # API server (runs migrations automatically on startup)
 cargo run -p bootstrap
@@ -182,20 +121,14 @@ Both processes share the same PostgreSQL database. The worker is optional but re
 ## Test
 
 ```bash
-# Unit tests only — no database required
+# Unit tests — no database required
-make test-unit
+cargo test -p application
 
-# Integration tests — requires DATABASE_URL pointing to a running PostgreSQL
+# Full workspace (requires DATABASE_URL pointing to a running PostgreSQL)
-make test-integration
+cargo test --workspace
-
-# Everything (unit + integration)
-make test
-
-# Full check suite: fmt + clippy + tests
-make check
 ```
 
-`make test-unit` runs domain, application, api-types, and activitypub tests using in-memory fakes — the fastest feedback loop for business logic. `make test-integration` runs the adapter crates against a live PostgreSQL.
+The `application` crate contains unit tests for all event services and use cases backed by in-memory fakes from `domain`'s `test-helpers` feature. These are the fastest feedback loop for business logic.
 
 ## API
 
@@ -208,7 +141,18 @@ Interactive API documentation is available at runtime:
 
 ## Frontend
 
-The Next.js frontend lives in `thoughts-frontend/`. See [Frontend environment](#frontend-environment) for required env vars, or follow the [local development](#local-development-recommended) steps above.
+The Next.js frontend lives in `thoughts-frontend/`. It requires two environment variables:
+
+```env
+NEXT_PUBLIC_API_URL=http://localhost:8000        # client-side requests
+NEXT_PUBLIC_SERVER_SIDE_API_URL=http://localhost:8000  # SSR requests
+```
+
+```bash
+cd thoughts-frontend
+bun install
+bun run dev   # http://localhost:3000
+```
 
 ## Docker
 
@@ -223,9 +167,6 @@ docker run -p 8000:8000 \
   -e JWT_SECRET=change-me \
   -e BASE_URL=https://yourdomain.example.com \
   -e NATS_URL=nats://nats:4222 \
-  -e STORAGE_BACKEND=local \
-  -e STORAGE_PATH=/data/media \
-  -v media_vol:/data/media \
   thoughts
 
 # Event worker (same image, different entrypoint)
@@ -244,12 +185,12 @@ docker build -t thoughts-frontend \
 docker run -p 3000:3000 thoughts-frontend
 ```
 
-### Full Docker stack
+### Local development stack
 
 `compose.yml` spins up the full stack: PostgreSQL, NATS (with JetStream and monitoring on port 8222), the API server, the event worker, and the frontend.
 
 ```bash
-make up          # or: docker compose up --build
+docker compose up
 ```
 
 Services:
@@ -266,7 +207,7 @@ Services:
 
 Contributions are welcome. A few guidelines:
 
-- **Run tests before opening a PR.** At minimum: `make test-unit` (no database needed). For adapter changes: `make test-integration` with a live database. `make check` runs the full suite (fmt + clippy + tests).
+- **Run tests before opening a PR.** At minimum: `cargo test -p application` (no database needed). For adapter changes: `cargo test --workspace` with a live database.
 - **Keep the hexagonal boundary.** `domain` and `application` must not import any adapter crate. Use `&dyn Port` traits for all I/O.
 - **No ORM.** The project uses raw `sqlx`. Keep it that way.
 - **ActivityPub changes** — test against a live Mastodon instance if possible, or use the AP debug logs (`RUST_ENV=development`).

compose.prod.yml

@@ -47,18 +47,11 @@ services:
     labels:
       - "traefik.enable=true"
       - "traefik.docker.network=traefik"
-      # Original API subdomain — keep for backwards compat and direct API access
       - "traefik.http.routers.thoughts-api.rule=Host(`api.thoughts.gabrielkaszewski.dev`)"
       - "traefik.http.routers.thoughts-api.entrypoints=web,websecure"
       - "traefik.http.routers.thoughts-api.tls.certresolver=letsencrypt"
       - "traefik.http.routers.thoughts-api.service=thoughts-api"
       - "traefik.http.services.thoughts-api.loadbalancer.server.port=8000"
-      # Federation routes on the main domain — higher priority than the frontend catch-all
-      - "traefik.http.routers.thoughts-federation.rule=Host(`thoughts.gabrielkaszewski.dev`) && (PathPrefix(`/.well-known`) || PathPrefix(`/nodeinfo`) || Path(`/inbox`) || (Method(`POST`) && PathPrefix(`/users/`)))"
-      - "traefik.http.routers.thoughts-federation.entrypoints=web,websecure"
-      - "traefik.http.routers.thoughts-federation.tls.certresolver=letsencrypt"
-      - "traefik.http.routers.thoughts-federation.service=thoughts-api"
-      - "traefik.http.routers.thoughts-federation.priority=1000"
 
   worker:
     container_name: thoughts-worker
@@ -84,7 +77,6 @@ services:
     environment:
       NEXT_PUBLIC_SERVER_SIDE_API_URL: http://api:8000
       NEXT_PUBLIC_API_URL: https://api.thoughts.gabrielkaszewski.dev
-      NEXT_PUBLIC_FEDIVERSE_DOMAIN: thoughts.gabrielkaszewski.dev
       PORT: 3000
       HOSTNAME: 0.0.0.0
     depends_on:

compose.yml

@@ -30,13 +30,8 @@ services:
       DATABASE_URL: postgres://postgres:postgres@postgres:5432/thoughts
       JWT_SECRET: change-me-in-production
       BASE_URL: http://localhost:8000
-      PORT: 8000
       NATS_URL: nats://nats:4222
       RUST_LOG: info
-      STORAGE_BACKEND: local
-      STORAGE_PATH: /data/media
-    volumes:
-      - media_data:/data/media
     depends_on:
       postgres:
         condition: service_healthy
@@ -70,4 +65,3 @@ services:
 
 volumes:
   postgres_data:
-  media_data:

crates/adapters/activitypub-base/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "activitypub-base"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tokio        = { workspace = true }
+futures      = { workspace = true }
+serde        = { workspace = true }
+serde_json   = { workspace = true }
+uuid         = { workspace = true }
+chrono       = { workspace = true }
+anyhow       = { workspace = true }
+tracing      = { workspace = true }
+async-trait  = { workspace = true }
+axum         = { workspace = true }
+reqwest      = { workspace = true }
+url          = { workspace = true }
+domain       = { workspace = true }
+
+activitypub_federation = "0.7.0-beta.11"
+enum_delegate          = "0.2"

crates/adapters/activitypub-base/src/activities.rs

@@ -0,0 +1,851 @@
+use activitypub_federation::{
+    config::Data,
+    fetch::object_id::ObjectId,
+    kinds::activity::{
+        AcceptType, CreateType, DeleteType, FollowType, RejectType, UndoType, UpdateType,
+    },
+    traits::Activity,
+};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Announce")]
+pub struct AnnounceType;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename = "Like")]
+pub struct LikeType;
+
+impl Default for LikeType {
+    fn default() -> Self {
+        Self
+    }
+}
+
+use crate::actors::DbActor;
+use crate::data::FederationData;
+use crate::error::Error;
+use crate::repository::{FollowerStatus, FollowingStatus};
+
+// --- Follow ---
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FollowActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: FollowType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: ObjectId<DbActor>,
+}
+
+#[async_trait::async_trait]
+impl Activity for FollowActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let target_url = self.object.inner();
+        let target_domain = match (target_url.host_str(), target_url.port()) {
+            (Some(host), Some(port)) => format!("{}:{}", host, port),
+            (Some(host), None) => host.to_string(),
+            _ => {
+                return Err(Error::bad_request(anyhow::anyhow!(
+                    "invalid follow target URL"
+                )));
+            }
+        };
+        if target_domain != data.domain {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "follow target is not a local actor"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let _follower = self.actor.dereference(data).await?;
+        let local_actor = self.object.dereference(data).await?;
+
+        if data
+            .federation_repo
+            .is_actor_blocked(local_actor.user_id, self.actor.inner().as_str())
+            .await?
+        {
+            tracing::info!(actor = %self.actor.inner(), "ignoring follow from blocked actor");
+            return Ok(());
+        }
+
+        data.federation_repo
+            .add_follower(
+                local_actor.user_id,
+                self.actor.inner().as_str(),
+                FollowerStatus::Pending,
+                self.id.as_str(),
+            )
+            .await?;
+
+        tracing::info!(
+            follower = %self.actor.inner(),
+            local_user = %local_actor.user_id,
+            "follow request pending approval"
+        );
+        Ok(())
+    }
+}
+
+// --- Accept ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AcceptActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: AcceptType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: FollowActivity,
+}
+
+#[async_trait::async_trait]
+impl Activity for AcceptActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        if self.actor.inner() != self.object.object.inner() {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "Accept actor does not match Follow target"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let local_user_id = crate::urls::extract_user_id_from_url(self.object.actor.inner())
+            .ok_or_else(|| Error::bad_request(anyhow::anyhow!("invalid actor URL in Follow")))?;
+        data.federation_repo
+            .update_following_status(
+                local_user_id,
+                self.actor.inner().as_str(),
+                FollowingStatus::Accepted,
+            )
+            .await?;
+
+        tracing::info!(remote_actor = %self.actor.inner(), "follow accepted by remote");
+        Ok(())
+    }
+}
+
+// --- Reject ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RejectActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: RejectType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: FollowActivity,
+}
+
+#[async_trait::async_trait]
+impl Activity for RejectActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        if self.actor.inner() != self.object.object.inner() {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "Reject actor does not match Follow target"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        if let Some(user_id) = crate::urls::extract_user_id_from_url(self.object.actor.inner()) {
+            data.federation_repo
+                .remove_following(user_id, self.actor.inner().as_str())
+                .await?;
+        }
+        tracing::info!(actor = %self.actor.inner(), "follow rejected");
+        Ok(())
+    }
+}
+
+// --- Undo ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UndoActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: UndoType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+}
+
+#[async_trait::async_trait]
+impl Activity for UndoActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring Undo from blocked domain");
+            return Ok(());
+        }
+
+        let obj_type = self
+            .object
+            .get("type")
+            .and_then(|t| t.as_str())
+            .unwrap_or("");
+
+        match obj_type {
+            "Follow" => {
+                if let Some(obj_url) = self.object.get("object").and_then(|o| o.as_str())
+                    && let Ok(url) = Url::parse(obj_url)
+                    && let Some(user_id) = crate::urls::extract_user_id_from_url(&url)
+                {
+                    data.federation_repo
+                        .remove_follower(user_id, self.actor.inner().as_str())
+                        .await?;
+                }
+                data.object_handler
+                    .on_actor_removed(self.actor.inner())
+                    .await
+                    .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+                tracing::info!(actor = %self.actor.inner(), "unfollowed");
+            }
+            "Add" => {
+                let ap_id_str = self
+                    .object
+                    .get("object")
+                    .and_then(|o| o.get("id"))
+                    .and_then(|id| id.as_str())
+                    .or_else(|| self.object.get("id").and_then(|id| id.as_str()));
+
+                if let Some(ap_id_str) = ap_id_str
+                    && let Ok(ap_id) = Url::parse(ap_id_str)
+                {
+                    data.object_handler
+                        .on_delete(&ap_id, self.actor.inner())
+                        .await
+                        .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+                    tracing::info!(ap_id = %ap_id_str, "undo Add (watchlist remove)");
+                }
+            }
+            "Like" => {
+                if let Some(obj_url_str) = self.object.get("object").and_then(|o| o.as_str())
+                    && let Ok(obj_url) = Url::parse(obj_url_str)
+                    && obj_url.host_str().unwrap_or("") == data.domain
+                {
+                    data.object_handler
+                        .on_unlike(&obj_url, self.actor.inner())
+                        .await
+                        .unwrap_or_else(|e| {
+                            tracing::warn!(error = %e, "failed to process unlike");
+                        });
+                }
+                tracing::info!(actor = %self.actor.inner(), "received Undo(Like)");
+            }
+            other => {
+                tracing::debug!(kind = %other, "ignoring Undo of unknown activity type");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+// --- Create ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: CreateType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) bto: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) bcc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for CreateActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        if let Some(attributed_to) = self.object.get("attributedTo").and_then(|v| v.as_str())
+            && let Ok(attributed_url) = Url::parse(attributed_to)
+            && &attributed_url != self.actor.inner()
+        {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "Create actor does not match object attributedTo"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        // Use the Note's own id, not the Create activity id (which ends in /activity).
+        // Delete activities reference the Note id, so they must match.
+        let ap_id = self
+            .object
+            .get("id")
+            .and_then(|v| v.as_str())
+            .and_then(|s| Url::parse(s).ok())
+            .unwrap_or_else(|| self.id.clone());
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_create(&ap_id, &actor_url, self.object)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(actor = %actor_url, "received create activity");
+        Ok(())
+    }
+}
+
+// --- Delete ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DeleteActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: DeleteType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for DeleteActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let actor_domain = self.actor.inner().host_str().unwrap_or("");
+        let object_domain = match &self.object {
+            serde_json::Value::String(s) => Url::parse(s)
+                .ok()
+                .and_then(|u| u.host_str().map(|h| h.to_string()))
+                .unwrap_or_default(),
+            serde_json::Value::Object(o) => o
+                .get("id")
+                .and_then(|v| v.as_str())
+                .and_then(|s| Url::parse(s).ok())
+                .and_then(|u| u.host_str().map(|h| h.to_string()))
+                .unwrap_or_default(),
+            _ => String::new(),
+        };
+        if !object_domain.is_empty() && actor_domain != object_domain {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "Delete actor domain does not match object domain"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let actor_url = self.actor.inner().clone();
+
+        // Extract object URL — handles plain string and Tombstone {"id":"...","type":"Tombstone"}
+        let object_url_str = match &self.object {
+            serde_json::Value::String(s) => s.clone(),
+            serde_json::Value::Object(o) => o
+                .get("id")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+                .unwrap_or_default(),
+            _ => String::new(),
+        };
+        let Ok(object_url) = Url::parse(&object_url_str) else {
+            tracing::warn!(actor = %actor_url, "Delete activity has unparseable object, ignoring");
+            return Ok(());
+        };
+
+        // Actor self-deletion: Mastodon sends Delete(actor_url) when an account is deleted.
+        if object_url == *self.actor.inner() {
+            data.object_handler
+                .on_actor_removed(&actor_url)
+                .await
+                .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+            tracing::info!(actor = %actor_url, "received Delete(actor) — remote account deleted");
+            return Ok(());
+        }
+
+        // Normal note deletion.
+        data.object_handler
+            .on_delete(&object_url, &actor_url)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(object = %object_url, "received Delete(note)");
+        Ok(())
+    }
+}
+
+// --- Update ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: UpdateType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for UpdateActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        if let Some(attributed_to) = self.object.get("attributedTo").and_then(|v| v.as_str())
+            && let Ok(attributed_url) = Url::parse(attributed_to)
+            && &attributed_url != self.actor.inner()
+        {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "Update actor does not match object attributedTo"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let ap_id = self
+            .object
+            .get("id")
+            .and_then(|v| v.as_str())
+            .and_then(|s| Url::parse(s).ok())
+            .unwrap_or_else(|| self.id.clone());
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_update(&ap_id, &actor_url, self.object)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(actor = %actor_url, "received update activity");
+        Ok(())
+    }
+}
+
+// --- Announce ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AnnounceActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: AnnounceType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: Url,
+    pub(crate) published: Option<chrono::DateTime<chrono::Utc>>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for AnnounceActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        let object_domain = self.object.host_str().unwrap_or("");
+        if object_domain != data.domain {
+            tracing::debug!(
+                actor = %self.actor.inner(),
+                object = %self.object,
+                "received Announce of non-local object — skipped (cross-server boost not supported)"
+            );
+            return Ok(());
+        }
+        data.federation_repo
+            .add_announce(
+                self.id.as_str(),
+                self.object.as_str(),
+                self.actor.inner().as_str(),
+                self.published.unwrap_or_else(chrono::Utc::now),
+            )
+            .await?;
+        data.object_handler
+            .on_announce_received(&self.object, self.actor.inner())
+            .await
+            .unwrap_or_else(|e| {
+                tracing::warn!(error = %e, "failed to process announce notification");
+            });
+        tracing::info!(actor = %self.actor.inner(), object = %self.object, "received announce");
+        Ok(())
+    }
+}
+
+// --- Like ---
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LikeActivity {
+    pub id: Url,
+    #[serde(rename = "type")]
+    pub kind: LikeType,
+    pub actor: ObjectId<DbActor>,
+    pub object: Url,
+}
+
+#[async_trait::async_trait]
+impl Activity for LikeActivity {
+    type DataType = FederationData;
+    type Error = crate::error::Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring Like from blocked domain");
+            return Ok(());
+        }
+
+        // Only process if the liked object is on our instance.
+        if self.object.host_str().unwrap_or("") != data.domain {
+            return Ok(());
+        }
+
+        data.object_handler
+            .on_like(&self.object, self.actor.inner())
+            .await
+            .map_err(|e| crate::error::Error::from(anyhow::anyhow!(e)))?;
+
+        tracing::info!(actor = %self.actor.inner(), object = %self.object, "received like");
+        Ok(())
+    }
+}
+
+// --- Add ---
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Add")]
+pub struct AddType;
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AddActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: AddType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: serde_json::Value,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) to: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub(crate) cc: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl Activity for AddActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring Add from blocked domain");
+            return Ok(());
+        }
+        let ap_id = self.id.clone();
+        let actor_url = self.actor.inner().clone();
+        data.object_handler
+            .on_create(&ap_id, &actor_url, self.object)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+        tracing::info!(actor = %actor_url, "received Add activity");
+        Ok(())
+    }
+}
+
+// --- Block ---
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Block")]
+pub struct BlockType;
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlockActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: BlockType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: Url,
+}
+
+#[async_trait::async_trait]
+impl Activity for BlockActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            tracing::info!(actor = %self.actor(), "ignoring activity from blocked domain");
+            return Ok(());
+        }
+        if let Some(local_user_id) = crate::urls::extract_user_id_from_url(&self.object) {
+            let _ = data
+                .federation_repo
+                .remove_following(local_user_id, self.actor.inner().as_str())
+                .await;
+            let _ = data
+                .federation_repo
+                .remove_follower(local_user_id, self.actor.inner().as_str())
+                .await;
+        }
+        tracing::info!(actor = %self.actor.inner(), "received block — removed following and follower");
+        Ok(())
+    }
+}
+
+// --- Move (account migration) ---
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[serde(rename = "Move")]
+pub struct MoveType;
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MoveActivity {
+    pub(crate) id: Url,
+    #[serde(rename = "type", default)]
+    pub(crate) kind: MoveType,
+    pub(crate) actor: ObjectId<DbActor>,
+    pub(crate) object: Url,
+    pub(crate) target: Url,
+}
+
+#[async_trait::async_trait]
+impl Activity for MoveActivity {
+    type DataType = FederationData;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        if &self.object != self.actor.inner() {
+            return Err(Error::bad_request(anyhow::anyhow!(
+                "Move object must be the actor itself"
+            )));
+        }
+        Ok(())
+    }
+
+    async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        let domain = self.actor().host_str().unwrap_or("");
+        if data.federation_repo.is_domain_blocked(domain).await? {
+            return Ok(());
+        }
+        tracing::info!(
+            actor = %self.actor.inner(),
+            target = %self.target,
+            "received Move (account migration) — target noted"
+        );
+        Ok(())
+    }
+}
+
+// --- Inbox dispatch enum ---
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(tag = "type")]
+#[enum_delegate::implement(Activity)]
+pub enum InboxActivities {
+    #[serde(rename = "Follow")]
+    Follow(FollowActivity),
+    #[serde(rename = "Accept")]
+    Accept(AcceptActivity),
+    #[serde(rename = "Reject")]
+    Reject(RejectActivity),
+    #[serde(rename = "Undo")]
+    Undo(UndoActivity),
+    #[serde(rename = "Create")]
+    Create(CreateActivity),
+    #[serde(rename = "Delete")]
+    Delete(DeleteActivity),
+    #[serde(rename = "Update")]
+    Update(UpdateActivity),
+    #[serde(rename = "Announce")]
+    Announce(AnnounceActivity),
+    #[serde(rename = "Add")]
+    Add(AddActivity),
+    #[serde(rename = "Block")]
+    Block(BlockActivity),
+    #[serde(rename = "Like")]
+    Like(LikeActivity),
+    #[serde(rename = "Move")]
+    Move(MoveActivity),
+}

crates/adapters/activitypub-base/src/actor_handler.rs

@@ -0,0 +1,25 @@
+use activitypub_federation::{
+    axum::json::FederationJson, config::Data, protocol::context::WithContext, traits::Object,
+};
+use axum::extract::Path;
+
+use crate::actors::{Person, get_local_actor};
+use crate::data::FederationData;
+use crate::error::Error;
+
+pub async fn actor_handler(
+    Path(username): Path<String>,
+    data: Data<FederationData>,
+) -> Result<FederationJson<WithContext<Person>>, Error> {
+    let ap_user = data
+        .user_repo
+        .find_by_username(&username)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::bad_request(anyhow::anyhow!("user not found")))?;
+
+    let db_actor = get_local_actor(ap_user.id, &data).await?;
+    let person = db_actor.into_json(&data).await?;
+
+    Ok(FederationJson(WithContext::new_default(person)))
+}

crates/adapters/activitypub-base/src/actors.rs

@@ -0,0 +1,372 @@
+use activitypub_federation::{
+    config::Data,
+    fetch::object_id::ObjectId,
+    http_signatures::generate_actor_keypair,
+    kinds::actor::PersonType,
+    protocol::{public_key::PublicKey, verification::verify_domains_match},
+    traits::{Actor, Object},
+};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::data::FederationData;
+use crate::error::Error;
+use crate::repository::RemoteActor;
+use crate::user::ApProfileField;
+
+#[derive(Debug, Clone)]
+pub struct DbActor {
+    pub user_id: uuid::Uuid,
+    pub username: String,
+    pub public_key_pem: String,
+    pub private_key_pem: Option<String>,
+    pub inbox_url: Url,
+    pub shared_inbox_url: Option<Url>,
+    pub outbox_url: Url,
+    pub followers_url: Url,
+    pub following_url: Url,
+    pub ap_id: Url,
+    pub last_refreshed_at: DateTime<Utc>,
+    pub bio: Option<String>,
+    pub avatar_url: Option<Url>,
+    pub banner_url: Option<Url>,
+    pub also_known_as: Option<String>,
+    pub profile_url: Option<Url>,
+    pub attachment: Vec<ApProfileField>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ApImageObject {
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub url: Url,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Endpoints {
+    pub shared_inbox: Url,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProfileFieldObject {
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Person {
+    #[serde(rename = "type")]
+    kind: PersonType,
+    id: ObjectId<DbActor>,
+    preferred_username: String,
+    inbox: Url,
+    outbox: Url,
+    followers: Url,
+    following: Url,
+    public_key: PublicKey,
+    name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    summary: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    icon: Option<ApImageObject>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    url: Option<Url>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    discoverable: Option<bool>,
+    manually_approves_followers: bool,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    updated: Option<DateTime<Utc>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    endpoints: Option<Endpoints>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    image: Option<ApImageObject>,
+    #[serde(rename = "alsoKnownAs", skip_serializing_if = "Vec::is_empty", default)]
+    also_known_as: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    attachment: Vec<ProfileFieldObject>,
+}
+
+struct ActorUrls {
+    ap_id: Url,
+    inbox_url: Url,
+    shared_inbox_url: Option<Url>,
+    outbox_url: Url,
+    followers_url: Url,
+    following_url: Url,
+}
+
+impl ActorUrls {
+    fn build(base_url: &str, user_id: uuid::Uuid) -> Self {
+        let ap_id = crate::urls::actor_url(base_url, user_id);
+        Self {
+            inbox_url: Url::parse(&format!("{}/inbox", &ap_id)).expect("valid url"),
+            shared_inbox_url: Url::parse(&format!("{}/inbox", base_url)).ok(),
+            outbox_url: Url::parse(&format!("{}/outbox", &ap_id)).expect("valid url"),
+            followers_url: Url::parse(&format!("{}/followers", &ap_id)).expect("valid url"),
+            following_url: Url::parse(&format!("{}/following", &ap_id)).expect("valid url"),
+            ap_id,
+        }
+    }
+}
+
+pub async fn get_local_actor(
+    user_id: uuid::Uuid,
+    data: &Data<FederationData>,
+) -> Result<DbActor, Error> {
+    let user = data
+        .user_repo
+        .find_by_id(user_id)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found: {}", user_id)))?;
+
+    let (public_key, private_key) = match data
+        .federation_repo
+        .get_local_actor_keypair(user_id)
+        .await?
+    {
+        Some(kp) => kp,
+        None => {
+            let kp = generate_actor_keypair()?;
+            data.federation_repo
+                .save_local_actor_keypair(user_id, kp.public_key.clone(), kp.private_key.clone())
+                .await?;
+            (kp.public_key, kp.private_key)
+        }
+    };
+
+    let ActorUrls {
+        ap_id,
+        inbox_url,
+        shared_inbox_url,
+        outbox_url,
+        followers_url,
+        following_url,
+    } = ActorUrls::build(&data.base_url, user_id);
+
+    Ok(DbActor {
+        user_id,
+        username: user.username,
+        public_key_pem: public_key,
+        private_key_pem: Some(private_key),
+        inbox_url,
+        shared_inbox_url,
+        outbox_url,
+        followers_url,
+        following_url,
+        ap_id,
+        last_refreshed_at: Utc::now(),
+        bio: user.bio,
+        avatar_url: user.avatar_url,
+        banner_url: user.banner_url,
+        also_known_as: user.also_known_as,
+        profile_url: user.profile_url,
+        attachment: user.attachment,
+    })
+}
+
+#[async_trait::async_trait]
+impl Object for DbActor {
+    type DataType = FederationData;
+    type Kind = Person;
+    type Error = Error;
+
+    fn id(&self) -> &Url {
+        &self.ap_id
+    }
+
+    fn last_refreshed_at(&self) -> Option<DateTime<Utc>> {
+        Some(self.last_refreshed_at)
+    }
+
+    async fn read_from_id(
+        object_id: Url,
+        data: &Data<Self::DataType>,
+    ) -> Result<Option<Self>, Self::Error> {
+        let user_id = match crate::urls::extract_user_id_from_url(&object_id) {
+            Some(id) => id,
+            None => return Ok(None),
+        };
+        let user = match data.user_repo.find_by_id(user_id).await {
+            Ok(Some(u)) => u,
+            _ => return Ok(None),
+        };
+
+        let keypair = data
+            .federation_repo
+            .get_local_actor_keypair(user_id)
+            .await?;
+
+        let (public_key, private_key) = match keypair {
+            Some(kp) => (kp.0, Some(kp.1)),
+            None => return Ok(None),
+        };
+
+        let ActorUrls {
+            ap_id,
+            inbox_url,
+            shared_inbox_url,
+            outbox_url,
+            followers_url,
+            following_url,
+        } = ActorUrls::build(&data.base_url, user_id);
+
+        Ok(Some(DbActor {
+            user_id,
+            username: user.username,
+            public_key_pem: public_key,
+            private_key_pem: private_key,
+            inbox_url,
+            shared_inbox_url,
+            outbox_url,
+            followers_url,
+            following_url,
+            ap_id,
+            last_refreshed_at: Utc::now(),
+            bio: None,
+            avatar_url: None,
+            banner_url: None,
+            also_known_as: None,
+            profile_url: None,
+            attachment: vec![],
+        }))
+    }
+
+    async fn into_json(self, data: &Data<Self::DataType>) -> Result<Self::Kind, Self::Error> {
+        let public_key = PublicKey {
+            id: format!("{}#main-key", &self.ap_id),
+            owner: self.ap_id.clone(),
+            public_key_pem: self.public_key_pem.clone(),
+        };
+
+        let icon = self.avatar_url.map(|url| ApImageObject {
+            kind: "Image".to_string(),
+            url,
+        });
+        let image = self.banner_url.map(|url| ApImageObject {
+            kind: "Image".to_string(),
+            url,
+        });
+        let profile_url = self.profile_url;
+        let also_known_as: Vec<String> = self.also_known_as.into_iter().collect();
+        let attachment: Vec<ProfileFieldObject> = self
+            .attachment
+            .into_iter()
+            .map(|f| ProfileFieldObject {
+                kind: "PropertyValue".to_string(),
+                name: f.name,
+                value: f.value,
+            })
+            .collect();
+
+        let shared_inbox =
+            Url::parse(&format!("{}/inbox", data.base_url)).expect("base_url is always valid");
+
+        Ok(Person {
+            kind: Default::default(),
+            id: self.ap_id.clone().into(),
+            preferred_username: self.username.clone(),
+            inbox: self.inbox_url.clone(),
+            outbox: self.outbox_url.clone(),
+            followers: self.followers_url.clone(),
+            following: self.following_url.clone(),
+            public_key,
+            name: Some(self.username.clone()),
+            summary: self.bio.clone(),
+            icon,
+            url: profile_url,
+            discoverable: Some(true),
+            manually_approves_followers: true,
+            updated: Some(self.last_refreshed_at),
+            endpoints: Some(Endpoints { shared_inbox }),
+            image,
+            also_known_as,
+            attachment,
+        })
+    }
+
+    async fn verify(
+        json: &Self::Kind,
+        expected_domain: &Url,
+        _data: &Data<Self::DataType>,
+    ) -> Result<(), Self::Error> {
+        verify_domains_match(json.id.inner(), expected_domain)?;
+        Ok(())
+    }
+
+    async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
+        let shared_inbox_url = json.endpoints.as_ref().map(|e| e.shared_inbox.to_string());
+        let actor = RemoteActor {
+            url: json.id.inner().to_string(),
+            handle: json.preferred_username.clone(),
+            inbox_url: json.inbox.to_string(),
+            shared_inbox_url,
+            display_name: json.name.clone(),
+            avatar_url: json.icon.as_ref().map(|i| i.url.to_string()),
+            outbox_url: Some(json.outbox.to_string()),
+        };
+        data.federation_repo.upsert_remote_actor(actor).await?;
+
+        let url_str = json.id.inner().to_string();
+        let user_id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_URL, url_str.as_bytes());
+        let ap_id = json.id.inner().clone();
+        let inbox_url = json.inbox.clone();
+        let shared_inbox_url = json
+            .endpoints
+            .as_ref()
+            .and_then(|e| Url::parse(e.shared_inbox.as_str()).ok());
+        let outbox_url = json.outbox.clone();
+        let followers_url = json.followers.clone();
+        let following_url = json.following.clone();
+
+        Ok(DbActor {
+            user_id,
+            username: json.preferred_username.clone(),
+            public_key_pem: json.public_key.public_key_pem,
+            private_key_pem: None,
+            inbox_url,
+            shared_inbox_url,
+            outbox_url,
+            followers_url,
+            following_url,
+            ap_id,
+            last_refreshed_at: Utc::now(),
+            bio: json.summary.clone(),
+            avatar_url: json.icon.as_ref().map(|i| i.url.clone()),
+            banner_url: json.image.as_ref().map(|i| i.url.clone()),
+            also_known_as: json.also_known_as.into_iter().next(),
+            profile_url: json.url.clone(),
+            attachment: json
+                .attachment
+                .iter()
+                .map(|f| crate::user::ApProfileField {
+                    name: f.name.clone(),
+                    value: f.value.clone(),
+                })
+                .collect(),
+        })
+    }
+}
+
+impl Actor for DbActor {
+    fn public_key_pem(&self) -> &str {
+        &self.public_key_pem
+    }
+
+    fn private_key_pem(&self) -> Option<String> {
+        self.private_key_pem.clone()
+    }
+
+    fn inbox(&self) -> Url {
+        self.inbox_url.clone()
+    }
+}
+
+#[cfg(test)]
+#[path = "tests/actors.rs"]
+mod tests;

crates/adapters/activitypub-base/src/ap_ports.rs

@@ -0,0 +1,167 @@
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    models::thought::Thought,
+    value_objects::{ThoughtId, UserId, Username},
+};
+
+/// AP-protocol endpoints for a locally-stored user (local or interned remote).
+#[derive(Debug, Clone)]
+pub struct ActorApUrls {
+    pub ap_id: String,
+    pub inbox_url: String,
+}
+
+/// A local thought ready for AP serialization, with the author's username
+/// pre-joined so the handler can build AP URLs without a second query.
+#[derive(Debug, Clone)]
+pub struct OutboxEntry {
+    pub thought: Thought,
+    pub author_username: Username,
+}
+
+#[async_trait]
+pub trait ActivityPubRepository: Send + Sync {
+    // ── Outbox (local → remote) ──────────────────────────────────────
+
+    /// All public local thoughts for this actor. Used for outbox totals
+    /// and full-collection delivery.
+    async fn outbox_entries_for_actor(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<OutboxEntry>, DomainError>;
+
+    /// Cursor page of public local thoughts, newest-first, before `before`.
+    /// Used for OrderedCollectionPage responses.
+    async fn outbox_page_for_actor(
+        &self,
+        user_id: &UserId,
+        before: Option<chrono::DateTime<chrono::Utc>>,
+        limit: usize,
+    ) -> Result<Vec<OutboxEntry>, DomainError>;
+
+    // ── Remote actor resolution ──────────────────────────────────────
+
+    /// Find the local UserId for a remote actor by its AP URL.
+    async fn find_remote_actor_id(&self, actor_ap_url: &str)
+        -> Result<Option<UserId>, DomainError>;
+
+    /// Ensure a remote actor placeholder exists; create one if absent.
+    /// Idempotent — safe to call multiple times with the same URL.
+    async fn intern_remote_actor(&self, actor_ap_url: &str) -> Result<UserId, DomainError>;
+
+    /// Update display_name and avatar_url for an already-interned remote actor.
+    async fn update_remote_actor_display(
+        &self,
+        user_id: &UserId,
+        display_name: Option<&str>,
+        avatar_url: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    // ── Inbox processing (remote → local) ───────────────────────────
+
+    /// Persist an incoming remote Note. Idempotent on ap_id.
+    #[allow(clippy::too_many_arguments)]
+    async fn accept_note(
+        &self,
+        ap_id: &str,
+        author_id: &UserId,
+        content: &str,
+        published: chrono::DateTime<chrono::Utc>,
+        sensitive: bool,
+        content_warning: Option<String>,
+        visibility: &str,
+        in_reply_to: Option<&str>,
+    ) -> Result<ThoughtId, DomainError>;
+
+    /// Apply an Update to a previously accepted remote Note.
+    async fn apply_note_update(&self, ap_id: &str, new_content: &str) -> Result<(), DomainError>;
+
+    /// Remove a specific remote Note (Delete activity). Only touches
+    /// remotely-originated thoughts.
+    async fn retract_note(&self, ap_id: &str) -> Result<(), DomainError>;
+
+    /// Remove all Notes from a remote actor (actor-level Delete/Tombstone).
+    async fn retract_actor_notes(&self, actor_ap_url: &str) -> Result<(), DomainError>;
+
+    // ── Node-level stats ─────────────────────────────────────────────
+
+    /// Total locally-authored thought count for NodeInfo responses.
+    async fn count_local_notes(&self) -> Result<u64, DomainError>;
+
+    /// Return the ActivityPub object URL for a thought, if one is stored.
+    /// Returns None for local thoughts (caller constructs URL from base_url + thought_id).
+    async fn get_thought_ap_id(
+        &self,
+        thought_id: &ThoughtId,
+    ) -> Result<Option<String>, DomainError>;
+
+    /// Return the AP actor URL and inbox URL for a user, if stored.
+    /// Returns None for users that have not been federated.
+    async fn get_actor_ap_urls(&self, user_id: &UserId)
+        -> Result<Option<ActorApUrls>, DomainError>;
+}
+
+#[async_trait]
+pub trait OutboundFederationPort: Send + Sync {
+    /// Fan out a new local Note to all accepted followers.
+    async fn broadcast_create(
+        &self,
+        author_user_id: &UserId,
+        thought: &Thought,
+        author_username: &str,
+        in_reply_to_url: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out a Delete tombstone for a now-deleted local Note.
+    /// `thought_ap_id` is pre-constructed by the caller because the thought
+    /// has already been deleted from the DB when this fires.
+    async fn broadcast_delete(
+        &self,
+        author_user_id: &UserId,
+        thought_ap_id: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Update(Note) for an edited local thought.
+    async fn broadcast_update(
+        &self,
+        author_user_id: &UserId,
+        thought: &Thought,
+        author_username: &str,
+        in_reply_to_url: Option<&str>,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Announce(object_ap_id) for a boost.
+    async fn broadcast_announce(
+        &self,
+        booster_user_id: &UserId,
+        object_ap_id: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Undo(Announce) to followers when a boost is removed.
+    async fn broadcast_undo_announce(
+        &self,
+        booster_user_id: &UserId,
+        object_ap_id: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Send a Like activity to a remote thought author's inbox.
+    /// Only called when a LOCAL user likes a REMOTE thought (one with an ap_id).
+    async fn broadcast_like(
+        &self,
+        liker_user_id: &UserId,
+        object_ap_id: &str,
+        author_inbox_url: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Send Undo(Like) to a remote thought author's inbox.
+    async fn broadcast_undo_like(
+        &self,
+        liker_user_id: &UserId,
+        object_ap_id: &str,
+        author_inbox_url: &str,
+    ) -> Result<(), DomainError>;
+
+    /// Fan out an Update(Actor) to all accepted followers after a profile change.
+    async fn broadcast_actor_update(&self, user_id: &UserId) -> Result<(), DomainError>;
+}

crates/adapters/activitypub-base/src/content.rs

@@ -0,0 +1,68 @@
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use url::Url;
+
+#[async_trait]
+pub trait ApObjectHandler: Send + Sync {
+    /// Returns (ap_id, serialized object) for all local content owned by this user.
+    /// Used by outbox (count) and backfill (delivery). Must only return locally-authored content.
+    async fn get_local_objects_for_user(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> anyhow::Result<Vec<(Url, serde_json::Value)>>;
+
+    /// Returns up to `limit` objects ordered newest-first, published before `before`.
+    /// Returns (ap_id, object_json, published_at).
+    async fn get_local_objects_page(
+        &self,
+        user_id: uuid::Uuid,
+        before: Option<DateTime<Utc>>,
+        limit: usize,
+    ) -> anyhow::Result<Vec<(Url, serde_json::Value, DateTime<Utc>)>>;
+
+    /// Incoming Create activity — persist remote content.
+    async fn on_create(
+        &self,
+        ap_id: &Url,
+        actor_url: &Url,
+        object: serde_json::Value,
+    ) -> anyhow::Result<()>;
+
+    /// Incoming Update activity — update existing remote content.
+    async fn on_update(
+        &self,
+        ap_id: &Url,
+        actor_url: &Url,
+        object: serde_json::Value,
+    ) -> anyhow::Result<()>;
+
+    /// Incoming Delete activity — remove specific remote content.
+    async fn on_delete(&self, ap_id: &Url, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Actor unfollowed/was removed — clean up all their remote content.
+    async fn on_actor_removed(&self, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Called when a remote actor likes a local thought.
+    /// `object_url` is the AP URL of the liked note (e.g. `{base}/thoughts/{uuid}`).
+    /// `actor_url` is the AP URL of the remote actor who sent the Like.
+    async fn on_like(&self, object_url: &Url, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Called when a remote actor boosts (Announce) a local thought.
+    /// `object_url` is the AP URL of the announced note.
+    /// `actor_url` is the AP URL of the remote actor who sent the Announce.
+    async fn on_announce_received(&self, object_url: &Url, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Called when a remote actor removes a Like from a local thought.
+    async fn on_unlike(&self, object_url: &Url, actor_url: &Url) -> anyhow::Result<()>;
+
+    /// Called when an inbound Note tags a local user with a Mention.
+    async fn on_mention(
+        &self,
+        thought_ap_id: &Url,
+        mentioned_user_uuid: uuid::Uuid,
+        actor_url: &Url,
+    ) -> anyhow::Result<()>;
+
+    /// Total number of locally-authored posts across all users.
+    async fn count_local_posts(&self) -> anyhow::Result<u64>;
+}

crates/adapters/activitypub-base/src/data.rs

@@ -0,0 +1,49 @@
+use std::sync::Arc;
+
+use crate::content::ApObjectHandler;
+use crate::repository::FederationRepository;
+use crate::user::ApUserRepository;
+use domain::ports::EventPublisher;
+
+#[derive(Clone)]
+pub struct FederationData {
+    pub(crate) federation_repo: Arc<dyn FederationRepository>,
+    pub(crate) user_repo: Arc<dyn ApUserRepository>,
+    pub(crate) object_handler: Arc<dyn ApObjectHandler>,
+    pub(crate) base_url: String,
+    pub(crate) domain: String,
+    pub(crate) allow_registration: bool,
+    pub(crate) software_name: String,
+    #[allow(dead_code)]
+    pub(crate) event_publisher: Option<Arc<dyn EventPublisher>>,
+}
+
+impl FederationData {
+    pub fn new(
+        federation_repo: Arc<dyn FederationRepository>,
+        user_repo: Arc<dyn ApUserRepository>,
+        object_handler: Arc<dyn ApObjectHandler>,
+        base_url: String,
+        allow_registration: bool,
+        software_name: String,
+        event_publisher: Option<Arc<dyn EventPublisher>>,
+    ) -> Self {
+        let domain = base_url
+            .trim_start_matches("https://")
+            .trim_start_matches("http://")
+            .split('/')
+            .next()
+            .unwrap_or("")
+            .to_string();
+        Self {
+            federation_repo,
+            user_repo,
+            object_handler,
+            base_url,
+            domain,
+            allow_registration,
+            software_name,
+            event_publisher,
+        }
+    }
+}

crates/adapters/activitypub-base/src/error.rs

@@ -0,0 +1,48 @@
+use std::fmt::{Display, Formatter};
+
+use axum::http::StatusCode;
+
+#[derive(Debug)]
+pub struct Error(pub(crate) anyhow::Error, pub(crate) StatusCode);
+
+impl Error {
+    pub fn not_found(e: impl Into<anyhow::Error>) -> Self {
+        Self(e.into(), StatusCode::NOT_FOUND)
+    }
+
+    pub fn bad_request(e: impl Into<anyhow::Error>) -> Self {
+        Self(e.into(), StatusCode::BAD_REQUEST)
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl<T> From<T> for Error
+where
+    T: Into<anyhow::Error>,
+{
+    fn from(t: T) -> Self {
+        Error(t.into(), StatusCode::INTERNAL_SERVER_ERROR)
+    }
+}
+
+impl axum::response::IntoResponse for Error {
+    fn into_response(self) -> axum::response::Response {
+        let status = self.1;
+        if status.is_server_error() {
+            tracing::error!(error = %self.0, status = status.as_u16(), "federation error");
+        } else {
+            tracing::debug!(error = %self.0, status = status.as_u16(), "federation response");
+        }
+        let body = if status.is_server_error() {
+            "internal server error".to_string()
+        } else {
+            self.0.to_string()
+        };
+        (status, body).into_response()
+    }
+}

crates/adapters/activitypub-base/src/federation.rs

@@ -0,0 +1,49 @@
+use activitypub_federation::config::{Data, FederationConfig, FederationMiddleware, UrlVerifier};
+use activitypub_federation::error::Error as FedError;
+use url::Url;
+
+use crate::data::FederationData;
+
+#[derive(Clone)]
+struct PermissiveVerifier;
+
+#[async_trait::async_trait]
+impl UrlVerifier for PermissiveVerifier {
+    async fn verify(&self, _url: &Url) -> Result<(), FedError> {
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct ApFederationConfig(pub FederationConfig<FederationData>);
+
+impl ApFederationConfig {
+    pub async fn new(data: FederationData, debug: bool) -> anyhow::Result<Self> {
+        let config = if debug {
+            FederationConfig::builder()
+                .domain(&data.domain)
+                .app_data(data)
+                .debug(true)
+                .http_signature_compat(true)
+                .url_verifier(Box::new(PermissiveVerifier))
+                .build()
+                .await?
+        } else {
+            FederationConfig::builder()
+                .domain(&data.domain)
+                .app_data(data)
+                .debug(false)
+                .build()
+                .await?
+        };
+        Ok(Self(config))
+    }
+
+    pub fn to_request_data(&self) -> Data<FederationData> {
+        self.0.to_request_data()
+    }
+
+    pub fn middleware(&self) -> FederationMiddleware<FederationData> {
+        FederationMiddleware::new(self.0.clone())
+    }
+}

crates/adapters/activitypub-base/src/followers_handler.rs

@@ -0,0 +1,105 @@
+use activitypub_federation::{axum::json::FederationJson, config::Data};
+use axum::extract::{Path, Query};
+use serde::Deserialize;
+use serde_json::json;
+
+use crate::data::FederationData;
+use crate::error::Error;
+use crate::urls::AP_PAGE_SIZE;
+
+#[derive(Deserialize)]
+pub struct PageQuery {
+    page: Option<u32>,
+}
+
+async fn collection_handler(
+    user_id_str: &str,
+    query: PageQuery,
+    data: Data<FederationData>,
+    collection_type: &str,
+) -> Result<FederationJson<serde_json::Value>, Error> {
+    let user_id = uuid::Uuid::parse_str(user_id_str)
+        .map_err(|_| Error::bad_request(anyhow::anyhow!("invalid user id")))?;
+
+    data.user_repo
+        .find_by_id(user_id)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let collection_id = format!(
+        "{}/users/{}/{}",
+        data.base_url, user_id_str, collection_type
+    );
+
+    let total = match collection_type {
+        "followers" => data.federation_repo.count_followers(user_id).await,
+        _ => data.federation_repo.count_following(user_id).await,
+    }
+    .map_err(Error::from)?;
+
+    if let Some(page) = query.page {
+        let page = page.max(1);
+        let offset = (page.saturating_sub(1) as usize) * AP_PAGE_SIZE;
+
+        let items: Vec<String> = match collection_type {
+            "followers" => data
+                .federation_repo
+                .get_followers_page(user_id, offset as u32, AP_PAGE_SIZE)
+                .await
+                .map_err(Error::from)?
+                .into_iter()
+                .map(|f| f.actor.url)
+                .collect(),
+            _ => data
+                .federation_repo
+                .get_following_page(user_id, offset as u32, AP_PAGE_SIZE)
+                .await
+                .map_err(Error::from)?
+                .into_iter()
+                .map(|a| a.url)
+                .collect(),
+        };
+
+        let has_next = offset + items.len() < total;
+
+        let mut obj = json!({
+            "@context": crate::urls::AP_CONTEXT,
+            "type": "OrderedCollectionPage",
+            "id": format!("{}?page={}", collection_id, page),
+            "partOf": collection_id,
+            "totalItems": total,
+            "orderedItems": items,
+        });
+
+        if has_next {
+            obj["next"] = json!(format!("{}?page={}", collection_id, page + 1));
+        }
+
+        Ok(FederationJson(obj))
+    } else {
+        Ok(FederationJson(json!({
+            "@context": crate::urls::AP_CONTEXT,
+            "type": "OrderedCollection",
+            "id": collection_id,
+            "totalItems": total,
+            "first": format!("{}?page=1", collection_id),
+        })))
+    }
+}
+
+pub async fn followers_handler(
+    Path(user_id_str): Path<String>,
+    Query(query): Query<PageQuery>,
+    data: Data<FederationData>,
+) -> Result<FederationJson<serde_json::Value>, Error> {
+    collection_handler(&user_id_str, query, data, "followers").await
+}
+
+pub async fn following_handler(
+    Path(user_id_str): Path<String>,
+    Query(query): Query<PageQuery>,
+    data: Data<FederationData>,
+) -> Result<FederationJson<serde_json::Value>, Error> {
+    collection_handler(&user_id_str, query, data, "following").await
+}

crates/adapters/activitypub-base/src/inbox.rs

@@ -0,0 +1,18 @@
+use activitypub_federation::{
+    axum::inbox::{ActivityData, receive_activity},
+    config::Data,
+    protocol::context::WithContext,
+};
+
+use crate::activities::InboxActivities;
+use crate::actors::DbActor;
+use crate::data::FederationData;
+use crate::error::Error;
+
+pub async fn inbox_handler(
+    data: Data<FederationData>,
+    activity_data: ActivityData,
+) -> Result<(), Error> {
+    receive_activity::<WithContext<InboxActivities>, DbActor, FederationData>(activity_data, &data)
+        .await
+}

crates/adapters/activitypub-base/src/lib.rs

@@ -0,0 +1,30 @@
+pub mod activities;
+pub mod actor_handler;
+pub mod actors;
+pub mod ap_ports;
+pub mod content;
+pub mod data;
+pub mod error;
+pub mod federation;
+pub mod followers_handler;
+pub mod inbox;
+pub mod nodeinfo;
+pub mod outbox;
+pub mod repository;
+pub mod service;
+pub(crate) mod urls;
+pub use urls::AS_PUBLIC;
+pub mod user;
+pub mod webfinger;
+
+pub use activitypub_federation::kinds::object::NoteType;
+pub use ap_ports::{ActorApUrls, ActivityPubRepository, OutboxEntry, OutboundFederationPort};
+pub use content::ApObjectHandler;
+pub use data::FederationData;
+pub use error::Error;
+pub use federation::ApFederationConfig;
+pub use repository::{
+    BlockedDomain, FederationRepository, Follower, FollowerStatus, FollowingStatus, RemoteActor,
+};
+pub use service::ActivityPubService;
+pub use user::{ApProfileField, ApUser, ApUserRepository};

crates/adapters/activitypub-base/src/nodeinfo.rs

@@ -0,0 +1,82 @@
+use activitypub_federation::config::Data;
+use axum::Json;
+use serde::Serialize;
+
+use crate::data::FederationData;
+use crate::error::Error;
+
+const NODEINFO_2_0_REL: &str = "http://nodeinfo.diaspora.software/ns/schema/2.0";
+
+#[derive(Serialize)]
+pub struct NodeInfoWellKnown {
+    pub links: Vec<NodeInfoLink>,
+}
+
+#[derive(Serialize)]
+pub struct NodeInfoLink {
+    pub rel: String,
+    pub href: String,
+}
+
+#[derive(Serialize)]
+pub struct NodeInfoSoftware {
+    pub name: String,
+    pub version: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NodeInfoUsage {
+    pub users: NodeInfoUsers,
+    pub local_posts: u64,
+}
+
+#[derive(Serialize)]
+pub struct NodeInfoUsers {
+    pub total: usize,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NodeInfo {
+    pub version: String,
+    pub software: NodeInfoSoftware,
+    pub protocols: Vec<String>,
+    pub usage: NodeInfoUsage,
+    pub open_registrations: bool,
+}
+
+pub async fn nodeinfo_well_known_handler(
+    data: Data<FederationData>,
+) -> Result<Json<NodeInfoWellKnown>, Error> {
+    let href = format!("{}/nodeinfo/2.0", data.base_url);
+    Ok(Json(NodeInfoWellKnown {
+        links: vec![NodeInfoLink {
+            rel: NODEINFO_2_0_REL.to_string(),
+            href,
+        }],
+    }))
+}
+
+pub async fn nodeinfo_handler(data: Data<FederationData>) -> Result<Json<NodeInfo>, Error> {
+    let user_count = data.user_repo.count_users().await.unwrap_or(0);
+    let local_posts = data.object_handler.count_local_posts().await.unwrap_or(0);
+
+    Ok(Json(NodeInfo {
+        version: "2.0".to_string(),
+        software: NodeInfoSoftware {
+            name: data.software_name.clone(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        },
+        protocols: vec!["activitypub".to_string()],
+        usage: NodeInfoUsage {
+            users: NodeInfoUsers { total: user_count },
+            local_posts,
+        },
+        open_registrations: data.allow_registration,
+    }))
+}
+
+#[cfg(test)]
+#[path = "tests/nodeinfo.rs"]
+mod tests;

crates/adapters/activitypub-base/src/outbox.rs

@@ -0,0 +1,138 @@
+use axum::extract::{Path, Query};
+use axum::response::IntoResponse;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use activitypub_federation::{
+    config::Data, fetch::object_id::ObjectId, kinds::activity::CreateType,
+    protocol::context::WithContext,
+};
+
+use crate::{activities::CreateActivity, data::FederationData, error::Error, urls::AP_PAGE_SIZE};
+
+#[derive(Deserialize)]
+pub struct OutboxQuery {
+    page: Option<bool>,
+    before: Option<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollection {
+    #[serde(rename = "@context")]
+    context: String,
+    #[serde(rename = "type")]
+    kind: String,
+    id: String,
+    total_items: u64,
+    first: String,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderedCollectionPage {
+    #[serde(rename = "@context")]
+    context: String,
+    #[serde(rename = "type")]
+    kind: String,
+    id: String,
+    part_of: String,
+    ordered_items: Vec<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    next: Option<String>,
+}
+
+pub async fn outbox_handler(
+    Path(user_id_str): Path<String>,
+    Query(query): Query<OutboxQuery>,
+    data: Data<FederationData>,
+) -> Result<axum::response::Response, Error> {
+    let uuid = uuid::Uuid::parse_str(&user_id_str)
+        .map_err(|_| Error::bad_request(anyhow::anyhow!("invalid user id")))?;
+
+    data.user_repo
+        .find_by_id(uuid)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let outbox_url = format!("{}/users/{}/outbox", data.base_url, user_id_str);
+
+    if query.page.unwrap_or(false) {
+        let before: Option<DateTime<Utc>> = query.before.as_deref().and_then(|s| s.parse().ok());
+
+        let items = data
+            .object_handler
+            .get_local_objects_page(uuid, before, AP_PAGE_SIZE)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!("{}", e)))?;
+
+        let actor_url: Url = format!("{}/users/{}", data.base_url, user_id_str)
+            .parse()
+            .expect("valid url");
+
+        let has_more = items.len() == AP_PAGE_SIZE;
+        let oldest_ts = items.last().map(|(_, _, ts)| *ts);
+
+        let followers_url = format!("{}/followers", actor_url);
+        let ordered_items: Vec<serde_json::Value> = items
+            .into_iter()
+            .map(|(ap_id, object, _)| {
+                let create_id = Url::parse(&format!("{}/activity", ap_id)).expect("valid url");
+                serde_json::to_value(WithContext::new_default(CreateActivity {
+                    id: create_id,
+                    kind: CreateType::default(),
+                    actor: ObjectId::from(actor_url.clone()),
+                    object,
+                    to: vec![crate::urls::AS_PUBLIC.to_string()],
+                    cc: vec![followers_url.clone()],
+                    bto: vec![],
+                    bcc: vec![],
+                }))
+                .expect("serializable")
+            })
+            .collect();
+
+        let page_id = match &query.before {
+            Some(b) => format!("{}?page=true&before={}", outbox_url, b),
+            None => format!("{}?page=true", outbox_url),
+        };
+
+        let next = if has_more {
+            oldest_ts.map(|ts| {
+                // Use RFC 3339 with Z suffix (no + sign) to avoid percent-encoding
+                let ts_str = ts.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string();
+                format!("{}?page=true&before={}", outbox_url, ts_str)
+            })
+        } else {
+            None
+        };
+
+        Ok(axum::Json(OrderedCollectionPage {
+            context: crate::urls::AP_CONTEXT.to_string(),
+            kind: "OrderedCollectionPage".to_string(),
+            id: page_id,
+            part_of: outbox_url,
+            ordered_items,
+            next,
+        })
+        .into_response())
+    } else {
+        let total = data
+            .object_handler
+            .get_local_objects_for_user(uuid)
+            .await
+            .map_err(|e| Error::from(anyhow::anyhow!("{}", e)))?
+            .len() as u64;
+
+        Ok(axum::Json(OrderedCollection {
+            context: crate::urls::AP_CONTEXT.to_string(),
+            kind: "OrderedCollection".to_string(),
+            id: outbox_url.clone(),
+            total_items: total,
+            first: format!("{}?page=true", outbox_url),
+        })
+        .into_response())
+    }
+}

crates/adapters/activitypub-base/src/repository.rs

@@ -0,0 +1,134 @@
+use anyhow::Result;
+use async_trait::async_trait;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FollowerStatus {
+    Pending,
+    Accepted,
+    Rejected,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FollowingStatus {
+    Pending,
+    Accepted,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RemoteActor {
+    pub url: String,
+    pub handle: String,
+    pub inbox_url: String,
+    pub shared_inbox_url: Option<String>,
+    pub display_name: Option<String>,
+    pub avatar_url: Option<String>,
+    pub outbox_url: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Follower {
+    pub actor: RemoteActor,
+    pub status: FollowerStatus,
+}
+
+#[derive(Debug, Clone)]
+pub struct BlockedDomain {
+    pub domain: String,
+    pub reason: Option<String>,
+    pub blocked_at: String,
+}
+
+#[async_trait]
+pub trait FederationRepository: Send + Sync {
+    async fn add_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+        follow_activity_id: &str,
+    ) -> Result<()>;
+    async fn get_follower_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>>;
+    async fn remove_follower(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<()>;
+    async fn get_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<Follower>>;
+    async fn get_followers_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<Follower>>;
+    async fn count_followers(&self, local_user_id: uuid::Uuid) -> Result<usize>;
+    async fn get_following_page(
+        &self,
+        local_user_id: uuid::Uuid,
+        offset: u32,
+        limit: usize,
+    ) -> Result<Vec<RemoteActor>>;
+    async fn update_follower_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowerStatus,
+    ) -> Result<()>;
+    async fn add_following(
+        &self,
+        local_user_id: uuid::Uuid,
+        actor: RemoteActor,
+        follow_activity_id: &str,
+    ) -> Result<()>;
+    async fn get_follow_activity_id(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>>;
+    async fn remove_following(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()>;
+    async fn get_following(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>>;
+    async fn count_following(&self, local_user_id: uuid::Uuid) -> Result<usize>;
+    async fn upsert_remote_actor(&self, actor: RemoteActor) -> Result<()>;
+    async fn get_remote_actor(&self, actor_url: &str) -> Result<Option<RemoteActor>>;
+    async fn get_local_actor_keypair(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Option<(String, String)>>;
+    async fn save_local_actor_keypair(
+        &self,
+        user_id: uuid::Uuid,
+        public_key: String,
+        private_key: String,
+    ) -> Result<()>;
+    async fn get_pending_followers(&self, local_user_id: uuid::Uuid) -> Result<Vec<RemoteActor>>;
+    async fn update_following_status(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+        status: FollowingStatus,
+    ) -> Result<()>;
+    async fn get_following_outbox_url(
+        &self,
+        local_user_id: uuid::Uuid,
+        remote_actor_url: &str,
+    ) -> Result<Option<String>>;
+    async fn add_announce(
+        &self,
+        activity_id: &str,
+        object_url: &str,
+        actor_url: &str,
+        announced_at: chrono::DateTime<chrono::Utc>,
+    ) -> Result<()>;
+    async fn count_announces(&self, object_url: &str) -> Result<usize>;
+    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> Result<()>;
+    async fn remove_blocked_domain(&self, domain: &str) -> Result<()>;
+    async fn get_blocked_domains(&self) -> Result<Vec<BlockedDomain>>;
+    async fn is_domain_blocked(&self, domain: &str) -> Result<bool>;
+    async fn add_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()>;
+    async fn remove_blocked_actor(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<()>;
+    async fn get_blocked_actors(&self, local_user_id: uuid::Uuid) -> Result<Vec<String>>;
+    async fn is_actor_blocked(&self, local_user_id: uuid::Uuid, actor_url: &str) -> Result<bool>;
+}

crates/adapters/activitypub-base/src/tests/actors.rs

@@ -0,0 +1,49 @@
+use super::*;
+
+#[test]
+fn person_serializes_with_enriched_fields() {
+    let person = Person {
+        kind: Default::default(),
+        id: "https://example.com/users/1"
+            .parse::<url::Url>()
+            .unwrap()
+            .into(),
+        preferred_username: "alice".to_string(),
+        inbox: "https://example.com/users/1/inbox".parse().unwrap(),
+        outbox: "https://example.com/users/1/outbox".parse().unwrap(),
+        followers: "https://example.com/users/1/followers".parse().unwrap(),
+        following: "https://example.com/users/1/following".parse().unwrap(),
+        public_key: PublicKey {
+            id: "https://example.com/users/1#main-key".to_string(),
+            owner: "https://example.com/users/1".parse().unwrap(),
+            public_key_pem: "pem".to_string(),
+        },
+        name: Some("Alice".to_string()),
+        summary: Some("Bio text".to_string()),
+        icon: Some(ApImageObject {
+            kind: "Image".to_string(),
+            url: "https://example.com/images/avatars/1".parse().unwrap(),
+        }),
+        url: Some("https://example.com/u/alice".parse().unwrap()),
+        discoverable: Some(true),
+        manually_approves_followers: true,
+        updated: Some(Utc::now()),
+        endpoints: Some(Endpoints {
+            shared_inbox: "https://example.com/inbox".parse().unwrap(),
+        }),
+        image: None,
+        also_known_as: vec![],
+        attachment: vec![],
+    };
+    let json = serde_json::to_value(&person).unwrap();
+    assert_eq!(json["discoverable"], true);
+    assert_eq!(json["summary"], "Bio text");
+    assert_eq!(json["icon"]["type"], "Image");
+    assert_eq!(json["manuallyApprovesFollowers"], true);
+    assert!(json.get("updated").is_some());
+    assert!(json.get("endpoints").is_some());
+    assert_eq!(
+        json["endpoints"]["sharedInbox"],
+        "https://example.com/inbox"
+    );
+}

crates/adapters/activitypub-base/src/tests/nodeinfo.rs

@@ -0,0 +1,40 @@
+use super::*;
+
+#[test]
+fn nodeinfo_well_known_serializes_correctly() {
+    let doc = NodeInfoWellKnown {
+        links: vec![NodeInfoLink {
+            rel: "http://nodeinfo.diaspora.software/ns/schema/2.0".to_string(),
+            href: "https://example.com/nodeinfo/2.0".to_string(),
+        }],
+    };
+    let json = serde_json::to_value(&doc).unwrap();
+    assert_eq!(
+        json["links"][0]["rel"],
+        "http://nodeinfo.diaspora.software/ns/schema/2.0"
+    );
+    assert_eq!(json["links"][0]["href"], "https://example.com/nodeinfo/2.0");
+}
+
+#[test]
+fn nodeinfo_serializes_camel_case() {
+    let doc = NodeInfo {
+        version: "2.0".to_string(),
+        software: NodeInfoSoftware {
+            name: "my-app".to_string(),
+            version: "0.1.0".to_string(),
+        },
+        protocols: vec!["activitypub".to_string()],
+        usage: NodeInfoUsage {
+            users: NodeInfoUsers { total: 3 },
+            local_posts: 42,
+        },
+        open_registrations: false,
+    };
+    let json = serde_json::to_value(&doc).unwrap();
+    assert_eq!(json["version"], "2.0");
+    assert_eq!(json["software"]["name"], "my-app");
+    assert_eq!(json["usage"]["users"]["total"], 3);
+    assert_eq!(json["usage"]["localPosts"], 42);
+    assert_eq!(json["openRegistrations"], false);
+}

crates/adapters/activitypub-base/src/tests/service.rs

@@ -0,0 +1,75 @@
+fn _assert_impl_federation_lookup_port()
+where
+    crate::service::ActivityPubService: domain::ports::FederationLookupPort,
+{
+}
+
+fn _assert_impl_federation_follow_port()
+where
+    crate::service::ActivityPubService: domain::ports::FederationFollowPort,
+{
+}
+
+fn _assert_impl_federation_follow_request_port()
+where
+    crate::service::ActivityPubService: domain::ports::FederationFollowRequestPort,
+{
+}
+
+fn _assert_impl_federation_fetch_port()
+where
+    crate::service::ActivityPubService: domain::ports::FederationFetchPort,
+{
+}
+
+fn _assert_impl_federation_action_port()
+where
+    crate::service::ActivityPubService: domain::ports::FederationActionPort,
+{
+}
+
+use super::*;
+use crate::repository::{Follower, FollowerStatus, RemoteActor};
+
+fn make_follower(inbox: &str, shared: Option<&str>) -> Follower {
+    Follower {
+        actor: RemoteActor {
+            url: format!("https://remote/{}", inbox),
+            handle: "user".to_string(),
+            inbox_url: inbox.to_string(),
+            shared_inbox_url: shared.map(|s| s.to_string()),
+            display_name: None,
+            avatar_url: None,
+            outbox_url: None,
+        },
+        status: FollowerStatus::Accepted,
+    }
+}
+
+#[test]
+fn collect_inboxes_deduplicates_shared() {
+    let followers = vec![
+        make_follower(
+            "https://mastodon.social/users/a/inbox",
+            Some("https://mastodon.social/inbox"),
+        ),
+        make_follower(
+            "https://mastodon.social/users/b/inbox",
+            Some("https://mastodon.social/inbox"),
+        ),
+        make_follower("https://other.instance/users/c/inbox", None),
+    ];
+    let inboxes = collect_inboxes(&followers);
+    assert_eq!(inboxes.len(), 2);
+    let strs: Vec<_> = inboxes.iter().map(|u| u.as_str()).collect();
+    assert!(strs.contains(&"https://mastodon.social/inbox"));
+    assert!(strs.contains(&"https://other.instance/users/c/inbox"));
+}
+
+#[test]
+fn collect_inboxes_falls_back_to_individual_inbox() {
+    let followers = vec![make_follower("https://example.com/users/x/inbox", None)];
+    let inboxes = collect_inboxes(&followers);
+    assert_eq!(inboxes.len(), 1);
+    assert_eq!(inboxes[0].as_str(), "https://example.com/users/x/inbox");
+}

crates/adapters/activitypub-base/src/urls.rs

@@ -0,0 +1,33 @@
+use url::Url;
+
+use crate::error::Error;
+
+pub const AS_PUBLIC: &str = "https://www.w3.org/ns/activitystreams#Public";
+pub const AP_CONTEXT: &str = "https://www.w3.org/ns/activitystreams";
+pub const AP_PAGE_SIZE: usize = 20;
+
+pub fn extract_user_id_from_url(url: &Url) -> Option<uuid::Uuid> {
+    let path = url.path();
+    path.strip_prefix("/users/")
+        .and_then(|s| s.split('/').next())
+        .and_then(|s| uuid::Uuid::parse_str(s).ok())
+}
+
+pub fn activity_url(base_url: &str) -> Result<Url, Error> {
+    Url::parse(&format!("{}/activities/{}", base_url, uuid::Uuid::new_v4()))
+        .map_err(|e| Error::bad_request(anyhow::anyhow!(e)))
+}
+
+pub fn actor_url(base_url: &str, user_id: uuid::Uuid) -> Url {
+    Url::parse(&format!("{}/users/{}", base_url, user_id))
+        .expect("base_url is always a valid URL prefix")
+}
+
+/// Extract the username segment from a /users/:username URL.
+#[allow(dead_code)]
+pub fn extract_username_from_url(url: &Url) -> Option<String> {
+    url.path()
+        .strip_prefix("/users/")
+        .and_then(|s| s.split('/').next())
+        .map(|s| s.to_string())
+}

crates/adapters/activitypub-base/src/user.rs

@@ -0,0 +1,27 @@
+use async_trait::async_trait;
+use url::Url;
+
+#[derive(Debug, Clone)]
+pub struct ApProfileField {
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ApUser {
+    pub id: uuid::Uuid,
+    pub username: String,
+    pub bio: Option<String>,
+    pub avatar_url: Option<Url>,
+    pub banner_url: Option<Url>,
+    pub also_known_as: Option<String>,
+    pub profile_url: Option<Url>,
+    pub attachment: Vec<ApProfileField>,
+}
+
+#[async_trait]
+pub trait ApUserRepository: Send + Sync {
+    async fn find_by_id(&self, id: uuid::Uuid) -> anyhow::Result<Option<ApUser>>;
+    async fn find_by_username(&self, username: &str) -> anyhow::Result<Option<ApUser>>;
+    async fn count_users(&self) -> anyhow::Result<usize>;
+}

crates/adapters/activitypub-base/src/webfinger.rs

@@ -0,0 +1,38 @@
+use activitypub_federation::{
+    config::Data,
+    fetch::webfinger::{Webfinger, build_webfinger_response, extract_webfinger_name},
+};
+use axum::{
+    extract::Query,
+    http::header,
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::data::FederationData;
+use crate::error::Error;
+
+#[derive(Deserialize)]
+pub struct WebfingerQuery {
+    resource: String,
+}
+
+pub async fn webfinger_handler(
+    Query(query): Query<WebfingerQuery>,
+    data: Data<FederationData>,
+) -> Result<Response, Error> {
+    let name = extract_webfinger_name(&query.resource, &data)?;
+
+    let user = data
+        .user_repo
+        .find_by_username(name)
+        .await
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::not_found(anyhow::anyhow!("user not found")))?;
+
+    let ap_id = crate::urls::actor_url(&data.base_url, user.id);
+
+    let wf: Webfinger = build_webfinger_response(query.resource, ap_id);
+    let body = serde_json::to_string(&wf).map_err(|e| Error::from(anyhow::anyhow!(e)))?;
+    Ok(([(header::CONTENT_TYPE, "application/jrd+json")], body).into_response())
+}

crates/adapters/activitypub/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-k-ap = { version = "0.4.0", registry = "gitea" }
+activitypub-base       = { workspace = true }
 domain                 = { workspace = true }
 url                    = { workspace = true }
 serde                  = { workspace = true }
@@ -14,7 +14,3 @@ chrono = { workspace = true }
 uuid                   = { workspace = true }
 async-trait            = { workspace = true }
 tracing                = { workspace = true }
-reqwest = { workspace = true }
-futures = { workspace = true }
-tokio = { workspace = true }
-axum = { workspace = true }

crates/adapters/activitypub/src/handler.rs

@@ -7,20 +7,17 @@ use chrono::{DateTime, Utc};
 use std::sync::Arc;
 use url::Url;
 
-use crate::note::{ThoughtNote, ThoughtNoteInput};
+use crate::note::ThoughtNote;
-use crate::port::{AcceptNoteInput, ActivityPubRepository};
 use crate::urls::ThoughtsUrls;
-use domain::ports::{BoostRepository, EventPublisher, LikeRepository, TagRepository};
+use activitypub_base::{ActivityPubRepository, ApObjectHandler};
+use domain::ports::{EventPublisher, TagRepository};
 use domain::value_objects::UserId;
-use k_ap::{ApContentReader, ApObjectHandler};
 
 pub struct ThoughtsObjectHandler {
     repo: Arc<dyn ActivityPubRepository>,
     urls: ThoughtsUrls,
     event_publisher: Option<Arc<dyn EventPublisher>>,
     tag_repo: Arc<dyn TagRepository>,
-    likes: Arc<dyn LikeRepository>,
-    boosts: Arc<dyn BoostRepository>,
 }
 
 impl ThoughtsObjectHandler {
@@ -29,24 +26,53 @@ impl ThoughtsObjectHandler {
         base_url: &str,
         event_publisher: Option<Arc<dyn EventPublisher>>,
         tag_repo: Arc<dyn TagRepository>,
-        likes: Arc<dyn LikeRepository>,
-        boosts: Arc<dyn BoostRepository>,
     ) -> Self {
         Self {
             repo,
             urls: ThoughtsUrls::new(base_url),
             event_publisher,
             tag_repo,
-            likes,
-            boosts,
         }
     }
 }
 
-// ── ApContentReader ───────────────────────────────────────────────────────────
-
 #[async_trait]
-impl ApContentReader for ThoughtsObjectHandler {
+impl ApObjectHandler for ThoughtsObjectHandler {
+    async fn get_local_objects_for_user(
+        &self,
+        user_id: uuid::Uuid,
+    ) -> Result<Vec<(Url, serde_json::Value)>> {
+        let uid = UserId::from_uuid(user_id);
+        let entries = self
+            .repo
+            .outbox_entries_for_actor(&uid)
+            .await
+            .map_err(|e| anyhow!("{e}"))?;
+        entries
+            .into_iter()
+            .map(|e| {
+                let note_url = self.urls.thought_url(e.thought.id.as_uuid());
+                let actor_url = self.urls.user_url(e.author_username.as_str());
+                let followers = self.urls.user_followers(e.author_username.as_str());
+                let in_reply_to = e
+                    .thought
+                    .in_reply_to_id
+                    .map(|id| self.urls.thought_url(id.as_uuid()));
+                let note = ThoughtNote::new_public(
+                    note_url.clone(),
+                    actor_url,
+                    e.thought.content.as_str().to_owned(),
+                    e.thought.created_at,
+                    in_reply_to,
+                    e.thought.sensitive,
+                    e.thought.content_warning,
+                    followers,
+                );
+                Ok((note_url, serde_json::to_value(&note)?))
+            })
+            .collect()
+    }
+
     async fn get_local_objects_page(
         &self,
         user_id: uuid::Uuid,
@@ -64,59 +90,41 @@ impl ApContentReader for ThoughtsObjectHandler {
             .map(|e| {
                 let created_at = e.thought.created_at;
                 let note_url = self.urls.thought_url(e.thought.id.as_uuid());
-                let actor_url = self.urls.user_url(&user_id.to_string());
+                let actor_url = self.urls.user_url(e.author_username.as_str());
-                let followers = self.urls.user_followers(&user_id.to_string());
+                let followers = self.urls.user_followers(e.author_username.as_str());
                 let in_reply_to = e
                     .thought
                     .in_reply_to_id
                     .map(|id| self.urls.thought_url(id.as_uuid()));
-                let note = ThoughtNote::new_public(ThoughtNoteInput {
+                let note = ThoughtNote::new_public(
-                    id: note_url.clone(),
+                    note_url.clone(),
                     actor_url,
-                    content: e.thought.content.as_str().to_owned(),
+                    e.thought.content.as_str().to_owned(),
-                    published: created_at,
+                    created_at,
                     in_reply_to,
-                    sensitive: e.thought.sensitive,
+                    e.thought.sensitive,
-                    summary: e.thought.content_warning,
+                    e.thought.content_warning,
-                    followers_url: followers,
+                    followers,
-                });
+                );
                 Ok((note_url, serde_json::to_value(&note)?, created_at))
             })
             .collect()
     }
 
-    async fn count_local_posts(&self) -> Result<u64> {
-        self.repo
-            .count_local_notes()
-            .await
-            .map_err(|e| anyhow!("{e}"))
-    }
-}
-
-// ── ApObjectHandler ───────────────────────────────────────────────────────────
-
-#[async_trait]
-impl ApObjectHandler for ThoughtsObjectHandler {
     async fn on_create(
         &self,
         ap_id: &Url,
         actor_url: &Url,
         object: serde_json::Value,
     ) -> Result<()> {
-        let Some((note, note_extensions)) = ThoughtNote::try_from_ap(object) else {
+        let note: ThoughtNote = serde_json::from_value(object)?;
-            tracing::debug!(ap_id = %ap_id, "on_create: skipping non-Note object");
-            return Ok(());
-        };
         let author_id = self
             .repo
             .intern_remote_actor(actor_url.as_str())
             .await
             .map_err(|e| anyhow!("{e}"))?;
-        let _ = self
-            .repo
-            .sync_remote_actor_to_user(actor_url.as_str())
-            .await;
 
+        // Derive visibility from AP addressing conventions.
         let as_public = "https://www.w3.org/ns/activitystreams#Public";
         let in_to = note.to.iter().any(|s| s == as_public);
         let in_cc = note.cc.iter().any(|s| s == as_public);
@@ -133,22 +141,21 @@ impl ApObjectHandler for ThoughtsObjectHandler {
             "direct"
         };
 
-        let thought_id = self
+        let thought_id = self.repo
-            .repo
+            .accept_note(
-            .accept_note(AcceptNoteInput {
+                ap_id.as_str(),
-                ap_id: ap_id.as_str(),
+                &author_id,
-                author_id: &author_id,
+                &note.content,
-                content: &note.content,
+                note.published,
-                published: note.published,
+                note.sensitive,
-                sensitive: note.sensitive,
+                note.summary,
-                content_warning: note.summary,
                 visibility,
-                in_reply_to: note.in_reply_to.as_ref().map(|u| u.as_str()),
+                note.in_reply_to.as_ref().map(|u| u.as_str()),
-                note_extensions,
+            )
-            })
             .await
             .map_err(|e| anyhow!("{e}"))?;
 
+        // Extract and index hashtags from the AP tag array.
         let hashtag_names: Vec<String> = note
             .tag
             .iter()
@@ -164,6 +171,7 @@ impl ApObjectHandler for ThoughtsObjectHandler {
             }
         }
 
+        // Fire mention notifications for local @mentions in the note's tag array.
         let base_url = url::Url::parse(&self.urls.base_url)
             .ok()
             .and_then(|u| u.host_str().map(|h| h.to_string()))
@@ -204,51 +212,15 @@ impl ApObjectHandler for ThoughtsObjectHandler {
     async fn on_update(
         &self,
         ap_id: &Url,
-        actor_url: &Url,
+        _actor_url: &Url,
         object: serde_json::Value,
     ) -> Result<()> {
-        let obj_type = object.get("type").and_then(|v| v.as_str()).unwrap_or("");
+        let note: ThoughtNote = serde_json::from_value(object)?;
-        match obj_type {
-            "Note" | "Article" | "Page" => {
-                let Some((note, note_extensions)) = ThoughtNote::try_from_ap(object) else {
-                    return Ok(());
-                };
         self.repo
-                    .apply_note_update(ap_id.as_str(), &note.content, note_extensions)
+            .apply_note_update(ap_id.as_str(), &note.content)
             .await
             .map_err(|e| anyhow!("{e}"))
     }
-            "Person" | "Service" | "Application" | "Group" | "Organization" => {
-                let display_name = object.get("name").and_then(|v| v.as_str());
-                let avatar_url = object
-                    .get("icon")
-                    .and_then(|v| v.get("url"))
-                    .and_then(|v| v.as_str());
-                self.repo
-                    .update_remote_actor_display(
-                        &self
-                            .repo
-                            .find_remote_actor_id(actor_url.as_str())
-                            .await
-                            .map_err(|e| anyhow!("{e}"))?
-                            .ok_or_else(|| anyhow!("unknown actor"))?,
-                        display_name,
-                        avatar_url,
-                    )
-                    .await
-                    .map_err(|e| anyhow!("{e}"))?;
-                let _ = self
-                    .repo
-                    .sync_remote_actor_to_user(actor_url.as_str())
-                    .await;
-                Ok(())
-            }
-            _ => {
-                tracing::debug!(ap_id = %ap_id, obj_type, "on_update: skipping");
-                Ok(())
-            }
-        }
-    }
 
     async fn on_delete(&self, ap_id: &Url, _actor_url: &Url) -> Result<()> {
         self.repo
@@ -288,24 +260,14 @@ impl ApObjectHandler for ThoughtsObjectHandler {
         let actor_user_id = match actor_user_id {
             Some(id) => id,
             None => {
-                tracing::debug!(actor = %actor_url, "on_like: remote actor not interned, skipping");
+                tracing::debug!(actor = %actor_url, "on_like: remote actor not interned, skipping notification");
                 return Ok(());
             }
         };
 
+        if let Some(ep) = &self.event_publisher {
             let thought_id = domain::value_objects::ThoughtId::from_uuid(thought_uuid);
             let like_id = domain::value_objects::LikeId::new();
-
-        let like = domain::models::social::Like {
-            id: like_id.clone(),
-            user_id: actor_user_id.clone(),
-            thought_id: thought_id.clone(),
-            ap_id: Some(object_url.to_string()),
-            created_at: Utc::now(),
-        };
-        let _ = self.likes.save(&like).await;
-
-        if let Some(ep) = &self.event_publisher {
             ep.publish(&domain::events::DomainEvent::LikeAdded {
                 like_id,
                 user_id: actor_user_id,
@@ -347,13 +309,10 @@ impl ApObjectHandler for ThoughtsObjectHandler {
             }
         };
 
-        let thought_id = domain::value_objects::ThoughtId::from_uuid(thought_uuid);
-        let _ = self.likes.delete(&actor_user_id, &thought_id).await;
-
         if let Some(ep) = &self.event_publisher {
             ep.publish(&domain::events::DomainEvent::LikeRemoved {
                 user_id: actor_user_id,
-                thought_id,
+                thought_id: domain::value_objects::ThoughtId::from_uuid(thought_uuid),
             })
             .await
             .map_err(|e| anyhow!("{e}"))?;
@@ -425,19 +384,9 @@ impl ApObjectHandler for ThoughtsObjectHandler {
             None => return Ok(()),
         };
 
+        if let Some(ep) = &self.event_publisher {
             let thought_id = domain::value_objects::ThoughtId::from_uuid(thought_uuid);
             let boost_id = domain::value_objects::BoostId::new();
-
-        let boost = domain::models::social::Boost {
-            id: boost_id.clone(),
-            user_id: actor_user_id.clone(),
-            thought_id: thought_id.clone(),
-            ap_id: Some(object_url.to_string()),
-            created_at: Utc::now(),
-        };
-        let _ = self.boosts.save(&boost).await;
-
-        if let Some(ep) = &self.event_publisher {
             ep.publish(&domain::events::DomainEvent::BoostAdded {
                 boost_id,
                 user_id: actor_user_id,
@@ -450,45 +399,10 @@ impl ApObjectHandler for ThoughtsObjectHandler {
         Ok(())
     }
 
-    async fn on_announce_removed(&self, object_url: &Url, actor_url: &Url) -> Result<()> {
+    async fn count_local_posts(&self) -> Result<u64> {
-        let thought_uuid = object_url
+        self.repo
-            .path()
+            .count_local_notes()
-            .strip_prefix(THOUGHTS_PATH_PREFIX)
-            .and_then(|s| s.split('/').next())
-            .and_then(|s| uuid::Uuid::parse_str(s).ok());
-
-        let thought_uuid = match thought_uuid {
-            Some(u) => u,
-            None => return Ok(()),
-        };
-
-        let actor_user_id = self
-            .repo
-            .find_remote_actor_id(actor_url.as_str())
             .await
-            .map_err(|e| anyhow!("{e}"))?;
+            .map_err(|e| anyhow!("{e}"))
-
-        let actor_user_id = match actor_user_id {
-            Some(id) => id,
-            None => return Ok(()),
-        };
-
-        let thought_id = domain::value_objects::ThoughtId::from_uuid(thought_uuid);
-        let _ = self.boosts.delete(&actor_user_id, &thought_id).await;
-
-        if let Some(ep) = &self.event_publisher {
-            ep.publish(&domain::events::DomainEvent::BoostRemoved {
-                user_id: actor_user_id,
-                thought_id,
-            })
-            .await
-            .map_err(|e| anyhow!("{e}"))?;
-        }
-
-        Ok(())
-    }
-
-    async fn on_announce_of_remote(&self, _object_url: &Url, _actor_url: &Url) -> Result<()> {
-        Ok(())
     }
 }

crates/adapters/activitypub/src/lib.rs

@@ -1,62 +1,7 @@
 pub mod handler;
 pub mod note;
-pub mod port;
-pub mod service;
 pub mod urls;
 
-pub const INSTANCE_ACTOR_ID: uuid::Uuid =
-    uuid::Uuid::from_bytes([0, 0, 0, 0, 0, 0, 0x40, 0, 0x80, 0, 0, 0, 0, 0, 0, 0]);
-
 pub use handler::ThoughtsObjectHandler;
 pub use note::ThoughtNote;
-pub use port::{
-    AcceptNoteInput, ActivityPubRepository, ActorApUrls, OutboundFederationPort, OutboxEntry,
-};
-pub use service::ApFederationAdapter;
 pub use urls::ThoughtsUrls;
-
-use domain::ports::RemoteActorConnectionRepository;
-use k_ap::ActivityPubService;
-use std::sync::Arc;
-
-pub struct ApServiceConfig {
-    pub base_url: String,
-    pub activity_repo: Arc<dyn k_ap::ActivityRepository>,
-    pub follow_repo: Arc<dyn k_ap::FollowRepository>,
-    pub actor_repo: Arc<dyn k_ap::ActorRepository>,
-    pub blocklist_repo: Arc<dyn k_ap::BlocklistRepository>,
-    pub user_repo: Arc<dyn k_ap::ApUserRepository>,
-    pub ap_handler: Arc<ThoughtsObjectHandler>,
-    pub connections_repo: Arc<dyn RemoteActorConnectionRepository>,
-    pub event_publisher: Option<Arc<dyn k_ap::data::EventPublisher>>,
-    pub allow_registration: bool,
-    pub debug: bool,
-}
-
-pub async fn build_ap_service(
-    cfg: ApServiceConfig,
-) -> (Arc<ActivityPubService>, Arc<ApFederationAdapter>) {
-    let mut builder = ActivityPubService::builder(cfg.base_url)
-        .activity_repo(cfg.activity_repo)
-        .follow_repo(cfg.follow_repo)
-        .actor_repo(cfg.actor_repo)
-        .blocklist_repo(cfg.blocklist_repo)
-        .user_repo(cfg.user_repo)
-        .content_reader(cfg.ap_handler.clone())
-        .object_handler(cfg.ap_handler)
-        .allow_registration(cfg.allow_registration)
-        .software_name("thoughts")
-        .debug(cfg.debug)
-        .signed_fetch_actor_id(INSTANCE_ACTOR_ID);
-    if let Some(publisher) = cfg.event_publisher {
-        builder = builder.event_publisher(publisher);
-    }
-    let raw = Arc::new(
-        builder
-            .build()
-            .await
-            .expect("Failed to build ActivityPubService"),
-    );
-    let adapter = Arc::new(ApFederationAdapter::new(raw.clone(), cfg.connections_repo));
-    (raw, adapter)
-}

crates/adapters/activitypub/src/note/mod.rs

@@ -1,40 +1,9 @@
+use activitypub_base::NoteType;
+use activitypub_base::AS_PUBLIC;
 use chrono::{DateTime, Utc};
-use k_ap::NoteType;
-use k_ap::AS_PUBLIC;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
-const STANDARD_NOTE_FIELDS: &[&str] = &[
-    "type",
-    "id",
-    "attributedTo",
-    "content",
-    "published",
-    "to",
-    "cc",
-    "inReplyTo",
-    "sensitive",
-    "summary",
-    "tag",
-    "url",
-    "@context",
-    "mediaType",
-];
-
-pub fn extract_extensions(obj: &serde_json::Value) -> Option<serde_json::Value> {
-    let extensions: serde_json::Map<String, serde_json::Value> = obj
-        .as_object()?
-        .iter()
-        .filter(|(k, _)| !STANDARD_NOTE_FIELDS.contains(&k.as_str()))
-        .map(|(k, v)| (k.clone(), v.clone()))
-        .collect();
-    if extensions.is_empty() {
-        None
-    } else {
-        Some(serde_json::Value::Object(extensions))
-    }
-}
-
 /// AP Note representing a Thought.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -42,8 +11,7 @@ pub struct ThoughtNote {
     #[serde(rename = "type")]
     pub kind: NoteType,
     pub id: Url,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub url: Url, // Mastodon uses this as the clickable link
-    pub url: Option<Url>,
     pub attributed_to: Url,
     pub content: String,
     pub published: DateTime<Utc>,
@@ -53,7 +21,6 @@ pub struct ThoughtNote {
     pub cc: Vec<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub in_reply_to: Option<Url>,
-    #[serde(default)]
     pub sensitive: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub summary: Option<String>,
@@ -61,46 +28,30 @@ pub struct ThoughtNote {
     pub tag: Vec<serde_json::Value>,
 }
 
-pub struct ThoughtNoteInput {
-    pub id: Url,
-    pub actor_url: Url,
-    pub content: String,
-    pub published: DateTime<Utc>,
-    pub in_reply_to: Option<Url>,
-    pub sensitive: bool,
-    pub summary: Option<String>,
-    pub followers_url: Url,
-}
-
 impl ThoughtNote {
-    /// Returns `(note, extensions)` if `value` is a Note object, `None` otherwise.
+    #[allow(clippy::too_many_arguments)]
-    pub fn try_from_ap(mut value: serde_json::Value) -> Option<(Self, Option<serde_json::Value>)> {
+    pub fn new_public(
-        let obj_type = value.get("type").and_then(|v| v.as_str());
+        id: Url,
-        if !matches!(obj_type, Some("Note" | "Article" | "Page")) {
+        actor_url: Url,
-            return None;
+        content: String,
-        }
+        published: DateTime<Utc>,
-        let extensions = extract_extensions(&value);
+        in_reply_to: Option<Url>,
-        if let Some(obj) = value.as_object_mut() {
+        sensitive: bool,
-            obj.insert("type".to_string(), serde_json::json!("Note"));
+        summary: Option<String>,
-        }
+        followers_url: Url,
-        serde_json::from_value(value)
+    ) -> Self {
-            .ok()
-            .map(|note| (note, extensions))
-    }
-
-    pub fn new_public(p: ThoughtNoteInput) -> Self {
         Self {
             kind: Default::default(),
-            url: Some(p.id.clone()),
+            url: id.clone(),
-            id: p.id,
+            id,
-            attributed_to: p.actor_url,
+            attributed_to: actor_url,
-            content: p.content,
+            content,
-            published: p.published,
+            published,
             to: vec![AS_PUBLIC.to_string()],
-            cc: vec![p.followers_url.to_string()],
+            cc: vec![followers_url.to_string()],
-            in_reply_to: p.in_reply_to,
+            in_reply_to,
-            sensitive: p.sensitive,
+            sensitive,
-            summary: p.summary,
+            summary,
             tag: Vec::new(),
         }
     }

crates/adapters/activitypub/src/note/tests.rs

@@ -1,67 +1,17 @@
 use super::*;
 
-#[test]
-fn extract_extensions_picks_up_non_standard_fields() {
-    let obj = serde_json::json!({
-        "type": "Note",
-        "id": "https://example.com/notes/1",
-        "content": "hello",
-        "published": "2025-01-01T00:00:00Z",
-        "movieTitle": "Dune",
-        "rating": 5,
-        "posterUrl": "https://example.com/poster.jpg"
-    });
-    let ext = extract_extensions(&obj).unwrap();
-    assert_eq!(ext["movieTitle"], "Dune");
-    assert_eq!(ext["rating"], 5);
-    assert_eq!(ext["posterUrl"], "https://example.com/poster.jpg");
-    assert!(ext.get("type").is_none());
-    assert!(ext.get("content").is_none());
-    assert!(ext.get("id").is_none());
-}
-
-#[test]
-fn extract_extensions_returns_none_for_standard_only_note() {
-    let obj = serde_json::json!({
-        "type": "Note",
-        "content": "hello",
-        "published": "2025-01-01T00:00:00Z",
-        "to": ["https://www.w3.org/ns/activitystreams#Public"],
-        "tag": []
-    });
-    assert!(extract_extensions(&obj).is_none());
-}
-
-#[test]
-fn extract_extensions_returns_none_for_non_object() {
-    let obj = serde_json::json!("not an object");
-    assert!(extract_extensions(&obj).is_none());
-}
-
-#[test]
-fn try_from_ap_returns_none_for_person() {
-    let person = serde_json::json!({ "type": "Person", "id": "https://example.com/users/1" });
-    assert!(ThoughtNote::try_from_ap(person).is_none());
-}
-
-#[test]
-fn try_from_ap_returns_none_for_missing_type() {
-    let obj = serde_json::json!({ "content": "hello" });
-    assert!(ThoughtNote::try_from_ap(obj).is_none());
-}
-
 #[test]
 fn note_serializes_with_public_audience() {
-    let note = ThoughtNote::new_public(super::ThoughtNoteInput {
+    let note = ThoughtNote::new_public(
-        id: "https://example.com/thoughts/1".parse().unwrap(),
+        "https://example.com/thoughts/1".parse().unwrap(),
-        actor_url: "https://example.com/users/alice".parse().unwrap(),
+        "https://example.com/users/alice".parse().unwrap(),
-        content: "Hello world".to_string(),
+        "Hello world".to_string(),
-        published: chrono::Utc::now(),
+        chrono::Utc::now(),
-        in_reply_to: None,
+        None,
-        sensitive: false,
+        false,
-        summary: None,
+        None,
-        followers_url: "https://example.com/users/alice/followers".parse().unwrap(),
+        "https://example.com/users/alice/followers".parse().unwrap(),
-    });
+    );
     let json = serde_json::to_string(&note).unwrap();
     assert!(json.contains(AS_PUBLIC));
     assert!(json.contains("Hello world"));

crates/adapters/activitypub/src/port.rs

@@ -1,5 +0,0 @@
-pub use domain::ports::{
-    AcceptNoteInput, ActorFederationUrls as ActorApUrls,
-    FederationBroadcastPort as OutboundFederationPort,
-    FederationContentRepository as ActivityPubRepository, OutboxEntry,
-};

crates/adapters/activitypub/src/service.rs

@@ -1,916 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use k_ap::ActivityPubService;
-
-use domain::{
-    errors::DomainError,
-    models::remote_actor::RemoteActor as DomainRemoteActor,
-    ports::{
-        FederationFetchPort, FederationFollowPort, FederationFollowRequestPort,
-        FederationLookupPort, FederationSchedulerPort, RemoteActorConnectionRepository,
-    },
-    value_objects::UserId,
-};
-
-const HTTP_FETCH_TIMEOUT_SECS: u64 = 30;
-const BATCH_FETCH_SLEEP_MS: u64 = 100;
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-fn content_to_html(text: &str) -> String {
-    let escaped = text
-        .replace('&', "&")
-        .replace('<', "&lt;")
-        .replace('>', "&gt;")
-        .replace('"', "&quot;")
-        .replace('\'', "&#39;");
-    let paragraphs: Vec<&str> = escaped.split('\n').filter(|s| !s.is_empty()).collect();
-    if paragraphs.is_empty() {
-        format!("<p>{}</p>", escaped)
-    } else {
-        paragraphs
-            .iter()
-            .map(|p| format!("<p>{}</p>", p))
-            .collect::<Vec<_>>()
-            .join("")
-    }
-}
-
-fn build_note_json(
-    thought: &domain::models::thought::Thought,
-    local_actor_ap_id: &str,
-    local_actor_followers_url: &str,
-    base_url: &str,
-    in_reply_to_url: Option<&str>,
-) -> serde_json::Value {
-    let ap_id = format!("{}/thoughts/{}", base_url, thought.id);
-
-    let (to, cc) = match thought.visibility {
-        domain::models::thought::Visibility::Public => (
-            vec![k_ap::AS_PUBLIC.to_string()],
-            vec![local_actor_followers_url.to_string()],
-        ),
-        domain::models::thought::Visibility::Unlisted => (
-            vec![local_actor_followers_url.to_string()],
-            vec![k_ap::AS_PUBLIC.to_string()],
-        ),
-        domain::models::thought::Visibility::Followers => {
-            (vec![local_actor_followers_url.to_string()], vec![])
-        }
-        domain::models::thought::Visibility::Direct => (vec![], vec![]),
-    };
-
-    let mut note = serde_json::json!({
-        "type": "Note",
-        "id": ap_id,
-        "url": ap_id,
-        "attributedTo": local_actor_ap_id,
-        "content": content_to_html(thought.content.as_str()),
-        "published": thought.created_at.to_rfc3339(),
-        "to": to,
-        "cc": cc,
-        "sensitive": thought.sensitive,
-    });
-    if let Some(ref cw) = thought.content_warning {
-        note["summary"] = serde_json::json!(cw);
-    }
-    if let Some(reply_url) = in_reply_to_url {
-        note["inReplyTo"] = serde_json::json!(reply_url);
-    }
-    if let Some(updated_at) = thought.updated_at {
-        note["updated"] = serde_json::json!(updated_at.to_rfc3339());
-    }
-    let hashtags = domain::hashtag::extract(thought.content.as_str());
-    if !hashtags.is_empty() {
-        let ap_tags: Vec<serde_json::Value> = hashtags
-            .iter()
-            .map(|h| {
-                serde_json::json!({
-                    "type": "Hashtag",
-                    "name": h.ap_name,
-                    "href": format!("{}/{}", base_url, h.url_slug),
-                })
-            })
-            .collect();
-        note["tag"] = serde_json::json!(ap_tags);
-    }
-    if let Some(ref mood) = thought.mood {
-        note["mood"] = serde_json::json!(mood);
-    }
-    if let Some(ref ext) = thought.note_extensions {
-        if let Some(obj) = ext.as_object() {
-            for (k, v) in obj {
-                note.as_object_mut().unwrap().entry(k).or_insert(v.clone());
-            }
-        }
-    }
-    note
-}
-
-fn thought_to_ap_visibility(v: &domain::models::thought::Visibility) -> k_ap::ApVisibility {
-    match v {
-        domain::models::thought::Visibility::Public => k_ap::ApVisibility::Public,
-        domain::models::thought::Visibility::Unlisted => k_ap::ApVisibility::Public,
-        domain::models::thought::Visibility::Followers => k_ap::ApVisibility::FollowersOnly,
-        domain::models::thought::Visibility::Direct => k_ap::ApVisibility::Private,
-    }
-}
-
-fn k_ap_actor_to_domain(a: k_ap::RemoteActor) -> DomainRemoteActor {
-    DomainRemoteActor {
-        url: a.url,
-        handle: a.handle,
-        display_name: a.display_name,
-        avatar_url: a.avatar_url,
-        outbox_url: a.outbox_url,
-        last_fetched_at: a.fetched_at.unwrap_or_else(chrono::Utc::now),
-        bio: a.bio,
-        banner_url: a.banner_url,
-        also_known_as: a.also_known_as,
-        followers_url: a.followers_url,
-        following_url: a.following_url,
-        inbox_url: Some(a.inbox_url),
-        shared_inbox_url: a.shared_inbox_url,
-        attachment: vec![],
-    }
-}
-
-async fn resolve_actor_profiles_from_urls(
-    urls: Vec<String>,
-) -> Vec<domain::models::actor_connection_summary::ActorConnectionSummary> {
-    use futures::future;
-
-    async fn fetch_one(
-        url: String,
-    ) -> Option<domain::models::actor_connection_summary::ActorConnectionSummary> {
-        let resp: serde_json::Value = tokio::time::timeout(
-            std::time::Duration::from_secs(5),
-            reqwest::Client::new()
-                .get(&url)
-                .header("Accept", "application/activity+json")
-                .send(),
-        )
-        .await
-        .ok()?
-        .ok()?
-        .json()
-        .await
-        .ok()?;
-
-        let ap_url = resp["id"].as_str()?.to_string();
-        let preferred_username = resp["preferredUsername"].as_str().unwrap_or("").to_string();
-        let domain_str = url::Url::parse(&ap_url)
-            .ok()
-            .and_then(|u| u.host_str().map(|s| s.to_string()))
-            .unwrap_or_default();
-        let handle = format!("{}@{}", preferred_username, domain_str);
-        let display_name = resp["name"].as_str().map(|s| s.to_string());
-        let avatar_url = resp["icon"]["url"].as_str().map(|s| s.to_string());
-
-        Some(
-            domain::models::actor_connection_summary::ActorConnectionSummary {
-                url: ap_url,
-                handle,
-                display_name,
-                avatar_url,
-            },
-        )
-    }
-
-    let futs: Vec<_> = urls.into_iter().map(fetch_one).collect();
-    let results = future::join_all(futs).await;
-
-    results
-        .into_iter()
-        .filter_map(|r| {
-            if r.is_none() {
-                tracing::warn!("failed to resolve actor profile (timeout or parse error)");
-            }
-            r
-        })
-        .collect()
-}
-
-async fn webfinger_resolve_actor_url(handle: &str) -> anyhow::Result<String> {
-    let normalized = handle.trim_start_matches('@');
-    let at = normalized
-        .rfind('@')
-        .ok_or_else(|| anyhow::anyhow!("handle must be user@domain"))?;
-    let (user, domain_str) = (&normalized[..at], &normalized[at + 1..]);
-    let wf_url = format!(
-        "https://{}/.well-known/webfinger?resource=acct:{}@{}",
-        domain_str, user, domain_str
-    );
-    let wf: serde_json::Value = reqwest::Client::new()
-        .get(&wf_url)
-        .header("Accept", "application/jrd+json, application/json")
-        .send()
-        .await?
-        .json()
-        .await?;
-    let self_href = wf["links"]
-        .as_array()
-        .and_then(|links| {
-            links.iter().find(|l| {
-                l["rel"].as_str() == Some("self")
-                    && l["type"].as_str().is_some_and(|t| {
-                        t == "application/activity+json" || t.starts_with("application/ld+json")
-                    })
-            })
-        })
-        .and_then(|l| l["href"].as_str())
-        .ok_or_else(|| anyhow::anyhow!("no self link in WebFinger response"))?
-        .to_owned();
-    Ok(self_href)
-}
-
-// ── ApFederationAdapter ───────────────────────────────────────────────────────
-
-/// Wraps `k_ap::ActivityPubService` together with the `RemoteActorConnectionRepository`
-/// (which k-ap doesn't own), and implements all domain federation port traits.
-#[derive(Clone)]
-pub struct ApFederationAdapter {
-    pub(crate) inner: Arc<ActivityPubService>,
-    pub(crate) connections_repo: Arc<dyn RemoteActorConnectionRepository>,
-}
-
-impl ApFederationAdapter {
-    pub fn new(
-        inner: Arc<ActivityPubService>,
-        connections_repo: Arc<dyn RemoteActorConnectionRepository>,
-    ) -> Self {
-        Self {
-            inner,
-            connections_repo,
-        }
-    }
-
-    pub fn router<S>(&self) -> axum::Router<S>
-    where
-        S: Clone + Send + Sync + 'static,
-    {
-        self.inner.router()
-    }
-
-    fn base_url(&self) -> &str {
-        self.inner.base_url()
-    }
-
-    fn actor_ap_id(&self, user_uuid: uuid::Uuid) -> String {
-        format!("{}/users/{}", self.base_url(), user_uuid)
-    }
-
-    fn actor_followers_url(&self, user_uuid: uuid::Uuid) -> String {
-        format!("{}/followers", self.actor_ap_id(user_uuid))
-    }
-}
-
-// ── OutboundFederationPort ────────────────────────────────────────────────────
-
-#[async_trait]
-impl crate::port::OutboundFederationPort for ApFederationAdapter {
-    async fn broadcast_create(
-        &self,
-        author_user_id: &UserId,
-        thought: &domain::models::thought::Thought,
-        _author_username: &str,
-        in_reply_to_url: Option<&str>,
-    ) -> Result<(), DomainError> {
-        let user_uuid = author_user_id.as_uuid();
-        let ap_id = self.actor_ap_id(user_uuid);
-        let followers_url = self.actor_followers_url(user_uuid);
-        let note = build_note_json(
-            thought,
-            &ap_id,
-            &followers_url,
-            self.base_url(),
-            in_reply_to_url,
-        );
-        self.inner
-            .broadcast_create_note(
-                user_uuid,
-                note,
-                thought_to_ap_visibility(&thought.visibility),
-                vec![],
-            )
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_delete(
-        &self,
-        author_user_id: &UserId,
-        thought_ap_id: &str,
-    ) -> Result<(), DomainError> {
-        let ap_id =
-            url::Url::parse(thought_ap_id).map_err(|e| DomainError::Internal(e.to_string()))?;
-        self.inner
-            .broadcast_delete_to_followers(author_user_id.as_uuid(), ap_id)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_update(
-        &self,
-        author_user_id: &UserId,
-        thought: &domain::models::thought::Thought,
-        _author_username: &str,
-        in_reply_to_url: Option<&str>,
-    ) -> Result<(), DomainError> {
-        let user_uuid = author_user_id.as_uuid();
-        let ap_id = self.actor_ap_id(user_uuid);
-        let followers_url = self.actor_followers_url(user_uuid);
-        let note = build_note_json(
-            thought,
-            &ap_id,
-            &followers_url,
-            self.base_url(),
-            in_reply_to_url,
-        );
-        self.inner
-            .broadcast_update_note(
-                user_uuid,
-                note,
-                thought_to_ap_visibility(&thought.visibility),
-                vec![],
-            )
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_announce(
-        &self,
-        booster_user_id: &UserId,
-        object_ap_id: &str,
-    ) -> Result<(), DomainError> {
-        let ap_id =
-            url::Url::parse(object_ap_id).map_err(|e| DomainError::Internal(e.to_string()))?;
-        self.inner
-            .broadcast_announce_to_followers(booster_user_id.as_uuid(), ap_id)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_undo_announce(
-        &self,
-        booster_user_id: &UserId,
-        object_ap_id: &str,
-    ) -> Result<(), DomainError> {
-        let ap_id =
-            url::Url::parse(object_ap_id).map_err(|e| DomainError::Internal(e.to_string()))?;
-        self.inner
-            .broadcast_undo_announce_to_followers(booster_user_id.as_uuid(), ap_id)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_like(
-        &self,
-        liker_user_id: &UserId,
-        object_ap_id: &str,
-        author_inbox_url: &str,
-    ) -> Result<(), DomainError> {
-        let object =
-            url::Url::parse(object_ap_id).map_err(|e| DomainError::Internal(e.to_string()))?;
-        let inbox =
-            url::Url::parse(author_inbox_url).map_err(|e| DomainError::Internal(e.to_string()))?;
-        self.inner
-            .broadcast_like_to_inbox(liker_user_id.as_uuid(), object, inbox)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_undo_like(
-        &self,
-        liker_user_id: &UserId,
-        object_ap_id: &str,
-        author_inbox_url: &str,
-    ) -> Result<(), DomainError> {
-        let object =
-            url::Url::parse(object_ap_id).map_err(|e| DomainError::Internal(e.to_string()))?;
-        let inbox =
-            url::Url::parse(author_inbox_url).map_err(|e| DomainError::Internal(e.to_string()))?;
-        self.inner
-            .broadcast_undo_like_to_inbox(liker_user_id.as_uuid(), object, inbox)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn broadcast_actor_update(&self, user_id: &UserId) -> Result<(), DomainError> {
-        self.inner
-            .broadcast_actor_update(user_id.as_uuid())
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-}
-
-// ── FederationSchedulerPort ───────────────────────────────────────────────────
-
-#[async_trait]
-impl FederationSchedulerPort for ApFederationAdapter {
-    async fn schedule_actor_posts_fetch(
-        &self,
-        actor_ap_url: &str,
-        outbox_url: &str,
-    ) -> Result<(), DomainError> {
-        let service = self.inner.clone();
-        let actor = actor_ap_url.to_string();
-        let outbox = outbox_url.to_string();
-        tokio::spawn(async move {
-            if let Err(e) = service.import_remote_outbox(&outbox, &actor).await {
-                tracing::warn!(actor = %actor, error = %e, "posts backfill failed");
-            }
-        });
-        Ok(())
-    }
-
-    async fn schedule_connections_fetch(
-        &self,
-        actor_ap_url: &str,
-        collection_url: &str,
-        connection_type: &str,
-        _page: u32,
-    ) -> Result<(), DomainError> {
-        let actor = actor_ap_url.to_string();
-        let collection = collection_url.to_string();
-        let conn_type = connection_type.to_string();
-        let connections_repo = self.connections_repo.clone();
-        tokio::spawn(async move {
-            let client = match reqwest::Client::builder()
-                .timeout(std::time::Duration::from_secs(HTTP_FETCH_TIMEOUT_SECS))
-                .build()
-            {
-                Ok(c) => c,
-                Err(e) => {
-                    tracing::warn!(error = %e, "connections fetch: failed to build client");
-                    return;
-                }
-            };
-
-            let mut all_urls: Vec<String> = Vec::new();
-            let mut current_url: Option<String> = Some(collection.clone());
-            const MAX_ACTORS: usize = 500;
-
-            while let Some(url) = current_url.take() {
-                let val: serde_json::Value = match client
-                    .get(&url)
-                    .header("Accept", "application/activity+json, application/ld+json")
-                    .send()
-                    .await
-                {
-                    Ok(r) => match r.json().await {
-                        Ok(v) => v,
-                        Err(e) => {
-                            tracing::warn!(error = %e, url = %url, "connections: parse error");
-                            break;
-                        }
-                    },
-                    Err(e) => {
-                        tracing::warn!(error = %e, url = %url, "connections: HTTP error");
-                        break;
-                    }
-                };
-
-                if val["type"].as_str() == Some("OrderedCollection") {
-                    current_url = val["first"].as_str().map(|s| s.to_string());
-                    continue;
-                }
-
-                let empty = vec![];
-                let items = val["orderedItems"].as_array().unwrap_or(&empty);
-                for item in items {
-                    let actor_url = item.as_str().or_else(|| item["id"].as_str()).unwrap_or("");
-                    if !actor_url.is_empty() {
-                        all_urls.push(actor_url.to_string());
-                    }
-                }
-
-                if all_urls.len() >= MAX_ACTORS {
-                    break;
-                }
-                current_url = val["next"].as_str().map(|s| s.to_string());
-                if current_url.is_some() {
-                    tokio::time::sleep(std::time::Duration::from_millis(BATCH_FETCH_SLEEP_MS))
-                        .await;
-                }
-            }
-
-            if all_urls.is_empty() {
-                tracing::debug!(
-                    actor = %actor,
-                    connection_type = %conn_type,
-                    "connections: empty collection"
-                );
-                return;
-            }
-
-            const PAGE_SIZE: usize = 20;
-            for (idx, chunk) in all_urls.chunks(PAGE_SIZE).enumerate() {
-                let page_num = (idx + 1) as u32;
-                let resolved = resolve_actor_profiles_from_urls(chunk.to_vec()).await;
-                if let Err(e) = connections_repo
-                    .upsert_connections(&actor, &conn_type, page_num, &resolved)
-                    .await
-                {
-                    tracing::warn!(error = %e, "connections: upsert failed");
-                }
-            }
-
-            tracing::debug!(
-                actor = %actor,
-                connection_type = %conn_type,
-                count = all_urls.len(),
-                "connections fetch complete"
-            );
-        });
-        Ok(())
-    }
-}
-
-// ── FederationLookupPort ──────────────────────────────────────────────────────
-
-#[async_trait]
-impl FederationLookupPort for ApFederationAdapter {
-    async fn lookup_actor(&self, handle: &str) -> Result<DomainRemoteActor, DomainError> {
-        let actor = self
-            .inner
-            .lookup_actor_by_handle(handle)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-
-        Ok(DomainRemoteActor {
-            url: actor.ap_url.to_string(),
-            handle: actor.handle,
-            display_name: actor.display_name,
-            avatar_url: actor.avatar_url.as_ref().map(|u| u.to_string()),
-            outbox_url: actor.outbox_url.as_ref().map(|u| u.to_string()),
-            last_fetched_at: chrono::Utc::now(),
-            bio: actor.bio,
-            banner_url: actor.banner_url.as_ref().map(|u| u.to_string()),
-            also_known_as: actor
-                .also_known_as
-                .into_iter()
-                .map(|u| u.to_string())
-                .collect(),
-            followers_url: actor.followers_url.as_ref().map(|u| u.to_string()),
-            following_url: actor.following_url.as_ref().map(|u| u.to_string()),
-            inbox_url: None,
-            shared_inbox_url: None,
-            attachment: actor
-                .attachment
-                .into_iter()
-                .map(|f| (f.name, f.value))
-                .collect(),
-        })
-    }
-
-    async fn actor_json(&self, user_id: &UserId) -> Result<String, DomainError> {
-        self.inner
-            .actor_json(&user_id.as_uuid().to_string())
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn followers_collection_json(
-        &self,
-        user_id: &UserId,
-        page: Option<u32>,
-    ) -> Result<String, DomainError> {
-        self.inner
-            .followers_collection_json(user_id.as_uuid(), page)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn following_collection_json(
-        &self,
-        user_id: &UserId,
-        page: Option<u32>,
-    ) -> Result<String, DomainError> {
-        self.inner
-            .following_collection_json(user_id.as_uuid(), page)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-}
-
-// ── FederationFetchPort ───────────────────────────────────────────────────────
-
-#[async_trait]
-impl FederationFetchPort for ApFederationAdapter {
-    async fn fetch_outbox_page(
-        &self,
-        outbox_url: &str,
-        page: u32,
-    ) -> Result<Vec<domain::models::remote_note::RemoteNote>, DomainError> {
-        use chrono::DateTime;
-
-        let client = reqwest::Client::new();
-        let base: serde_json::Value = client
-            .get(outbox_url)
-            .header("Accept", "application/activity+json, application/ld+json")
-            .send()
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?
-            .json()
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-
-        let first_url = base["first"]
-            .as_str()
-            .map(|s| s.to_string())
-            .unwrap_or_else(|| format!("{}?page=1", outbox_url));
-
-        let mut current_url = first_url;
-        let mut hops = 0u32;
-        let target_page = page.max(1);
-        let max_hops = 10u32;
-
-        let resp: serde_json::Value = loop {
-            let page_resp: serde_json::Value = client
-                .get(&current_url)
-                .header("Accept", "application/activity+json, application/ld+json")
-                .send()
-                .await
-                .map_err(|e| DomainError::ExternalService(e.to_string()))?
-                .json()
-                .await
-                .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-
-            hops += 1;
-            if hops >= target_page || hops >= max_hops {
-                break page_resp;
-            }
-            match page_resp["next"].as_str() {
-                Some(next) => current_url = next.to_string(),
-                None => break page_resp,
-            }
-        };
-
-        let empty = vec![];
-        let items = resp["orderedItems"].as_array().unwrap_or(&empty);
-
-        let notes = items
-            .iter()
-            .filter_map(|item| {
-                let note = if item["type"].as_str() == Some("Create") {
-                    &item["object"]
-                } else if item["type"].as_str() == Some("Note") {
-                    item
-                } else {
-                    return None;
-                };
-
-                let to = note["to"].as_array()?;
-                let is_public = to
-                    .iter()
-                    .any(|t| t.as_str() == Some("https://www.w3.org/ns/activitystreams#Public"));
-                if !is_public {
-                    return None;
-                }
-
-                let published = DateTime::parse_from_rfc3339(note["published"].as_str()?)
-                    .ok()?
-                    .with_timezone(&chrono::Utc);
-
-                let text = note["content"].as_str().unwrap_or("").to_string();
-                let has_attachments = note["attachment"]
-                    .as_array()
-                    .map(|a| !a.is_empty())
-                    .unwrap_or(false);
-
-                let content = if has_attachments {
-                    let notice =
-                        "<p class=\"media-notice\">📎 Media attachment — not supported</p>";
-                    if text.is_empty() {
-                        notice.to_string()
-                    } else {
-                        format!("{text}{notice}")
-                    }
-                } else {
-                    text
-                };
-
-                Some(domain::models::remote_note::RemoteNote {
-                    ap_id: note["id"].as_str()?.to_string(),
-                    content,
-                    published,
-                    sensitive: note["sensitive"].as_bool().unwrap_or(false),
-                    content_warning: note["summary"].as_str().map(|s| s.to_string()),
-                })
-            })
-            .collect();
-
-        Ok(notes)
-    }
-
-    async fn fetch_actor_urls_from_collection(
-        &self,
-        collection_url: &str,
-    ) -> Result<Vec<String>, DomainError> {
-        let client = reqwest::Client::new();
-        let base: serde_json::Value = client
-            .get(collection_url)
-            .header("Accept", "application/activity+json, application/ld+json")
-            .send()
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?
-            .json()
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-
-        let page = if base["orderedItems"].is_null() {
-            if let Some(first_url) = base["first"].as_str() {
-                client
-                    .get(first_url)
-                    .header("Accept", "application/activity+json, application/ld+json")
-                    .send()
-                    .await
-                    .map_err(|e| DomainError::ExternalService(e.to_string()))?
-                    .json()
-                    .await
-                    .map_err(|e| DomainError::ExternalService(e.to_string()))?
-            } else {
-                base
-            }
-        } else {
-            base
-        };
-
-        let empty = vec![];
-        let items = page["orderedItems"].as_array().unwrap_or(&empty);
-        Ok(items
-            .iter()
-            .filter_map(|v| v.as_str().map(|s| s.to_string()))
-            .collect())
-    }
-
-    async fn resolve_actor_profiles(
-        &self,
-        urls: Vec<String>,
-    ) -> Vec<domain::models::actor_connection_summary::ActorConnectionSummary> {
-        resolve_actor_profiles_from_urls(urls).await
-    }
-}
-
-// ── FederationFollowPort ──────────────────────────────────────────────────────
-
-#[async_trait]
-impl FederationFollowPort for ApFederationAdapter {
-    async fn follow_remote(&self, local_user_id: &UserId, handle: &str) -> Result<(), DomainError> {
-        self.inner
-            .follow(local_user_id.as_uuid(), handle)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn unfollow_remote(
-        &self,
-        local_user_id: &UserId,
-        handle: &str,
-    ) -> Result<(), DomainError> {
-        let actor_url = webfinger_resolve_actor_url(handle)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-        self.inner
-            .unfollow(local_user_id.as_uuid(), &actor_url)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn get_remote_following(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<DomainRemoteActor>, DomainError> {
-        self.inner
-            .get_following(user_id.as_uuid())
-            .await
-            .map(|v| v.into_iter().map(k_ap_actor_to_domain).collect())
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn broadcast_move(
-        &self,
-        user_id: &UserId,
-        new_actor_url: url::Url,
-    ) -> Result<(), DomainError> {
-        self.inner
-            .broadcast_move(user_id.as_uuid(), new_actor_url)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-}
-
-// ── FederationFollowRequestPort ───────────────────────────────────────────────
-
-#[async_trait]
-impl FederationFollowRequestPort for ApFederationAdapter {
-    async fn get_pending_followers(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<DomainRemoteActor>, DomainError> {
-        self.inner
-            .get_pending_followers(user_id.as_uuid())
-            .await
-            .map(|v| v.into_iter().map(k_ap_actor_to_domain).collect())
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn accept_follow_request(
-        &self,
-        user_id: &UserId,
-        actor_url: &str,
-    ) -> Result<(), DomainError> {
-        self.inner
-            .accept_follower(user_id.as_uuid(), actor_url)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn reject_follow_request(
-        &self,
-        user_id: &UserId,
-        actor_url: &str,
-    ) -> Result<(), DomainError> {
-        self.inner
-            .reject_follower(user_id.as_uuid(), actor_url)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn get_remote_followers(
-        &self,
-        user_id: &UserId,
-    ) -> Result<Vec<DomainRemoteActor>, DomainError> {
-        self.inner
-            .get_accepted_followers(user_id.as_uuid())
-            .await
-            .map(|v| v.into_iter().map(k_ap_actor_to_domain).collect())
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn remove_remote_follower(
-        &self,
-        user_id: &UserId,
-        actor_url: &str,
-    ) -> Result<(), DomainError> {
-        self.inner
-            .remove_follower(user_id.as_uuid(), actor_url)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn mark_follower_accepted(
-        &self,
-        user_id: &UserId,
-        actor_url: &str,
-    ) -> Result<(), DomainError> {
-        self.inner
-            .mark_follower_accepted(user_id.as_uuid(), actor_url)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn mark_follower_rejected(
-        &self,
-        user_id: &UserId,
-        actor_url: &str,
-    ) -> Result<(), DomainError> {
-        self.inner
-            .mark_follower_rejected(user_id.as_uuid(), actor_url)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-}
-
-// ── FederationBlockPort ──────────────────────────────────────────────────────
-
-#[async_trait]
-impl domain::ports::FederationBlockPort for ApFederationAdapter {
-    async fn block_remote(&self, local_user_id: &UserId, handle: &str) -> Result<(), DomainError> {
-        let actor_url = webfinger_resolve_actor_url(handle)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-        self.inner
-            .block_actor(local_user_id.as_uuid(), &actor_url)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-
-    async fn unblock_remote(
-        &self,
-        local_user_id: &UserId,
-        handle: &str,
-    ) -> Result<(), DomainError> {
-        let actor_url = webfinger_resolve_actor_url(handle)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))?;
-        self.inner
-            .unblock_actor(local_user_id.as_uuid(), &actor_url)
-            .await
-            .map_err(|e| DomainError::ExternalService(e.to_string()))
-    }
-}
-
-// FederationActionPort is a blanket supertrait; no explicit impl needed.

crates/adapters/activitypub/src/urls/mod.rs

@@ -11,24 +11,24 @@ impl ThoughtsUrls {
         }
     }
 
-    pub fn user_url(&self, id: &str) -> Url {
+    pub fn user_url(&self, username: &str) -> Url {
-        Url::parse(&format!("{}/users/{}", self.base_url, id)).expect("valid URL")
+        Url::parse(&format!("{}/users/{}", self.base_url, username)).expect("valid URL")
     }
 
     pub fn thought_url(&self, thought_id: uuid::Uuid) -> Url {
         Url::parse(&format!("{}/thoughts/{}", self.base_url, thought_id)).expect("valid URL")
     }
 
-    pub fn user_inbox(&self, id: &str) -> Url {
+    pub fn user_inbox(&self, username: &str) -> Url {
-        Url::parse(&format!("{}/users/{}/inbox", self.base_url, id)).expect("valid URL")
+        Url::parse(&format!("{}/users/{}/inbox", self.base_url, username)).expect("valid URL")
     }
 
-    pub fn user_outbox(&self, id: &str) -> Url {
+    pub fn user_outbox(&self, username: &str) -> Url {
-        Url::parse(&format!("{}/users/{}/outbox", self.base_url, id)).expect("valid URL")
+        Url::parse(&format!("{}/users/{}/outbox", self.base_url, username)).expect("valid URL")
     }
 
-    pub fn user_followers(&self, id: &str) -> Url {
+    pub fn user_followers(&self, username: &str) -> Url {
-        Url::parse(&format!("{}/users/{}/followers", self.base_url, id)).expect("valid URL")
+        Url::parse(&format!("{}/users/{}/followers", self.base_url, username)).expect("valid URL")
     }
 }
 

crates/adapters/auth/src/api_key_service/tests.rs

@@ -18,13 +18,7 @@ impl ApiKeyRepository for FakeApiKeyRepo {
         Ok(())
     }
     async fn find_by_hash(&self, hash: &str) -> Result<Option<ApiKey>, DomainError> {
-        Ok(self
+        Ok(self.0.lock().unwrap().iter().find(|k| k.key_hash == hash).cloned())
-            .0
-            .lock()
-            .unwrap()
-            .iter()
-            .find(|k| k.key_hash == hash)
-            .cloned())
     }
     async fn list_for_user(&self, _uid: &UserId) -> Result<Vec<ApiKey>, DomainError> {
         Ok(vec![])

crates/adapters/event-payload/src/lib.rs

@@ -71,32 +71,11 @@ pub enum EventPayload {
     ProfileUpdated {
         user_id: String,
     },
-    RemoteFollowAccepted {
-        local_user_id: String,
-        remote_actor_url: String,
-    },
-    RemoteFollowRejected {
-        local_user_id: String,
-        remote_actor_url: String,
-    },
-    ActorMoved {
-        user_id: String,
-        new_actor_url: String,
-    },
     MentionReceived {
         thought_id: String,
         mentioned_user_id: String,
         author_user_id: String,
     },
-    FederationDeliveryRequested {
-        inbox: String,
-        activity: serde_json::Value,
-        signing_actor_id: String,
-    },
-    FederationBackfillRequested {
-        owner_user_id: String,
-        follower_inbox_url: String,
-    },
 }
 
 impl EventPayload {
@@ -118,12 +97,7 @@ impl EventPayload {
             Self::UserUnblocked { .. } => "users.unblocked",
             Self::UserRegistered { .. } => "users.registered",
             Self::ProfileUpdated { .. } => "users.profile_updated",
-            Self::RemoteFollowAccepted { .. } => "federation.follow.accepted",
-            Self::RemoteFollowRejected { .. } => "federation.follow.rejected",
-            Self::ActorMoved { .. } => "federation.actor.moved",
             Self::MentionReceived { .. } => "mentions.received",
-            Self::FederationDeliveryRequested { .. } => "federation.delivery.requested",
-            Self::FederationBackfillRequested { .. } => "federation.backfill.requested",
         }
     }
 }
@@ -236,27 +210,6 @@ impl From<&DomainEvent> for EventPayload {
             DomainEvent::ProfileUpdated { user_id } => Self::ProfileUpdated {
                 user_id: user_id.to_string(),
             },
-            DomainEvent::RemoteFollowAccepted {
-                local_user_id,
-                remote_actor_url,
-            } => Self::RemoteFollowAccepted {
-                local_user_id: local_user_id.to_string(),
-                remote_actor_url: remote_actor_url.clone(),
-            },
-            DomainEvent::RemoteFollowRejected {
-                local_user_id,
-                remote_actor_url,
-            } => Self::RemoteFollowRejected {
-                local_user_id: local_user_id.to_string(),
-                remote_actor_url: remote_actor_url.clone(),
-            },
-            DomainEvent::ActorMoved {
-                user_id,
-                new_actor_url,
-            } => Self::ActorMoved {
-                user_id: user_id.to_string(),
-                new_actor_url: new_actor_url.clone(),
-            },
             DomainEvent::MentionReceived {
                 thought_id,
                 mentioned_user_id,
@@ -387,27 +340,6 @@ impl TryFrom<EventPayload> for DomainEvent {
             EventPayload::ProfileUpdated { user_id } => DomainEvent::ProfileUpdated {
                 user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
             },
-            EventPayload::RemoteFollowAccepted {
-                local_user_id,
-                remote_actor_url,
-            } => DomainEvent::RemoteFollowAccepted {
-                local_user_id: UserId::from_uuid(parse_uuid(&local_user_id, "local_user_id")?),
-                remote_actor_url,
-            },
-            EventPayload::RemoteFollowRejected {
-                local_user_id,
-                remote_actor_url,
-            } => DomainEvent::RemoteFollowRejected {
-                local_user_id: UserId::from_uuid(parse_uuid(&local_user_id, "local_user_id")?),
-                remote_actor_url,
-            },
-            EventPayload::ActorMoved {
-                user_id,
-                new_actor_url,
-            } => DomainEvent::ActorMoved {
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                new_actor_url,
-            },
             EventPayload::MentionReceived {
                 thought_id,
                 mentioned_user_id,
@@ -420,15 +352,10 @@ impl TryFrom<EventPayload> for DomainEvent {
                 )?),
                 author_user_id: UserId::from_uuid(parse_uuid(&author_user_id, "author_user_id")?),
             },
-            EventPayload::FederationDeliveryRequested { .. }
-            | EventPayload::FederationBackfillRequested { .. } => {
-                return Err(DomainError::Internal(
-                    "federation infrastructure event — not a domain event".into(),
-                ));
-            }
         })
     }
 }
 
+
 #[cfg(test)]
 mod tests;

crates/adapters/event-transport/src/lib.rs

@@ -109,5 +109,6 @@ impl<S: MessageSource> EventConsumer for EventConsumerAdapter<S> {
     }
 }
 
+
 #[cfg(test)]
 mod tests;

crates/adapters/event-transport/src/tests.rs

@@ -3,13 +3,11 @@ use async_trait::async_trait;
 use domain::value_objects::{ThoughtId, UserId};
 use std::sync::{Arc, Mutex};
 
-type CallLog = Arc<Mutex<Vec<(String, Vec<u8>)>>>;
-
 struct SpyTransport {
-    calls: CallLog,
+    calls: Arc<Mutex<Vec<(String, Vec<u8>)>>>,
 }
 impl SpyTransport {
-    fn new() -> (Self, CallLog) {
+    fn new() -> (Self, Arc<Mutex<Vec<(String, Vec<u8>)>>>) {
         let calls = Arc::new(Mutex::new(vec![]));
         (
             Self {

crates/adapters/nats/src/lib.rs

@@ -239,5 +239,6 @@ impl MessageSource for NatsMessageSource {
     }
 }
 
+
 #[cfg(test)]
 mod tests;

crates/adapters/nats/src/tests.rs

@@ -1,3 +1,4 @@
+use super::*;
 use domain::{
     events::DomainEvent,
     value_objects::{LikeId, ThoughtId, UserId},

crates/adapters/postgres-federation/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-k-ap = { version = "0.4.0", registry = "gitea" }
+activitypub-base = { workspace = true }
 sqlx        = { workspace = true }
 uuid        = { workspace = true }
 chrono      = { workspace = true }
@@ -12,7 +12,6 @@ tracing = { workspace = true }
 async-trait = { workspace = true }
 anyhow      = { workspace = true }
 url         = { workspace = true }
-serde_json = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }

crates/adapters/postgres-federation/migrations

@@ -1 +0,0 @@
-../postgres/migrations

crates/adapters/postgres-search/Cargo.toml

@@ -10,7 +10,6 @@ sqlx        = { workspace = true }
 uuid        = { workspace = true }
 chrono      = { workspace = true }
 async-trait = { workspace = true }
-serde_json  = { workspace = true }
 
 [dev-dependencies]
 tokio    = { workspace = true, features = ["full"] }

crates/adapters/postgres-search/src/lib.rs

@@ -9,9 +9,9 @@ use domain::{
         user::User,
     },
     ports::SearchPort,
-    value_objects::{Content, ThoughtId, UserId},
+    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
 };
-use postgres::user::USER_SELECT;
+use postgres::user::{UserRow, USER_SELECT};
 use sqlx::PgPool;
 
 pub struct PgSearchRepository {
@@ -34,11 +34,19 @@ struct FeedRow {
     sensitive: bool,
     t_local: bool,
     thought_created_at: DateTime<Utc>,
-    thought_updated_at: Option<DateTime<Utc>>,
+    updated_at: Option<DateTime<Utc>>,
-    note_extensions: Option<serde_json::Value>,
+    author_id: uuid::Uuid,
-    mood: Option<String>,
+    username: String,
-    #[sqlx(flatten)]
+    email: String,
-    author: postgres::user::UserRow,
+    password_hash: String,
+    display_name: Option<String>,
+    bio: Option<String>,
+    avatar_url: Option<String>,
+    header_url: Option<String>,
+    custom_css: Option<String>,
+    author_local: bool,
+    author_created_at: DateTime<Utc>,
+    author_updated_at: DateTime<Utc>,
     like_count: i64,
     boost_count: i64,
     reply_count: i64,
@@ -59,11 +67,11 @@ fn feed_select(viewer: Option<uuid::Uuid>) -> String {
          t.id AS thought_id, t.user_id AS t_user_id, t.content,\n\
          t.in_reply_to_id,\n\
          t.visibility, t.content_warning, t.sensitive, t.local AS t_local,\n\
-         t.created_at AS thought_created_at, t.updated_at AS thought_updated_at, t.note_extensions, t.mood,\n\
+         t.created_at AS thought_created_at, t.updated_at,\n\
-         u.id, u.username, u.email, u.password_hash,\n\
+         u.id AS author_id, u.username, u.email, u.password_hash,\n\
-         u.display_name, u.bio, u.avatar_url, u.header_url, u.custom_css, u.profile_fields, u.custom_moods,\n\
+         u.display_name, u.bio, u.avatar_url, u.header_url, u.custom_css,\n\
-         u.local,\n\
+         u.local AS author_local,\n\
-         u.created_at, u.updated_at,\n\
+         u.created_at AS author_created_at, u.updated_at AS author_updated_at,\n\
          (SELECT COUNT(*) FROM likes  l WHERE l.thought_id=t.id) AS like_count,\n\
          (SELECT COUNT(*) FROM boosts b WHERE b.thought_id=t.id) AS boost_count,\n\
          (SELECT COUNT(*) FROM thoughts r WHERE r.in_reply_to_id=t.id) AS reply_count,\n\
@@ -83,11 +91,22 @@ fn row_to_entry(r: FeedRow, viewer: Option<uuid::Uuid>) -> Result<FeedEntry, Dom
         sensitive: r.sensitive,
         local: r.t_local,
         created_at: r.thought_created_at,
-        updated_at: r.thought_updated_at,
+        updated_at: r.updated_at,
-        note_extensions: r.note_extensions,
+    };
-        mood: r.mood,
+    let author = User {
+        id: UserId::from_uuid(r.author_id),
+        username: Username::from_trusted(r.username),
+        email: Email::from_trusted(r.email),
+        password_hash: PasswordHash(r.password_hash),
+        display_name: r.display_name,
+        bio: r.bio,
+        avatar_url: r.avatar_url,
+        header_url: r.header_url,
+        custom_css: r.custom_css,
+        local: r.author_local,
+        created_at: r.author_created_at,
+        updated_at: r.author_updated_at,
     };
-    let author = User::from(r.author);
     Ok(FeedEntry {
         thought,
         author,
@@ -168,7 +187,7 @@ impl SearchPort for PgSearchRepository {
              ORDER BY similarity(username || ' ' || COALESCE(display_name,''), $1) DESC
              LIMIT $2 OFFSET $3"
         );
-        let rows = sqlx::query_as::<_, postgres::user::UserRow>(&sql)
+        let rows = sqlx::query_as::<_, UserRow>(&sql)
             .bind(query)
             .bind(page.limit())
             .bind(page.offset())

crates/adapters/postgres-search/src/tests.rs

@@ -1,11 +1,11 @@
 use super::*;
 use domain::{
     models::{
-        thought::{NewThought, Thought, Visibility},
+        thought::{Thought, Visibility},
         user::User,
     },
     ports::{SearchPort, ThoughtRepository, UserWriter},
-    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
+    value_objects::*,
 };
 
 async fn seed_thought(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
@@ -19,16 +19,15 @@ async fn seed_thought(pool: &sqlx::PgPool, username: &str, content: &str) -> (Us
         PasswordHash("h".into()),
     );
     urepo.save(&u).await.unwrap();
-    let t = Thought::new_local(NewThought {
+    let t = Thought::new_local(
-        id: ThoughtId::new(),
+        ThoughtId::new(),
-        user_id: u.id.clone(),
+        u.id.clone(),
-        content: Content::new_local(content).unwrap(),
+        Content::new_local(content).unwrap(),
-        in_reply_to_id: None,
+        None,
-        visibility: Visibility::Public,
+        Visibility::Public,
-        content_warning: None,
+        None,
-        sensitive: false,
+        false,
-        mood: None,
+    );
-    });
     trepo.save(&t).await.unwrap();
     (u, t)
 }
@@ -103,9 +102,9 @@ async fn search_thoughts_returns_empty_for_no_match(pool: sqlx::PgPool) {
 #[sqlx::test(migrations = "../postgres/migrations")]
 async fn search_thoughts_viewer_context(pool: sqlx::PgPool) {
     use domain::models::social::Like;
-    use domain::ports::LikeRepository;
+    use domain::ports::{LikeRepository, UserWriter};
     use domain::value_objects::LikeId;
-    use postgres::like::PgLikeRepository;
+    use postgres::{like::PgLikeRepository, user::PgUserRepository};
 
     let (alice, thought) = seed_thought(&pool, "alice", "hello world").await;
 

crates/adapters/postgres/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 domain           = { workspace = true }
-activitypub      = { workspace = true }
+activitypub-base = { workspace = true }
 event-payload    = { workspace = true }
 sqlx             = { workspace = true }
 uuid        = { workspace = true }

crates/adapters/postgres/migrations/012_note_extensions.sql

@@ -1 +0,0 @@
-ALTER TABLE thoughts ADD COLUMN note_extensions JSONB;

crates/adapters/postgres/migrations/013_also_known_as.sql

@@ -1 +0,0 @@
-ALTER TABLE users ADD COLUMN IF NOT EXISTS also_known_as TEXT;

crates/adapters/postgres/migrations/014_federation_processed_activities.sql

@@ -1,7 +0,0 @@
-CREATE TABLE IF NOT EXISTS federation_processed_activities (
-    activity_id  TEXT PRIMARY KEY,
-    processed_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_fed_processed_activities_at
-    ON federation_processed_activities(processed_at);

crates/adapters/postgres/migrations/015_remote_actors_rich_fields.sql

@@ -1,6 +0,0 @@
-ALTER TABLE remote_actors
-    ADD COLUMN IF NOT EXISTS bio           TEXT,
-    ADD COLUMN IF NOT EXISTS banner_url    TEXT,
-    ADD COLUMN IF NOT EXISTS followers_url TEXT,
-    ADD COLUMN IF NOT EXISTS following_url TEXT,
-    ADD COLUMN IF NOT EXISTS also_known_as TEXT[];

crates/adapters/postgres/migrations/016_engagement_indexes.sql

@@ -1,10 +0,0 @@
--- Indexes for feed engagement counts and sorting.
--- likes and boosts are joined/counted per thought on every feed query.
--- thoughts(in_reply_to_id) is scanned for reply_count.
-CREATE INDEX IF NOT EXISTS idx_likes_thought_id         ON likes(thought_id);
-CREATE INDEX IF NOT EXISTS idx_boosts_thought_id        ON boosts(thought_id);
-CREATE INDEX IF NOT EXISTS idx_thoughts_in_reply_to_id  ON thoughts(in_reply_to_id) WHERE in_reply_to_id IS NOT NULL;
-
--- Viewer-context lookups: "did I like/boost this?"
-CREATE INDEX IF NOT EXISTS idx_likes_user_thought        ON likes(user_id, thought_id);
-CREATE INDEX IF NOT EXISTS idx_boosts_user_thought       ON boosts(user_id, thought_id);

crates/adapters/postgres/migrations/017_widen_username.sql

@@ -1 +0,0 @@
-ALTER TABLE users ALTER COLUMN username TYPE VARCHAR(255);

crates/adapters/postgres/migrations/018_federation_following_status.sql

@@ -1,2 +0,0 @@
-ALTER TABLE federation_following
-  ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'accepted';

crates/adapters/postgres/migrations/019_remote_actor_attachment.sql

@@ -1 +0,0 @@
-ALTER TABLE remote_actors ADD COLUMN IF NOT EXISTS attachment JSONB DEFAULT '[]'::jsonb;

crates/adapters/postgres/migrations/020_user_profile_fields.sql

@@ -1 +0,0 @@
-ALTER TABLE users ADD COLUMN IF NOT EXISTS profile_fields JSONB DEFAULT '[]'::jsonb;

crates/adapters/postgres/migrations/021_thought_mood_and_custom_moods.sql

@@ -1,2 +0,0 @@
-ALTER TABLE thoughts ADD COLUMN IF NOT EXISTS mood VARCHAR(64);
-ALTER TABLE users ADD COLUMN IF NOT EXISTS custom_moods JSONB DEFAULT '[]'::jsonb;

crates/adapters/postgres/migrations/022_instance_actor.sql

@@ -1,10 +0,0 @@
-INSERT INTO users (id, username, email, password_hash, display_name, bio)
-VALUES (
-    '00000000-0000-4000-8000-000000000000',
-    'instance',
-    'noreply@instance.invalid',
-    '!service-actor-no-login',
-    NULL,
-    NULL
-)
-ON CONFLICT (id) DO NOTHING;

crates/adapters/postgres/src/activitypub/mod.rs

@@ -1,53 +1,18 @@
 use crate::db_error::IntoDbResult;
 use async_trait::async_trait;
 
-const MAX_REMOTE_CONTENT_CHARS: usize = 5000;
+const MAX_REMOTE_CONTENT_CHARS: usize = 500;
 const THOUGHTS_PATH_PREFIX: &str = "/thoughts/";
 use chrono::{DateTime, Utc};
 use sqlx::PgPool;
 
-use activitypub::{AcceptNoteInput, ActivityPubRepository, ActorApUrls, OutboxEntry};
+use activitypub_base::{ActivityPubRepository, ActorApUrls, OutboxEntry};
 use domain::{
     errors::DomainError,
     models::thought::{Thought, Visibility},
     value_objects::{Content, ThoughtId, UserId, Username},
 };
 
-#[derive(sqlx::FromRow)]
-struct OutboxRow {
-    id: uuid::Uuid,
-    user_id: uuid::Uuid,
-    content: String,
-    created_at: DateTime<Utc>,
-    in_reply_to_id: Option<uuid::Uuid>,
-    content_warning: Option<String>,
-    sensitive: bool,
-    username: String,
-    updated_at: Option<DateTime<Utc>>,
-}
-
-impl OutboxRow {
-    fn into_entry(self) -> OutboxEntry {
-        OutboxEntry {
-            thought: Thought {
-                id: ThoughtId::from_uuid(self.id),
-                user_id: UserId::from_uuid(self.user_id),
-                content: Content::new_remote(self.content),
-                in_reply_to_id: self.in_reply_to_id.map(ThoughtId::from_uuid),
-                visibility: Visibility::Public,
-                content_warning: self.content_warning,
-                sensitive: self.sensitive,
-                local: true,
-                created_at: self.created_at,
-                updated_at: self.updated_at,
-                note_extensions: None,
-                mood: None,
-            },
-            author_username: Username::from_trusted(self.username),
-        }
-    }
-}
-
 pub struct PgActivityPubRepository {
     pool: PgPool,
 }
@@ -64,7 +29,19 @@ impl ActivityPubRepository for PgActivityPubRepository {
         &self,
         user_id: &UserId,
     ) -> Result<Vec<OutboxEntry>, DomainError> {
-        sqlx::query_as::<_, OutboxRow>(
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            content: String,
+            created_at: DateTime<Utc>,
+            in_reply_to_id: Option<uuid::Uuid>,
+            content_warning: Option<String>,
+            sensitive: bool,
+            username: String,
+            updated_at: Option<DateTime<Utc>>,
+        }
+        sqlx::query_as::<_, Row>(
             "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
              FROM thoughts t JOIN users u ON u.id=t.user_id
              WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
@@ -74,7 +51,25 @@ impl ActivityPubRepository for PgActivityPubRepository {
         .fetch_all(&self.pool)
         .await
         .into_domain()
-        .map(|rows| rows.into_iter().map(OutboxRow::into_entry).collect())
+        .map(|rows| {
+            rows.into_iter()
+                .map(|r| OutboxEntry {
+                    thought: Thought {
+                        id: ThoughtId::from_uuid(r.id),
+                        user_id: UserId::from_uuid(r.user_id),
+                        content: Content::new_remote(r.content),
+                        in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                        visibility: Visibility::Public,
+                        content_warning: r.content_warning,
+                        sensitive: r.sensitive,
+                        local: true,
+                        created_at: r.created_at,
+                        updated_at: r.updated_at,
+                    },
+                    author_username: Username::from_trusted(r.username),
+                })
+                .collect()
+        })
     }
 
     async fn outbox_page_for_actor(
@@ -83,8 +78,20 @@ impl ActivityPubRepository for PgActivityPubRepository {
         before: Option<DateTime<Utc>>,
         limit: usize,
     ) -> Result<Vec<OutboxEntry>, DomainError> {
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            content: String,
+            created_at: DateTime<Utc>,
+            in_reply_to_id: Option<uuid::Uuid>,
+            content_warning: Option<String>,
+            sensitive: bool,
+            username: String,
+            updated_at: Option<DateTime<Utc>>,
+        }
         let rows = if let Some(before) = before {
-            sqlx::query_as::<_, OutboxRow>(
+            sqlx::query_as::<_, Row>(
                 "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
                  FROM thoughts t JOIN users u ON u.id=t.user_id
                  WHERE t.user_id=$1 AND t.local=true AND t.visibility='public' AND t.created_at < $2
@@ -96,7 +103,7 @@ impl ActivityPubRepository for PgActivityPubRepository {
             .fetch_all(&self.pool)
             .await
         } else {
-            sqlx::query_as::<_, OutboxRow>(
+            sqlx::query_as::<_, Row>(
                 "SELECT t.id, t.user_id, t.content, t.created_at, t.in_reply_to_id, t.content_warning, t.sensitive, u.username, t.updated_at
                  FROM thoughts t JOIN users u ON u.id=t.user_id
                  WHERE t.user_id=$1 AND t.local=true AND t.visibility='public'
@@ -109,7 +116,24 @@ impl ActivityPubRepository for PgActivityPubRepository {
         }
         .into_domain()?;
 
-        Ok(rows.into_iter().map(OutboxRow::into_entry).collect())
+        Ok(rows
+            .into_iter()
+            .map(|r| OutboxEntry {
+                thought: Thought {
+                    id: ThoughtId::from_uuid(r.id),
+                    user_id: UserId::from_uuid(r.user_id),
+                    content: Content::new_remote(r.content),
+                    in_reply_to_id: r.in_reply_to_id.map(ThoughtId::from_uuid),
+                    visibility: Visibility::Public,
+                    content_warning: r.content_warning,
+                    sensitive: r.sensitive,
+                    local: true,
+                    created_at: r.created_at,
+                    updated_at: r.updated_at,
+                },
+                author_username: Username::from_trusted(r.username),
+            })
+            .collect())
     }
 
     async fn find_remote_actor_id(
@@ -129,28 +153,24 @@ impl ActivityPubRepository for PgActivityPubRepository {
             return Ok(id);
         }
         let new_id = uuid::Uuid::new_v4();
-        let parsed = url::Url::parse(actor_ap_url).ok();
+        // Use the last path segment as username (e.g. /users/alice → "alice").
-        let domain_str = parsed
+        // Falls back to a random short id for long segments (e.g. UUID-based actor URLs).
-            .as_ref()
+        // username column is VARCHAR(32).
-            .and_then(|u| u.host_str().map(|s| s.to_string()))
+        let last_seg = url::Url::parse(actor_ap_url)
-            .unwrap_or_default();
+            .ok()
-        let last_seg = parsed
             .and_then(|u| {
                 u.path_segments()
                     .and_then(|mut s| s.next_back().map(|s| s.to_string()))
             })
             .unwrap_or_default();
-        let handle = if last_seg.is_empty() || domain_str.is_empty() {
+        let handle = if last_seg.is_empty() {
-            format!("r_{}", &new_id.to_string()[..13])
+            format!("remote_{}", &new_id.to_string()[..13])
+        } else if last_seg.len() <= 32 {
+            last_seg
         } else {
-            let candidate = format!("{}@{}", last_seg, domain_str);
+            format!("remote_{}", &new_id.to_string()[..13])
-            if candidate.len() <= 255 {
-                candidate
-            } else {
-                format!("r_{}", &new_id.to_string()[..13])
-            }
         };
-        let result = sqlx::query(
+        sqlx::query(
             "INSERT INTO users(id,username,email,password_hash,local,ap_id,created_at,updated_at)
              VALUES($1,$2,$3,'',false,$4,NOW(),NOW()) ON CONFLICT(ap_id) DO NOTHING",
         )
@@ -159,24 +179,9 @@ impl ActivityPubRepository for PgActivityPubRepository {
         .bind(format!("{}@remote", new_id))
         .bind(actor_ap_url)
         .execute(&self.pool)
-        .await;
-
-        if result.is_err() {
-            let fallback = format!("r_{}", &new_id.to_string()[..13]);
-            let new_id2 = uuid::Uuid::new_v4();
-            sqlx::query(
-                "INSERT INTO users(id,username,email,password_hash,local,ap_id,created_at,updated_at)
-                 VALUES($1,$2,$3,'',false,$4,NOW(),NOW()) ON CONFLICT(ap_id) DO NOTHING",
-            )
-            .bind(new_id2)
-            .bind(&fallback)
-            .bind(format!("{}@remote", new_id2))
-            .bind(actor_ap_url)
-            .execute(&self.pool)
         .await
         .into_domain()?;
-        }
+        // Re-fetch to get whichever id won the race
-
         self.find_remote_actor_id(actor_ap_url)
             .await?
             .ok_or_else(|| {
@@ -205,46 +210,34 @@ impl ActivityPubRepository for PgActivityPubRepository {
         .map(|_| ())
     }
 
-    async fn accept_note(&self, input: AcceptNoteInput<'_>) -> Result<ThoughtId, DomainError> {
+    async fn accept_note(
-        let AcceptNoteInput {
+        &self,
-            ap_id,
+        ap_id: &str,
-            author_id,
+        author_id: &UserId,
-            content,
+        content: &str,
-            published,
+        published: DateTime<Utc>,
-            sensitive,
+        sensitive: bool,
-            content_warning,
+        content_warning: Option<String>,
-            visibility,
+        visibility: &str,
-            in_reply_to,
+        in_reply_to: Option<&str>,
-            note_extensions,
+    ) -> Result<ThoughtId, DomainError> {
-        } = input;
         let capped: String = content.chars().take(MAX_REMOTE_CONTENT_CHARS).collect();
         let (in_reply_to_id, in_reply_to_url) = match in_reply_to {
             Some(url) => {
-                // Fast path: local thought URL contains the UUID directly.
+                // If the parent is a local thought, extract its UUID for in_reply_to_id.
                 let local_uuid = url::Url::parse(url).ok().and_then(|u| {
                     u.path()
                         .strip_prefix(THOUGHTS_PATH_PREFIX)
                         .and_then(|s| s.split('/').next())
                         .and_then(|s| uuid::Uuid::parse_str(s).ok())
                 });
-                // Slow path: remote parent — look up by ap_id so remote-to-remote
+                (local_uuid, Some(url.to_string()))
-                // replies are threaded correctly in the feed.
-                let resolved = if local_uuid.is_some() {
-                    local_uuid
-                } else {
-                    sqlx::query_scalar::<_, uuid::Uuid>("SELECT id FROM thoughts WHERE ap_id=$1")
-                        .bind(url)
-                        .fetch_optional(&self.pool)
-                        .await
-                        .into_domain()?
-                };
-                (resolved, Some(url.to_string()))
             }
             None => (None, None),
         };
         sqlx::query(
-            "INSERT INTO thoughts(id,user_id,content,ap_id,visibility,sensitive,local,content_warning,created_at,in_reply_to_id,in_reply_to_url,note_extensions)
+            "INSERT INTO thoughts(id,user_id,content,ap_id,visibility,sensitive,local,content_warning,created_at,in_reply_to_id,in_reply_to_url)
-             VALUES($1,$2,$3,$4,$8,$5,false,$6,$7,$9,$10,$11) ON CONFLICT(ap_id) DO NOTHING",
+             VALUES($1,$2,$3,$4,$8,$5,false,$6,$7,$9,$10) ON CONFLICT(ap_id) DO NOTHING",
         )
         .bind(uuid::Uuid::new_v4())
         .bind(author_id.as_uuid())
@@ -256,13 +249,13 @@ impl ActivityPubRepository for PgActivityPubRepository {
         .bind(visibility)
         .bind(in_reply_to_id)
         .bind(&in_reply_to_url)
-        .bind(note_extensions)
         .execute(&self.pool)
         .await
         .into_domain()?;
 
         // SELECT the id — works whether the INSERT was a no-op or not (idempotent).
-        let row: (uuid::Uuid,) = sqlx::query_as("SELECT id FROM thoughts WHERE ap_id=$1")
+        let row: (uuid::Uuid,) =
+            sqlx::query_as("SELECT id FROM thoughts WHERE ap_id=$1")
                 .bind(ap_id)
                 .fetch_one(&self.pool)
                 .await
@@ -270,19 +263,13 @@ impl ActivityPubRepository for PgActivityPubRepository {
         Ok(ThoughtId::from_uuid(row.0))
     }
 
-    async fn apply_note_update(
+    async fn apply_note_update(&self, ap_id: &str, new_content: &str) -> Result<(), DomainError> {
-        &self,
-        ap_id: &str,
-        new_content: &str,
-        note_extensions: Option<serde_json::Value>,
-    ) -> Result<(), DomainError> {
         let capped: String = new_content.chars().take(MAX_REMOTE_CONTENT_CHARS).collect();
         sqlx::query(
-            "UPDATE thoughts SET content=$2,note_extensions=$3,updated_at=NOW() WHERE ap_id=$1 AND local=false",
+            "UPDATE thoughts SET content=$2,updated_at=NOW() WHERE ap_id=$1 AND local=false",
         )
         .bind(ap_id)
         .bind(&capped)
-        .bind(&note_extensions)
         .execute(&self.pool)
         .await
         .into_domain()
@@ -344,19 +331,6 @@ impl ActivityPubRepository for PgActivityPubRepository {
         .into_domain()
         .map(|opt| opt.map(|(ap_id, inbox_url)| ActorApUrls { ap_id, inbox_url }))
     }
-
-    async fn sync_remote_actor_to_user(&self, actor_ap_url: &str) -> Result<(), DomainError> {
-        sqlx::query(
-            "UPDATE users SET display_name = ra.display_name, avatar_url = ra.avatar_url, updated_at = NOW()
-             FROM remote_actors ra
-             WHERE users.ap_id = ra.url AND users.ap_id = $1 AND users.local = false",
-        )
-        .bind(actor_ap_url)
-        .execute(&self.pool)
-        .await
-        .into_domain()
-        .map(|_| ())
-    }
 }
 
 #[cfg(test)]

crates/adapters/postgres/src/activitypub/tests.rs

@@ -1,5 +1,5 @@
     use super::*;
-use activitypub::{AcceptNoteInput, ActivityPubRepository};
+    use activitypub_base::ActivityPubRepository;
 
     #[sqlx::test(migrations = "./migrations")]
     async fn intern_remote_actor_is_idempotent(pool: sqlx::PgPool) {
@@ -16,17 +16,16 @@ async fn accept_and_retract_note(pool: sqlx::PgPool) {
         let actor_url = "https://remote.example/users/bob";
         let ap_id = "https://remote.example/notes/1";
         let author = repo.intern_remote_actor(actor_url).await.unwrap();
-    repo.accept_note(AcceptNoteInput {
+        repo.accept_note(
             ap_id,
-        author_id: &author,
+            &author,
-        content: "hello from remote",
+            "hello from remote",
-        published: chrono::Utc::now(),
+            chrono::Utc::now(),
-        sensitive: false,
+            false,
-        content_warning: None,
+            None,
-        visibility: "public",
+            "public",
-        in_reply_to: None,
+            None,
-        note_extensions: None,
+        )
-    })
         .await
         .unwrap();
         repo.retract_note(ap_id).await.unwrap();
@@ -47,17 +46,16 @@ async fn accept_note_returns_thought_id(pool: sqlx::PgPool) {
             .unwrap();
 
         let thought_id = repo
-        .accept_note(AcceptNoteInput {
+            .accept_note(
-            ap_id: "https://remote.example/notes/1",
+                "https://remote.example/notes/1",
-            author_id: &actor_user_id,
+                &actor_user_id,
-            content: "Hello #rust world",
+                "Hello #rust world",
-            published: chrono::Utc::now(),
+                chrono::Utc::now(),
-            sensitive: false,
+                false,
-            content_warning: None,
+                None,
-            visibility: "public",
+                "public",
-            in_reply_to: None,
+                None,
-            note_extensions: None,
+            )
-        })
             .await
             .unwrap();
 

crates/adapters/postgres/src/api_key/mod.rs

@@ -9,27 +9,6 @@ use domain::{
 };
 use sqlx::PgPool;
 
-#[derive(sqlx::FromRow)]
-struct ApiKeyRow {
-    id: uuid::Uuid,
-    user_id: uuid::Uuid,
-    key_hash: String,
-    name: String,
-    created_at: DateTime<Utc>,
-}
-
-impl ApiKeyRow {
-    fn into_domain(self) -> ApiKey {
-        ApiKey {
-            id: ApiKeyId::from_uuid(self.id),
-            user_id: UserId::from_uuid(self.user_id),
-            key_hash: self.key_hash,
-            name: self.name,
-            created_at: self.created_at,
-        }
-    }
-}
-
 pub struct PgApiKeyRepository {
     pool: PgPool,
 }
@@ -57,21 +36,45 @@ impl ApiKeyRepository for PgApiKeyRepository {
     }
 
     async fn find_by_hash(&self, hash: &str) -> Result<Option<ApiKey>, DomainError> {
-        sqlx::query_as::<_, ApiKeyRow>(
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            key_hash: String,
+            name: String,
+            created_at: DateTime<Utc>,
+        }
+        sqlx::query_as::<_, Row>(
             "SELECT id,user_id,key_hash,name,created_at FROM api_keys WHERE key_hash=$1",
         )
         .bind(hash)
         .fetch_optional(&self.pool)
         .await
         .into_domain()
-        .map(|o| o.map(ApiKeyRow::into_domain))
+        .map(|o| {
+            o.map(|r| ApiKey {
+                id: ApiKeyId::from_uuid(r.id),
+                user_id: UserId::from_uuid(r.user_id),
+                key_hash: r.key_hash,
+                name: r.name,
+                created_at: r.created_at,
+            })
+        })
     }
 
     async fn list_for_user(&self, user_id: &UserId) -> Result<Vec<ApiKey>, DomainError> {
-        sqlx::query_as::<_, ApiKeyRow>("SELECT id,user_id,key_hash,name,created_at FROM api_keys WHERE user_id=$1 ORDER BY created_at DESC")
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: uuid::Uuid,
+            user_id: uuid::Uuid,
+            key_hash: String,
+            name: String,
+            created_at: DateTime<Utc>,
+        }
+        sqlx::query_as::<_, Row>("SELECT id,user_id,key_hash,name,created_at FROM api_keys WHERE user_id=$1 ORDER BY created_at DESC")
             .bind(user_id.as_uuid()).fetch_all(&self.pool).await
             .into_domain()
-            .map(|rows| rows.into_iter().map(ApiKeyRow::into_domain).collect())
+            .map(|rows| rows.into_iter().map(|r| ApiKey { id: ApiKeyId::from_uuid(r.id), user_id: UserId::from_uuid(r.user_id), key_hash: r.key_hash, name: r.name, created_at: r.created_at }).collect())
     }
 
     async fn delete(&self, id: &ApiKeyId, user_id: &UserId) -> Result<(), DomainError> {

crates/adapters/postgres/src/block/tests.rs

@@ -1,6 +1,7 @@
     use super::*;
     use crate::test_helpers::seed_user;
     use chrono::Utc;
+    use domain::value_objects::*;
 
     #[sqlx::test(migrations = "./migrations")]
     async fn block_exists(pool: sqlx::PgPool) {

crates/adapters/postgres/src/boost/tests.rs

@@ -1,6 +1,7 @@
     use super::*;
     use crate::test_helpers::seed_user_and_thought;
     use chrono::Utc;
+    use domain::value_objects::*;
 
     #[sqlx::test(migrations = "./migrations")]
     async fn boost_and_count(pool: sqlx::PgPool) {

crates/adapters/postgres/src/constants.rs

@@ -1,8 +0,0 @@
-pub const STATUS_ACCEPTED: &str = "accepted";
-pub const STATUS_PENDING: &str = "pending";
-pub const STATUS_REJECTED: &str = "rejected";
-
-pub const VIS_PUBLIC: &str = "public";
-pub const VIS_UNLISTED: &str = "unlisted";
-pub const VIS_FOLLOWERS: &str = "followers";
-pub const VIS_DIRECT: &str = "direct";

crates/adapters/postgres/src/feed/mod.rs

@@ -9,8 +9,8 @@ use domain::{
         thought::{Thought, Visibility},
         user::User,
     },
-    ports::{FeedOptions, FeedRepository, FeedRequest, FeedScope, FeedSort},
+    ports::{FeedQuery, FeedRepository, FeedScope},
-    value_objects::{Content, ThoughtId, UserId},
+    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
 };
 use sqlx::PgPool;
 
@@ -34,11 +34,19 @@ struct FeedRow {
     sensitive: bool,
     t_local: bool,
     thought_created_at: DateTime<Utc>,
-    thought_updated_at: Option<DateTime<Utc>>,
+    updated_at: Option<DateTime<Utc>>,
-    note_extensions: Option<serde_json::Value>,
+    author_id: uuid::Uuid,
-    mood: Option<String>,
+    username: String,
-    #[sqlx(flatten)]
+    email: String,
-    author: crate::user::UserRow,
+    password_hash: String,
+    display_name: Option<String>,
+    bio: Option<String>,
+    avatar_url: Option<String>,
+    header_url: Option<String>,
+    custom_css: Option<String>,
+    author_local: bool,
+    author_created_at: DateTime<Utc>,
+    author_updated_at: DateTime<Utc>,
     like_count: i64,
     boost_count: i64,
     reply_count: i64,
@@ -46,6 +54,58 @@ struct FeedRow {
     boosted_by_viewer: bool,
 }
 
+fn federation_following_clause(follower: Option<uuid::Uuid>) -> String {
+    match follower {
+        Some(fid) => format!(
+            " OR t.user_id IN (
+                SELECT u2.id FROM users u2
+                JOIN federation_following ff ON u2.ap_id = ff.remote_actor_url
+                WHERE ff.local_user_id = '{fid}'
+            )"
+        ),
+        None => String::new(),
+    }
+}
+
+fn feed_select(viewer: Option<uuid::Uuid>) -> String {
+    let viewer_checks = match viewer {
+        Some(uid) => format!(
+            "EXISTS(SELECT 1 FROM likes WHERE user_id='{uid}' AND thought_id=t.id) AS liked_by_viewer,
+             EXISTS(SELECT 1 FROM boosts WHERE user_id='{uid}' AND thought_id=t.id) AS boosted_by_viewer"
+        ),
+        None => "false AS liked_by_viewer, false AS boosted_by_viewer".to_string(),
+    };
+    format!(
+        "
+    SELECT
+        t.id AS thought_id, t.user_id AS t_user_id, t.content,
+        t.in_reply_to_id,
+        t.visibility, t.content_warning, t.sensitive, t.local AS t_local,
+        t.created_at AS thought_created_at, t.updated_at,
+        u.id AS author_id,
+        CASE WHEN NOT u.local AND ra.handle IS NOT NULL AND ra.handle != ''
+             THEN '@' || ra.handle ||
+                  CASE WHEN ra.handle NOT LIKE '%@%'
+                       THEN '@' || SPLIT_PART(ra.url, '/', 3)
+                       ELSE '' END
+             ELSE u.username END AS username,
+        u.email, u.password_hash,
+        COALESCE(ra.display_name, u.display_name) AS display_name,
+        u.bio,
+        COALESCE(ra.avatar_url, u.avatar_url) AS avatar_url,
+        u.header_url, u.custom_css,
+        u.local AS author_local,
+        u.created_at AS author_created_at, u.updated_at AS author_updated_at,
+        (SELECT COUNT(*) FROM likes l WHERE l.thought_id=t.id) AS like_count,
+        (SELECT COUNT(*) FROM boosts b WHERE b.thought_id=t.id) AS boost_count,
+        (SELECT COUNT(*) FROM thoughts r WHERE r.in_reply_to_id=t.id) AS reply_count,
+        {viewer_checks}
+    FROM thoughts t
+    JOIN users u ON u.id=t.user_id
+    LEFT JOIN remote_actors ra ON u.ap_id = ra.url"
+    )
+}
+
 fn row_to_entry(r: FeedRow, viewer: Option<uuid::Uuid>) -> Result<FeedEntry, DomainError> {
     let thought = Thought {
         id: ThoughtId::from_uuid(r.thought_id),
@@ -57,11 +117,22 @@ fn row_to_entry(r: FeedRow, viewer: Option<uuid::Uuid>) -> Result<FeedEntry, Dom
         sensitive: r.sensitive,
         local: r.t_local,
         created_at: r.thought_created_at,
-        updated_at: r.thought_updated_at,
+        updated_at: r.updated_at,
-        note_extensions: r.note_extensions,
+    };
-        mood: r.mood,
+    let author = User {
+        id: UserId::from_uuid(r.author_id),
+        username: Username::from_trusted(r.username),
+        email: Email::from_trusted(r.email),
+        password_hash: PasswordHash(r.password_hash),
+        display_name: r.display_name,
+        bio: r.bio,
+        avatar_url: r.avatar_url,
+        header_url: r.header_url,
+        custom_css: r.custom_css,
+        local: r.author_local,
+        created_at: r.author_created_at,
+        updated_at: r.author_updated_at,
     };
-    let author = User::from(r.author);
     Ok(FeedEntry {
         thought,
         author,
@@ -77,227 +148,36 @@ fn row_to_entry(r: FeedRow, viewer: Option<uuid::Uuid>) -> Result<FeedEntry, Dom
     })
 }
 
-struct FeedSqlBuilder<'a> {
-    options: &'a FeedOptions,
-    scope: &'a FeedScope,
-    viewer: Option<uuid::Uuid>,
-}
-
-impl<'a> FeedSqlBuilder<'a> {
-    fn new(options: &'a FeedOptions, scope: &'a FeedScope, viewer: Option<uuid::Uuid>) -> Self {
-        Self {
-            options,
-            scope,
-            viewer,
-        }
-    }
-
-    fn select(&self, viewer_param: &str) -> String {
-        let (viewer_cols, viewer_joins) = match self.viewer {
-            Some(_) => (
-                "(lv.thought_id IS NOT NULL) AS liked_by_viewer,
-                 (bv.thought_id IS NOT NULL) AS boosted_by_viewer".to_string(),
-                format!(
-                    "LEFT JOIN (SELECT thought_id FROM likes WHERE user_id={viewer_param}) lv ON lv.thought_id = t.id
-                     LEFT JOIN (SELECT thought_id FROM boosts WHERE user_id={viewer_param}) bv ON bv.thought_id = t.id"
-                ),
-            ),
-            None => (
-                "false AS liked_by_viewer, false AS boosted_by_viewer".to_string(),
-                String::new(),
-            ),
-        };
-        format!(
-            "
-    SELECT
-        t.id AS thought_id, t.user_id AS t_user_id, t.content,
-        t.in_reply_to_id,
-        t.visibility, t.content_warning, t.sensitive, t.local AS t_local,
-        t.created_at AS thought_created_at, t.updated_at AS thought_updated_at,
-        t.note_extensions, t.mood,
-        u.id,
-        CASE WHEN NOT u.local AND ra.handle IS NOT NULL AND ra.handle != ''
-             THEN '@' || ra.handle ||
-                  CASE WHEN ra.handle NOT LIKE '%@%'
-                       THEN '@' || SPLIT_PART(ra.url, '/', 3)
-                       ELSE '' END
-             ELSE u.username END AS username,
-        u.email, u.password_hash,
-        COALESCE(ra.display_name, u.display_name) AS display_name,
-        u.bio,
-        COALESCE(ra.avatar_url, u.avatar_url) AS avatar_url,
-        u.header_url, u.custom_css, u.profile_fields, u.custom_moods,
-        u.local,
-        u.created_at, u.updated_at,
-        COALESCE(l_agg.cnt, 0) AS like_count,
-        COALESCE(b_agg.cnt, 0) AS boost_count,
-        COALESCE(r_agg.cnt, 0) AS reply_count,
-        {viewer_cols}
-    FROM thoughts t
-    JOIN users u ON u.id=t.user_id
-    LEFT JOIN remote_actors ra ON u.ap_id = ra.url
-    LEFT JOIN (SELECT thought_id, COUNT(*) AS cnt FROM likes GROUP BY thought_id) l_agg ON l_agg.thought_id = t.id
-    LEFT JOIN (SELECT thought_id, COUNT(*) AS cnt FROM boosts GROUP BY thought_id) b_agg ON b_agg.thought_id = t.id
-    LEFT JOIN (SELECT in_reply_to_id, COUNT(*) AS cnt FROM thoughts WHERE in_reply_to_id IS NOT NULL GROUP BY in_reply_to_id) r_agg ON r_agg.in_reply_to_id = t.id
-    {viewer_joins}"
-        )
-    }
-
-    fn fed_clause(&self, viewer_param: &str) -> String {
-        match self.viewer {
-            Some(_) => format!(
-                " OR t.user_id IN (
-                SELECT u2.id FROM users u2
-                JOIN federation_following ff ON u2.ap_id = ff.remote_actor_url
-                WHERE ff.local_user_id = {viewer_param}
-            )"
-            ),
-            None => String::new(),
-        }
-    }
-
-    fn filter_sql(&self) -> String {
-        let f = &self.options.filter;
-        let mut s = String::new();
-        if f.originals_only {
-            s += " AND t.in_reply_to_id IS NULL";
-        }
-        if f.replies_only {
-            s += " AND t.in_reply_to_id IS NOT NULL";
-        }
-        if f.local_only {
-            s += " AND t.local = true";
-        }
-        if f.hide_sensitive {
-            s += " AND t.sensitive = false";
-        }
-        s
-    }
-
-    fn order_sql(&self) -> &'static str {
-        if matches!(self.scope, FeedScope::Search { .. }) {
-            return "ORDER BY similarity(t.content, $1) DESC";
-        }
-        match &self.options.sort {
-            FeedSort::Newest => "ORDER BY t.created_at DESC",
-            FeedSort::Oldest => "ORDER BY t.created_at ASC",
-            FeedSort::MostLiked => "ORDER BY like_count DESC, t.created_at DESC",
-            FeedSort::MostBoosted => "ORDER BY boost_count DESC, t.created_at DESC",
-            FeedSort::MostDiscussed => "ORDER BY reply_count DESC, t.created_at DESC",
-        }
-    }
-
-    fn public(&self) -> (String, String) {
-        let filter = self.filter_sql();
-        let order = self.order_sql();
-        let count = format!(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'{}",
-            filter
-        );
-        let data = format!(
-            "{} WHERE t.local=true AND t.visibility='public'{} {} LIMIT $1 OFFSET $2",
-            self.select("$3"),
-            filter,
-            order
-        );
-        (count, data)
-    }
-
-    fn home(&self) -> (String, String) {
-        let filter = self.filter_sql();
-        let order = self.order_sql();
-        let count = format!(
-            "SELECT COUNT(*) FROM thoughts t WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct'{}",
-            self.fed_clause("$2"), filter
-        );
-        let data =
-            format!(
-            "{} WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct'{} {} LIMIT $2 OFFSET $3",
-            self.select("$4"), self.fed_clause("$4"), filter, order
-        );
-        (count, data)
-    }
-
-    fn search(&self) -> (String, String) {
-        let filter = self.filter_sql();
-        let order = self.order_sql();
-        let count = format!(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'{}",
-            filter
-        );
-        let data = format!(
-            "{} WHERE t.content % $1 AND t.visibility='public'{} {} LIMIT $2 OFFSET $3",
-            self.select("$4"),
-            filter,
-            order
-        );
-        (count, data)
-    }
-
-    fn tag(&self) -> (String, String) {
-        let filter = self.filter_sql();
-        let order = self.order_sql();
-        let count = format!(
-            "SELECT COUNT(*) FROM thoughts t
-             JOIN thought_tags tt ON tt.thought_id = t.id
-             JOIN tags tg ON tg.id = tt.tag_id
-             WHERE tg.name = $1 AND t.visibility = 'public'{}",
-            filter
-        );
-        let data = format!(
-            "{}
-             JOIN thought_tags tt ON tt.thought_id = t.id
-             JOIN tags tg ON tg.id = tt.tag_id
-             WHERE tg.name = $1 AND t.visibility = 'public'{} {} LIMIT $2 OFFSET $3",
-            self.select("$4"),
-            filter,
-            order
-        );
-        (count, data)
-    }
-
-    fn user(&self) -> (String, String) {
-        let filter = self.filter_sql();
-        let order = self.order_sql();
-        let count  = format!(
-            "SELECT COUNT(*) FROM thoughts t WHERE t.user_id = $1 AND ($2::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $2 AND following_id = $1 AND state = 'accepted'))))){}",
-            filter
-        );
-        let data = format!(
-            "{} WHERE t.user_id = $1 AND ($4::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $4 AND following_id = $1 AND state = 'accepted'))))){} {} LIMIT $2 OFFSET $3",
-            self.select("$4"), filter, order
-        );
-        (count, data)
-    }
-}
-
 #[async_trait]
 impl FeedRepository for PgFeedRepository {
-    async fn query(&self, req: &FeedRequest) -> Result<Paginated<FeedEntry>, DomainError> {
+    async fn query(&self, q: &FeedQuery) -> Result<Paginated<FeedEntry>, DomainError> {
-        let viewer = req.query.viewer_id.as_ref().map(|v| v.as_uuid());
+        let viewer = q.viewer_id.as_ref().map(|v| v.as_uuid());
-        let page = &req.query.page;
+        let page = &q.page;
-        let builder = FeedSqlBuilder::new(&req.options, &req.query.scope, viewer);
 
-        let viewer_uuid = viewer.unwrap_or(uuid::Uuid::nil());
+        match &q.scope {
-
-        match &req.query.scope {
             FeedScope::Home { following_ids } => {
                 let ids: Vec<uuid::Uuid> = following_ids.iter().map(|id| id.as_uuid()).collect();
-                let (count_sql, data_sql) = builder.home();
+                let fed_clause = federation_following_clause(viewer);
+                let count_sql = format!(
+                    "SELECT COUNT(*) FROM thoughts t WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct'",
+                    fed_clause
+                );
                 let total: i64 = sqlx::query_scalar(&count_sql)
                     .bind(&ids)
-                    .bind(viewer_uuid)
                     .fetch_one(&self.pool)
                     .await
                     .into_domain()?;
-                let rows = sqlx::query_as::<_, FeedRow>(&data_sql)
+
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE (t.user_id=ANY($1){}) AND t.visibility != 'direct' ORDER BY t.created_at DESC LIMIT $2 OFFSET $3", fed_clause);
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
                     .bind(&ids)
                     .bind(page.limit())
                     .bind(page.offset())
-                    .bind(viewer_uuid)
                     .fetch_all(&self.pool)
                     .await
                     .into_domain()?;
+
                 Ok(Paginated {
                     items: rows
                         .into_iter()
@@ -310,18 +190,22 @@ impl FeedRepository for PgFeedRepository {
             }
 
             FeedScope::Public => {
-                let (count_sql, data_sql) = builder.public();
+                let total: i64 = sqlx::query_scalar(
-                let total: i64 = sqlx::query_scalar(&count_sql)
+                    "SELECT COUNT(*) FROM thoughts t WHERE t.local=true AND t.visibility='public'",
+                )
                 .fetch_one(&self.pool)
                 .await
                 .into_domain()?;
-                let rows = sqlx::query_as::<_, FeedRow>(&data_sql)
+
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE t.local=true AND t.visibility='public' ORDER BY t.created_at DESC LIMIT $1 OFFSET $2");
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
                     .bind(page.limit())
                     .bind(page.offset())
-                    .bind(viewer_uuid)
                     .fetch_all(&self.pool)
                     .await
                     .into_domain()?;
+
                 Ok(Paginated {
                     items: rows
                         .into_iter()
@@ -334,20 +218,24 @@ impl FeedRepository for PgFeedRepository {
             }
 
             FeedScope::Search { query } => {
-                let (count_sql, data_sql) = builder.search();
+                let total: i64 = sqlx::query_scalar(
-                let total: i64 = sqlx::query_scalar(&count_sql)
+                    "SELECT COUNT(*) FROM thoughts t WHERE t.content % $1 AND t.visibility='public'",
+                )
                 .bind(query)
                 .fetch_one(&self.pool)
                 .await
                 .into_domain()?;
-                let rows = sqlx::query_as::<_, FeedRow>(&data_sql)
+
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE t.content % $1 AND t.visibility='public' ORDER BY similarity(t.content, $1) DESC LIMIT $2 OFFSET $3");
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
                     .bind(query)
                     .bind(page.limit())
                     .bind(page.offset())
-                    .bind(viewer_uuid)
                     .fetch_all(&self.pool)
                     .await
                     .into_domain()?;
+
                 Ok(Paginated {
                     items: rows
                         .into_iter()
@@ -360,20 +248,33 @@ impl FeedRepository for PgFeedRepository {
             }
 
             FeedScope::Tag { tag_name } => {
-                let (count_sql, data_sql) = builder.tag();
+                let total: i64 = sqlx::query_scalar(
-                let total: i64 = sqlx::query_scalar(&count_sql)
+                    "SELECT COUNT(*) FROM thoughts t
+                     JOIN thought_tags tt ON tt.thought_id = t.id
+                     JOIN tags tg ON tg.id = tt.tag_id
+                     WHERE tg.name = $1 AND t.visibility = 'public'",
+                )
                 .bind(tag_name)
                 .fetch_one(&self.pool)
                 .await
                 .into_domain()?;
-                let rows = sqlx::query_as::<_, FeedRow>(&data_sql)
+
+                let sel = feed_select(viewer);
+                let sql = format!(
+                    "{sel}
+                     JOIN thought_tags tt ON tt.thought_id = t.id
+                     JOIN tags tg ON tg.id = tt.tag_id
+                     WHERE tg.name = $1 AND t.visibility = 'public'
+                     ORDER BY t.created_at DESC LIMIT $2 OFFSET $3"
+                );
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
                     .bind(tag_name)
                     .bind(page.limit())
                     .bind(page.offset())
-                    .bind(viewer_uuid)
                     .fetch_all(&self.pool)
                     .await
                     .into_domain()?;
+
                 Ok(Paginated {
                     items: rows
                         .into_iter()
@@ -387,14 +288,21 @@ impl FeedRepository for PgFeedRepository {
 
             FeedScope::User { user_id } => {
                 let uid = user_id.as_uuid();
-                let (count_sql, data_sql) = builder.user();
+                // Use nil UUID for unauthenticated viewers — won't match owner or follower checks.
-                let total: i64 = sqlx::query_scalar(&count_sql)
+                let viewer_uuid = viewer.unwrap_or(uuid::Uuid::nil());
+
+                let total: i64 = sqlx::query_scalar(
+                    "SELECT COUNT(*) FROM thoughts t WHERE t.user_id = $1 AND ($2::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $2 AND following_id = $1 AND state = 'accepted')))))",
+                )
                 .bind(uid)
                 .bind(viewer_uuid)
                 .fetch_one(&self.pool)
                 .await
                 .into_domain()?;
-                let rows = sqlx::query_as::<_, FeedRow>(&data_sql)
+
+                let sel = feed_select(viewer);
+                let sql = format!("{sel} WHERE t.user_id = $1 AND ($4::uuid = $1 OR (t.visibility != 'direct' AND (t.visibility IN ('public', 'unlisted') OR (t.visibility = 'followers' AND EXISTS(SELECT 1 FROM follows WHERE follower_id = $4 AND following_id = $1 AND state = 'accepted'))))) ORDER BY t.created_at DESC LIMIT $2 OFFSET $3");
+                let rows = sqlx::query_as::<_, FeedRow>(&sql)
                     .bind(uid)
                     .bind(page.limit())
                     .bind(page.offset())
@@ -402,6 +310,7 @@ impl FeedRepository for PgFeedRepository {
                     .fetch_all(&self.pool)
                     .await
                     .into_domain()?;
+
                 Ok(Paginated {
                     items: rows
                         .into_iter()

crates/adapters/postgres/src/feed/tests.rs

@@ -3,11 +3,11 @@ use crate::{thought::PgThoughtRepository, user::PgUserRepository};
     use domain::{
         models::{
             feed::PageParams,
-        thought::{NewThought, Thought, Visibility},
+            thought::{Thought, Visibility},
             user::User,
         },
-    ports::{FeedOptions, FeedQuery, FeedRequest, ThoughtRepository, UserWriter},
+        ports::{FeedQuery, ThoughtRepository, UserWriter},
-    value_objects::{Content, Email, PasswordHash, ThoughtId, UserId, Username},
+        value_objects::*,
     };
 
     async fn seed(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thought) {
@@ -20,16 +20,15 @@ async fn seed(pool: &sqlx::PgPool, username: &str, content: &str) -> (User, Thou
             PasswordHash("h".into()),
         );
         urepo.save(&u).await.unwrap();
-    let t = Thought::new_local(NewThought {
+        let t = Thought::new_local(
-        id: ThoughtId::new(),
+            ThoughtId::new(),
-        user_id: u.id.clone(),
+            u.id.clone(),
-        content: Content::new_local(content).unwrap(),
+            Content::new_local(content).unwrap(),
-        in_reply_to_id: None,
+            None,
-        visibility: Visibility::Public,
+            Visibility::Public,
-        content_warning: None,
+            None,
-        sensitive: false,
+            false,
-        mood: None,
+        );
-    });
         trepo.save(&t).await.unwrap();
         (u, t)
     }
@@ -39,16 +38,10 @@ async fn public_feed_returns_local_thoughts(pool: sqlx::PgPool) {
         let (_, _) = seed(&pool, "alice", "hello").await;
         let repo = PgFeedRepository::new(pool);
         let result = repo
-        .query(&FeedRequest {
+            .query(&FeedQuery::public(
-            query: FeedQuery::public(
+                PageParams { page: 1, per_page: 20 },
-                PageParams {
-                    page: 1,
-                    per_page: 20,
-                },
                 None,
-            ),
+            ))
-            options: FeedOptions::default(),
-        })
             .await
             .unwrap();
         assert_eq!(result.total, 1);
@@ -61,17 +54,11 @@ async fn search_returns_matching_thoughts(pool: sqlx::PgPool) {
         let (_, _) = seed(&pool, "bob", "goodbye world").await;
         let repo = PgFeedRepository::new(pool);
         let result = repo
-        .query(&FeedRequest {
+            .query(&FeedQuery::search(
-            query: FeedQuery::search(
                 "hello world",
-                PageParams {
+                PageParams { page: 1, per_page: 20 },
-                    page: 1,
-                    per_page: 20,
-                },
                 None,
-            ),
+            ))
-            options: FeedOptions::default(),
-        })
             .await
             .unwrap();
         assert!(result.total >= 1);

crates/adapters/postgres/src/follow/mod.rs

@@ -120,7 +120,7 @@ impl FollowRepository for PgFollowRepository {
         .into_domain()?;
 
         let rows = sqlx::query_as::<_, crate::user::UserRow>(
-            "SELECT u.id,u.username,u.email,u.password_hash,u.display_name,u.bio,u.avatar_url,u.header_url,u.custom_css,u.profile_fields,u.custom_moods,u.local,u.created_at,u.updated_at
+            "SELECT u.id,u.username,u.email,u.password_hash,u.display_name,u.bio,u.avatar_url,u.header_url,u.custom_css,u.local,u.ap_id,u.inbox_url,u.created_at,u.updated_at
              FROM users u JOIN follows f ON f.follower_id=u.id
              WHERE f.following_id=$1 AND f.state='accepted'
              ORDER BY f.created_at DESC LIMIT $2 OFFSET $3"
@@ -154,7 +154,7 @@ impl FollowRepository for PgFollowRepository {
         .into_domain()?;
 
         let rows = sqlx::query_as::<_, crate::user::UserRow>(
-            "SELECT u.id,u.username,u.email,u.password_hash,u.display_name,u.bio,u.avatar_url,u.header_url,u.custom_css,u.profile_fields,u.custom_moods,u.local,u.created_at,u.updated_at
+            "SELECT u.id,u.username,u.email,u.password_hash,u.display_name,u.bio,u.avatar_url,u.header_url,u.custom_css,u.local,u.ap_id,u.inbox_url,u.created_at,u.updated_at
              FROM users u JOIN follows f ON f.following_id=u.id
              WHERE f.follower_id=$1 AND f.state='accepted'
              ORDER BY f.created_at DESC LIMIT $2 OFFSET $3"
@@ -187,59 +187,6 @@ impl FollowRepository for PgFollowRepository {
         .into_domain()?;
         Ok(ids.into_iter().map(UserId::from_uuid).collect())
     }
-
-    async fn list_mutual(
-        &self,
-        user_id: &UserId,
-        page: &PageParams,
-    ) -> Result<Paginated<User>, DomainError> {
-        let total: i64 = sqlx::query_scalar(
-            "SELECT COUNT(*) FROM follows f1
-             WHERE f1.follower_id = $1 AND f1.state = 'accepted'
-               AND EXISTS (
-                 SELECT 1 FROM follows f2
-                 WHERE f2.follower_id  = f1.following_id
-                   AND f2.following_id = f1.follower_id
-                   AND f2.state = 'accepted'
-               )",
-        )
-        .bind(user_id.as_uuid())
-        .fetch_one(&self.pool)
-        .await
-        .into_domain()?;
-
-        let rows = sqlx::query_as::<_, crate::user::UserRow>(
-            "SELECT u.id, u.username, u.email, u.password_hash, u.display_name, u.bio,
-                    u.avatar_url, u.header_url, u.custom_css, u.profile_fields, u.custom_moods, u.local,
-                    u.created_at, u.updated_at
-             FROM users u
-             JOIN follows f1
-               ON f1.follower_id  = $1
-              AND f1.following_id = u.id
-              AND f1.state = 'accepted'
-             WHERE EXISTS (
-               SELECT 1 FROM follows f2
-               WHERE f2.follower_id  = u.id
-                 AND f2.following_id = $1
-                 AND f2.state = 'accepted'
-             )
-             ORDER BY f1.created_at DESC
-             LIMIT $2 OFFSET $3",
-        )
-        .bind(user_id.as_uuid())
-        .bind(page.limit())
-        .bind(page.offset())
-        .fetch_all(&self.pool)
-        .await
-        .into_domain()?;
-
-        Ok(Paginated {
-            items: rows.into_iter().map(User::from).collect(),
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
-    }
 }
 
 #[cfg(test)]

crates/adapters/postgres/src/follow/tests.rs

@@ -1,6 +1,7 @@
     use super::*;
     use crate::test_helpers::seed_user;
     use chrono::Utc;
+    use domain::value_objects::*;
 
     #[sqlx::test(migrations = "./migrations")]
     async fn save_and_find_follow(pool: sqlx::PgPool) {
@@ -55,86 +56,3 @@ async fn get_accepted_following_ids(pool: sqlx::PgPool) {
         let ids = repo.get_accepted_following_ids(&alice.id).await.unwrap();
         assert_eq!(ids, vec![bob.id]);
     }
-
-#[sqlx::test(migrations = "./migrations")]
-async fn list_mutual_returns_only_mutual_accepted_follows(pool: sqlx::PgPool) {
-    let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-    let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-    let carol = seed_user(&pool, "carol", "carol@ex.com").await;
-    let repo = PgFollowRepository::new(pool);
-    let page = domain::models::feed::PageParams {
-        page: 1,
-        per_page: 20,
-    };
-
-    // alice → bob (accepted), bob → alice (accepted) = friends
-    repo.save(&Follow {
-        follower_id: alice.id.clone(),
-        following_id: bob.id.clone(),
-        state: FollowState::Accepted,
-        ap_id: None,
-        created_at: Utc::now(),
-    })
-    .await
-    .unwrap();
-    repo.save(&Follow {
-        follower_id: bob.id.clone(),
-        following_id: alice.id.clone(),
-        state: FollowState::Accepted,
-        ap_id: None,
-        created_at: Utc::now(),
-    })
-    .await
-    .unwrap();
-
-    // alice → carol (accepted), carol does NOT follow back = not a friend
-    repo.save(&Follow {
-        follower_id: alice.id.clone(),
-        following_id: carol.id.clone(),
-        state: FollowState::Accepted,
-        ap_id: None,
-        created_at: Utc::now(),
-    })
-    .await
-    .unwrap();
-
-    let result = repo.list_mutual(&alice.id, &page).await.unwrap();
-    assert_eq!(result.total, 1);
-    assert_eq!(result.items.len(), 1);
-    assert_eq!(result.items[0].id, bob.id);
-}
-
-#[sqlx::test(migrations = "./migrations")]
-async fn list_mutual_excludes_pending_follows(pool: sqlx::PgPool) {
-    let alice = seed_user(&pool, "alice", "alice@ex.com").await;
-    let bob = seed_user(&pool, "bob", "bob@ex.com").await;
-    let repo = PgFollowRepository::new(pool);
-    let page = domain::models::feed::PageParams {
-        page: 1,
-        per_page: 20,
-    };
-
-    // alice → bob (accepted), bob → alice (PENDING) = NOT a friend
-    repo.save(&Follow {
-        follower_id: alice.id.clone(),
-        following_id: bob.id.clone(),
-        state: FollowState::Accepted,
-        ap_id: None,
-        created_at: Utc::now(),
-    })
-    .await
-    .unwrap();
-    repo.save(&Follow {
-        follower_id: bob.id.clone(),
-        following_id: alice.id.clone(),
-        state: FollowState::Pending,
-        ap_id: None,
-        created_at: Utc::now(),
-    })
-    .await
-    .unwrap();
-
-    let result = repo.list_mutual(&alice.id, &page).await.unwrap();
-    assert_eq!(result.total, 0);
-    assert!(result.items.is_empty());
-}

crates/adapters/postgres/src/jsonb.rs

@@ -1,20 +0,0 @@
-pub fn parse_name_value(v: Option<serde_json::Value>) -> Vec<(String, String)> {
-    v.and_then(|v| v.as_array().cloned())
-        .map(|arr| {
-            arr.into_iter()
-                .filter_map(|item| {
-                    let name = item.get("name")?.as_str()?.to_string();
-                    let value = item.get("value")?.as_str()?.to_string();
-                    Some((name, value))
-                })
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
-pub fn serialize_name_value(fields: &[(String, String)]) -> serde_json::Value {
-    fields
-        .iter()
-        .map(|(n, v)| serde_json::json!({"name": n, "value": v}))
-        .collect()
-}

crates/adapters/postgres/src/lib.rs

@@ -1,17 +1,15 @@
 pub mod activitypub;
+pub mod engagement;
 pub mod api_key;
 pub mod block;
 pub mod boost;
-pub mod constants;
 mod db_error;
-pub mod engagement;
 pub mod failed_event;
+pub mod outbox;
 pub mod feed;
 pub mod follow;
-pub(crate) mod jsonb;
 pub mod like;
 pub mod notification;
-pub mod outbox;
 pub mod remote_actor;
 pub mod remote_actor_connections;
 pub mod tag;

crates/adapters/postgres/src/like/tests.rs

@@ -1,6 +1,7 @@
     use super::*;
     use crate::test_helpers::seed_user_and_thought;
     use chrono::Utc;
+    use domain::value_objects::*;
 
     #[sqlx::test(migrations = "./migrations")]
     async fn like_and_count(pool: sqlx::PgPool) {

crates/adapters/postgres/src/notification/tests.rs

@@ -1,7 +1,10 @@
     use super::*;
     use crate::test_helpers;
     use chrono::Utc;
-use domain::models::notification::NotificationKind;
+    use domain::{
+        models::{notification::NotificationKind, user::User},
+        value_objects::*,
+    };
 
     #[sqlx::test(migrations = "./migrations")]
     async fn save_and_list(pool: sqlx::PgPool) {

crates/adapters/postgres/src/outbox.rs

@@ -32,9 +32,6 @@ fn aggregate_id(event: &DomainEvent) -> Uuid {
         DomainEvent::UserUnblocked { blocker_id, .. } => blocker_id.as_uuid(),
         DomainEvent::UserRegistered { user_id } => user_id.as_uuid(),
         DomainEvent::ProfileUpdated { user_id } => user_id.as_uuid(),
-        DomainEvent::RemoteFollowAccepted { local_user_id, .. } => local_user_id.as_uuid(),
-        DomainEvent::RemoteFollowRejected { local_user_id, .. } => local_user_id.as_uuid(),
-        DomainEvent::ActorMoved { user_id, .. } => user_id.as_uuid(),
         DomainEvent::MentionReceived { thought_id, .. } => thought_id.as_uuid(),
     }
 }

crates/adapters/postgres/src/remote_actor.rs

@@ -18,40 +18,14 @@ impl PgRemoteActorRepository {
 #[async_trait]
 impl RemoteActorRepository for PgRemoteActorRepository {
     async fn upsert(&self, a: &RemoteActor) -> Result<(), DomainError> {
-        let also_known_as: Option<Vec<&str>> = if a.also_known_as.is_empty() {
-            None
-        } else {
-            Some(a.also_known_as.iter().map(|s| s.as_str()).collect())
-        };
-        let attachment_json = crate::jsonb::serialize_name_value(&a.attachment);
         sqlx::query(
-            "INSERT INTO remote_actors(url,handle,display_name,avatar_url,last_fetched_at,
+            "INSERT INTO remote_actors(url,handle,display_name,avatar_url,last_fetched_at)
-             bio,banner_url,outbox_url,followers_url,following_url,also_known_as,attachment)
+             VALUES($1,$2,$3,$4,$5)
-             VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)
+             ON CONFLICT(url) DO UPDATE SET handle=EXCLUDED.handle,display_name=EXCLUDED.display_name,
-             ON CONFLICT(url) DO UPDATE SET
+             avatar_url=EXCLUDED.avatar_url,last_fetched_at=EXCLUDED.last_fetched_at"
-             handle=EXCLUDED.handle,display_name=EXCLUDED.display_name,
-             avatar_url=EXCLUDED.avatar_url,last_fetched_at=EXCLUDED.last_fetched_at,
-             bio=EXCLUDED.bio,banner_url=EXCLUDED.banner_url,
-             outbox_url=EXCLUDED.outbox_url,followers_url=EXCLUDED.followers_url,
-             following_url=EXCLUDED.following_url,also_known_as=EXCLUDED.also_known_as,
-             attachment=EXCLUDED.attachment",
         )
-        .bind(&a.url)
+        .bind(&a.url).bind(&a.handle).bind(&a.display_name).bind(&a.avatar_url).bind(a.last_fetched_at)
-        .bind(&a.handle)
+        .execute(&self.pool).await.into_domain().map(|_| ())
-        .bind(&a.display_name)
-        .bind(&a.avatar_url)
-        .bind(a.last_fetched_at)
-        .bind(&a.bio)
-        .bind(&a.banner_url)
-        .bind(&a.outbox_url)
-        .bind(&a.followers_url)
-        .bind(&a.following_url)
-        .bind(also_known_as.as_deref())
-        .bind(&attachment_json)
-        .execute(&self.pool)
-        .await
-        .into_domain()
-        .map(|_| ())
     }
 
     async fn find_by_url(&self, url: &str) -> Result<Option<RemoteActor>, DomainError> {
@@ -62,43 +36,24 @@ impl RemoteActorRepository for PgRemoteActorRepository {
             display_name: Option<String>,
             avatar_url: Option<String>,
             last_fetched_at: DateTime<Utc>,
-            bio: Option<String>,
-            banner_url: Option<String>,
-            outbox_url: Option<String>,
-            followers_url: Option<String>,
-            following_url: Option<String>,
-            also_known_as: Option<Vec<String>>,
-            inbox_url: Option<String>,
-            shared_inbox_url: Option<String>,
-            attachment: Option<serde_json::Value>,
         }
         sqlx::query_as::<_, Row>(
-            "SELECT url,handle,display_name,avatar_url,last_fetched_at,
+            "SELECT url,handle,display_name,avatar_url,last_fetched_at FROM remote_actors WHERE url=$1"
-             bio,banner_url,outbox_url,followers_url,following_url,also_known_as,
+        ).bind(url).fetch_optional(&self.pool).await
-             inbox_url,shared_inbox_url,attachment
-             FROM remote_actors WHERE url=$1",
-        )
-        .bind(url)
-        .fetch_optional(&self.pool)
-        .await
         .into_domain()
-        .map(|o| {
+        .map(|o| o.map(|r| RemoteActor {
-            o.map(|r| RemoteActor {
             url: r.url,
             handle: r.handle,
             display_name: r.display_name,
             avatar_url: r.avatar_url,
             last_fetched_at: r.last_fetched_at,
-                bio: r.bio,
+            bio: None,
-                banner_url: r.banner_url,
+            banner_url: None,
-                also_known_as: r.also_known_as.unwrap_or_default(),
+            also_known_as: None,
-                outbox_url: r.outbox_url,
+            outbox_url: None,
-                followers_url: r.followers_url,
+            followers_url: None,
-                following_url: r.following_url,
+            following_url: None,
-                inbox_url: r.inbox_url,
+            attachment: vec![],
-                shared_inbox_url: r.shared_inbox_url,
+        }))
-                attachment: crate::jsonb::parse_name_value(r.attachment),
-            })
-        })
     }
 }

crates/adapters/postgres/src/tag/mod.rs

@@ -12,12 +12,6 @@ use domain::{
 };
 use sqlx::PgPool;
 
-#[derive(sqlx::FromRow)]
-struct TagRow {
-    id: i32,
-    name: String,
-}
-
 pub struct PgTagRepository {
     pool: PgPool,
 }
@@ -36,7 +30,12 @@ impl TagRepository for PgTagRepository {
             .execute(&self.pool)
             .await
             .into_domain()?;
-        let row = sqlx::query_as::<_, TagRow>("SELECT id,name FROM tags WHERE name=$1")
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: i32,
+            name: String,
+        }
+        let row = sqlx::query_as::<_, Row>("SELECT id,name FROM tags WHERE name=$1")
             .bind(&name)
             .fetch_one(&self.pool)
             .await
@@ -73,7 +72,12 @@ impl TagRepository for PgTagRepository {
     }
 
     async fn list_for_thought(&self, thought_id: &ThoughtId) -> Result<Vec<Tag>, DomainError> {
-        sqlx::query_as::<_, TagRow>(
+        #[derive(sqlx::FromRow)]
+        struct Row {
+            id: i32,
+            name: String,
+        }
+        sqlx::query_as::<_, Row>(
             "SELECT t.id,t.name FROM tags t JOIN thought_tags tt ON tt.tag_id=t.id WHERE tt.thought_id=$1"
         ).bind(thought_id.as_uuid()).fetch_all(&self.pool).await
         .into_domain()

crates/adapters/postgres/src/tag/tests.rs

@@ -3,7 +3,7 @@ use crate::{thought::PgThoughtRepository, user::PgUserRepository};
     use domain::ports::{ThoughtRepository, UserWriter};
     use domain::{
         models::{
-        thought::{NewThought, Thought, Visibility},
+            thought::{Thought, Visibility},
             user::User,
         },
         value_objects::*,
@@ -29,16 +29,15 @@ async fn attach_and_list(pool: sqlx::PgPool) {
             PasswordHash("h".into()),
         );
         urepo.save(&u).await.unwrap();
-    let t = Thought::new_local(NewThought {
+        let t = Thought::new_local(
-        id: ThoughtId::new(),
+            ThoughtId::new(),
-        user_id: u.id.clone(),
+            u.id.clone(),
-        content: Content::new_local("hi").unwrap(),
+            Content::new_local("hi").unwrap(),
-        in_reply_to_id: None,
+            None,
-        visibility: Visibility::Public,
+            Visibility::Public,
-        content_warning: None,
+            None,
-        sensitive: false,
+            false,
-        mood: None,
+        );
-    });
         trepo.save(&t).await.unwrap();
         let repo = PgTagRepository::new(pool);
         let tag = repo.find_or_create("greetings").await.unwrap();

crates/adapters/postgres/src/test_helpers.rs

@@ -1,7 +1,7 @@
 use crate::{thought::PgThoughtRepository, user::PgUserRepository};
 use domain::{
     models::{
-        thought::{NewThought, Thought, Visibility},
+        thought::{Thought, Visibility},
         user::User,
     },
     ports::{ThoughtRepository, UserWriter},
@@ -23,16 +23,15 @@ pub async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User
 pub async fn seed_user_and_thought(pool: &sqlx::PgPool) -> (User, Thought) {
     let user = seed_user(pool, "alice", "alice@ex.com").await;
     let trepo = PgThoughtRepository::new(pool.clone());
-    let t = Thought::new_local(NewThought {
+    let t = Thought::new_local(
-        id: ThoughtId::new(),
+        ThoughtId::new(),
-        user_id: user.id.clone(),
+        user.id.clone(),
-        content: Content::new_local("hi").unwrap(),
+        Content::new_local("hi").unwrap(),
-        in_reply_to_id: None,
+        None,
-        visibility: Visibility::Public,
+        Visibility::Public,
-        content_warning: None,
+        None,
-        sensitive: false,
+        false,
-        mood: None,
+    );
-    });
     trepo.save(&t).await.unwrap();
     (user, t)
 }

crates/adapters/postgres/src/thought/mod.rs

@@ -34,8 +34,6 @@ pub(crate) struct ThoughtRow {
     pub local: bool,
     pub created_at: DateTime<Utc>,
     pub updated_at: Option<DateTime<Utc>>,
-    pub note_extensions: Option<serde_json::Value>,
-    pub mood: Option<String>,
 }
 
 impl TryFrom<ThoughtRow> for Thought {
@@ -52,21 +50,19 @@ impl TryFrom<ThoughtRow> for Thought {
             local: r.local,
             created_at: r.created_at,
             updated_at: r.updated_at,
-            note_extensions: r.note_extensions,
-            mood: r.mood,
         })
     }
 }
 
 const THOUGHT_SELECT: &str =
-    "SELECT id,user_id,content,in_reply_to_id,visibility,content_warning,sensitive,local,created_at,updated_at,note_extensions,mood FROM thoughts";
+    "SELECT id,user_id,content,in_reply_to_id,visibility,content_warning,sensitive,local,created_at,updated_at FROM thoughts";
 
 #[async_trait]
 impl ThoughtRepository for PgThoughtRepository {
     async fn save(&self, t: &Thought) -> Result<(), DomainError> {
         sqlx::query(
-            "INSERT INTO thoughts(id,user_id,content,in_reply_to_id,visibility,content_warning,sensitive,local,created_at,mood)
+            "INSERT INTO thoughts(id,user_id,content,in_reply_to_id,visibility,content_warning,sensitive,local,created_at)
-             VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)
+             VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)
              ON CONFLICT(id) DO UPDATE SET content=EXCLUDED.content,updated_at=NOW()"
         )
         .bind(t.id.as_uuid())
@@ -78,7 +74,6 @@ impl ThoughtRepository for PgThoughtRepository {
         .bind(t.sensitive)
         .bind(t.local)
         .bind(t.created_at)
-        .bind(&t.mood)
         .execute(&self.pool)
         .await
         .into_domain()
@@ -122,11 +117,11 @@ impl ThoughtRepository for PgThoughtRepository {
         sqlx::query_as::<_, ThoughtRow>(
             "WITH RECURSIVE thread AS (
                 SELECT id,user_id,content,in_reply_to_id,
-                       visibility,content_warning,sensitive,local,created_at,updated_at,note_extensions,mood
+                       visibility,content_warning,sensitive,local,created_at,updated_at
                 FROM thoughts WHERE id = $1
                 UNION ALL
                 SELECT t.id,t.user_id,t.content,t.in_reply_to_id,
-                       t.visibility,t.content_warning,t.sensitive,t.local,t.created_at,t.updated_at,t.note_extensions,t.mood
+                       t.visibility,t.content_warning,t.sensitive,t.local,t.created_at,t.updated_at
                 FROM thoughts t JOIN thread ON t.in_reply_to_id = thread.id
             )
             SELECT * FROM thread ORDER BY created_at ASC",

crates/adapters/postgres/src/thought/tests.rs

@@ -1,21 +1,23 @@
     use super::*;
     use crate::test_helpers::seed_user;
-use domain::models::thought::{NewThought, Thought, Visibility};
+    use domain::{
+        models::thought::{Thought, Visibility},
+        value_objects::*,
+    };
 
     #[sqlx::test(migrations = "./migrations")]
     async fn save_and_find_thought(pool: sqlx::PgPool) {
         let user = seed_user(&pool, "alice", "alice@ex.com").await;
         let repo = PgThoughtRepository::new(pool);
-    let t = Thought::new_local(NewThought {
+        let t = Thought::new_local(
-        id: ThoughtId::new(),
+            ThoughtId::new(),
-        user_id: user.id.clone(),
+            user.id.clone(),
-        content: Content::new_local("hello world").unwrap(),
+            Content::new_local("hello world").unwrap(),
-        in_reply_to_id: None,
+            None,
-        visibility: Visibility::Public,
+            Visibility::Public,
-        content_warning: None,
+            None,
-        sensitive: false,
+            false,
-        mood: None,
+        );
-    });
         repo.save(&t).await.unwrap();
         let found = repo.find_by_id(&t.id).await.unwrap().unwrap();
         assert_eq!(found.content.as_str(), "hello world");
@@ -26,16 +28,15 @@ async fn save_and_find_thought(pool: sqlx::PgPool) {
     async fn delete_thought(pool: sqlx::PgPool) {
         let user = seed_user(&pool, "bob", "bob@ex.com").await;
         let repo = PgThoughtRepository::new(pool);
-    let t = Thought::new_local(NewThought {
+        let t = Thought::new_local(
-        id: ThoughtId::new(),
+            ThoughtId::new(),
-        user_id: user.id.clone(),
+            user.id.clone(),
-        content: Content::new_local("bye").unwrap(),
+            Content::new_local("bye").unwrap(),
-        in_reply_to_id: None,
+            None,
-        visibility: Visibility::Public,
+            Visibility::Public,
-        content_warning: None,
+            None,
-        sensitive: false,
+            false,
-        mood: None,
+        );
-    });
         repo.save(&t).await.unwrap();
         repo.delete(&t.id, &user.id).await.unwrap();
         assert!(repo.find_by_id(&t.id).await.unwrap().is_none());
@@ -46,16 +47,15 @@ async fn delete_wrong_owner_returns_not_found(pool: sqlx::PgPool) {
         let alice = seed_user(&pool, "alice", "alice@ex.com").await;
         let bob = seed_user(&pool, "bob", "bob@ex.com").await;
         let repo = PgThoughtRepository::new(pool);
-    let t = Thought::new_local(NewThought {
+        let t = Thought::new_local(
-        id: ThoughtId::new(),
+            ThoughtId::new(),
-        user_id: alice.id.clone(),
+            alice.id.clone(),
-        content: Content::new_local("secret").unwrap(),
+            Content::new_local("secret").unwrap(),
-        in_reply_to_id: None,
+            None,
-        visibility: Visibility::Public,
+            Visibility::Public,
-        content_warning: None,
+            None,
-        sensitive: false,
+            false,
-        mood: None,
+        );
-    });
         repo.save(&t).await.unwrap();
         let err = repo.delete(&t.id, &bob.id).await.unwrap_err();
         assert!(matches!(err, DomainError::NotFound));
@@ -65,26 +65,24 @@ async fn delete_wrong_owner_returns_not_found(pool: sqlx::PgPool) {
     async fn get_thread_returns_root_and_replies(pool: sqlx::PgPool) {
         let user = seed_user(&pool, "charlie", "charlie@ex.com").await;
         let repo = PgThoughtRepository::new(pool);
-    let root = Thought::new_local(NewThought {
+        let root = Thought::new_local(
-        id: ThoughtId::new(),
+            ThoughtId::new(),
-        user_id: user.id.clone(),
+            user.id.clone(),
-        content: Content::new_local("root").unwrap(),
+            Content::new_local("root").unwrap(),
-        in_reply_to_id: None,
+            None,
-        visibility: Visibility::Public,
+            Visibility::Public,
-        content_warning: None,
+            None,
-        sensitive: false,
+            false,
-        mood: None,
+        );
-    });
+        let reply = Thought::new_local(
-    let reply = Thought::new_local(NewThought {
+            ThoughtId::new(),
-        id: ThoughtId::new(),
+            user.id.clone(),
-        user_id: user.id.clone(),
+            Content::new_local("reply").unwrap(),
-        content: Content::new_local("reply").unwrap(),
+            Some(root.id.clone()),
-        in_reply_to_id: Some(root.id.clone()),
+            Visibility::Public,
-        visibility: Visibility::Public,
+            None,
-        content_warning: None,
+            false,
-        sensitive: false,
+        );
-        mood: None,
-    });
         repo.save(&root).await.unwrap();
         repo.save(&reply).await.unwrap();
         let thread = repo.get_thread(&root.id).await.unwrap();

crates/adapters/postgres/src/top_friend/mod.rs

@@ -44,17 +44,27 @@ impl TopFriendRepository for PgTopFriendRepository {
 
     async fn list_for_user(&self, user_id: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> {
         #[derive(sqlx::FromRow)]
-        struct TopFriendRow {
+        struct Row {
             tf_user_id: uuid::Uuid,
             friend_id: uuid::Uuid,
             position: i16,
-            #[sqlx(flatten)]
+            id: uuid::Uuid,
-            user: crate::user::UserRow,
+            username: String,
+            email: String,
+            password_hash: String,
+            display_name: Option<String>,
+            bio: Option<String>,
+            avatar_url: Option<String>,
+            header_url: Option<String>,
+            custom_css: Option<String>,
+            local: bool,
+            created_at: chrono::DateTime<chrono::Utc>,
+            updated_at: chrono::DateTime<chrono::Utc>,
         }
-        let rows = sqlx::query_as::<_, TopFriendRow>(
+        let rows = sqlx::query_as::<_, Row>(
             "SELECT tf.user_id AS tf_user_id, tf.friend_id, tf.position,
              u.id, u.username, u.email, u.password_hash, u.display_name, u.bio,
-             u.avatar_url, u.header_url, u.custom_css, u.profile_fields, u.custom_moods, u.local,
+             u.avatar_url, u.header_url, u.custom_css, u.local,
              u.created_at, u.updated_at
              FROM top_friends tf JOIN users u ON u.id=tf.friend_id
              WHERE tf.user_id=$1 ORDER BY tf.position",
@@ -67,12 +77,27 @@ impl TopFriendRepository for PgTopFriendRepository {
         Ok(rows
             .into_iter()
             .map(|r| {
+                use domain::value_objects::{Email, PasswordHash, Username};
                 let tf = TopFriend {
                     user_id: UserId::from_uuid(r.tf_user_id),
                     friend_id: UserId::from_uuid(r.friend_id),
                     position: r.position,
                 };
-                (tf, User::from(r.user))
+                let u = User {
+                    id: UserId::from_uuid(r.id),
+                    username: Username::from_trusted(r.username),
+                    email: Email::from_trusted(r.email),
+                    password_hash: PasswordHash(r.password_hash),
+                    display_name: r.display_name,
+                    bio: r.bio,
+                    avatar_url: r.avatar_url,
+                    header_url: r.header_url,
+                    custom_css: r.custom_css,
+                    local: r.local,
+                    created_at: r.created_at,
+                    updated_at: r.updated_at,
+                };
+                (tf, u)
             })
             .collect())
     }

crates/adapters/postgres/src/user/mod.rs

@@ -4,7 +4,7 @@ use chrono::{DateTime, Utc};
 use domain::{
     errors::DomainError,
     models::feed::{PageParams, Paginated, UserSummary},
-    models::user::{UpdateProfileInput, User},
+    models::user::User,
     ports::{UserReader, UserWriter},
     value_objects::{Email, PasswordHash, UserId, Username},
 };
@@ -31,8 +31,6 @@ pub struct UserRow {
     pub avatar_url: Option<String>,
     pub header_url: Option<String>,
     pub custom_css: Option<String>,
-    pub profile_fields: Option<serde_json::Value>,
-    pub custom_moods: Option<serde_json::Value>,
     pub local: bool,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
@@ -50,8 +48,6 @@ impl From<UserRow> for User {
             avatar_url: r.avatar_url,
             header_url: r.header_url,
             custom_css: r.custom_css,
-            profile_fields: crate::jsonb::parse_name_value(r.profile_fields),
-            custom_moods: crate::jsonb::parse_name_value(r.custom_moods),
             local: r.local,
             created_at: r.created_at,
             updated_at: r.updated_at,
@@ -61,7 +57,7 @@ impl From<UserRow> for User {
 
 pub const USER_SELECT: &str =
     "SELECT id,username,email,password_hash,display_name,bio,avatar_url,header_url,\
-     custom_css,profile_fields,custom_moods,local,created_at,updated_at FROM users";
+     custom_css,local,created_at,updated_at FROM users";
 
 #[async_trait]
 impl UserReader for PgUserRepository {
@@ -143,10 +139,7 @@ impl UserReader for PgUserRepository {
             .into_domain()
     }
 
-    async fn list_paginated(
+    async fn list_paginated(&self, page: PageParams) -> Result<Paginated<UserSummary>, DomainError> {
-        &self,
-        page: PageParams,
-    ) -> Result<Paginated<UserSummary>, DomainError> {
         #[derive(sqlx::FromRow)]
         struct Row {
             id: uuid::Uuid,
@@ -194,12 +187,7 @@ impl UserReader for PgUserRepository {
                 following_count: r.following_count,
             })
             .collect();
-        Ok(Paginated {
+        Ok(Paginated { items, total, page: page.page, per_page: page.per_page })
-            items,
-            total,
-            page: page.page,
-            per_page: page.per_page,
-        })
     }
 
     async fn find_by_ids(&self, ids: &[UserId]) -> Result<HashMap<UserId, User>, DomainError> {
@@ -207,37 +195,32 @@ impl UserReader for PgUserRepository {
             return Ok(HashMap::new());
         }
         let uuids: Vec<uuid::Uuid> = ids.iter().map(|id| id.as_uuid()).collect();
-        let rows = sqlx::query_as::<_, UserRow>(&format!("{USER_SELECT} WHERE id = ANY($1)"))
+        let rows = sqlx::query_as::<_, UserRow>(
+            &format!("{USER_SELECT} WHERE id = ANY($1)")
+        )
         .bind(&uuids[..])
         .fetch_all(&self.pool)
         .await
         .into_domain()?;
 
-        Ok(rows
+        Ok(rows.into_iter().map(|r| {
-            .into_iter()
-            .map(|r| {
             let user = User::from(r);
             (user.id.clone(), user)
-            })
+        }).collect())
-            .collect())
     }
 }
 
 #[async_trait]
 impl UserWriter for PgUserRepository {
     async fn save(&self, user: &User) -> Result<(), DomainError> {
-        let profile_fields_json = crate::jsonb::serialize_name_value(&user.profile_fields);
-        let custom_moods_json = crate::jsonb::serialize_name_value(&user.custom_moods);
         sqlx::query(
-            "INSERT INTO users (id,username,email,password_hash,display_name,bio,avatar_url,header_url,custom_css,profile_fields,custom_moods,local,created_at,updated_at)
+            "INSERT INTO users (id,username,email,password_hash,display_name,bio,avatar_url,header_url,custom_css,local,created_at,updated_at)
-             VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)
+             VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)
              ON CONFLICT(id) DO UPDATE SET
                username=EXCLUDED.username, email=EXCLUDED.email,
                password_hash=EXCLUDED.password_hash, display_name=EXCLUDED.display_name,
                bio=EXCLUDED.bio, avatar_url=EXCLUDED.avatar_url,
                header_url=EXCLUDED.header_url, custom_css=EXCLUDED.custom_css,
-               profile_fields=EXCLUDED.profile_fields,
-               custom_moods=EXCLUDED.custom_moods,
                local=EXCLUDED.local,
                updated_at=NOW()"
         )
@@ -250,8 +233,6 @@ impl UserWriter for PgUserRepository {
         .bind(&user.avatar_url)
         .bind(&user.header_url)
         .bind(&user.custom_css)
-        .bind(&profile_fields_json)
-        .bind(&custom_moods_json)
         .bind(user.local)
         .bind(user.created_at)
         .bind(user.updated_at)
@@ -275,50 +256,21 @@ impl UserWriter for PgUserRepository {
     async fn update_profile(
         &self,
         user_id: &UserId,
-        input: UpdateProfileInput,
+        display_name: Option<String>,
+        bio: Option<String>,
+        avatar_url: Option<String>,
+        header_url: Option<String>,
+        custom_css: Option<String>,
     ) -> Result<(), DomainError> {
-        let profile_fields_json: Option<serde_json::Value> = input
-            .profile_fields
-            .as_ref()
-            .map(|f| crate::jsonb::serialize_name_value(f));
-        let custom_moods_json: Option<serde_json::Value> = input
-            .custom_moods
-            .as_ref()
-            .map(|f| crate::jsonb::serialize_name_value(f));
         sqlx::query(
-            "UPDATE users SET \
+            "UPDATE users SET display_name=$2,bio=$3,avatar_url=$4,header_url=$5,custom_css=$6,updated_at=NOW() WHERE id=$1"
-             display_name    = COALESCE($2, display_name), \
-             bio             = COALESCE($3, bio), \
-             avatar_url      = COALESCE($4, avatar_url), \
-             header_url      = COALESCE($5, header_url), \
-             custom_css      = COALESCE($6, custom_css), \
-             profile_fields  = COALESCE($7, profile_fields), \
-             custom_moods    = COALESCE($8, custom_moods), \
-             updated_at      = NOW() \
-             WHERE id = $1",
         )
         .bind(user_id.as_uuid())
-        .bind(input.display_name)
+        .bind(display_name)
-        .bind(input.bio)
+        .bind(bio)
-        .bind(input.avatar_url)
+        .bind(avatar_url)
-        .bind(input.header_url)
+        .bind(header_url)
-        .bind(input.custom_css)
+        .bind(custom_css)
-        .bind(profile_fields_json)
-        .bind(custom_moods_json)
-        .execute(&self.pool)
-        .await
-        .into_domain()
-        .map(|_| ())
-    }
-
-    async fn set_also_known_as(
-        &self,
-        user_id: &UserId,
-        value: Option<String>,
-    ) -> Result<(), DomainError> {
-        sqlx::query("UPDATE users SET also_known_as = $2, updated_at = NOW() WHERE id = $1")
-            .bind(user_id.as_uuid())
-            .bind(value)
         .execute(&self.pool)
         .await
         .into_domain()

crates/adapters/postgres/src/user/tests.rs

@@ -1,5 +1,5 @@
     use super::*;
-use domain::models::user::{UpdateProfileInput, User};
+    use domain::{models::user::User, value_objects::*};
 
     #[sqlx::test(migrations = "./migrations")]
     async fn save_and_find_by_id(pool: sqlx::PgPool) {
@@ -55,11 +55,11 @@ async fn update_profile_changes_fields(pool: sqlx::PgPool) {
         repo.save(&user).await.unwrap();
         repo.update_profile(
             &user.id,
-        UpdateProfileInput {
+            Some("Charlie".into()),
-            display_name: Some("Charlie".into()),
+            Some("bio".into()),
-            bio: Some("bio".into()),
+            None,
-            ..Default::default()
+            None,
-        },
+            None,
         )
         .await
         .unwrap();

crates/adapters/storage/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "storage"
-version = "0.1.0"
-edition = "2021"
-
-[features]
-s3 = ["object_store/aws"]
-
-[dependencies]
-domain      = { workspace = true }
-async-trait = { workspace = true }
-bytes       = { workspace = true }
-futures     = { workspace = true }
-anyhow      = { workspace = true }
-object_store = { version = "0.11" }
-
-[dev-dependencies]
-tokio = { workspace = true, features = ["full"] }

crates/adapters/storage/src/adapter.rs

@@ -1,237 +0,0 @@
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    ports::{DataStream, MediaStore},
-};
-use futures::stream::StreamExt;
-use object_store::{path::Path, Error as OsError, ObjectStore};
-use std::sync::Arc;
-
-pub struct ObjectStorageAdapter {
-    store: Arc<dyn ObjectStore>,
-    prefix: String,
-}
-
-fn validate_key(key: &str) -> Result<(), DomainError> {
-    if key.is_empty() {
-        return Err(DomainError::InvalidInput(
-            "storage key must not be empty".into(),
-        ));
-    }
-    if key.starts_with('/') {
-        return Err(DomainError::InvalidInput(format!(
-            "storage key must not start with '/': {key}"
-        )));
-    }
-    if key.split('/').any(|seg| seg == ".." || seg == ".") {
-        return Err(DomainError::InvalidInput(format!(
-            "storage key contains invalid path segment: {key}"
-        )));
-    }
-    Ok(())
-}
-
-fn map_os_err(e: OsError) -> DomainError {
-    match e {
-        OsError::NotFound { .. } => DomainError::NotFound,
-        e => DomainError::Internal(e.to_string()),
-    }
-}
-
-impl ObjectStorageAdapter {
-    pub fn new(
-        store: Arc<dyn ObjectStore>,
-        prefix: impl Into<String>,
-    ) -> Result<Self, DomainError> {
-        let prefix = prefix.into();
-        if !prefix.is_empty() {
-            validate_key(&prefix)?;
-        }
-        Ok(Self { store, prefix })
-    }
-
-    fn path(&self, key: &str) -> Path {
-        if self.prefix.is_empty() {
-            Path::from(key)
-        } else {
-            Path::from(format!("{}/{key}", self.prefix))
-        }
-    }
-}
-
-#[async_trait]
-impl MediaStore for ObjectStorageAdapter {
-    async fn put(&self, key: &str, data: DataStream) -> Result<(), DomainError> {
-        validate_key(key)?;
-        let path = self.path(key);
-        let mut upload = self
-            .store
-            .put_multipart(&path)
-            .await
-            .map_err(|e| DomainError::Internal(e.to_string()))?;
-        let mut stream = data;
-        while let Some(result) = stream.next().await {
-            match result {
-                Ok(bytes) => {
-                    if let Err(e) = upload.put_part(bytes.into()).await {
-                        let _ = upload.abort().await;
-                        return Err(DomainError::Internal(e.to_string()));
-                    }
-                }
-                Err(e) => {
-                    let _ = upload.abort().await;
-                    return Err(e);
-                }
-            }
-        }
-        upload
-            .complete()
-            .await
-            .map(|_| ())
-            .map_err(|e| DomainError::Internal(e.to_string()))
-    }
-
-    async fn get(&self, key: &str) -> Result<DataStream, DomainError> {
-        validate_key(key)?;
-        let path = self.path(key);
-        let result = self.store.get(&path).await.map_err(map_os_err)?;
-        let s = result
-            .into_stream()
-            .map(|r| r.map_err(|e| DomainError::Internal(e.to_string())));
-        Ok(Box::pin(s))
-    }
-
-    async fn delete(&self, key: &str) -> Result<(), DomainError> {
-        validate_key(key)?;
-        let path = self.path(key);
-        match self.store.delete(&path).await {
-            Ok(()) => Ok(()),
-            Err(OsError::NotFound { .. }) => Ok(()),
-            Err(e) => Err(DomainError::Internal(e.to_string())),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use bytes::Bytes;
-    use futures::stream;
-    use object_store::memory::InMemory;
-
-    fn make_adapter() -> ObjectStorageAdapter {
-        ObjectStorageAdapter::new(Arc::new(InMemory::new()), "test").unwrap()
-    }
-
-    fn one_shot(data: &'static [u8]) -> DataStream {
-        Box::pin(stream::once(async move { Ok(Bytes::from(data)) }))
-    }
-
-    #[tokio::test]
-    async fn put_get_roundtrip() {
-        let a = make_adapter();
-        a.put("hello.txt", one_shot(b"world")).await.unwrap();
-        let mut s = a.get("hello.txt").await.unwrap();
-        let mut out = Vec::new();
-        while let Some(chunk) = s.next().await {
-            out.extend_from_slice(&chunk.unwrap());
-        }
-        assert_eq!(out, b"world");
-    }
-
-    #[tokio::test]
-    async fn get_missing_is_not_found() {
-        let a = make_adapter();
-        assert!(matches!(
-            a.get("nope.txt").await,
-            Err(DomainError::NotFound)
-        ));
-    }
-
-    #[tokio::test]
-    async fn delete_is_idempotent() {
-        let a = make_adapter();
-        a.delete("nope.txt").await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn delete_removes_key() {
-        let a = make_adapter();
-        a.put("file.txt", one_shot(b"data")).await.unwrap();
-        a.delete("file.txt").await.unwrap();
-        assert!(matches!(
-            a.get("file.txt").await,
-            Err(DomainError::NotFound)
-        ));
-    }
-
-    #[tokio::test]
-    async fn put_overwrites_existing() {
-        let a = make_adapter();
-        a.put("file.txt", one_shot(b"v1")).await.unwrap();
-        a.put("file.txt", one_shot(b"v2")).await.unwrap();
-        let mut s = a.get("file.txt").await.unwrap();
-        let mut out = Vec::new();
-        while let Some(chunk) = s.next().await {
-            out.extend_from_slice(&chunk.unwrap());
-        }
-        assert_eq!(out, b"v2");
-    }
-
-    #[tokio::test]
-    async fn rejects_empty_key() {
-        let a = make_adapter();
-        assert!(matches!(
-            a.put("", one_shot(b"x")).await,
-            Err(DomainError::InvalidInput(_))
-        ));
-        assert!(matches!(a.get("").await, Err(DomainError::InvalidInput(_))));
-        assert!(matches!(
-            a.delete("").await,
-            Err(DomainError::InvalidInput(_))
-        ));
-    }
-
-    #[tokio::test]
-    async fn rejects_absolute_key() {
-        let a = make_adapter();
-        assert!(matches!(
-            a.put("/etc/passwd", one_shot(b"x")).await,
-            Err(DomainError::InvalidInput(_))
-        ));
-    }
-
-    #[tokio::test]
-    async fn rejects_path_traversal() {
-        let a = make_adapter();
-        assert!(matches!(
-            a.get("../escape").await,
-            Err(DomainError::InvalidInput(_))
-        ));
-        assert!(matches!(
-            a.get("a/../../../etc").await,
-            Err(DomainError::InvalidInput(_))
-        ));
-    }
-
-    #[test]
-    fn new_rejects_traversal_prefix() {
-        assert!(matches!(
-            ObjectStorageAdapter::new(Arc::new(InMemory::new()), "../evil"),
-            Err(DomainError::InvalidInput(_))
-        ));
-    }
-
-    #[test]
-    fn new_rejects_absolute_prefix() {
-        assert!(matches!(
-            ObjectStorageAdapter::new(Arc::new(InMemory::new()), "/root"),
-            Err(DomainError::InvalidInput(_))
-        ));
-    }
-
-    #[test]
-    fn new_accepts_empty_prefix() {
-        assert!(ObjectStorageAdapter::new(Arc::new(InMemory::new()), "").is_ok());
-    }
-}

crates/adapters/storage/src/config.rs

@@ -1,67 +0,0 @@
-use anyhow::{Context, Result};
-use object_store::local::LocalFileSystem;
-use object_store::ObjectStore;
-use std::sync::Arc;
-
-#[derive(Debug, Clone)]
-pub struct StorageConfig {
-    pub backend: String,
-    pub local_path: Option<String>,
-    pub s3_endpoint: Option<String>,
-    pub s3_access_key_id: Option<String>,
-    pub s3_secret_access_key: Option<String>,
-    pub s3_bucket: Option<String>,
-    pub s3_region: Option<String>,
-}
-
-pub fn build_store(config: &StorageConfig) -> Result<Arc<dyn ObjectStore>> {
-    match config.backend.as_str() {
-        "local" => {
-            let path = config
-                .local_path
-                .as_deref()
-                .context("STORAGE_PATH must be set when STORAGE_BACKEND=local")?;
-            std::fs::create_dir_all(path)
-                .with_context(|| format!("failed to create storage dir: {path}"))?;
-            let store = LocalFileSystem::new_with_prefix(path)?;
-            Ok(Arc::new(store))
-        }
-        #[cfg(feature = "s3")]
-        "s3" => {
-            use object_store::aws::AmazonS3Builder;
-            let store = AmazonS3Builder::new()
-                .with_endpoint(
-                    config
-                        .s3_endpoint
-                        .as_deref()
-                        .context("S3_ENDPOINT must be set")?,
-                )
-                .with_access_key_id(
-                    config
-                        .s3_access_key_id
-                        .as_deref()
-                        .context("S3_ACCESS_KEY_ID must be set")?,
-                )
-                .with_secret_access_key(
-                    config
-                        .s3_secret_access_key
-                        .as_deref()
-                        .context("S3_SECRET_ACCESS_KEY must be set")?,
-                )
-                .with_bucket_name(
-                    config
-                        .s3_bucket
-                        .as_deref()
-                        .context("S3_BUCKET must be set")?,
-                )
-                .with_region(config.s3_region.as_deref().unwrap_or("us-east-1"))
-                .with_allow_http(true)
-                .build()?;
-            Ok(Arc::new(store))
-        }
-        other => anyhow::bail!(
-            "unknown STORAGE_BACKEND={other:?}; supported: local{}",
-            if cfg!(feature = "s3") { ", s3" } else { "" },
-        ),
-    }
-}

crates/adapters/storage/src/lib.rs

@@ -1,5 +0,0 @@
-pub mod adapter;
-pub mod config;
-
-pub use adapter::ObjectStorageAdapter;
-pub use config::{build_store, StorageConfig};

crates/api-types/Cargo.toml

@@ -5,7 +5,6 @@ edition = "2021"
 
 [dependencies]
 serde  = { workspace = true }
-serde_json = { workspace = true }
 uuid   = { workspace = true }
 chrono = { workspace = true }
 utoipa = { version = "5.5.0", features = ["uuid", "chrono"] }

crates/api-types/src/requests.rs

@@ -31,7 +31,6 @@ pub struct CreateThoughtRequest {
     pub visibility: Option<String>,
     pub content_warning: Option<String>,
     pub sensitive: Option<bool>,
-    pub mood: Option<String>,
 }
 
 #[derive(Deserialize, utoipa::ToSchema)]
@@ -48,8 +47,6 @@ pub struct UpdateProfileRequest {
     pub avatar_url: Option<String>,
     pub header_url: Option<String>,
     pub custom_css: Option<String>,
-    pub profile_fields: Option<Vec<crate::responses::ProfileField>>,
-    pub custom_moods: Option<Vec<crate::responses::ProfileField>>,
 }
 
 #[derive(Deserialize, utoipa::ToSchema)]

crates/api-types/src/responses.rs

@@ -1,5 +1,5 @@
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use uuid::Uuid;
 
 #[derive(Serialize, utoipa::ToSchema)]
@@ -19,8 +19,6 @@ pub struct UserResponse {
     pub avatar_url: Option<String>,
     pub header_url: Option<String>,
     pub custom_css: Option<String>,
-    pub profile_fields: Vec<ProfileField>,
-    pub custom_moods: Vec<ProfileField>,
     pub local: bool,
     pub is_followed_by_viewer: bool,
     #[serde(rename = "joinedAt")]
@@ -47,10 +45,6 @@ pub struct ThoughtResponse {
     pub boosted_by_viewer: bool,
     pub created_at: DateTime<Utc>,
     pub updated_at: Option<DateTime<Utc>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub note_extensions: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mood: Option<String>,
 }
 
 #[derive(Serialize, utoipa::ToSchema)]
@@ -87,13 +81,6 @@ pub struct TopFriendsResponse {
     pub top_friends: Vec<UserResponse>,
 }
 
-#[derive(Serialize, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct NotificationSummaryResponse {
-    pub total: i64,
-    pub unread: u64,
-}
-
 #[derive(Serialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ErrorResponse {
@@ -109,7 +96,7 @@ pub struct CreatedApiKeyResponse {
     pub key: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, utoipa::ToSchema)]
+#[derive(Serialize, Clone, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileField {
     pub name: String,
@@ -125,7 +112,7 @@ pub struct RemoteActorResponse {
     pub url: String,
     pub bio: Option<String>,
     pub banner_url: Option<String>,
-    pub also_known_as: Vec<String>,
+    pub also_known_as: Option<String>,
     pub outbox_url: Option<String>,
     pub followers_url: Option<String>,
     pub following_url: Option<String>,

crates/application/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 domain           = { workspace = true }
+activitypub-base = { workspace = true }
 async-trait      = { workspace = true }
 thiserror   = { workspace = true }
 uuid        = { workspace = true }
@@ -14,10 +15,7 @@ hex         = "0.4"
 tracing     = { workspace = true }
 url         = { workspace = true }
 tokio       = { workspace = true }
-bytes       = { workspace = true }
-futures     = { workspace = true }
 
 [dev-dependencies]
 tokio  = { workspace = true, features = ["full"] }
 domain = { workspace = true, features = ["test-helpers"] }
-serde_json = { workspace = true }

crates/application/src/services/federation_event/mod.rs

@@ -1,22 +1,19 @@
+use activitypub_base::{ActivityPubRepository, OutboundFederationPort};
 use domain::{
     errors::DomainError,
     events::DomainEvent,
     models::thought::Visibility,
-    ports::{FederationBroadcastPort, FederationContentRepository, ThoughtRepository, UserReader},
+    ports::{ThoughtRepository, UserReader},
     value_objects::ThoughtId,
 };
 use std::sync::Arc;
 
-fn should_broadcast(t: &domain::models::thought::Thought) -> bool {
-    t.local && matches!(t.visibility, Visibility::Public | Visibility::Unlisted)
-}
-
 pub struct FederationEventService {
     pub thoughts: Arc<dyn ThoughtRepository>,
     pub users: Arc<dyn UserReader>,
-    pub ap: Arc<dyn FederationBroadcastPort>,
+    pub ap: Arc<dyn OutboundFederationPort>,
     pub base_url: String,
-    pub ap_repo: Arc<dyn FederationContentRepository>,
+    pub ap_repo: Arc<dyn ActivityPubRepository>,
 }
 
 impl FederationEventService {
@@ -35,11 +32,16 @@ impl FederationEventService {
                 ..
             } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
-                    Some(t) if should_broadcast(&t) => t,
+                    Some(t)
-                    _ => {
+                        if t.local
-                        tracing::debug!(thought_id = %thought_id, "federation: skipping ThoughtCreated (remote or non-public)");
+                            && matches!(
-                        return Ok(());
+                                t.visibility,
+                                Visibility::Public | Visibility::Unlisted
+                            ) =>
+                    {
+                        t
                     }
+                    _ => return Ok(()),
                 };
                 let user = match self.users.find_by_id(user_id).await? {
                     Some(u) => u,
@@ -56,7 +58,6 @@ impl FederationEventService {
                 } else {
                     None
                 };
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Create(Note)");
                 self.ap
                     .broadcast_create(
                         user_id,
@@ -71,7 +72,8 @@ impl FederationEventService {
                 thought_id,
                 user_id,
             } => {
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Delete");
+                // No DB lookup — thought is already deleted when this event fires.
+                // No locality guard: delete commands only reach local thoughts via the use case.
                 let ap_id = format!("{}/thoughts/{}", self.base_url, thought_id);
                 self.ap.broadcast_delete(user_id, &ap_id).await
             }
@@ -81,7 +83,15 @@ impl FederationEventService {
                 user_id,
             } => {
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
-                    Some(t) if should_broadcast(&t) => t,
+                    Some(t)
+                        if t.local
+                            && matches!(
+                                t.visibility,
+                                Visibility::Public | Visibility::Unlisted
+                            ) =>
+                    {
+                        t
+                    }
                     _ => return Ok(()),
                 };
                 let user = match self.users.find_by_id(user_id).await? {
@@ -96,7 +106,6 @@ impl FederationEventService {
                 } else {
                     None
                 };
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Update(Note)");
                 self.ap
                     .broadcast_update(
                         user_id,
@@ -112,15 +121,16 @@ impl FederationEventService {
                 user_id,
                 thought_id,
             } => {
-                if !matches!(self.users.find_by_id(user_id).await?, Some(u) if u.local) {
+                // Only fan-out if the booster is a local user. Remote boosts must not be re-broadcast.
-                    tracing::debug!(user_id = %user_id, "federation: skipping BoostAdded (remote user)");
+                let booster = match self.users.find_by_id(user_id).await? {
-                    return Ok(());
+                    Some(u) if u.local => u,
-                }
+                    _ => return Ok(()),
+                };
+                let _ = booster;
                 if self.thoughts.find_by_id(thought_id).await?.is_none() {
                     return Ok(());
                 }
                 let object_ap_id = self.object_ap_id(thought_id).await?;
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Announce");
                 self.ap.broadcast_announce(user_id, &object_ap_id).await
             }
 
@@ -132,7 +142,6 @@ impl FederationEventService {
                     return Ok(());
                 }
                 let object_ap_id = self.object_ap_id(thought_id).await?;
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Undo(Announce)");
                 self.ap
                     .broadcast_undo_announce(user_id, &object_ap_id)
                     .await
@@ -143,26 +152,24 @@ impl FederationEventService {
                 user_id,
                 thought_id,
             } => {
-                if !matches!(self.users.find_by_id(user_id).await?, Some(u) if u.local) {
+                // Only federate: local liker + remote thought (has ap_id) + author has inbox.
-                    tracing::debug!(user_id = %user_id, "federation: skipping LikeAdded (remote user)");
+                let liker = match self.users.find_by_id(user_id).await? {
-                    return Ok(());
+                    Some(u) if u.local => u,
-                }
+                    _ => return Ok(()),
+                };
+                let _ = liker;
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
                     Some(t) => t,
                     _ => return Ok(()),
                 };
                 let thought_ap_id = match self.ap_repo.get_thought_ap_id(thought_id).await? {
                     Some(id) => id,
-                    None => {
+                    None => return Ok(()), // local thought — no federation needed
-                        tracing::debug!(thought_id = %thought_id, "federation: skipping LikeAdded (local thought)");
-                        return Ok(());
-                    }
                 };
                 let actor_urls = match self.ap_repo.get_actor_ap_urls(&thought.user_id).await? {
                     Some(u) => u,
                     None => return Ok(()),
                 };
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Like");
                 self.ap
                     .broadcast_like(user_id, &thought_ap_id, &actor_urls.inbox_url)
                     .await
@@ -172,9 +179,11 @@ impl FederationEventService {
                 user_id,
                 thought_id,
             } => {
-                if !matches!(self.users.find_by_id(user_id).await?, Some(u) if u.local) {
+                let liker = match self.users.find_by_id(user_id).await? {
-                    return Ok(());
+                    Some(u) if u.local => u,
-                }
+                    _ => return Ok(()),
+                };
+                let _ = liker;
                 let thought = match self.thoughts.find_by_id(thought_id).await? {
                     Some(t) => t,
                     _ => return Ok(()),
@@ -187,14 +196,12 @@ impl FederationEventService {
                     Some(u) => u,
                     None => return Ok(()),
                 };
-                tracing::info!(thought_id = %thought_id, user_id = %user_id, "federation: broadcasting Undo(Like)");
                 self.ap
                     .broadcast_undo_like(user_id, &thought_ap_id, &actor_urls.inbox_url)
                     .await
             }
 
             DomainEvent::ProfileUpdated { user_id } => {
-                tracing::info!(user_id = %user_id, "federation: broadcasting actor update");
                 self.ap.broadcast_actor_update(user_id).await
             }