ci: fail clearly when PACKAGE_TOKEN is missing

Fetch the registry token from the public address, not the runner's

See merge request coffey-labs/ihasmail!9

.dockerignore

@@ -3,4 +3,7 @@ node_modules
 **/dist
 .git
 .env
+# deploy.example.sh keeps its settings in .env.production; any .env.* holds APP_SECRET.
+.env.*
+!.env.example
 server/data

.env.example

@@ -61,6 +61,12 @@ MAX_UPLOAD_BYTES=52428800
 # Remote-image privacy proxy (Gmail-style). Set to 0 to load remote images directly.
 IMAGE_PROXY=1
 
+# In-app administration, for accounts whose Stalwart role manages accounts and
+# domains. 0 turns it off for everyone: no menu, and the JMAP proxy refuses
+# Stalwart's registry methods beyond an account's own password, app passwords
+# and settings. Stalwart's own admin interface is not affected.
+ADMINISTRATION=1
+
 # Branding
 APP_NAME=ihasmail
 

.gitea/workflows/ci.yml

@@ -0,0 +1,170 @@
+# CI on the self-hosted Gitea, ported from .gitlab-ci.yml during the move off
+# GitLab (2026-09-22). Gitea reads .gitea/workflows and ignores .github/ once
+# this directory exists; .github/workflows stays as it was for GitHub.
+#
+# Every job runs in an image pinned by digest (tag in the trailing comment),
+# and the only action used is coffey-labs/actions/checkout pinned by SHA. The
+# instance resolves short `uses:` against itself, never GitHub, so nothing
+# unreviewed can be pulled in. Read the comment for the version; the digest is
+# what runs. Do not "simplify" one back to a bare tag.
+#
+# Jobs run on the runner's `ci-net` network and clone from Gitea's internal
+# address, never through the Cloudflare-proxied public name, which caps
+# request bodies at 100 MB. Images go to the registry's own DNS-only name
+# (vars.REGISTRY, an org variable).
+#
+# The weekly release is its own workflow, weekly-release.yml.
+name: ci
+
+on:
+  push:
+    branches: [main]
+    tags: ['**']
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # -------------------------------------------------------------- test ------
+  node:
+    runs-on: docker
+    container:
+      image: node:26-bookworm-slim@sha256:582460f614631b59b824ac6020533b9bf339c7fdf3a6d7db31abb6b4065f0212 # 26-bookworm-slim
+    env:
+      NPM_CONFIG_CACHE: ${{ github.workspace }}/.npm
+    steps:
+      # version.test.ts shells out to git to resolve a build version, and the
+      # slim image ships without it; the checkout action installs it when it
+      # is missing, so it is there for the tests too. Full history, because
+      # the version is computed from it.
+      - uses: coffey-labs/actions/checkout@fab0c4d45e0162963965f1555df27b7bed5e20ec
+        with:
+          fetch-depth: 0
+      # config.test.ts chmods a directory to 0555 and expects the write to be
+      # refused. Root ignores the permission bits, so as root that assertion
+      # can never hold. The tests run as the image's unprivileged `node` user
+      # for that reason; -p keeps the environment.
+      #
+      # imageproxy.test.ts needs IPv6 as well, which is not set here but on the
+      # runner: jobs run on the `ci-net` docker network, created with --ipv6.
+      # Without a non-loopback IPv6 address on the container, getaddrinfo's
+      # AI_ADDRCONFIG drops ::1 from the results entirely, localhost resolves
+      # to IPv4 only, and the test's control case connects to a port nothing
+      # is listening on. That is a runner property, so it cannot be fixed from
+      # this file -- if these tests ever fail again with ECONNREFUSED on
+      # 127.0.0.1, check that the runner still puts jobs on an IPv6-enabled
+      # network.
+      - run: chown -R node:node "$GITHUB_WORKSPACE"
+      - run: su node -p -c "npm ci --ignore-scripts"
+      - run: su node -p -c "npm run typecheck"
+      - run: su node -p -c "npm test"
+      - run: su node -p -c "npm run build"
+
+  # ------------------------------------------------------------- build ------
+  # Proves the Dockerfile still builds on every change, without pushing. The
+  # equivalent of ci.yml's final `docker build -t ihasmail:ci .` step. The
+  # Dockerfile builds everything itself, so nothing is handed over from the
+  # node job; `needs` only keeps the order.
+  docker-build:
+    if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+    needs: [node]
+    runs-on: docker
+    container:
+      image: docker:28-cli@sha256:625d9431a9f54c5a2bc90f24f0e1c3d55b1349fd857dd85035f98c2c9acbdd4d # 28-cli
+      volumes:
+        - /var/run/docker.sock:/var/run/docker.sock
+    steps:
+      - uses: coffey-labs/actions/checkout@fab0c4d45e0162963965f1555df27b7bed5e20ec
+      - run: |
+          tag="ihasmail:ci-$(echo "$GITHUB_SHA" | cut -c1-8)"
+          docker build -t "$tag" .
+          docker image rm "$tag"
+
+  # ----------------------------------------------------------- publish ------
+  # Tag-driven. GitHub needed a release -> publish workflow_call chain because
+  # a release cut with GITHUB_TOKEN raises no event -- and Gitea behaves the
+  # same way, which is why weekly-release.yml cuts its release with
+  # RELEASE_TOKEN: a tag made with that token is an ordinary push, and starts
+  # this workflow.
+  #
+  # The version the image is built with, computed the way publish.yml did it:
+  # scripts/version.mjs, which needs node and the full history. The build is
+  # *told* the real form (IHASMAIL_VERSION, what About and /api/health
+  # report); the Docker tag gets the same string with '+' turned into '-',
+  # because a tag may not contain '+'. Leaving the build arg out would ship an
+  # image reporting itself unversioned -- which is exactly what
+  # version.test.ts calls looking wrong.
+  version:
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
+    runs-on: docker
+    container:
+      image: node:26-bookworm-slim@sha256:582460f614631b59b824ac6020533b9bf339c7fdf3a6d7db31abb6b4065f0212 # 26-bookworm-slim
+    outputs:
+      version: ${{ steps.v.outputs.VERSION }}
+      docker_tag: ${{ steps.v.outputs.DOCKER_TAG }}
+    steps:
+      - uses: coffey-labs/actions/checkout@fab0c4d45e0162963965f1555df27b7bed5e20ec
+        with:
+          fetch-depth: 0
+      - id: v
+        shell: bash
+        run: |
+          V="$(node scripts/version.mjs)"
+          echo "VERSION=$V" >> "$GITHUB_OUTPUT"
+          echo "DOCKER_TAG=${V/+/-}" >> "$GITHUB_OUTPUT"
+          echo "VERSION=$V DOCKER_TAG=${V/+/-}"
+
+  # arm64 is built under QEMU on this amd64 host, not on a native runner as
+  # GitHub's free `ubuntu-24.04-arm` did. It is slow -- tens of minutes for the
+  # npm install and Vite build through instruction translation -- which is
+  # tolerable for a weekly tag and would not be for every push. That is why
+  # this job is tag-only. If arm64 ever starts timing out, the fix is an arm64
+  # runner, not dropping the platform: TrueNAS and Unraid users pull it.
+  #
+  # The push logs in with PACKAGE_TOKEN (jcoffey-dev, write:package): Gitea's
+  # per-job token is refused by the container registry. The registry hands out
+  # its push tokens from its own name, so unlike on GitLab nothing here has to
+  # be pointed at a public address.
+  publish:
+    if: ${{ startsWith(github.ref, 'refs/tags/') }}
+    needs: [node, version]
+    runs-on: docker
+    container:
+      image: docker:28-cli@sha256:625d9431a9f54c5a2bc90f24f0e1c3d55b1349fd857dd85035f98c2c9acbdd4d # 28-cli
+      volumes:
+        - /var/run/docker.sock:/var/run/docker.sock
+    env:
+      DOCKER_BUILDKIT: "1"
+      REGISTRY: ${{ vars.REGISTRY }}
+      IMAGE: ${{ vars.REGISTRY }}/${{ github.repository }}
+      VERSION: ${{ needs.version.outputs.version }}
+      DOCKER_TAG: ${{ needs.version.outputs.docker_tag }}
+      PACKAGE_TOKEN: ${{ secrets.PACKAGE_TOKEN }}
+    steps:
+      - uses: coffey-labs/actions/checkout@fab0c4d45e0162963965f1555df27b7bed5e20ec
+      - run: |
+          test -n "$REGISTRY" && test -n "$VERSION" && test -n "$DOCKER_TAG"
+          test -n "$PACKAGE_TOKEN" || { echo "PACKAGE_TOKEN secret is not set on this repository" >&2; exit 1; }
+          echo "$PACKAGE_TOKEN" | docker login -u jcoffey-dev --password-stdin "$REGISTRY"
+          docker run --privileged --rm tonistiigi/binfmt --install arm64
+          docker buildx create --use --name gitea-builder --driver docker-container || docker buildx use gitea-builder
+      - run: |
+          docker buildx build \
+            --platform linux/amd64,linux/arm64 \
+            --build-arg IHASMAIL_VERSION="$VERSION" \
+            --provenance=false --sbom=false \
+            --tag "$IMAGE:$DOCKER_TAG" \
+            --tag "$IMAGE:latest" \
+            --push .
+          docker buildx imagetools inspect "$IMAGE:$DOCKER_TAG"
+      # Gitea keeps a container package on its owner; linking it shows it on
+      # the repository's Packages tab. Idempotent.
+      - run: |
+          apk add --no-cache -q curl
+          curl -fsS -o /dev/null -X POST -H "Authorization: token $PACKAGE_TOKEN" \
+            "$CI_SERVER_INTERNAL/api/v1/packages/${GITHUB_REPOSITORY%%/*}/container/${GITHUB_REPOSITORY#*/}/-/link/${GITHUB_REPOSITORY#*/}" \
+            || echo "package already linked (or link refused); not fatal"
+      - if: always()
+        run: docker logout "$REGISTRY" || true

.gitea/workflows/weekly-release.yml

@@ -0,0 +1,101 @@
+# Weekly release, ported from the weekly-release job in .gitlab-ci.yml (itself
+# a port of .github/workflows/release.yml): cut a release once a week, but
+# only when there is something in it. The decision is unchanged -- count the
+# commits on main since the newest published release, and skip the week if
+# there are none or if the tag already exists (the version comes from the
+# commit, so an unchanged commit is an existing tag).
+#
+# Mondays 09:17 UTC, the same odd minute as before. Run it by hand from the
+# Actions tab (workflow_dispatch); dry_run defaults to true, so a manual run
+# shows the decision and stops unless you untick it.
+#
+# SIDE-BY-SIDE PERIOD: until the GitLab cutover, GitLab's own schedule is
+# still live and still cuts the real release, and its tags reach this copy
+# through the sync. Two releasers would race to create the same tag, so this
+# workflow only ever dry-runs unless the variable RELEASE_LIVE is '1'. Set
+# RELEASE_LIVE=1 (repo or org Actions variable) at cutover, when GitLab's
+# schedule is switched off -- not before.
+#
+# Reads use the job's own token. The release -- and with it the tag -- is
+# created with RELEASE_TOKEN (jcoffey-dev, write:repository), because a tag
+# Gitea creates for the job token raises no event (checked 2026-09-22), and
+# the tag has to start ci.yml's version and publish jobs.
+name: weekly-release
+
+on:
+  schedule:
+    - cron: '17 9 * * 1'
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: Show the decision and stop
+        type: boolean
+        default: true
+
+# One at a time: two overlapping runs would race to create the same tag.
+concurrency:
+  group: weekly-release
+  cancel-in-progress: false
+
+jobs:
+  weekly-release:
+    runs-on: docker
+    container:
+      image: node:26-bookworm-slim@sha256:582460f614631b59b824ac6020533b9bf339c7fdf3a6d7db31abb6b4065f0212 # 26-bookworm-slim
+    env:
+      READ_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+      # Live only with RELEASE_LIVE=1 AND either the schedule or a manual run
+      # with dry_run unticked.
+      DRY_RUN: ${{ (vars.RELEASE_LIVE == '1' && (github.event_name == 'schedule' || inputs.dry_run == false || inputs.dry_run == 'false')) && '0' || '1' }}
+    steps:
+      - uses: coffey-labs/actions/checkout@fab0c4d45e0162963965f1555df27b7bed5e20ec
+        with:
+          fetch-depth: 0
+      - run: apt-get update -qq && apt-get install -y -qq --no-install-recommends curl jq >/dev/null
+      - shell: bash
+        run: |
+          set -euo pipefail
+          # Internal address, as for everything else CI does: never through the proxy.
+          API="${CI_SERVER_INTERNAL}/api/v1/repos/${GITHUB_REPOSITORY}"
+          # The newest published release, or empty on a project that has never
+          # had one -- in which case everything counts as new.
+          previous="$(curl -fsS -H "Authorization: token ${READ_TOKEN}" "${API}/releases?draft=false&pre-release=false&limit=1" | jq -r '.[0].tag_name // ""')"
+          # A release can outlive its tag. Falling back to the whole history
+          # over-counts, which cuts a release that was due anyway;
+          # under-counting would skip one that was.
+          # Tag lookups use show-ref, which matches an exact ref and nothing
+          # else. `rev-parse --verify refs/tags/<name>` does not: on the git in
+          # this image (2.39) a name ending in -g<hex> falls back to being read
+          # as git-describe output, resolves to that commit, and so "exists"
+          # whether or not the tag does. Every commit not merged through a pull
+          # request has a -g<hex> version, so that check reported every such
+          # week as already released.
+          if [ -n "$previous" ] && git show-ref --verify --quiet "refs/tags/${previous}"; then
+            count="$(git rev-list --count "${previous}..HEAD")"; range="${previous}..HEAD"
+          else
+            count="$(git rev-list --count HEAD)"; range="HEAD"
+          fi
+          version="$(node scripts/version.mjs)"
+          # A Docker tag may not contain '+', and neither should the git tag,
+          # so the two always agree about what to call a build.
+          tag="v${version/+/-}"
+          title="v${version%%+*}"
+          sha="$(git rev-parse HEAD)"
+          if [ "$count" -eq 0 ]; then
+            echo "Nothing to release: no commits since ${previous}."; exit 0
+          fi
+          if git show-ref --verify --quiet "refs/tags/${tag}"; then
+            echo "Nothing to release: tag ${tag} already exists."; exit 0
+          fi
+          echo "Releasing ${tag} -- ${count} commit(s) since ${previous:-the beginning}, at ${sha}."
+          if [ "$DRY_RUN" = "1" ]; then echo "Dry run (RELEASE_LIVE='${{ vars.RELEASE_LIVE }}'): stopping here."; exit 0; fi
+          # Notes bounded to what is new, from the first-parent history of
+          # main -- one line per merge, which is what GitHub's generated notes
+          # listed.
+          notes="$(git log --first-parent --format='- %s' "$range")"
+          jq -n --arg tag "$tag" --arg ref "$sha" --arg name "$title" \
+                --arg body "$(printf '%s commit(s) since %s.\n\n%s' "$count" "${previous:-the beginning}" "$notes")" \
+                '{tag_name:$tag, target_commitish:$ref, name:$name, body:$body}' > release.json
+          curl -fsS -H "Authorization: token ${RELEASE_TOKEN}" -H "Content-Type: application/json" \
+               --data @release.json "${API}/releases" | jq -r '"created release " + .tag_name'

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# Funding platforms shown behind the repository's Sponsor button.
+# https://docs.github.com/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/displaying-a-sponsor-button-in-your-repository
+
+github: jcoffey-dev

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,43 @@
+<!--
+  Thanks for contributing to ihasmail. CONTRIBUTING.md has the full guide;
+  this is the short version. Delete any section that does not apply.
+-->
+
+## Summary
+
+<!-- What changes, and why. -->
+
+## Related issues
+
+<!-- e.g. Closes #123. Leave blank if there are none. -->
+
+## Translations
+
+<!--
+  Nine languages ship alongside English, and a missing key silently renders
+  its English source -- so an untranslated string is invisible until somebody
+  reading that language finds it. Say which this PR is, explicitly:
+
+  - Adds or alters user-visible strings: how many keys, and the fallback
+    count before and after.
+  - Adds none.
+
+  "Adds none" is an answer. Saying nothing is not -- it leaves it to be
+  inferred. See CONTRIBUTING.md -> Translations.
+-->
+
+## Testing
+
+<!--
+  What you ran, and what you saw. `npm run typecheck`, `npm test` and
+  `npm run build` all run in CI, so the useful thing here is what CI cannot
+  do: which flows you exercised by hand, and against what -- a real Stalwart
+  instance, or `npm run dev:mock`.
+
+  If the change is visible on screen, drive the built app, not just the
+  store. See CONTRIBUTING.md -> Verifying UI work.
+-->
+
+## Screenshots
+
+<!-- For UI changes. Before/after, or a GIF for anything with motion. -->

.github/dependabot.yml

@@ -0,0 +1,44 @@
+version: 2
+updates:
+  # The npm entry sits at the root because that is where the single lockfile
+  # is: root, server and web are one npm workspace, so one entry covers all
+  # three. Pointing entries at server/ or web/ would find package.json files
+  # with no lockfile beside them and update nothing.
+  - package-ecosystem: npm
+    directory: "/"
+    schedule:
+      interval: weekly
+      day: tuesday
+      time: "09:00"
+      timezone: Etc/UTC
+    open-pull-requests-limit: 5
+    groups:
+      # Everything routine arrives as one PR a week, so the dashboard is not
+      # the only place these get noticed. Majors are deliberately left out of
+      # the group: they are migrations, not bumps -- vitest 3 to 4 is one --
+      # and each deserves its own PR and its own CI run.
+      minor-and-patch:
+        update-types:
+          - minor
+          - patch
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+      day: tuesday
+      time: "09:00"
+      timezone: Etc/UTC
+    groups:
+      actions:
+        patterns:
+          - "*"
+  # The runtime and build stages both pin node:22-alpine, so this is what
+  # keeps the published container images off a stale base between the weekly
+  # releases.
+  - package-ecosystem: docker
+    directory: "/"
+    schedule:
+      interval: weekly
+      day: tuesday
+      time: "09:00"
+      timezone: Etc/UTC

.github/workflows/ci.yml

@@ -7,7 +7,7 @@ on:
   # Without this there is no way to re-run a check that never started: a run
   # GitHub queues and then orphans -- as it did to every run created during the
   # Actions outage on 2026-08-26 -- can be neither rerun ("already running")
-  # nor cancelled ("already completed"), and the workflow has no other trigger
+  # nor canceled ("already completed"), and the workflow has no other trigger
   # to reach for. Useful too for putting a check on a commit that predates a CI
   # change, without pushing an empty commit to move it.
   workflow_dispatch:
@@ -15,10 +15,21 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      # Every `uses:` in this repository is pinned to a full commit SHA, with
+      # the release it belongs to in the trailing comment, and the repository
+      # requires it -- an unpinned ref fails the run rather than quietly
+      # resolving. A tag is a mutable pointer: `@v7` is whatever the publisher
+      # last moved it to, so trusting one is trusting every future version of
+      # that action, including the one pushed by whoever compromises the
+      # account. Read the comment for the version; the SHA is what runs.
+      #
+      # Dependabot updates both halves together on its weekly github-actions
+      # run, so this costs nothing to keep current -- do not "simplify" a pin
+      # back to a tag.
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
-          node-version: 22
+          node-version: 26
           cache: npm
       - run: npm ci --ignore-scripts
       - run: npm run typecheck

.github/workflows/cleanup.yml

@@ -39,11 +39,12 @@ jobs:
     permissions:
       packages: write
     steps:
-      # Pinned to a commit rather than a moving major tag. This action is
-      # handed `packages: write` and its whole job is deletion, so a tag
-      # repointed at something else -- by a compromise or a mistake upstream --
-      # is a bad day. v1.2.2.
-      - uses: dataaxiom/ghcr-cleanup-action@d52806a0dc70b430571a37da1fde39733ffd640f
+      # The only third-party action here that is not published by GitHub or
+      # Docker, and the one with the most to lose: it is handed
+      # `packages: write` and its whole job is deletion, so a ref repointed at
+      # something else -- by a compromise or a mistake upstream -- is a bad
+      # day. It was pinned to a commit long before the rest of them were.
+      - uses: dataaxiom/ghcr-cleanup-action@d52806a0dc70b430571a37da1fde39733ffd640f # v1.2.2
         with:
           owner: Coffey-Labs
           package: ihasmail

.github/workflows/publish.yml

@@ -4,7 +4,7 @@
 # `ghcr.io/coffey-labs/ihasmail:latest` for a long time, and nothing ever
 # pushed it: `docker pull` answered `denied`, because the package did not
 # exist. This is the workflow that makes those instructions true. It is also
-# the prerequisite for the self-hosted app catalogues -- TrueNAS and Unraid
+# the prerequisite for the self-hosted app catalogs -- TrueNAS and Unraid
 # both install by pulling an image and neither builds from source.
 #
 # FIRST RUN: a package GHCR creates for the first time is **private**, even in
@@ -44,7 +44,7 @@ on:
         type: boolean
         default: false
   # Same reasoning as ci.yml's dispatch trigger: a run GitHub queues and then
-  # orphans can be neither rerun nor cancelled, and this workflow otherwise
+  # orphans can be neither rerun nor canceled, and this workflow otherwise
   # only fires on a release -- which is not something to cut twice because a
   # runner died. `ref` also allows publishing an image for a tag that predates
   # this workflow, which is how the first one gets built.
@@ -76,13 +76,13 @@ jobs:
       version: ${{ steps.v.outputs.version }}
       docker_tag: ${{ steps.v.outputs.docker_tag }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: ${{ inputs.ref || github.ref }}
           fetch-depth: 0
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
-          node-version: 22
+          node-version: 26
       - id: v
         run: |
           V="$(node scripts/version.mjs)"
@@ -108,18 +108,18 @@ jobs:
           - platform: linux/arm64
             runner: ubuntu-24.04-arm
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: ${{ inputs.ref || github.ref }}
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
+      - uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+      - uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push by digest
         id: push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
         with:
           context: .
           platforms: ${{ matrix.platform }}
@@ -140,7 +140,7 @@ jobs:
           # `image@sha256:sha256:...` when the reference is rebuilt.
           digest="${{ steps.push.outputs.digest }}"
           touch "/tmp/digests/${digest#sha256:}"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           # One artifact per platform; the merge job globs them back together.
           name: digest-${{ strategy.job-index }}
@@ -157,13 +157,13 @@ jobs:
       contents: read
       packages: write
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           path: /tmp/digests
           pattern: digest-*
           merge-multiple: true
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
+      - uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+      - uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
         with:
           registry: ghcr.io
           username: ${{ github.actor }}

.github/workflows/release.yml

@@ -13,13 +13,21 @@ name: Weekly release
 
 on:
   schedule:
-    # Mondays, 09:00 UTC. GitHub runs scheduled jobs on a best-effort basis and
+    # Mondays, 09:17 UTC. GitHub runs scheduled jobs on a best-effort basis and
     # can delay a run by a good while when the queue is busy, so do not read
-    # the exact minute as a promise. Note also that GitHub disables scheduled
-    # workflows in a repository with no activity for 60 days -- not a concern
-    # while this one is being worked on weekly, but it is why a silent stop is
-    # worth checking for before assuming the file is broken.
-    - cron: "0 9 * * 1"
+    # the exact minute as a promise. The odd minute is deliberate: the top of
+    # the hour is when most schedules fire, and at 09:00 the first scheduled
+    # run started almost six hours late and the second had not started at all
+    # four and a half hours in. Moving off the hour does not make GitHub keep
+    # time, but it stops competing for the busiest slot. A missed week can be
+    # cut by hand with workflow_dispatch; a late scheduled run that follows
+    # finds the tag already there and does nothing.
+    #
+    # Note also that GitHub disables scheduled workflows in a repository with
+    # no activity for 60 days -- not a concern while this one is being worked
+    # on weekly, but it is why a silent stop is worth checking for before
+    # assuming the file is broken.
+    - cron: "17 9 * * 1"
   workflow_dispatch:
     inputs:
       dry_run:
@@ -46,13 +54,13 @@ jobs:
       previous: ${{ steps.decide.outputs.previous }}
       count: ${{ steps.decide.outputs.count }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: main
           fetch-depth: 0
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
-          node-version: 22
+          node-version: 26
       - id: decide
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -122,7 +130,7 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: main
           fetch-depth: 0

.gitignore

@@ -1,11 +1,12 @@
 node_modules/
 dist/
 .env
+# deploy.example.sh keeps its settings in .env.production; any .env.* holds APP_SECRET.
+.env.*
+!.env.example
 *.log
 .DS_Store
 server/data/
 .vite/
 coverage/
 
-# Worktrees used by parallel agents; never part of a commit.
-.claude/worktrees/

.gitlab-ci.yml

@@ -0,0 +1,250 @@
+# CI for the self-hosted GitLab that replaced GitHub Actions when the account
+# was suspended on 2026-09-20. This is a port of .github/workflows/ci.yml and
+# publish.yml, which are kept in the tree for reference and for the day the
+# appeal succeeds.
+#
+# Every `image:` here is pinned to a digest, with the tag it belonged to in the
+# trailing comment. That is the direct replacement for the SHA-pinned `uses:`
+# in the Actions workflows: GitLab has no equivalent of an action allowlist, so
+# the only thing standing between this pipeline and whatever the publisher
+# pushes to a tag next is the digest. Read the comment for the version; the
+# digest is what runs. Do not "simplify" one back to a bare tag.
+#
+# The runner is a group runner on Web_Host with the host docker socket bound
+# in, reached over the internal container network rather than
+# https://git.coffeylabs.org -- that name is Cloudflare-proxied on the Free
+# plan, which caps request bodies at 100 MB and would break artifact uploads.
+
+stages: [test, build, publish, release]
+
+variables:
+  # Jobs talk to the registry directly on its DNS-only name, never through the
+  # proxy, for the same 100 MB reason.
+  IMAGE: $CI_REGISTRY_IMAGE
+  GIT_DEPTH: "0"
+
+default:
+  interruptible: true
+
+# ---------------------------------------------------------------- test ------
+node:
+  stage: test
+  image: node:26-bookworm-slim@sha256:582460f614631b59b824ac6020533b9bf339c7fdf3a6d7db31abb6b4065f0212 # 26-bookworm-slim
+  variables:
+    NPM_CONFIG_CACHE: "$CI_PROJECT_DIR/.npm"
+  cache:
+    key:
+      files: [package-lock.json]
+    paths: [.npm/]
+  before_script:
+    # version.test.ts shells out to git to resolve a build version, and the
+    # slim image ships without it. The clone is done by the runner's helper
+    # image, so nothing else here needs git and its absence is easy to miss.
+    - apt-get update -qq && apt-get install -y -qq --no-install-recommends git
+    # config.test.ts chmods a directory to 0555 and expects the write to be
+    # refused. Root ignores the permission bits, so as root that assertion can
+    # never hold. The tests run as the image's unprivileged `node` user for
+    # that reason; -p keeps the environment.
+    #
+    # imageproxy.test.ts needs IPv6 as well, which is not set here but on the
+    # runner: jobs run on the `ci-net` docker network, created with --ipv6.
+    # Without a non-loopback IPv6 address on the container, getaddrinfo's
+    # AI_ADDRCONFIG drops ::1 from the results entirely, localhost resolves to
+    # IPv4 only, and the test's control case connects to a port nothing is
+    # listening on. That is a runner property, so it cannot be fixed from this
+    # file -- if these tests ever fail again with ECONNREFUSED on 127.0.0.1,
+    # check that the runner still puts jobs on an IPv6-enabled network.
+    - chown -R node:node "$CI_PROJECT_DIR"
+  script:
+    - su node -p -c "npm ci --ignore-scripts"
+    - su node -p -c "npm run typecheck"
+    - su node -p -c "npm test"
+    - su node -p -c "npm run build"
+  artifacts:
+    paths: [dist/]
+    expire_in: 1 week
+  rules:
+    - if: $RELEASE_WEEKLY == "1"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    - if: $CI_COMMIT_TAG
+
+# --------------------------------------------------------------- build ------
+# Proves the Dockerfile still builds on every change, without pushing. The
+# equivalent of ci.yml's final `docker build -t ihasmail:ci .` step.
+#
+# Not called `image`: that is a reserved keyword, and a job by that name is
+# silently read as the global image: setting instead ("image name should be a
+# string"). Same trap for `stages`, `cache`, `services` and `variables`.
+docker-build:
+  stage: build
+  image: docker:28-cli@sha256:625d9431a9f54c5a2bc90f24f0e1c3d55b1349fd857dd85035f98c2c9acbdd4d # 28-cli
+  needs: [node]
+  script:
+    - docker build -t ihasmail:ci-$CI_COMMIT_SHORT_SHA .
+    - docker image rm ihasmail:ci-$CI_COMMIT_SHORT_SHA
+  rules:
+    - if: $RELEASE_WEEKLY == "1"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+
+# ------------------------------------------------------------- publish ------
+# Tag-driven, replacing the release -> publish workflow_call chain. GitHub
+# needed that dance because a release cut with GITHUB_TOKEN raises no event;
+# GitLab has no such rule, so a tag pipeline is enough.
+#
+# arm64 is built under QEMU on this amd64 host, not on a native runner as
+# GitHub's free `ubuntu-24.04-arm` did. It is slow -- tens of minutes for the
+# npm install and Vite build through instruction translation -- which is
+# tolerable for a weekly tag and would not be for every push. That is why this
+# job is tag-only. If arm64 ever starts timing out, the fix is an arm64 runner,
+# not dropping the platform: TrueNAS and Unraid users pull it.
+# The version the image is built with, computed the way publish.yml did it:
+# scripts/version.mjs, which needs node and the full history. The build is
+# *told* the real form (IHASMAIL_VERSION, what About and /api/health report);
+# the Docker tag gets the same string with '+' turned into '-', because a tag
+# may not contain '+'. The first port of this job left the build arg out, so
+# a tag would have shipped an image reporting itself unversioned -- which is
+# exactly what version.test.ts calls looking wrong.
+version:
+  stage: build
+  image: node:26-bookworm-slim@sha256:582460f614631b59b824ac6020533b9bf339c7fdf3a6d7db31abb6b4065f0212 # 26-bookworm-slim
+  variables:
+    GIT_DEPTH: "0"
+  before_script:
+    - apt-get update -qq && apt-get install -y -qq --no-install-recommends git >/dev/null
+    # The build directory is reused between jobs, and the node job chowns it to
+    # the unprivileged `node` user so its tests can run. A later job running
+    # git as root then finds the checkout owned by somebody else, and git
+    # refuses with "detected dubious ownership" (exit 128). Whether it happens
+    # depends on which cached directory a job lands on, so it comes and goes.
+    - git config --global --add safe.directory "$CI_PROJECT_DIR"
+  script:
+    - V="$(node scripts/version.mjs)"
+    - echo "VERSION=$V" > version.env
+    - echo "DOCKER_TAG=${V/+/-}" >> version.env
+    - cat version.env
+  artifacts:
+    reports:
+      dotenv: version.env
+  rules:
+    - if: $CI_COMMIT_TAG
+
+publish:
+  stage: publish
+  image: docker:28-cli@sha256:625d9431a9f54c5a2bc90f24f0e1c3d55b1349fd857dd85035f98c2c9acbdd4d # 28-cli
+  needs: [node, version]
+  variables:
+    DOCKER_BUILDKIT: "1"
+  before_script:
+    - echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
+    - docker run --privileged --rm tonistiigi/binfmt --install arm64
+    # The registry hands out push tokens from https://git.coffeylabs.org/jwt/auth,
+    # and buildx fetches them here, in the job, not in its builder. On ci-net
+    # that name is the gitlab container itself (172.30.0.2), which serves
+    # plain HTTP to the runner and nothing on 443, so every push failed at the
+    # last step with "connection refused". The login above works because the
+    # host's daemon does it, and the host resolves the name publicly. So, for
+    # this job only, point the name at its public address the same way. Only
+    # the token request uses it; layers go to the registry's own DNS-only name.
+    - |
+      public="$(nslookup "$CI_SERVER_HOST" 1.1.1.1 2>/dev/null | awk '/^Address: / && $2 !~ /:/ { print $2; exit }')"
+      if [ -z "$public" ]; then echo "Could not resolve $CI_SERVER_HOST publicly" >&2; exit 1; fi
+      echo "$public $CI_SERVER_HOST" >> /etc/hosts
+      echo "$CI_SERVER_HOST -> $public for the registry token"
+    - docker buildx create --use --name ci-builder --driver docker-container || docker buildx use ci-builder
+  script:
+    - |
+      docker buildx build \
+        --platform linux/amd64,linux/arm64 \
+        --build-arg IHASMAIL_VERSION="$VERSION" \
+        --provenance=false --sbom=false \
+        --tag "$IMAGE:$DOCKER_TAG" \
+        --tag "$IMAGE:latest" \
+        --push .
+  after_script:
+    - docker logout "$CI_REGISTRY" || true
+  rules:
+    - if: $CI_COMMIT_TAG
+
+# ----------------------------------------------------------- weekly release --
+# Port of .github/workflows/release.yml: cut a release once a week, but only
+# when there is something in it. The decision is the workflow's, unchanged --
+# count the commits on main since the newest published release, and skip the
+# week if there are none or if the tag already exists (the version comes from
+# the commit, so an unchanged commit is an existing tag).
+#
+# It runs from a pipeline schedule (Mondays 09:17 UTC, the same odd minute as
+# before) that sets RELEASE_WEEKLY=1. GitLab keeps schedules on the project,
+# not in this file, so the schedule and this job only work as a pair. Run it by
+# hand with RELEASE_WEEKLY=1, adding DRY_RUN=1 to see the decision and stop.
+#
+# The release -- and with it the tag -- is created with RELEASE_TOKEN, a
+# project access token (protected, masked), not CI_JOB_TOKEN. A tag pushed that
+# way is an ordinary push, so it starts the tag pipeline, and the version and
+# publish jobs above build the image from it. That replaces release.yml's
+# direct call of publish.yml, which only existed because a tag created with
+# GITHUB_TOKEN raises no event. The token expires; when it does this job fails
+# at the API call, loudly, and a new one goes in the same variable.
+weekly-release:
+  stage: release
+  image: node:26-bookworm-slim@sha256:582460f614631b59b824ac6020533b9bf339c7fdf3a6d7db31abb6b4065f0212 # 26-bookworm-slim
+  # One at a time: two overlapping runs would race to create the same tag.
+  resource_group: weekly-release
+  variables:
+    GIT_DEPTH: "0"
+  before_script:
+    - apt-get update -qq && apt-get install -y -qq --no-install-recommends git curl jq >/dev/null
+    # See the version job: same shared directory, same root, same refusal.
+    - git config --global --add safe.directory "$CI_PROJECT_DIR"
+  script:
+    - |
+      set -euo pipefail
+      # Internal address, as for everything else CI does: never through the proxy.
+      API="http://gitlab/api/v4/projects/${CI_PROJECT_ID}"
+      auth=(--header "PRIVATE-TOKEN: ${RELEASE_TOKEN}")
+      # The newest published release, or empty on a project that has never had
+      # one -- in which case everything counts as new.
+      previous="$(curl -fsS "${auth[@]}" "${API}/releases?order_by=released_at&sort=desc&per_page=1" | jq -r '.[0].tag_name // ""')"
+      # A release can outlive its tag. Falling back to the whole history
+      # over-counts, which cuts a release that was due anyway; under-counting
+      # would skip one that was.
+      # Tag lookups use show-ref, which matches an exact ref and nothing else.
+      # `rev-parse --verify refs/tags/<name>` does not: on the git in this image
+      # (2.39) a name ending in -g<hex> falls back to being read as
+      # git-describe output, resolves to that commit, and so "exists" whether
+      # or not the tag does. Every commit not merged through a pull request has
+      # a -g<hex> version, so that check reported every such week as already
+      # released. Newer git (and GitHub's runners) do not fall back, which is
+      # why release.yml never showed it.
+      if [ -n "$previous" ] && git show-ref --verify --quiet "refs/tags/${previous}"; then
+        count="$(git rev-list --count "${previous}..HEAD")"; range="${previous}..HEAD"
+      else
+        count="$(git rev-list --count HEAD)"; range="HEAD"
+      fi
+      version="$(node scripts/version.mjs)"
+      # A Docker tag may not contain '+', and neither should the git tag, so
+      # the two always agree about what to call a build.
+      tag="v${version/+/-}"
+      title="v${version%%+*}"
+      sha="$(git rev-parse HEAD)"
+      if [ "$count" -eq 0 ]; then
+        echo "Nothing to release: no commits since ${previous}."; exit 0
+      fi
+      if git show-ref --verify --quiet "refs/tags/${tag}"; then
+        echo "Nothing to release: tag ${tag} already exists."; exit 0
+      fi
+      echo "Releasing ${tag} -- ${count} commit(s) since ${previous:-the beginning}, at ${sha}."
+      if [ "${DRY_RUN:-0}" = "1" ]; then echo "DRY_RUN=1: stopping here."; exit 0; fi
+      # Notes bounded to what is new, from the first-parent history of main --
+      # one line per merge, which is what GitHub's generated notes listed.
+      notes="$(git log --first-parent --format='- %s' "$range")"
+      jq -n --arg tag "$tag" --arg ref "$sha" --arg name "$title" \
+            --arg desc "$(printf '%s commit(s) since %s.\n\n%s' "$count" "${previous:-the beginning}" "$notes")" \
+            '{tag_name:$tag, ref:$ref, name:$name, description:$desc}' > release.json
+      curl -fsS "${auth[@]}" --header "Content-Type: application/json" \
+           --data @release.json "${API}/releases" | jq -r '"created release " + .tag_name'
+  rules:
+    - if: $RELEASE_WEEKLY == "1" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

.palette-sources/palettes-upstream.md

@@ -47,3 +47,104 @@ bg #e6e7ed · bg_dark #d6d8df · fg #343b59 · line numbers #9da0ab · border #c
 link #2959aa
 accents: purple #65359d · red #8c4351 · cyan #006c86 · blue #2959aa
 yellow #8f5e15 · teal #33635c · green #385f0d
+
+---
+
+Fetched 2026-09-06 from the projects' own repositories, same rule as above.
+Where a project publishes fewer background tiers than ihasmail needs, the
+missing one is derived and marked **derived** here rather than passed off as
+upstream. Body text is lifted to 7:1 by the build script for most of these —
+they target their own ~4.5:1 — and every shift is printed in the generated CSS.
+
+## Catppuccin — catppuccin/palette, MIT (palette.json)
+Cited from the palette repo rather than the hub README; it is the normative
+machine-readable source.
+
+### Mocha (dark)
+base #1e1e2e · mantle #181825 · crust #11111b · surface0 #313244 · surface1 #45475a
+text #cdd6f4 · subtext0 #a6adc8 · overlay1 #7f849c
+mauve #cba6f7 · blue #89b4fa · red #f38ba8 · peach #fab387 · green #a6e3a1
+yellow #f9e2af · pink #f5c2e7
+
+### Latte (light)
+base #eff1f5 · mantle #e6e9ef · crust #dce0e8 · surface0 #ccd0da · surface1 #bcc0cc
+text #4c4f69 · subtext0 #6c6f85
+mauve #8839ef · blue #1e66f5 · red #d20f39 · peach #fe640b · green #40a02b
+yellow #df8e1d · pink #ea76cb
+
+Latte publishes no tier lighter than `base`, so `base` is used as the elevated
+surface and `mantle` as the page behind it.
+
+## Solarized — altercation/solarized, MIT (README "The Values")
+base03 #002b36 · base02 #073642 · base01 #586e75 · base00 #657b83
+base0 #839496 · base1 #93a1a1 · base2 #eee8d5 · base3 #fdf6e3
+yellow #b58900 · orange #cb4b16 · red #dc322f · magenta #d33682
+violet #6c71c4 · blue #268bd2 · cyan #2aa198 · green #859900
+
+The accents are shared by both modes by design. Two tiers are **derived**: the
+sunken dark surface #001f28 (below base03) and the raised light surface
+#fffdf6 (above base3), neither of which Solarized publishes, plus the two
+rule colors #0d4552 and #e6dfc8.
+
+## Everforest — sainnhe/everforest, MIT (palette.md), medium contrast
+### Dark
+bg_dim #232a2e · bg0 #2d353b · bg1 #343f44 · bg3 #475258
+fg #d3c6aa · gray1 #859289
+red #e67e80 · orange #e69875 · yellow #dbbc7f · green #a7c080 · aqua #83c092
+blue #7fbbb3 · purple #d699b6
+
+### Light
+bg_dim #efebd4 · bg0 #fdf6e3 · bg3 #e6e2cc · bg5 #bdc3af
+fg #5c6a72 · gray1 #939f91
+red #f85552 · orange #f57d26 · yellow #dfa000 · green #8da101 · aqua #35a77c
+blue #3a94c5 · purple #df69ba
+
+Light uses bg_dim as the page and bg0 as the raised surface, so the card the
+reader looks at is the color Everforest calls its background.
+
+## Kanagawa — rebelot/kanagawa.nvim, MIT (lua/kanagawa/colors.lua)
+### Wave (dark)
+sumiInk0 #16161D · sumiInk3 #1F1F28 · sumiInk4 #2A2A37 · sumiInk5 #363646
+fujiWhite #DCD7BA · fujiGray #727169
+crystalBlue #7E9CD8 · springBlue #7FB4CA · samuraiRed #E82424 · roninYellow #FF9E3B
+springGreen #98BB6C · carpYellow #E6C384 · sakuraPink #D27E99
+
+### Lotus (light)
+lotusWhite0 #d5cea3 · lotusWhite1 #dcd5ac · lotusWhite2 #e5ddb0 · lotusWhite3 #f2ecbc
+lotusInk1 #545464 · lotusGray2 #716e61
+lotusViolet4 #624c83 · lotusBlue4 #4d699b · lotusRed #c84053 · lotusOrange #cc6d00
+lotusGreen #6f894e · lotusYellow #77713f · lotusPink #b35b79
+
+## Ayu — ayu-theme/ayu-colors, MIT (themes/dark.yaml, themes/light.yaml)
+The YAMLs give the base palette and the surfaces as literals but express syntax
+roles as references (`$palette.indigo.l2`), and the resolved files are not
+committed. The two signature accents are taken from the same organization's
+MIT-licensed ayu-theme/vscode-ayu build.
+
+### Dark
+surface base #0D1017 · lift #10141C (sunk is `base -L0.1`, **derived** here as #070a0f)
+ui line #1B1F29 · ui fg #5A6378 · editor fg #BFBDB6
+red #F07178 · orange #FF8F40 · yellow #FFB454 · green #AAD94C · teal #95E6CB
+indigo #39BAE6 · blue #59C2FF · purple #D2A6FF · accent #E6B450 (vscode-ayu)
+
+### Light
+surface sunk #EBEEF0 · base #F8F9FA · lift #FCFCFC
+ui fg #828E9F · editor fg #5C6166 · rule #dfe2e5 (**derived**)
+red #F07171 · orange #FA8532 · yellow #EBA400 · green #86B300 · teal #4CBF99
+indigo #55B4D4 · blue #22A4E6 · purple #A37ACC · accent #F29718 (vscode-ayu)
+
+## Primer — primer/primitives, MIT (src/tokens/base/color/{dark,light})
+Named "Primer" after the design system. The color values are MIT; "GitHub"
+and the Invertocat are trademarks, and nothing here is endorsed by them.
+
+### Dark
+neutral #0D1117 #151B23 #212830 #262C36 #2A313C #2F3742 #3D444D #656C76
+        #9198A1 #B7BDC8 #D1D7E0 #F0F6FC · black #010409
+blue #79c0ff #58a6ff · green #56d364 #3fb950 · yellow #e3b341 #d29922
+red #ff7b72 · purple #d2a8ff
+
+### Light
+neutral #F6F8FA #EFF2F5 #E6EAEF #E0E6EB #DAE0E7 #D1D9E0 #C8D1DA #818B98
+        #59636E #454C54 #393F46 #25292E
+blue #0969da #0550ae · green #1a7f37 #116329 · yellow #bf8700 #9a6700
+red #cf222e · purple #8250df

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing to ihasmail
 
-Thanks for your interest in contributing to **ihasmail** — a Gmail-style, JMAP-only webmail client for [Stalwart Mail Server](https://stalw.art/). Contributions of all kinds are welcome: bug reports, feature requests, code, documentation, and testing.
+Thanks for your interest in contributing to **ihasmail** — an immutable, JMAP-only webmail client for [Stalwart Mail Server](https://stalw.art/). Contributions of all kinds are welcome: bug reports, feature requests, code, documentation, and testing.
 
 ## Code of Conduct
 
@@ -30,7 +30,7 @@ Before opening a new issue, please search [existing issues](https://github.com/C
 Open an issue describing:
 
 - The problem you're trying to solve (not just the solution)
-- How it fits with ihasmail's JMAP-only, Gmail-style design philosophy
+- How it fits with ihasmail's JMAP-only, nothing-to-persist design
 - Any relevant JMAP RFC references (RFC 8620, RFC 8621) if the feature touches protocol behavior
 
 For larger changes, please open an issue to discuss the approach **before** submitting a pull request — this saves everyone time if the direction needs adjusting.
@@ -48,6 +48,21 @@ For larger changes, please open an issue to discuss the approach **before** subm
    - Related issue number(s), if any
    - Screenshots/GIFs for UI changes
    - Any manual testing you performed
+8. **Add translations** for any new user-visible string — see
+   [Translations](#translations) below — and **drive the built app** for any
+   change that is visible on screen, as described in
+   [Verifying UI work](#verifying-ui-work).
+
+`main` is protected. A change reaches it through a pull request whose **build**
+check has passed — not afterwards — and the branch cannot be force-pushed or
+deleted. No approving review is required, so a PR of your own is not blocked
+waiting for one.
+
+**CI on a PR from a fork waits to be approved.** Every workflow run on an
+outside contributor's branch sits at *awaiting approval* until a maintainer
+starts it by hand, so the **build** check will not appear the moment you open
+the PR — that is the gate working, not a broken run. Pushing again will not
+start it, and neither will closing and reopening.
 
 ### Code Style
 
@@ -56,6 +71,56 @@ For larger changes, please open an issue to discuss the approach **before** subm
 - Prefer clarity over cleverness — this is a mail client people rely on for their inbox.
 - Comment non-obvious JMAP interactions, especially around state/`changes` handling, since JMAP's delta-sync model can be easy to get subtly wrong.
 
+### Translations
+
+Nine languages ship alongside English: German, Spanish, French, Dutch,
+Portuguese (Brazil), Russian, Ukrainian, Simplified Chinese and Japanese, in
+`web/src/locales/`. A missing key renders its English source rather than
+failing, so an untranslated string is invisible until somebody reading that
+language finds it.
+
+**Any change that adds or alters a user-visible string adds work in all nine
+catalogs.** Say so explicitly in the PR — how many keys, and the fallback
+count before and after — and say so just as explicitly when a change adds none,
+so it is never left to be inferred.
+
+#### The catalog key for a plural is the `other` form
+
+`plural()` looks the entry up by `forms.other`, so a call site written as
+
+```ts
+plural(n, { one: "Deleted {n} contact", other: "Deleted {n} contacts" })
+```
+
+is keyed on **`"Deleted {n} contacts"`**. Keying the catalog on the `one`
+form type-checks, builds, passes every test, and silently falls back to English
+in all nine languages. Nothing errors. The only signal is the fallback count
+going up, so read it:
+
+```sh
+npm run i18n:check                    # literals wrapped, and catalog health; exits 1 on a finding
+node scripts/i18n-catalog-check.mjs   # per-language: translated / used / falling back
+```
+
+Compare the "falling back to English" number against `main` before and after.
+It should not rise. Do not read the percentage instead — adding keys moves the
+denominator, so it can hold steady while new strings go untranslated.
+
+Plural forms are per language, from `Intl.PluralRules`: `one`/`other` for most,
+`one`/`few`/`many`/`other` for Russian and Ukrainian, `other` alone for Japanese
+and Chinese. Supplying a form a language does not draw is inventing a
+distinction, not being thorough.
+
+### Verifying UI work
+
+Store tests do not exercise the component. At least one bug in this repo's
+history — a shift-click range measured inside a `setState` updater, which React
+runs after the anchor ref has already moved — passed every store assertion and
+failed the moment the built app was driven. If a change is visible on screen,
+run it: `npm run dev:mock` (mock Stalwart, credentials printed on start), then
+drive the real thing. Add a component test for what you find; there are
+examples in `web/src/views/*/__tests__/`.
+
 ### Development Setup
 
 1. Clone your fork:
@@ -63,10 +128,83 @@ For larger changes, please open an issue to discuss the approach **before** subm
    git clone https://github.com/YOUR-USERNAME/ihasmail.git
    cd ihasmail
    ```
-2. Point your local instance at a running Stalwart Mail Server (a test/dev instance is strongly recommended — do not develop against a production mailbox).
-3. Follow the setup instructions in the repository's `README.md` for installing dependencies and running the app locally.
+2. Point your local instance at a running Stalwart Mail Server (a test/dev instance is strongly recommended — do not develop against a production mailbox), or use the built-in mock below.
+3. Install and run, as below.
 4. Verify your changes don't break existing JMAP calls by exercising core flows: login, list/read mail, send, search, and folder/label operations.
 
+Requirements: Node ≥ 20.19 (26 recommended), npm ≥ 10.
+
+```bash
+npm install
+
+npm run dev            # real Stalwart (STALWART_URL in .env) — server :8080, Vite :5173
+npm run dev:mock       # built-in mock Stalwart ([email protected] / demo), mock on :8788
+npm run dev:mock:no-future-release   # mock that advertises FUTURERELEASE and drops every hold
+
+npm run typecheck      # tsc for both packages
+npm test               # vitest (web) + node:test (server)
+npm run build          # web/dist + server/dist
+npm start              # serve the production build
+```
+
+Open http://localhost:5173 in dev, or http://localhost:8080 for the production
+build.
+
+#### Architecture
+
+```
+browser  ──(same-origin /api/*)──►  ihasmail server (Node + Hono)  ──(JMAP over HTTPS)──►  Stalwart
+  React SPA                           • session cookie ⇄ Basic auth
+  JMAP client + stores                • /api/jmap, /api/blob, /api/upload, /api/events (SSE), /api/image
+```
+
+- `web/` — Vite + React 19 + TypeScript SPA. `src/jmap` (client, push, types), `src/store` (zustand: session, mail, compose, contacts, calendar, files, sieve, settings), `src/views`, `src/lib` (sanitizer, search parser, Sieve codec, locale-aware dates, vCard, …).
+- `server/` — Node/Hono backend: authenticates against Stalwart's JMAP session endpoint, seals the credentials with a key derived from the cookie secret, proxies JMAP/blob/SSE, serves the SPA under a strict CSP. `src/mock/` is an in-memory fake Stalwart for development and demos.
+
+Capabilities used: `core`, `mail`, `submission`, `vacationresponse`, `sieve`,
+`contacts`(+`parse`), `calendars`(+`parse`), `principals`(+`availability`),
+`quota`, `blob`, `filenode`, EventSource push, plus Stalwart's own
+`urn:stalwart:jmap`. Features degrade gracefully when one is missing.
+
+#### The mock
+
+An in-memory fake Stalwart 0.16 — enough JMAP to develop and demo against
+without a real mailbox. It reproduces the things a naive fake would get wrong,
+because each cost a live debugging session: `urn:stalwart:jmap` advertised
+**per-account** rather than session-level, identity signatures capped at 2047
+**bytes**, and `CalendarEvent/set` speaking Stalwart's vocabulary rather than
+RFC 8984's.
+
+| Switch | What it does |
+| --- | --- |
+| `MOCK_NO_FUTURE_RELEASE=1` | Advertises FUTURERELEASE, then drops every hold |
+| `MOCK_NO_REGISTRY=1` | Omits the Stalwart capability, so the sign-in refusal can be tested |
+| `MOCK_NO_SCHEDULING_SEND=1` | Refuses a calendar write that asks for scheduling messages, as for an account without that permission |
+| `MOCK_ROLE` | Who the demo user is for Administration: `admin` (the default), `tenant-admin`, `helpdesk` or `user` |
+| `MOCK_METRICS=off` | Refuses the dashboard's metric history, as Community does |
+| `MOCK_EDITION=enterprise` | Reports Enterprise, which Tenants needs |
+
+It tracks the current Stalwart release rather than 0.16 in general, and each
+behavior is confirmed against a real server before it is copied here — the
+comments say which version and on what date. Where a release changes something
+a client can see, the mock changes with it, and the test that pinned the old
+behavior is rewritten rather than deleted, so the reversal stays on the record.
+
+#### Version numbers
+
+`2026.8.30+pr129` is the date of the commit a build came from and the pull
+request that commit arrived through; a commit that did not come through one
+carries its short SHA instead (`2026.8.30+g1fa6578`). It is worked out from git
+at build time — nothing writes a version into the tree, and `package.json` stays
+at `0.0.0`. `node scripts/version.mjs` prints it for the current checkout.
+
+The PR number sits after the `+` as build metadata because it records where a
+build came from, not how new it is. The version says nothing about Stalwart on
+purpose: what a build needs from the server is stated in the README badge and
+in [KNOWN-ISSUES.md](KNOWN-ISSUES.md). Building an image with the version on it,
+and the single-host `deploy.example.sh`, are covered in
+[Installing](https://docs.ihasmail.org/install/).
+
 ## Review Process
 
 - A maintainer will review your PR and may request changes.

Dockerfile

@@ -1,5 +1,5 @@
 # ---- build stage ----
-FROM node:22-alpine AS build
+FROM node:26-alpine AS build
 # What this build calls itself: 2.16.<PR>, worked out by whoever runs the
 # build. It cannot be worked out in here -- .dockerignore keeps .git out of the
 # context on purpose, and git is not installed either. `node scripts/version.mjs`
@@ -25,7 +25,7 @@ COPY . .
 RUN npm run build
 
 # ---- runtime stage ----
-FROM node:22-alpine AS runtime
+FROM node:26-alpine AS runtime
 # Re-declared: an ARG does not cross stages.
 ARG IHASMAIL_VERSION=""
 ARG BASE_PATH=""
@@ -37,16 +37,28 @@ ENV NODE_ENV=production \
     IHASMAIL_VERSION=$IHASMAIL_VERSION \
     BASE_PATH=$BASE_PATH
 WORKDIR /app
-COPY package.json ./
+COPY package.json package-lock.json* ./
 COPY server/package.json server/
 # config.ts reads the version through this at startup. With IHASMAIL_VERSION
 # set it never looks further; without it, it falls back to package.json rather
 # than failing, since there is no git in here to ask.
 COPY scripts/ ./scripts/
-COPY --from=build /app/node_modules ./node_modules
+# Only what the server loads at runtime: hono and its Node adapter, about 4 MB.
+# The build stage's tree is 132 MB of vite, TypeScript, esbuild and React that
+# never executes here but shipped anyway -- and showed up in every CVE scan.
+RUN npm ci --ignore-scripts --omit=dev --workspace server \
+    && rm -rf /root/.npm /tmp/*
 COPY --from=build /app/server/dist ./server/dist
 COPY --from=build /app/web/dist ./web/dist
-RUN mkdir -p /data && chown -R node:node /data /app
+# /data is the only path the process may write. /app stays root-owned and
+# read-only to the runtime user on purpose; the previous `chown -R /app`
+# re-wrote every file and, on overlayfs, duplicated the whole tree into a
+# second 173 MB layer.
+RUN mkdir -p /data && chown node:node /data \
+    # The base image ships a package manager the server never calls. Anyone who
+    # gets code execution should not find one waiting for them.
+    && rm -rf /usr/local/lib/node_modules /usr/local/bin/npm /usr/local/bin/npx \
+              /usr/local/bin/corepack /opt/yarn* /usr/local/bin/yarn /usr/local/bin/yarnpkg
 USER node
 # No `VOLUME ["/data"]`. It reads like documentation for where the session file
 # goes, but Docker acts on it: a container started without `-v` gets an

FEATURES.md

@@ -12,8 +12,12 @@ questions:
 | [KNOWN-ISSUES.md](KNOWN-ISSUES.md) | What was verified live, and where Stalwart departs from a spec |
 | [docs.ihasmail.org](https://docs.ihasmail.org) | How to install, configure and drive each of these |
 
-Written against the tree at Stalwart **0.16.20**, which is the version the live
-instance runs and the one every behaviour below was checked against. ihasmail
+Written against the tree at Stalwart **0.16.22**, which is the version the live
+instance runs. Behaviors carrying an older version below were checked against
+that one and have not changed since; where a later release changed something,
+the entry says so and names both. 0.16.22 changed nothing described here: its
+client-visible changes are in what `CalendarEvent/get` and `ContactCard/get`
+return, and [KNOWN-ISSUES.md](KNOWN-ISSUES.md) lists them. ihasmail
 requires 0.16 or newer and refuses older servers at sign-in, by name.
 
 ## The shape of it
@@ -67,9 +71,11 @@ per-account shape.
 ## Layout
 
 Three panes: folder tree, message list, reading pane. The splitter between the
-list and the reading pane is dragged to resize, and the size is remembered per
-device — a width chosen on a 27" monitor is wrong on a laptop, so it is one of
-the few settings that does not follow the account.
+list and the reading pane is dragged to resize, and so is the edge of the
+sidebar, between 240 and 480px; arrow keys move either one, and a double-click
+puts it back. The sizes are remembered per device — a width chosen on a 27"
+monitor is wrong on a laptop, so they are among the few settings that do not
+follow the account.
 
 - **Reading pane** right of the list, below it, or off (messages open full width).
 - **Density** comfortable, cozy or compact, which changes row height as well as padding.
@@ -97,7 +103,7 @@ every drag.
   archives and left deletes by default, which is what the mail app the phone
   came with already does. Either direction can be set to archive, delete,
   report spam, read/unread, star or move to… — or to nothing, which turns that
-  direction off. The coloured strip revealed behind the row names what will
+  direction off. The colored strip revealed behind the row names what will
   actually happen *in the folder it is happening in*: "Delete forever" out of
   Deleted Items, "Not spam" inside Junk Mail. Where an action
   is meaningless there — archiving out of the archive, calling your own drafts
@@ -137,14 +143,14 @@ it is silently nothing there.
 
 The arithmetic lives in `web/src/lib/touch.ts`, away from the components and
 under test, because the numbers are the whole thing. The axis lock is
-deliberately biased towards the vertical: scrolling is what a finger on a
+deliberately biased toward the vertical: scrolling is what a finger on a
 message list is doing almost every time, and a scroll misread as a swipe grabs
 the list out from under the reader, while a swipe misread as a scroll costs one
 more attempt. A drag that is merely more sideways than not stays a scroll.
 
 ## The message list
 
-- **Virtualised** — rows are windowed with `@tanstack/react-virtual`, so a
+- **Virtualized** — rows are windowed with `@tanstack/react-virtual`, so a
   folder of 100,000 messages scrolls at the same speed as one of ten. Row
   height follows density and the one- or two-line layout.
 - **Infinite scroll** with server-side paging, 50 at a time by default.
@@ -230,28 +236,35 @@ for that one, and the dialog says so.
 
 ## Folders
 
-Real JMAP mailboxes, with the server's roles honoured.
+Real JMAP mailboxes, with the server's roles honored.
 
 - Create, rename, create a subfolder, delete (with or without its mail).
-- **Drag a folder onto another** to reparent it. Folders with a server role
-  (Inbox, Sent, Drafts, Trash, Junk, Archive) are structural and are not
-  offered the drag, because the server refuses to move them anyway.
+- **Order:** Inbox first, then the other special folders (Drafts, Sent,
+  Archive, Junk, Trash), then everything else A–Z, at every level.
+- **Drag a folder between two others** to put it there. The line shows where
+  it will land. The order is saved on the server as the folders' JMAP
+  `sortOrder`, so it follows you to every device, and other clients that
+  honor `sortOrder` show it too. *Move up* and *Move down* in the folder menu
+  do the same from the keyboard or on touch. Inbox always stays first.
+- **Drag a folder onto the middle of another** to reparent it. Folders with a
+  server role (Sent, Drafts, Trash, Junk, Archive) can be reordered but not
+  nested, because the server refuses to move them to another parent.
 - **Subscribe / unsubscribe** — *Show in list* / *Hide from list*. An
   unsubscribed folder still exists and still receives; it is just out of the
   way. Inbox cannot be hidden.
 - **Mark all as read**, optionally including subfolders.
-- **Folder colours**, per mailbox id.
+- **Folder colors**, per mailbox id.
 - **Unread counts** per folder, live.
 - **Storage quota** bar under the tree where the server reports one.
 - Rights are respected per folder: rename, delete, create-child and share each
-  grey out when `myRights` says no.
+  gray out when `myRights` says no.
 - A folder in the address that this account does not have says *this folder is
   missing*, rather than drawing an empty folder — a stale link should not read
   as a folder that emptied itself.
 
 ## Labels
 
-Labels are **IMAP keywords** with a colour and a display name kept in settings.
+Labels are **IMAP keywords** with a color and a display name kept in settings.
 Because they are keywords, every other client that reads the mailbox sees them,
 and they survive ihasmail entirely. A message can carry any number. They are
 managed in Settings › Labels, applied from `l` or the context menu, and
@@ -305,7 +318,7 @@ same query string — so what it builds can be read, edited and learned from.
 
 ## Reading a message
 
-- **Sanitised HTML**, rendered inside a **Shadow DOM** so the sender's CSS
+- **Sanitized HTML**, rendered inside a **Shadow DOM** so the sender's CSS
   cannot reach the app. DOMPurify strips scripts, event handlers, forms and
   anything that could navigate the top window.
 - **Remote images blocked by default**, with a banner offering *Show images* or
@@ -364,8 +377,16 @@ same query string — so what it builds can be read, edited and learned from.
   since the filter applies policy ihasmail cannot see. Mail that arrived without
   these headers shows nothing.
 - **Message body theming** is off by default — sender HTML is left exactly as it
-  was designed, on a light card. One setting lets mail that brings no colours of
-  its own follow the app's theme instead.
+  was designed, on a light card. One setting lets mail that brings no colors of
+  its own follow the app's theme instead. That is a low bar in practice: one
+  `color:#FFFFFF` on one button label opts a whole message out, so for mail
+  built from a template it changed nothing. A second setting, off unless the
+  first is on, forces the theme over the sender's own colors. It tells a
+  *sheet* the design sits on, like a white wrapper table, from a *painted
+  surface* like a button or a banner, by relative luminance: the first is
+  neutralized so the bright card goes away, the second is kept whole so its
+  label stays readable on it. Nothing the sender wrote is removed, so the
+  switch is reversible, and print is unaffected either way.
 
 ### Conversations
 
@@ -383,7 +404,7 @@ same query string — so what it builds can be read, edited and learned from.
 
 - **Invitations (iTIP)** render an invite card: what, when, where, the guest
   list with each person's status, and Yes / Maybe / No. The reply is written to
-  the event and sent back to the organiser. Cancellations are recognised too.
+  the event and sent back to the organizer. Cancellations are recognized too.
 - **vCard attachments** render a card offering to add the person to an address
   book.
 - **Right-click anyone named** in the message — From, To, Cc, Bcc or Reply-To —
@@ -413,13 +434,28 @@ Requesting one on your own outgoing mail is a separate switch.
 ## Composing
 
 **Multiple composers at once**, floating in a dock at the bottom right, each
-minimisable and maximisable; full-screen on mobile.
+minimizable and maximizable; full-screen on mobile.
 
-- **Rich text**: bold, italic, underline, strikethrough, text colour, highlight,
+- **Rich text**: bold, italic, underline, strikethrough, text color, highlight,
   font size, alignment, bulleted and numbered lists, indent/outdent, blockquote,
   code block, links (`Ctrl+K`), inline images, an emoji picker, and remove
   formatting. Tab and Shift+Tab indent inside the body.
 - **Plain text** as a per-message or default format.
+- **Quoting follows the message's own image decision.** A quote renders the
+  message again, so the reply blocks its remote images unless that message was
+  allowed them — by policy, by a trusted sender, by the sender being a
+  contact, or by *Show images* having been pressed on it. Blocked images keep
+  their address and get it back when the reply is sent, so the recipient's
+  copy is the quote as its sender wrote it. Allowed ones are fetched through
+  the server's image proxy, the same as when the message was read, and the
+  sent copy points at their own addresses rather than at this server.
+- **Answering in the format the message was written in.** Replying in plain
+  text to a rich text message, or the reverse, loses either the formatting or
+  the plain text somebody chose to write in. The composer opens in the default
+  format and offers the other one for that message, above the editor; the
+  offer is dismissible and changes no setting. Forwards too. What counts as
+  rich text is the body part's own type, not the presence of `htmlBody`, which
+  RFC 8621 derives for plain-text mail as well.
 - **Recipient chips** with autocomplete from contacts, shared address books you
   have added, the server directory and recent recipients; your own cards win a
   tie against a colleague's copy of the same person. Free-form addresses parse
@@ -454,7 +490,7 @@ minimisable and maximisable; full-screen on mobile.
 - **Attachments** by picking or dragging onto the composer, with progress per
   file and the size limit the server states (`MAX_UPLOAD_BYTES`, 50 MB by
   default). A pasted image is inserted inline instead, and pasted HTML is
-  sanitised on the way in.
+  sanitized on the way in.
 - **Attach from Files** — anything the server already holds attaches with **no
   upload at all**, however large. A file from someone else's shared folder is
   copied to your account first, because a message can only carry blobs from the
@@ -468,6 +504,8 @@ minimisable and maximisable; full-screen on mobile.
   uploaded, which it was not being.
 - **Attachment reminder** when the text mentions an attachment and none is there.
 - **Spell check** toggle.
+- **Open the composer full screen**, as a setting, for anyone whose first
+  move is always Maximize. Off by default; on a phone it changes nothing.
 - **Drafts** save as you type and on close, with the save state shown.
 - **Quoting** on reply, with the signature placed above or below it, and
   reply-all as an optional default.
@@ -495,7 +533,7 @@ out whether or not ihasmail is open, or ever opened again.
 
 Held messages wait in a **Scheduled** folder ihasmail maintains itself (JMAP has
 no role for one), and reconciles when you next open it: released messages move
-to Sent, cancelled ones back to Drafts. The picker offers presets and an exact
+to Sent, canceled ones back to Drafts. The picker offers presets and an exact
 date and time, bounded by the maximum delay the server advertises.
 
 > If Stalwart's `futureRelease` is not configured, a "scheduled" message is sent
@@ -522,23 +560,41 @@ are settings.
 
 The sidebar keeps three groups apart:
 
-- **My calendars** — yours, each with a colour, each hideable with a click.
+- **My calendars** — yours, each with a color, each hideable with a click.
 - **Shared with me** — other people's, once added.
 - **Available to add** — shared with you but not yet added, with a plus beside
   each. An unadded calendar draws nothing. This is deliberate: the server
   reports every collection in an account you can reach, whether or not anyone
   meant to share it, so being handed one is not evidence that it was offered.
 
-Right-click your own to rename, recolour, share, stop sharing or delete;
+Right-click your own to rename, recolor, share, stop sharing or delete;
 right-click one of someone else's to remove it from your view, which changes
 nothing for anybody else.
 
 - **iCal import** through `CalendarEvent/parse` (a file of any number of
   events), from the calendar's own menu, into that calendar. The events are
   filed rather than scheduled: no invitations go out to anyone named in them.
+- **Re-importing updates rather than duplicates**, as a contacts import does.
+  An event is recognized by its UID, per calendar, and what the file carries
+  wins -- so a corrected export corrects what the first attempt got wrong.
+
+  Two things are deliberately left alone: **who accepted**, and **edits to a
+  single occurrence**. Both are answers and decisions taken here after the file
+  was written, and a file that mentions them at all describes them as they were
+  at export, so writing either one over would throw away work silently and
+  return no error anywhere. A corrected export therefore fixes the time, the
+  title and the location, and leaves the RSVPs and the "just this Wednesday"
+  changes where they are.
+
+  The cost runs both ways and is worth knowing. An attendee added at the source
+  since the last import does not arrive, because nothing here can tell that
+  apart from an answer given in ihasmail. And an import still sends no
+  scheduling messages, so an event a re-import moves is moved *here* --
+  everybody else's copy still says the old time until whoever is organizing
+  sends the update from the event itself.
 - **Subscribed calendars** by URL — a timetable, a rota, a public holiday list.
   Added in Settings › Calendar & contacts, read-only, and shown beside your own
-  with their own colour.
+  with their own color.
 
   **Nothing is stored.** The document is fetched when you open the calendar and
   parsed in the browser; the server keeps no copy, no cache and no schedule,
@@ -576,7 +632,7 @@ nothing for anybody else.
   They cannot be edited or deleted, and that falls out of the design rather
   than being special-cased: the virtual calendar reports no write rights, so
   every control that asks before offering Edit or Delete already declines. The
-  store refuses a synthesised id as well, whatever calls it.
+  store refuses a synthesized id as well, whatever calls it.
 
   A card that records only a day and month — the common case — gets a birthday
   with no age rather than no birthday. And 29 February falls on the 28th in a
@@ -591,16 +647,16 @@ empty space offers a timed or all-day event at that moment, or *Go to day* /
 
 The editor covers title, start and end (all-day or timed, with a time zone),
 calendar, location, meeting link, guests, description, reminders, repeat,
-status (confirmed / tentative / cancelled), show-as (busy / free), visibility
-(default / private / secret), category and colour.
+status (confirmed / tentative / canceled), show-as (busy / free), visibility
+(default / private / secret), category and color.
 
 - **Recurrence** — none, daily, weekly, weekdays, monthly, yearly, or a custom
   builder: interval, by-weekday, by-month-day, and an end by count or by date.
 - **Reminders** — one or more alerts before the start, with a default in settings.
-- **Colour categories**, Outlook-style: named colours managed in Settings ›
+- **Color categories**, Outlook-style: named colors managed in Settings ›
   Calendar, assigned from the editor or the context menu, and stored as
-  JSCalendar `categories` so other clients see them. (The per-event colour
-  picker that predated them is gone; a colour comes from the category, or the
+  JSCalendar `categories` so other clients see them. (The per-event color
+  picker that predated them is gone; a color comes from the category, or the
   calendar.)
 - **Duplicate** an event from the context menu.
 - **Create event…** from a message, in its context menu and its ⋮ menu (and,
@@ -617,7 +673,7 @@ status (confirmed / tentative / cancelled), show-as (busy / free), visibility
 ## Attendees, invitations and free/busy
 
 Invitations go out as iTIP when guests are added, replies come back and are
-applied to the event, and cancelling notifies the guests. Guests are added by
+applied to the event, and canceling notifies the guests. Guests are added by
 name or address with the same autocomplete the composer uses.
 
 Where the server implements `Principal/getAvailability`, the event editor grows
@@ -662,13 +718,18 @@ work:
   success; the rest are applied. ihasmail checks the patch before sending it, so
   a rejected property is an error you can see and an inherited one is reported
   as something it could not do for one date, rather than claimed as saved.
-- **Occurrence ids are not stable across a write.** Stalwart's synthetic ids
-  encode a position in the expanded series, and writing an override renumbers
-  them — confirmed live on 0.16.20: after one override, the same five ids
-  addressed a different five dates. So an occurrence is re-resolved from its
-  `recurrenceId` (the date itself) immediately before it is touched, and a
-  vanished date says so rather than acting on an id that now means something
-  else.
+- **Occurrence ids became stable in 0.16.21, and were not before it.** Through
+  0.16.20 Stalwart's synthetic ids encoded a *position* in the expanded series,
+  so writing one override renumbered the rest and the same five ids addressed a
+  different five dates. 0.16.21 identifies an occurrence by its recurrence id
+  instead — confirmed live on 0.16.21 (2026-09-06): a five-week series was
+  expanded, its third occurrence retitled through its own synthetic id, and all
+  five original ids re-read afterwards still named their own dates. ihasmail
+  re-resolves an occurrence from its `recurrenceId` immediately before touching
+  it anyway. That is no longer load-bearing on the current server, and it stays
+  because it costs one lookup, because a vanished date still has to say so
+  rather than be acted on, and because the client supports 0.16 as a whole
+  rather than only its newest release.
 
 *This and future* is not offered: the server refuses an occurrence that belongs
 to such a change, and where it does, ihasmail says so and offers the series.
@@ -711,19 +772,33 @@ JMAP Contacts and JSContact.
   company, job title, any number of emails, phones and addresses with types,
   birthday, website and notes.
 - **Groups** as a card kind, with members picked from the book.
+- **Select and delete in bulk** — tick rows in the list, shift-click for a run,
+  and delete the lot; or **Empty address book** from the book's own menu, which
+  is the operation a migration asks for when an import needs doing again. A card
+  filed in two books is only ever removed from the one being emptied, since
+  deleting it would empty a book nobody asked about, and what is reported
+  afterwards is what the server confirmed rather than what was asked for.
 - **Letter index** down the list, with `#` for everything that does not start
   with a letter.
-- **Search** across name, address, organisation and notes, in one book or all.
+- **Search** across name, address, organization and notes, in one book or all.
 - **vCard import** through `ContactCard/parse` (a file of any number of cards),
   and **export** of one card or the whole book as `.vcf`.
 - **LDIF import**, for address books coming from SOGo, Thunderbird or an LDAP
   directory. Nothing on the server reads LDIF, so the file is read here:
   RFC 2849 for the syntax, [Mozilla's address book schema][ldif-schema] for what
   the attributes mean, which is the one such exports almost always use. Work and
-  home addresses, every phone kind, second email, organisation and units, job
+  home addresses, every phone kind, second email, organization and units, job
   title, nickname, web pages and the custom fields all come across. The import
   control takes either format and decides by what is in the file, not by what it
   is called.
+- **Re-importing updates rather than duplicates.** A vCard is recognized by its
+  UID; an LDIF entry, whose schema has none, by its distinguished name. The card
+  already here is merged with the file's version -- what the file carries wins,
+  what it does not mention is left alone -- so a corrected export can correct
+  what the first attempt got wrong. Matching is per address book, which is also
+  how two directories that each hold a `cn=John Smith` stay two people. An entry
+  no longer recognizable, because its `dn` moved between exports, is imported
+  again and counted: *"3 of them look like contacts you already had."*
 
 [ldif-schema]: https://wiki.mozilla.org/MailNews:Mozilla_LDAP_Address_Book_Schema
 - **Directory lookup** through `Principal/query`, so colleagues on the server
@@ -847,7 +922,7 @@ individual rights by hand.
 
 Preferences live in a `settings.json` in the account's own JMAP Files, beside
 the signature images. So identity, signatures, locale, date and time formats,
-theme, labels, templates, folder colours, trusted image senders and added shares
+theme, labels, templates, folder colors, trusted image senders and added shares
 are the same wherever you sign in, private windows included — and they are
 backed up with the mail store, because they *are* in the mail store. ihasmail
 still stores nothing of its own.
@@ -870,16 +945,16 @@ not reach another that already has ihasmail open until it signs in again.
 
 | Section | Holds |
 | --- | --- |
-| **General** | Reading pane, mark-as-read delay, auto-advance, conversation view, snippets, avatars; compose format, quoting, signature placement, spell check; time zone, week start, language & region, date format, time format; `mailto:` handler; export / import / reset |
+| **General** | Reading pane, mark-as-read delay, auto-advance, conversation view, snippets, avatars; compose format, quoting, signature placement, spell check, full-screen composer; time zone, week start, language & region, date format, time format; `mailto:` handler; export / import / reset |
 | **Privacy & safety** | Remote images and the senders trusted with them, read receipts asked for and answered; the three warnings and the domains they measure against; undo-send window, attachment reminder, confirm-before-delete |
-| **Appearance** | Theme, accent colour, density, font size, sidebar, swipe actions, interface language |
+| **Appearance** | Theme, accent color, density, font size, sidebar, swipe actions, interface language |
 | **Identities & signatures** | Addresses, names, Reply-To, HTML signatures, the default, and which to hide from the picker |
 | **Filters & rules** | The visual builder and raw Sieve editor |
 | **Out of office** | Vacation response |
-| **Folders** | Create, rename, colour, subscribe |
-| **Labels** | Keyword, display name, colour |
+| **Folders** | Create, rename, color, subscribe |
+| **Labels** | Keyword, display name, color |
 | **Templates** | Named subject + body |
-| **Calendar & contacts** | Colour categories, working hours, default view, default duration, default reminder |
+| **Calendar & contacts** | Color categories, working hours, default view, default duration, default reminder |
 | **Notifications** | In-tab notifications, notify-when-closed (Web Push), sound |
 | **Security & sessions** | Password, two-factor state, app passwords, active webmail sessions |
 | **Keyboard shortcuts** | The full list, grouped |
@@ -889,7 +964,7 @@ not reach another that already has ihasmail open until it signs in again.
 between them is worth stating because two similar words in one nav is how a
 menu becomes something people hunt through. Security & sessions is credentials
 and access: password, two-factor state, app passwords, live sessions. Privacy &
-safety is how the app behaves towards the reader and towards senders: what
+safety is how the app behaves toward the reader and toward senders: what
 loads, what leaks, and what asks before it happens. These had been spread
 through General, which had grown five unrelated headings — remote images filed
 under "Reading", the read-receipt policy under "Composing", the undo-send window
@@ -959,12 +1034,12 @@ is why they are two settings and not one.
 
 | | |
 | --- | --- |
-| English | the source language, and what every other catalogue falls back to |
+| English | the source language, and what every other catalog falls back to |
 | Deutsch · Español · Français · Nederlands · Português (Brasil) | Beta |
 | Русский · Українська · 简体中文 · 日本語 | Beta |
 
 **All nine translations are marked Beta, and the label is not modesty.**
-The catalogues were produced by AI against standard dictionaries and have not
+The catalogs were produced by AI against standard dictionaries and have not
 been read by anybody who speaks the language. That is stated in Settings, next
 to a link for reporting anything that reads wrongly, because the alternative —
 shipping them quietly — would ask people to trust text nobody has checked. A
@@ -974,7 +1049,7 @@ deliberate act by a person and not something a percentage earns.
 Two things follow from the design rather than the translation:
 
 - **A missing entry renders its English source.** So deleting a bad line is a
-  valid fix, not a regression, and a catalogue is never in a half-broken state.
+  valid fix, not a regression, and a catalog is never in a half-broken state.
 - **Plurals are asked for, never assumed.** `Intl.PluralRules` decides the form,
   so Russian and Ukrainian get their three (1 письмо, 2–4 письма, 5+ писем) and
   Japanese and Chinese get the one they actually have — with counters doing the
@@ -986,7 +1061,7 @@ The interface language also feeds the *automatic* date locale, so choosing
 page that is already in the reader's language — and accepting that offer is
 what rewrites the DOM underneath React.
 
-Only languages with a catalogue shipped appear in the picker. A language
+Only languages with a catalog shipped appear in the picker. A language
 offered without strings behind it would leave the page claiming to be in a
 language it is not, which is worse than not offering it: it stops a browser
 offering to translate a page the reader cannot read.
@@ -1005,29 +1080,311 @@ at two.
 | **Gruvbox** | |
 | **Rosé Pine** | Dawn as its light half |
 | **Tokyo Night** | Day as its light half |
+| **Catppuccin** | Mocha and Latte |
+| **Solarized** | Light and dark are both original to it, and share one set of accents |
+| **Ayu** | |
+| **Kanagawa** | Wave, with Lotus as its light half |
+| **Everforest** | The medium-contrast variant of each side |
+| **Primer** | The colors behind GitHub's design system. Named for the system, not for GitHub, which has not endorsed anything here |
 
 Every one has both halves, so the top-bar toggle only ever changes the side and
-never the colours. Accent colours still sit on top of any of them.
+never the colors. Accent colors still sit on top of any of them.
 
-The four borrowed palettes are the work of their own projects and are used
-under the MIT licence — see [NOTICE](NOTICE). Only the published colour values
+The ten borrowed palettes are the work of their own projects and are used
+under the MIT license — see [NOTICE](NOTICE). Only the published color values
 are used, taken from each project's own repository; the values as fetched are
 recorded in `.palette-sources/palettes-upstream.md`.
 
 **The shades between those values are derived, and every one is checked.**
 ihasmail needs about thirty tokens and these projects publish between twelve
 and twenty, so the tiers in between are computed by
-`scripts/build-palettes.py`, which then measures every text colour against the
+`scripts/build-palettes.py`, which then measures every text color against the
 surface it sits on — 4.5:1 for prose, 3:1 for borders and marks — and lifts
-anything that falls short, towards white on a dark ground and towards black on
+anything that falls short, toward white on a dark ground and toward black on
 a light one so the hue survives. The script refuses to write a palette that
 would not pass.
 
-That check is not a formality. **Every one of the nine palette halves needed at
-least one lift**, because these palettes are designed for code editors rather
-than for prose at this size: Dracula's comment grey is 3.03:1 on its own
-background, and Rosé Pine's gold is 2.7:1 on Dawn. Shipping them as published
-would have quietly ended the WCAG AA claim two sections down.
+That check is not a formality. **Twenty-one of the twenty-two palette halves
+needed at least one lift**, because these palettes are designed for code
+editors rather than for prose at this size: Dracula's comment gray is 3.03:1 on
+its own background, and Rosé Pine's gold is 2.7:1 on Dawn. Shipping them as
+published would have quietly ended the WCAG AA claim two sections down.
+
+Body text is lifted the same way, which it was not at first. It used to be
+checked and then either accepted or rejected, and that rule would have turned
+away five of the six palettes added in September 2026: most of them target
+around 4.5:1 for body text, their own goal, where ihasmail asks 7:1 of the text
+a reader looks at all day. Rejecting a palette over a bar its designers never
+aimed at is the wrong answer when the same arithmetic already adjusts muted
+text, links and accents. Solarized Light moves 4.13 to 7.07 that way; Primer
+needed nothing in either half.
+
+---
+
+# Administration
+
+An account whose Stalwart role manages other accounts finds **Administration**
+in the account menu, top right. Nobody else sees the entry, and the page
+redirects them to their mail if they type its address in.
+
+## What it offers is what the role allows
+
+At sign-in the server already asks Stalwart's `GET /api/account` for the
+edition; it now keeps the account's **permissions** from the same answer and
+hands them to the browser with the session. The menu appears for an account
+that can count something the dashboard shows — accounts (`sysAccountQuery`),
+domains (`sysDomainQuery`), the delivery queue (`sysQueuedMessageQuery`) or the
+metric history (`sysMetricQuery` with `sysMetricGet`) — and each section and
+control inside is there only when the matching permission is:
+**New account** with `sysAccountCreate`, editing with `sysAccountUpdate`,
+**Delete** with `sysAccountDestroy`. A system administrator, a tenant
+administrator and a custom helpdesk role each see the same screen shaped to
+what they can do.
+
+None of that is the security boundary. Every read and write is a JMAP `x:`
+call through the ordinary `/api/jmap` proxy, authenticated as the signed-in
+account, and Stalwart decides each one — scoping a tenant administrator's
+queries to their own tenant and refusing anything the role does not allow.
+The client's gating only avoids offering what would fail.
+
+## Dashboard
+
+Administration opens on a grid of cards, one for each number the role can read:
+
+| Card | What it counts | Needs |
+|---|---|---|
+| **Users** | user accounts, not groups | `sysAccountQuery` |
+| **Domains** | mail domains | `sysDomainQuery` |
+| **Pending** | messages waiting in the delivery queue | `sysQueuedMessageQuery` |
+| **Server memory** | the latest reading, and when it was taken | `sysMetricQuery`, `sysMetricGet` |
+| **Received** | messages queued for delivery in the last 24 hours | the same |
+| **Sent** | authenticated submissions, bounces and reports queued in the last 24 hours | the same |
+
+Users and Domains open their sections when the role can. The counts are what
+Stalwart answers for the signed-in account, so a **tenant administrator sees
+their tenancy**: its accounts, its domains, and the queued messages that touch
+them. The last three come from Stalwart's metric history, which has no tenant
+in it and which the Tenant Administrator role Stalwart creates does not hold,
+so a tenant's dashboard is Users, Domains and Pending. A helpdesk role that can
+read accounts and domains sees those two cards.
+
+The history is an Enterprise feature that has to be switched on. A server that
+refuses it — Community does — leaves those three cards off rather than showing
+them broken, and one that records nothing says *Not recorded on this server*
+rather than showing a day of zeroes. Received and sent add up the same metric
+names Stalwart's own dashboard uses. The columns follow the number of cards,
+so rows come out even: six are three over three, and fall to two and then one
+as the space narrows. **Refresh** reads everything again; nothing is polled.
+
+Below the cards, a line says where the rest is: detailed metrics, the delivery
+queue, logs and server settings are in Stalwart's own administration, and it
+links there. The address is found rather than configured: the public host
+Stalwart advertises in its own session — the one people reach it at, even when
+ihasmail talks to it on a private address — and the prefix its web interface is
+installed under, read from its `x:Application` objects (`/admin` unless it was
+moved). A server whose web interface is disabled or moved away gets no link, and
+an administrator who may not read applications gets Stalwart's default `/admin`.
+`STALWART_ADMIN_URL`, or a servers file entry's `adminUrl`, overrides it for an
+administration that lives somewhere else.
+
+## Accounts
+
+- **List and search** by name or address, fifty to a page, newest first — the
+  server's own order. Role, storage used against the limit, and groups at a
+  glance.
+- **Create** an account on any domain the role can see: display name, address,
+  a generated password to copy and pass on, role, and storage limit.
+- **Edit** the display name, other addresses (aliases), role and storage limit.
+  One save sends only what changed.
+- **Set a new password.** It goes into the account's existing password
+  credential, and signs the person out of every app and device using the old
+  one, because Stalwart ties every token to the password.
+- **Delete**, after typing the address to confirm. Stalwart removes the
+  mailbox's data in the background, and says so.
+
+Roles are offered only when the viewer holds every permission they carry,
+which is the check Stalwart makes on a grant. It does **not** make that check
+when only a password changes, or on a delete, so an account allowed to edit
+accounts could otherwise reset the password of one that can do more and sign
+in as it. ihasmail shows any account that outranks the viewer read-only, and
+counts a role it cannot read as outranking rather than not. Nobody can change
+their own role or delete the account they are signed in with.
+
+## Groups
+
+A group is a shared address and mailbox, and the people who share it. To
+Stalwart it is an account whose type is Group, so it takes the same
+permissions as Accounts (`sysAccountQuery`, `sysAccountGet`) and sits beside
+it in the menu.
+
+- **List and search** by name or address, with each group's member count.
+- **Create** a group on a domain, with a display name, a role and a storage
+  limit; **edit** those and its other addresses, which save together.
+- **Members** are added by searching for a person and removed one at a time,
+  and each change applies straight away. Stalwart keeps a membership on the
+  member rather than the group, so every change is a one-line update to that
+  person's account that leaves their other groups alone. Nobody can add or
+  remove themselves.
+- **What a group gives its members** is what has been shared with it — its
+  mailbox, a calendar — not its permissions: a person's permissions come from
+  their own role. The group's own role says what the group may do, and only
+  roles whose permissions the viewer holds are offered, as for accounts.
+- **Delete** asks for the address to be typed. Stalwart keeps anything that
+  something else still names, and every member's account names its groups, so
+  deleting takes the members out first and then deletes the group — the same
+  order a domain's keys go before the domain. A role that cannot change the
+  members' accounts is not offered a delete it could only half finish.
+
+Groups do not contain groups; Stalwart has no nesting.
+
+## Mailing lists
+
+A mailing list is an address that passes mail on to everyone on it, on this
+server or anywhere else. For a role with `sysMailingListQuery` and
+`sysMailingListGet`, under Directory after Groups:
+
+- **List and search** by name or address, with each list's recipient count.
+- **Create** a list on a domain; **edit** its display name, recipients and
+  other addresses, which save together.
+- **Recipients** can be pasted several at a time — a column from a
+  spreadsheet, a line of addresses separated by commas, `Name <address>` —
+  and anything with an @ that is not an address stays in the box with a note
+  rather than being dropped. Past a dozen, a filter narrows them. Saving sends
+  only the addresses added and removed, so a recipient someone else added while
+  the panel was open is not lost.
+- **Delete** asks for the address to be typed. The recipients' own mail is not
+  touched.
+
+That is all a list is in Stalwart: there are no owners, moderators or posting
+rules to set.
+
+## Roles
+
+A role is a named set of permissions that accounts, groups and tenants are
+given. For a role with `sysRoleQuery` and `sysRoleGet`, under Access:
+
+- **List and search** every role, with the number of permissions each grants
+  once the roles it builds on are followed, what it builds on, and a note on the
+  ones Stalwart hands out by default.
+- **Builds on** other roles, and gets everything they grant. A role cannot build
+  on itself or on one already built on it.
+- **Permissions** come from Stalwart's own list — every permission the server
+  knows, grouped under its headings, searchable, and filterable to the ones
+  granted or set on this role. Each is not set, allowed or denied; one it
+  inherits says which role it comes from. A denial wins over anything allowed,
+  here or on any role underneath, as it does in Stalwart. Only permissions the
+  viewer holds can be allowed: Stalwart refuses the rest.
+- **Saving** sends only the permissions and roles that changed.
+- **A role that carries permissions the viewer lacks opens read-only**, with no
+  delete — Stalwart checks a grant but not a delete, so this stands in for it.
+- **A default role** — one Stalwart gives new users, groups, tenant
+  administrators or administrators — says so before anything is changed, and
+  cannot be deleted from here. A role still in use is kept by the server, and
+  the refusal names what uses it.
+
+The list of permissions is Stalwart's schema (`GET /api/schema`), fetched by
+ihasmail's server as the signed-in account and cut down to names and labels.
+Its labels are English only, so ihasmail ships its own translation of every one
+of them, loaded only when the Roles screen opens; a permission added by a later
+Stalwart shows the server's English until it is translated.
+
+## Tenants
+
+A tenant is a separate organization on the same server — its own people,
+domains and limits, and an administrator who manages only what is in it. It is
+a Stalwart Enterprise feature. On a server that does not report Enterprise — or
+reports no edition at all — the page is only the notice *Tenants are a Stalwart
+Enterprise feature.*: no list, no search, nothing to create. On Enterprise the
+notice is left out, unless `SHOW_ENTERPRISE_NOTICES=1` asks for it above the
+list, as the public demo does. On Enterprise, for a role with `sysTenantQuery`
+and `sysTenantGet`, under Access:
+
+- **List and search** tenants, with each one's storage and account limit.
+- **Create and edit** a tenant's name, logo (an https address, drawn through the
+  image proxy, or an image data URL), role and limits — accounts, groups,
+  mailing lists, domains, roles, DKIM keys and storage. An empty limit is no
+  limit, and a limit ihasmail does not offer keeps whatever it had.
+- **The tenant's role** is the most anyone inside it can be allowed: their own
+  roles are cut down to it.
+- **What it holds** is counted, each against its limit. Stalwart keeps no list
+  on the tenant; each account, group, domain, list, role and DKIM key names its
+  tenant, so the counts are queries for those. A domain created in a tenant
+  brings its keys with it.
+- **Domains** are added to a tenant, or taken out, from its panel. Only a domain
+  in no tenant can be added, and the accounts already on it stay where they
+  are. A domain comes out only once none of the tenant's accounts are on it —
+  Stalwart would allow it, and strand them.
+- **An account's tenant** is chosen on the account's own panel, which is how a
+  tenant gets its first administrator: an Administrator inside a tenant
+  administers that tenant. Stalwart puts something in a tenant only on a domain
+  in that tenant, so the choice is between no tenant and the domain's own, and
+  a new account starts in its domain's tenant.
+- **Delete** is offered once the tenant holds nothing.
+
+Only an administrator outside every tenant can put anything into one; Stalwart
+refuses anyone else, and inside a tenant it scopes every list to that tenant.
+
+## Domains
+
+For a role that can read domains (`sysDomainQuery`, `sysDomainGet`):
+
+- **List and search**, with how many accounts use each domain and whether its
+  DNS records, DKIM keys and certificate are managed automatically or by hand.
+- **Add** a domain. Stalwart gives a new one automatic DKIM, so it has keys
+  straight away.
+- **Edit** the description, other names for the domain, the catch-all address,
+  and plus addressing (`name+anything@`). A plus-addressing rule set on the
+  server is shown and left alone.
+- **DNS records**, one per row with a copy button each, and the lot as a zone
+  file. Stalwart computes them per domain — MX, SPF, DKIM, DMARC, the service
+  records, MTA-STS, TLS reporting, CAA — and ihasmail joins a long DKIM record
+  back into the single value a DNS provider's form wants.
+- **DKIM keys** with their stage — signing, published and waiting, retiring —
+  read-only, because the server creates and rotates them itself when DKIM is
+  automatic, and a key added by hand needs its private key.
+- **Remove** a domain once nothing uses it. While accounts do, removal says how
+  many and stays unavailable. The domain's own DKIM keys go with it, since the
+  server will not remove a domain its keys still name — which also means a role
+  that cannot delete keys cannot remove a domain that has any.
+
+Switching DNS, DKIM or certificate management between automatic and manual,
+and choosing a DNS or ACME provider, stay in Stalwart's own interface for now.
+
+## Only on your own device
+
+Administration is available only to a session signed in with **"This is my own
+device"** ticked. A borrowed laptop or a shared machine is exactly where nobody
+should be able to reset a password or remove a domain, and that tickbox is the
+one question the sign-in page already asks about where it is being used.
+
+It is enforced the same way as the switch below: an untrusted session is sent
+no permissions, and the JMAP proxy refuses registry methods beyond the account's
+own. The menu still shows **Administration** to an administrator in that
+session, grayed out, with the reason and what to do about it — signing in again
+with the box ticked — rather than losing the entry without a word. All the
+server tells that session is that the account administers, never what it may do.
+
+## An operator can turn it off
+
+`ADMINISTRATION=0` at launch removes it for everyone, and not only from the
+menu. The permissions are no longer sent to the browser, and the JMAP proxy
+refuses Stalwart registry methods except the ones about the signed-in account
+itself — its password, app passwords, API keys, public keys, masked addresses
+and account settings. Without that, hiding the menu would leave an
+administrator's browser console able to make every call the menu made.
+Stalwart's own interface is unaffected; this decides what ihasmail offers.
+
+## Stateless, as everything else
+
+Nothing new is stored anywhere. There is no admin route on ihasmail's server,
+no database and no cache beyond the permissions list that rides along with the
+session information already kept for thirty minutes — so a role granted or
+taken away shows in the menu at the next sign-in or within half an hour, and in
+the meantime Stalwart refuses what is no longer allowed.
+
+The dashboard, accounts, groups, mailing lists, tenants, roles and domains are
+the sections so far. Beyond the dashboard's counts, managing queues, logs and
+server settings is deliberately out of scope.
 
 ---
 
@@ -1057,9 +1414,14 @@ would have quietly ended the WCAG AA claim two sections down.
   when the open page happened to be the root.
 - **The subscription is renewed on every app start**, because a JMAP push
   subscription expires — seven days is the ceiling — and re-registering before
-  it lapses is the client's job. Renewal can only happen with a page open:
-  registering is a JMAP call and the service worker has no session to make one
-  with. So the guarantee is that background notifications keep working as long
+  it lapses is the client's job. Renewal happens with a page open, and the
+  reason is *when* the service worker runs rather than what it is allowed to
+  do: it only wakes for an event, and the event that would wake it is a push
+  that stops arriving the moment the subscription lapses. A renewal that can
+  only run while renewal is still unnecessary is no schedule at all. (This
+  page previously said the worker had no session to register with. That was
+  wrong — see **Acting on a notification** below.) So the guarantee is that
+  background notifications keep working as long
   as ihasmail is opened now and again, and the two-day renewal window means
   once a week is enough. A browser that dropped or rotated its subscription on
   its own is re-subscribed at the same moment, rather than left with a switch
@@ -1076,9 +1438,84 @@ would have quietly ended the WCAG AA claim two sections down.
 # Platform
 
 - **Installable PWA** with a service worker: the app shell is cached for
-  installability and fast loads, API requests never are, and navigations are
-  network-first with the shell as fallback.
+  installability and fast loads, API requests never are. An app route is
+  answered from the kept shell at once while a fresh copy is fetched behind it;
+  a shell a build behind is caught by the version check at start and reloaded.
+  After a new version is seen, the rest of its code (composer, settings,
+  viewers) is fetched in the background, so opening them later does not wait on
+  the server; language catalogs are cached when first used, and nothing is
+  fetched ahead when the browser is set to save data.
 - **Manifest shortcuts** for Compose, Calendar and Contacts.
+- **One window, not one per launch.** A `mailto:` link, a shortcut or a
+  notification opened while ihasmail is already running arrives in the copy
+  that is running. Two windows on the same inbox disagree about what has been
+  read, and only one of them is where the half-written reply is.
+- **The unread count on the installed app's icon.** The tab title and the
+  painted favicon are the same idea for a browser tab, and an installed app has
+  neither -- in `display: standalone` there is no tab strip and no favicon on
+  screen, so a home-screen ihasmail showed nothing at all. Web Push marks the
+  icon while the app is closed, with a dot rather than a figure: the service
+  worker is not told how many messages are unread — a push carries the new mail
+  rather than a total, so counting the payload would badge "2" over an inbox
+  holding forty. The next tab to open writes the real count over it. It could
+  now ask, which is a change since this was written; whether a badge is worth a
+  request on every push is a separate question and has not been answered yet.
+  Unsupported browsers show nothing, as does iOS until notification permission
+  has been granted, which is that platform's condition for a badge.
+- **In the share sheet** — share a photo, a link or a file from any other app
+  and ihasmail is one of the places it can go, opening a draft that holds it.
+  The subject comes from the shared title, the text and the link become the
+  body above your signature, and files are attached and start uploading. It
+  addresses nothing: a share says what to send, never who to.
+
+  A share is a POST, which is not something a client-side router can answer, so
+  the service worker takes the body, leaves it where a tab can collect it and
+  redirects to the app. That indirection is also what lets a share to a
+  signed-out ihasmail work — it waits through the sign-in page and opens after,
+  which the query string could not have survived. One nobody comes back for
+  expires after ten minutes rather than opening a composer full of a forgotten
+  photo the next time you look. Android and Chromium only; iOS does not
+  implement share targets.
+- **Acting on a notification.** Archive and Mark as read sit on the
+  notification itself, and both happen where you are — the phone stays in your
+  hand, or in your pocket. They are the two a phone shows: `maxActions` is two
+  on Android, and anything past it is dropped silently, so these are the two
+  worth having rather than the two that came first. Reply is deliberately not
+  among them, because it would have to open the app, and tapping the
+  notification already does that.
+
+  This was described here as impossible, and it is worth saying why it was not.
+  ihasmail's session is an httpOnly cookie against its own origin, and the only
+  other thing the API asks for is a fixed header that is not a secret. A
+  same-origin request from the service worker carries the cookie like any
+  other, so `Email/set` from a notification is an ordinary call. What the
+  worker genuinely cannot reach is anything a *tab* holds in memory — and the
+  API asks for none of it.
+
+  What it cannot reach is a catalog. The worker is plain JavaScript outside
+  the bundle, with no i18n and no idea which mailbox is the archive, so the app
+  writes both down for it whenever the language, the account or the folder list
+  changes. Where there is no such note — between installing a new worker and
+  next opening ihasmail — the notification appears with no action buttons at
+  all rather than English ones over a guessed mailbox.
+
+  A session can still be gone by the time a button is pressed: expired, signed
+  out, or a cookie that did not outlive the browser. That comes back as a
+  refusal, and the notification says so rather than disappearing as though it
+  had worked. It does not open the app to recover — being interrupted is the
+  thing the button existed to avoid.
+- **Share** — a message, or one attachment, handed to the operating system's
+  share sheet instead of to the filesystem. On a phone a download is close to a
+  dead end: the file lands in Downloads and whoever wanted to send it somewhere
+  goes hunting for it in a file manager. The sheet is on the message menu, on
+  each attachment row, and in the file viewer, which is where an attachment is
+  already open. A message shares as text rather than as the `.eml` beside it,
+  because a share sheet is aimed at everything that is not a mail client and an
+  `.eml` in a chat app is an attachment nobody can open. Every one of those
+  controls is drawn only where the browser has Web Share -- absent on desktop
+  Linux and in Firefox -- and sharing a file is asked about separately from
+  sharing at all. Where the share cannot be made, the download it sits beside
+  happens instead, so the worst case costs a tap rather than the file.
 - **`mailto:` handler** — registered from Settings › General for the browser
   (needs HTTPS; Safari does not support it), and declared in the manifest so an
   installed ihasmail is offered by the operating system wherever something asks
@@ -1137,14 +1574,23 @@ costs something to get wrong is the one that assumes the machine is yours.
 | --- | --- | --- |
 | Stays signed in | until the browser closes | up to 30 days (`SESSION_REMEMBER_TTL`) |
 | Idle sign-out | after 5 minutes | none |
-| Kept on the computer | nothing | settings cache, recent addresses, username |
+| Kept on the computer | nothing | settings cache, recent addresses, username, and the folder list with the first page of recently read folders (list rows only: sender, subject, preview, flags — no message bodies) |
 | Background notifications | refused | available |
+| Administration | unavailable | available, if the role allows it |
 
 Local storage is gated on that answer for **reads** as well as writes — a
-machine trusted once still has residue, and honouring it would let a previous
+machine trusted once still has residue, and honoring it would let a previous
 session's data surface in a later untrusted one. Signing out clears the settings
-cache and recent addresses and tears down the push subscription, whichever
-answer was given.
+cache, recent addresses and kept folder list, and tears down the push
+subscription, whichever answer was given.
+
+What a ticked device keeps is what makes it **start quickly on a distant
+link**: once the server has confirmed the session, the folders and the inbox
+paint from the kept copy straight away, and the request for the open folder
+goes out without waiting on the folder list first. The server's answers
+replace the copy a round trip later. **Nothing kept is shown before the session
+is confirmed** — until then the app shows a spinner, so a session that has
+ended goes from the spinner to the sign-in form and never past a mailbox.
 
 The idle timer exists because the alternative does not work: `beforeunload` text
 was removed from browsers years ago, and **no event fires at all** for walking
@@ -1198,6 +1644,68 @@ Over Stalwart's own registry objects, so there is no administrator in the loop:
   credentials". Doing it properly means implementing OAuth; that is in
   [ROADMAP.md](ROADMAP.md).
 
+## Checking a signature
+
+A signed message says who signed it, and ihasmail checks whether that holds up.
+This is S/MIME only, and it stops at reading: nothing here signs, encrypts or
+decrypts anything.
+
+**What it checks.** For a `multipart/signed` message carrying a PKCS#7
+signature, the exact bytes of the signed part — headers included, canonicalized
+to CRLF — are hashed and compared against the `messageDigest` the signature
+covers, and the signature over the signed attributes is verified with WebCrypto
+against the certificate traveling inside the message. RSA (PKCS#1 v1.5) and
+ECDSA over P-256, P-384 and P-521 are supported, with SHA-256, SHA-384 or
+SHA-512.
+
+**What a check is allowed to claim, which is the whole design.** A browser has
+no system trust store, and the certificate arrives inside the message, so anyone
+can self-sign as anyone. On its own a verified signature proves only that
+whoever wrote the message held the key attached to it — which is why ihasmail
+never renders the bare word *verified*.
+
+What makes it worth anything is remembering. The first signed message from an
+address pins that certificate's fingerprint in your settings; later ones are
+compared against it. That is trust on first use, and it needs no certificate
+authority:
+
+| what happened | what you see |
+|---|---|
+| first signed message from this address | *"Signed by X, seen here for the first time"* — gray, and deliberately not congratulatory |
+| same certificate as before | *"the same signer as before"* — the only case that gets a tick |
+| **different certificate than before** | **loud**: both names, and told to check by some other route |
+| valid signature, certificate for a different address | **loud**: the signature is not for this sender |
+| body changed after signing | **loud**: the signature does not check out |
+| signed, but uncheckable | gray, and careful to say *could not check* rather than *did not check out* |
+
+The pins live in the account's settings file rather than in the browser, so the
+same correspondent is not greeted as new on every device — which is what trains
+people to click past the one warning that matters. A pin records the message
+that created it, so the message which established a signer keeps saying so
+rather than appearing to be corroborated by itself. A signer that changed, one
+whose certificate does not name the sender, or one already expired is never
+pinned: writing an anomaly into the baseline would make every later message
+agree with it.
+
+**What it will not do.**
+
+- **OpenPGP is not checked**, and says so by name rather than as an unknown
+  format. The signature does not carry the key, and ihasmail has nowhere to get
+  a correspondent's public key from — `x:PublicKey` holds the account's *own*
+  keys, and fetching from a keyserver or WKD would leak who you correspond with
+  to a third party, which is the exact thing the image proxy exists to prevent.
+- **No chain of trust.** Nothing is validated against a certificate authority,
+  no CA bundle is shipped, and revocation is not checked. "Issued by" reports
+  what the certificate says, and a self-signed certificate says it issued
+  itself.
+- **SHA-1 signatures are refused**, not reported as valid.
+- **RSA-PSS is declined** rather than attempted, because guessing the salt
+  length wrong would report a good signature as bad — a worse thing to say than
+  "cannot check".
+
+The verifier is a separate bundle chunk, loaded only when a message's structure
+says it is signed, so reading ordinary mail costs nothing for any of this.
+
 ## Privacy by default
 
 Remote images blocked, the proxy on, read receipts never automatic, no
@@ -1218,7 +1726,7 @@ docker run --read-only --tmpfs /tmp -e IMMUTABLE=1 -e SESSION_FILE= ...
 ```
 
 `IMMUTABLE=1` is an **assertion the server checks at startup**, not a switch
-that changes behaviour. It refuses to boot if `SESSION_FILE` is still set, or if
+that changes behavior. It refuses to boot if `SESSION_FILE` is still set, or if
 the filesystem it is installed on turns out to be writable after all. Without
 it, the same misconfiguration is silent — sessions are held in memory and
 persisting them is best-effort, so a read-only `/data` costs one warning at the
@@ -1247,6 +1755,8 @@ wizard, because either would be state.
 | Variable | Default | Does |
 | --- | --- | --- |
 | `STALWART_URL` | — | Where Stalwart is; the JMAP session is discovered at `/.well-known/jmap` |
+| `SHOW_ENTERPRISE_NOTICES` | `0` | Say an Enterprise-only section (Tenants) is Enterprise-only even when the server is Enterprise. For a demo that reports Enterprise to show those sections; a real installation leaves it off |
+| `STALWART_ADMIN_URL` | found | Where a browser opens Stalwart's own administration, linked from the Administration dashboard. Unset, it is found: the host Stalwart advertises and its web interface's prefix. Set it only when the administration lives somewhere else |
 | `APP_SECRET` | — | Key material for sealing sessions. **Required in production** — the server refuses to start without it |
 | `HOST` / `PORT` | `0.0.0.0` / `8080` | Listen address |
 | `BASE_PATH` | — (the domain root) | Subpath to serve from, e.g. `/mail`. Must be set for the **build** as well as the run — see below |
@@ -1260,6 +1770,7 @@ wizard, because either would be state.
 | `UPSTREAM_TIMEOUT` | `30000` | Milliseconds |
 | `MAX_UPLOAD_BYTES` | `52428800` | 50 MB |
 | `IMAGE_PROXY` | `1` | Privacy proxy for remote images |
+| `ADMINISTRATION` | `1` | Offer in-app administration to accounts whose Stalwart role allows it; `0` turns it off, in the proxy as well as the menu |
 | `LOGIN_RATE_LIMIT` | `10` | Attempts per window |
 | `COOKIE_NAME` | `ihm_session` | |
 | `APP_NAME` | `ihasmail` | Branding |
@@ -1345,6 +1856,17 @@ moves an occurrence renumbering the ids around it. Two switches:
 `MOCK_NO_REGISTRY=1` omits the Stalwart capability so the sign-in refusal can be
 tested.
 
+Administration works against it too, with a directory of about thirty accounts,
+three domains with their DKIM keys and zone files, nine queued messages and
+thirty hours of metric history ending in the current hour, behind the same
+permission names Stalwart uses. `MOCK_ROLE` decides who the
+demo user is: `admin` (the default), `tenant-admin` (the queue but not the
+history), `helpdesk` — a custom role that may view and edit accounts but not
+create or delete them, and read domains — or `user`, who is not offered the
+menu at all. `MOCK_METRICS=off` refuses the history the way a Community server
+does, and `MOCK_EDITION=enterprise` reports Enterprise so Tenants can be
+worked on (the default, `oss`, shows only its notice). Two mailing lists round it out.
+
 ---
 
 # What it does not do

KNOWN-ISSUES.md

@@ -4,14 +4,35 @@ What was checked, against which server, and when. For a failure you are hitting
 right now, start with [Troubleshooting](https://docs.ihasmail.org/troubleshooting/);
 for what is not built yet, see [ROADMAP.md](ROADMAP.md).
 
-The live instance runs **0.16.20**, upgraded from 0.16.19 on 2026-08-31 with
-eight seconds of downtime, and as of **2026-08-26 there is nothing left
-pending**. Every entry below was exercised against 0.16.19 on the date it
-names, and the dates still say so: the upgrade was read against the
-0.16.19→0.16.20 diff rather than re-run, and nothing in it touches the session
+The live instance runs **0.16.22**, and as of **2026-08-26 there is nothing
+left pending**. Most entries below were exercised against 0.16.19 on the date
+they name, and the dates still say so: each upgrade since was read against the
+diff rather than re-run, and nothing in those diffs touches the session
 capabilities, blob, quota, submission or registry paths these entries describe.
-The calendar entries below carrying a 2026-08-31 date are the exception: those
-were exercised against the live 0.16.20 directly.
+The calendar entries carrying a 2026-08-31 date were exercised against a live
+0.16.20 directly, as were the public-key entries dated 2026-09-05.
+
+**0.16.21 was different and was re-run rather than read.** It changed four
+things a client can see, one of which resolved an entry below outright: an
+occurrence of a recurring event is identified by its recurrence id rather than
+its position in the series, so an id held across a write no longer names a
+different date; `Calendar/get` and `AddressBook/get` return every property when
+none are named; EventSource advertises its ping interval in seconds rather than
+milliseconds; and a calendar write that asks for scheduling messages is refused
+when the account may not send them. The mock reproduces all four. The app
+was run against a real 0.16.21 with mail, calendar and contacts exercised by
+hand, including editing one occurrence of a recurring series through the
+interface and confirming the rest of the series stayed where it was.
+
+**0.16.22 (2026-09-13) was tested too.** The app has been tested against it on
+the live instance. Its changes a client can see are all in `CalendarEvent/get`
+and `ContactCard/get`, and were read from its source before the mock was made
+to follow them: `baseEventId` is `null` for an event read by its stored id,
+`recurrenceRule` and `recurrenceOverrides` asked for on a synthetic id come back
+`null`, `useDefaultAlerts` belongs to the reader and reads `false` until set,
+and an empty `properties` list returns `id` alone. None of them contradicts an
+entry below.
+
 What remains here is not a list of unknowns but of things worth knowing — where
 Stalwart departs from a spec, where a setting has to be turned on for a feature
 to work, and what ihasmail deliberately does not do.
@@ -27,9 +48,75 @@ works the same way — and dropped where 0.15 was the whole subject. Support for
 0.15 was removed on 2026-08-26; the last release that runs on it is tagged
 [`stalwart-0.15-support`](https://github.com/Coffey-Labs/ihasmail/releases/tag/stalwart-0.15-support).
 
-- **All nine translations have never been read by anybody who speaks them.** They were produced by AI against standard dictionaries on 2026-08-31 — German, Spanish, French, Dutch, Portuguese (Brazil), Russian, Ukrainian, Simplified Chinese and Japanese, which with English makes ten languages in the picker — and every one of the nine is marked **Beta** in the picker, with that stated in Settings beside a link for reporting anything that reads wrongly. This is the entry that matters most on this page, because it is the one thing here that cannot be closed by testing: a translation can be complete, consistent, pass every check, and still read like a machine wrote it, and nobody on this project can tell which. What *is* verified is the machinery around them. A missing key renders its English source, so a bad line can simply be deleted; a stale key — one whose English no longer exists — is caught by `npm run i18n:check` rather than sitting in the file looking correct and never being looked up. Plurals are asked of `Intl.PluralRules` rather than assumed, which is why Russian and Ukrainian carry three forms and Japanese and Chinese carry one; supplying `one` for Japanese would have been filling in a distinction the language does not draw. Confirmed live on the deployed instance (2026-08-31) against a 6,289-message mailbox: role folders localise and the ~20 custom folders keep the names their owner gave them, dates and the calendar follow the language, and 6,289 renders as *6289 листувань* — the genitive plural a number ending in nine takes, which is the first time the plural machinery ran on anything but a hand-picked value.
+- **`ContactCard/changes` works, and a download honors one byte range but does not say so.** Both **confirmed live (0.16.22, 2026-09-16)**, with objects on a throwaway account that were removed afterwards. `ContactCard/changes` reports a create, an update and a destroy exactly, nets a card created and destroyed since the given state out to nothing, and answers a state it does not recognize with `invalidArguments` rather than `cannotCalculateChanges`; the contacts store syncs from it and falls back to a full reload on any error. The download endpoint answers a single range (`bytes=0-9`, `bytes=-5`, `bytes=995-`) with `206` and a correct `Content-Range`, and anything else (several ranges, or a range past the end) with the whole file and `200`, never `416`. It sends no `Accept-Ranges`, so ihasmail's proxy advertises it: Chrome's PDF viewer reads a file in pieces only when told it can. The mock answers the same way.
 
-- **`npm run i18n:coverage` reported 100% while about two hundred strings rendered English in every language.** It reads JSX text, and it was not wrong about what it measured — none of them were JSX text. They were `toast.error(...)` arguments, `confirmDialog({ title, confirmLabel })` props, `title=` and `aria-label=` attributes, and template literals: every one built from an expression a codemod cannot read. The calendar's own view switcher was the clearest case, spelling its labels `v[0].toUpperCase() + v.slice(1)` — correct English, untranslatable anywhere else, and galling because **Day**, **Week**, **Month** and **Agenda** were already in all nine catalogues and the buttons simply never asked for them. Reported from production, where the switcher stayed English in a Japanese interface. All of them are now wrapped, and `npm run i18n:check` grew a second half (`scripts/i18n-literals.mjs`) that accepts a string wrapped where it is written *or* present as a catalogue key — the constant-table convention, where `SECTIONS` holds `label: "About"` and the render site calls `t(s.label)` — and refuses one that is neither, because that is a string no catalogue can translate however many languages ship. It found twenty more than a hand sweep had. Worth recording as a general lesson rather than an i18n one: a coverage number measures the thing it can see, and the strings it cannot see are exactly the ones nobody is checking.
+- **Push subscriptions are not replaced by a repeated `deviceClientId`, and an account holds fifteen.** ihasmail registered a new subscription on every renewal believing the old one would be replaced, as the mock did. **Confirmed live (0.16.22, 2026-09-16)**: a second create with the same `deviceClientId` leaves both in place, the sixteenth create is refused with `overQuota`, "There are too many subscriptions, please delete some before adding a new one.", and `update` of `expires` is accepted. `PushSubscription/get` does not return `url` (nor `keys`), so a subscription can only be matched by its `deviceClientId`. A `types` of `[]` or `null` is stored as *every* type, not none. Read from the 0.16.22 source: `EmailDelivery` changes only on delivery, a delivery reaches a subscription with an `emailPush` filter as an EmailPush alone, and the payload carries `id` and `threadId` only when they are named in `properties`. Browsers now subscribe to `EmailDelivery` only, extend rather than re-create, clear their own duplicates and make room on `overQuota`; the server removes what its previous process registered. The mock follows all of it ([#375](https://github.com/Coffey-Labs/ihasmail/issues/375)).
+
+- **A contact photo has to be a `data:` URI; Stalwart refuses one given as a `blobId`.** RFC 9610 lets JMAP put a `blobId` in a JSContact `Media` object, and ihasmail uploaded the photo and saved it that way, which the mock accepted. Stalwart does not: **confirmed live (0.16.22, 2026-09-16)**, a `ContactCard/set` create with `media.*.blobId` fails with `invalidProperties` on `media`, "blobIds in media is not supported." The RFC 9553 `uri` form with a `data:image/jpeg;base64,…` value is accepted on create and on update, and `ContactCard/get` returns it unchanged; a 134 KB one was accepted. Photos are now saved inline, and the mock refuses a `blobId` the same way ([#376](https://github.com/Coffey-Labs/ihasmail/issues/376)).
+
+- **Administration was built from Stalwart's source, and the first live run found the one thing the source reading got wrong.** Accounts and Domains were written on 2026-09-13 against the 0.16.22 source and a mock reproducing it, deployed the same day, and exercised against the live server from an administrator's session. On that server the Accounts list did not load: `x:Account/query` answered **`unsupportedFilter - type`**. A registry filter is keyed by the property's name *as it appears on the object*, and the discriminator is `@type`, so `{"type": "User"}` names nothing the server knows and fails the whole query; `{"@type": "User"}` is accepted. The research that fed the build had listed the field as `type`, and the mock took it without complaint — which is how it shipped. Fixed in [#336](https://github.com/Coffey-Labs/ihasmail/pull/336), and the mock now refuses any filter name the real server does not index, answering the way Stalwart does. Everything else was **confirmed live (2026-09-13)**, mostly read-only, with the domain writes made on a throwaway domain created for the purpose and removed afterwards:
+
+  - **Permissions** come from `GET /api/account` in camelCase (`sysAccountGet`); an administrator's list held 641 of them and none were kebab-case, whatever the documentation shows. The menu gates on these.
+  - **The Basic credential ihasmail proxies with reaches the admin `x:` methods**, as it already reached the self-service ones. No separate token is involved.
+  - **An account reads back in the shapes the code expects**: `credentials` as `{"0": {"@type": "Password", …}}`, aliases and group memberships as objects, the disk limit under `quotas.maxDiskQuota`.
+  - **A new domain gets automatic DKIM straight away** — an Ed25519 and an RSA key, both `active`, with their records already in the zone file — and manual DNS and certificates.
+  - **`dnsZoneFile` is BIND text**, one record per line as `name IN TYPE value`, with a long TXT record split into a parenthesized run of quoted chunks. A throwaway domain's file held 18 records and 3 continuation lines; every record parsed and the panel showed 18 rows. The production domains also carry TLSA records, which show as rows like any other.
+  - **`x:DkimSignature/query` accepts a `domainId` filter.**
+  - **`catchAllAddress` wants a whole address.** A bare local part is refused with `invalidPatch`, *"Invalid email address"*.
+  - **A domain its keys still name cannot be destroyed**: `objectIsLinked`, with `linkedObjects` listing each as `{"object": "DkimSignature", "id": …}` and no description. Removing through the panel destroys the keys first and then the domain; both were gone afterwards.
+  - **A reserved TLD is refused**: `example` as a domain's top level comes back `invalidPatch`, *"Invalid domain name"*, naming `name`.
+
+  The last two were then tried by hand on the live server the same day and behaved as described. **A password set by an administrator** — written to the account's existing credential, `credentials/<index>/secret` — signs in. **The outranking guard** held: an account with more rights than the viewer's role opens read-only. The guard exists because the source shows Stalwart skipping its grant check when only a password changes and on a delete, and it stays for that reason.
+
+- **The dashboard's feeds were settled on the live server before the code was written (2026-09-15, 0.16.22 Enterprise, read-only calls from an administrator's session).** The first probes guessed two of these wrong — filtering on `timestamp`, and counting received mail from `message-ingest.*` — and the server and the 0.16.22 source agreed on the answers below:
+
+  - **The metric history filters on comparison names.** `x:Metric/query` accepts `{"timestampIsGreaterThanOrEqual": …, "metric": [names]}`; a bare `timestamp`, `after` or `metric` as a string is `unsupportedFilter`. Sorting on `timestamp` works. At the default interval a day is about 80 records for the six metrics the dashboard reads, and a get takes at most 500.
+  - **Received and sent are `queue.*` counters**, not `message-ingest.*`: `queue.message-queued` for received, and `queue.authenticated-message-queued` + `queue.dsn-queued` + `queue.report-queued` for sent, which is what Stalwart's own dashboard adds up. A Counter holds its interval's count and a zero one is not written; the `*-time` histograms are cumulative, which is why nothing reads them.
+  - **Memory is the `server.memory` Gauge**, in bytes, one per interval. **Counts** come from `/query` with `calculateTotal: true` and `limit: 0`, which returned the whole total for `x:Account` (users only, via `@type`), `x:Domain` and `x:QueuedMessage`.
+  - **`x:Metrics/get` is not the history.** It is the singleton holding the collection settings (Prometheus and OpenTelemetry export, the metrics policy); the history is `x:Metric`.
+
+  **Not confirmed live:** that a tenant administrator's counts are scoped to the tenancy, and that a Community server refuses `x:Metric` as `forbidden`. Both are read from the 0.16.22 source (`query.rs`, `queued_message.rs`, `registry/mod.rs`); the production server has no tenants and is Enterprise, so neither could be tried there without writing. The dashboard's handling of both is covered by tests against the refusal Stalwart's source gives.
+
+- **Groups were built from the 0.16.22 source and a mock, then confirmed on the live server (2026-09-15)** with a throwaway group on one of the server's domains, created and removed, its only member the administrator's own account:
+
+  - **A group is created** as `x:Account` with `@type: "Group"`, no credentials and no encryption setting, and reads back with roles `{"@type": "Default"}`, `permissions` `Inherit`, a `locale` of `en-US` and `usedDiskQuota` 0.
+  - **Membership is the member's.** `"memberGroupIds/<group>": true` on the user was accepted; `{"@type": "User", "memberGroupIds": <group>}` then found them with a total of 1, and the user's own `memberGroupIds` read `{"<group>": true}`. The same pointer with `null` took them out again and left the set as it was before.
+  - **A group with members cannot be deleted**: `objectIsLinked`, with `objectId` as `{"object": "Account", "id": <group>}` and `linkedObjects` listing each member as `{"object": "Account", "id": …}`. With the member out, the delete went through and the group read back as `notFound`.
+
+  The same run tried a throwaway mailing list before the Mailing lists section was written. It was created with `recipients` as a set, `{"[email protected]": true}`, and read back as `name`, `domainId`, `description`, `aliases`, `memberTenantId`, `recipients` and a computed `emailAddress`. `"recipients/<address>": true` added one and left the other; a `text` filter found it; it was destroyed with nothing linked. Not tried: removing a recipient with `null` (the same set patch as a group membership, which was), and how the server words a recipient that is not an address.
+
+  Still from source only: that membership gives a member no permissions (`access_token.rs` builds a user's permissions from their own roles), and that groups cannot nest.
+
+- **Roles were built from the 0.16.22 source, its schema and the mock, then confirmed on the live server (2026-09-15)** with throwaway `ihasmail-role-test` roles, created and removed:
+
+  - **A role is created** with `description`, `roleIds`, `enabledPermissions` and `disabledPermissions` as sets, and reads back with them and `memberTenantId`.
+  - **Pointers change one entry each**: `enabledPermissions/<p>` and `disabledPermissions/<p>` with `true` or `null`, `roleIds/<id>` likewise, and `description` in the same update, all applied together.
+  - **A name that is not a permission fails the whole update** as `invalidPatch`, *"Invalid value for object property"*, naming the pointer — which is how a probe using the mock's made-up `jmapEmailSet` found that the mock had carried a permission Stalwart does not have since Accounts was built; it is `jmapEmailUpdate` now, and the mock refuses unknown names.
+  - **A grant the caller does not hold is refused**: `forbidden`, *"You are not authorized to grant permissions: scimAccess"*.
+  - **A role another role builds on cannot be deleted**: `objectIsLinked`, `objectId` `{"object": "Role", …}`, `linkedObjects` naming the child.
+  - **The defaults** read from `x:Authentication`: users get User; groups get Group; tenant administrators get Tenant Administrator and User; administrators get System Administrator and User.
+
+  **The picker is stricter than the server for a few permissions.** `GET /api/account` never lists some permissions an administrator holds — `sysLogCreate` among them, which was granted without complaint — so their *Allow* is locked for everyone. That errs toward refusing and can be revisited if it gets in anyone's way. Still from source only: that a denial anywhere in a role's tree wins (`permissions.rs` unions enabled and disabled across the tree, then subtracts). **`GET /api/schema` through ihasmail's server was confirmed on production after the deploy (2026-09-15, v2026.9.15+pr364)**: `/api/admin/permissions` answered 200 with all 661 permissions, the same list as the 0.16.22 snapshot, and the Roles picker drew them under 60 headings. The four bootstrap roles grant 244 (User), 229 (Group), 50 (Tenant Administrator) and 452 (System Administrator) once their trees are followed.
+
+- **Tenants were built from the 0.16.22 source, its schema and the mock, then tried on the live server (2026-09-15)** with throwaway `ihasmail-tenant-test` tenants, a throwaway role, two throwaway lists and a throwaway domain, all removed. The live run changed the design twice:
+
+  - **A tenant is created and edited as built**: `name`, `logo`, `roles`, `permissions`, `quotas`; `quotas/<name>` pointers, a logo and a rename in one update; an unknown quota name is `invalidPatch`.
+  - **Something in a tenant has to be on a domain in that tenant.** A list in the tenant on a domain in none was refused, `invalidForeignKey` with `objectId` `{"object": "Domain", …}`; the same list on a domain created in the tenant was accepted — and so was a list in *no* tenant on that domain. **So an account's tenant choice offers only its domain's tenant**, and a new account starts in the tenant of the domain it is made on.
+  - **A domain created in a tenant puts its DKIM keys in the tenant too**, and they stay there. They count against `maxDkimKeys` and keep the tenant from being deleted, so they are counted with everything else.
+  - **Stalwart lets a domain leave a tenant while the tenant still has things on it**, leaving them in a tenant on a domain outside it. **The panel refuses to take a domain out while any of the tenant's accounts are on it.** Mailing lists cannot be filtered by domain, so a list is not checked.
+  - **A tenant still holding anything is kept**: `objectIsLinked`, `objectId` `{"object": "Tenant", …}`, `linkedObjects` naming a role, a list and DKIM keys. A role set to `memberTenantId: null` left it, after which the tenant was deleted.
+
+  Still from source only: that only a caller outside every tenant may set `memberTenantId` (`set.rs` passes `can_set_tenant` only when the token has no tenant), and that a tenant administrator's queries are scoped to the tenant. On a server that does not report Enterprise the Tenants page is only its notice.
+
+- **The permission labels in eight languages are machine translations awaiting native review.** 661 labels and 59 headings per language, written against each catalog's existing terms. The translators flagged the terms they were least sure of, which are the place to start: *principal* (JMAP/DAV), *throttles*, *listeners*, *lookups*, *milters*, *masked emails*, *samples* (spam training), *schedules* (MTA delivery), *email submission*, and the MTA stage settings. Several of Stalwart's own English labels are identical for different permissions (ARF, DMARC and TLS reports are all "Get reports"), and the translations inherit that; the heading above tells them apart.
+
+- **A refused password shows the server's reason in English.** Every other refusal from the registry is said in the reader's language: each error type has its own message, and a value one of Stalwart's validators refused — a domain name, an address, an empty field — is recognized by the validator's wording and explained again rather than shown. A password policy is the exception, on purpose. Its rule is the server's to set, so there is nothing to translate it from in advance, and its reason follows a translated sentence rather than being dropped, which would leave "not accepted" with no way to find out why.
+
+- **Administration is off for a device not marked as your own, and for an installation that says so.** Both are enforced by the server rather than hidden by the menu: such a session is sent no permissions, and the JMAP proxy refuses registry methods beyond the account's own. That is worth stating because the proxy otherwise forwards whatever the browser sends, and before these gates an administrator's console could make any registry call their role allowed. For a session that may not administer, the proxy reads a request body only when it could name a registry method — a `"x:` in the text, or a `\u` escape that could spell one — so ordinary mail traffic is forwarded untouched.
+
+- **All nine translations have never been read by anybody who speaks them.** They were produced by AI against standard dictionaries on 2026-08-31 — German, Spanish, French, Dutch, Portuguese (Brazil), Russian, Ukrainian, Simplified Chinese and Japanese, which with English makes ten languages in the picker — and every one of the nine is marked **Beta** in the picker, with that stated in Settings beside a link for reporting anything that reads wrongly. This is the entry that matters most on this page, because it is the one thing here that cannot be closed by testing: a translation can be complete, consistent, pass every check, and still read like a machine wrote it, and nobody on this project can tell which. What *is* verified is the machinery around them. A missing key renders its English source, so a bad line can simply be deleted; a stale key — one whose English no longer exists — is caught by `npm run i18n:check` rather than sitting in the file looking correct and never being looked up. Plurals are asked of `Intl.PluralRules` rather than assumed, which is why Russian and Ukrainian carry three forms and Japanese and Chinese carry one; supplying `one` for Japanese would have been filling in a distinction the language does not draw. Confirmed live on the deployed instance (2026-08-31) against a 6,289-message mailbox: role folders localize and the ~20 custom folders keep the names their owner gave them, dates and the calendar follow the language, and 6,289 renders as *6289 листувань* — the genitive plural a number ending in nine takes, which is the first time the plural machinery ran on anything but a hand-picked value.
+
+- **`npm run i18n:coverage` reported 100% while about two hundred strings rendered English in every language.** It reads JSX text, and it was not wrong about what it measured — none of them were JSX text. They were `toast.error(...)` arguments, `confirmDialog({ title, confirmLabel })` props, `title=` and `aria-label=` attributes, and template literals: every one built from an expression a codemod cannot read. The calendar's own view switcher was the clearest case, spelling its labels `v[0].toUpperCase() + v.slice(1)` — correct English, untranslatable anywhere else, and galling because **Day**, **Week**, **Month** and **Agenda** were already in all nine catalogs and the buttons simply never asked for them. Reported from production, where the switcher stayed English in a Japanese interface. All of them are now wrapped, and `npm run i18n:check` grew a second half (`scripts/i18n-literals.mjs`) that accepts a string wrapped where it is written *or* present as a catalog key — the constant-table convention, where `SECTIONS` holds `label: "About"` and the render site calls `t(s.label)` — and refuses one that is neither, because that is a string no catalog can translate however many languages ship. It found twenty more than a hand sweep had. Worth recording as a general lesson rather than an i18n one: a coverage number measures the thing it can see, and the strings it cannot see are exactly the ones nobody is checking. **The check had the same blind spot one level down (2026-09-14).** It looked at `title=`, `aria-label=`, `placeholder=` and `alt=` on elements, but not at props passed to components, so `<MenuItem label={x ? "Collapse all" : "Expand all"}>` passed. It also accepted a JSX literal that was a catalog key, although no component here runs its props through `t()`, so 19 strings with translations in every catalog (Report spam, Mark as read, Add star, Save…) still rendered in English. And the script only exited non-zero with `--check`, which `npm run i18n:check` never passed, so it could print a finding without failing. Component props are checked now, a key no longer excuses a literal in an attribute, and both halves run with `--check`. That turned up 28 strings, all fixed: 19 wrapped, and 9 that needed new keys in all nine catalogs. English built with a template literal inside an attribute, such as ``aria-label={`Remove ${email}`}``, was the last gap. It can't be a catalog key as written. Since 2026-09-14 the check flags any template literal in one of these positions that has words between its values, and the twelve that existed are now keys with placeholders. They were the quota bar, the address menu, a folder's unread count, the recipient chips, the contact editor's title, shared calendars and address books, the date and time fields, the attachment fallback name, and the free/busy bar. That bar showed the raw JMAP value (`confirmed`) in every language.
 
 - **A compressing hop in front of Stalwart truncated every blob download, and nothing said so.** Node decompresses a gzip response before the code ever sees the body, but leaves the `content-length` header describing the *compressed* bytes. The blob proxy copied that header onto the longer body it forwarded, so the browser stopped reading exactly that many bytes in and called the download complete. Reported on [#76](https://github.com/Coffey-Labs/ihasmail/issues/76) against a Coolify deployment, where Traefik's compress middleware only engages above 1 KiB: filter rules one and two were fine and the third pushed the script past the threshold, after which it came back cut off mid-rule — 384 bytes of a 1.3 KB script. The size threshold is what made it look like a race. This is the *second* cause behind that issue, and the first fix did not touch it: a truncated script is neither unknown nor empty, so the "refuse to save from a baseline we could not read" guard never fired — the script parsed, just with rules missing, and the next save wrote the short version back over the real one. Every blob download shared the fault, not just Sieve: message source, vCards, signature HTML, attachments being forwarded, and the `settings.json` sync. Settings degraded honestly by luck rather than design — a truncated file fails `JSON.parse`, which is caught and leaves the local cache in charge — so it stopped syncing between devices instead of being overwritten. The proxy now asks upstream for `identity` and, for a hop that compresses anyway, forwards no length at all rather than one describing different bytes. The image proxy is unaffected: it uses `node:http` directly, sends no `accept-encoding`, and never decompresses. The save path no longer trusts the transport either: a script is now checked for completeness against the shape the generator emits — every `# rule:` comment parses, every enabled rule has an `if` and a closed body below it, every block ends with a blank line — and saving refuses on anything short, as does the rule editor, which reports the script as unreadable rather than showing the rules that happened to parse. The check is structural rather than a re-serialize-and-compare, so a script written by an older version with a different serializer is still editable; refusing over a changed byte would be the worse bug. It catches a cut at every offset except the end of a complete rule block, which is a legitimately shorter script and indistinguishable from one in the bytes alone — that residual is what the proxy fix covers.
 
@@ -37,20 +124,32 @@ works the same way — and dropped where 0.15 was the whole subject. Support for
 - **Sharing a mail folder is accepted and does nothing.** `Mailbox/set` with a `shareWith` map is applied, `Mailbox/get` reads it back, and the folder never appears for the account it was shared with — **confirmed live on 0.16.19 (2026-08-27)** with a folder shared read-only to another account on the same server, which never saw it. Stalwart's own sharing documentation lists calendars, address books and file storage; mail folders are not among them. Nothing reports a failure at any point, which is the whole problem: the share is stored, so a client that trusts what it reads back shows it as live for ever. The entry point is withdrawn. A folder that is *already* shared still offers **Stop sharing**, because a share nobody can see is exactly the one you want to be able to clear, and there is no other way to. File sharing is unaffected and works end to end.
 - **Address book sharing works, and was briefly withdrawn by mistake.** It was taken out alongside mail folders on 2026-08-27 on a report that it behaved the same way; the report was mistaken and the feature was put back the same day. Nothing was ever shown to be wrong with it, and Stalwart documents address books as shareable. Recorded because the withdrawal is in the history and would otherwise read as a finding. Shared books now appear in the Contacts pane under "Shared with me" rather than behind an account switch, and their contacts are offered when addressing a message.
 - **Stalwart lets a sharee subscribe to a shared calendar but not a shared address book.** Subscribing is a write to the *owner's* account -- `isSubscribed` lives on the collection, not on the reader -- and 0.16.19 refuses it for a book shared read-only: `AddressBook/set` answers successfully with the id in `notUpdated`, `forbidden`, *"You are not allowed to modify this address book."* The identical `Calendar/set` on a shared calendar is accepted. **Confirmed live on 0.16.19 (2026-08-27)** from a second account holding both shares, which is the only place it shows: from the owner's own account the write succeeds and everything looks fine. So ihasmail asks the server first, because a preference the server holds is one every client agrees about, and keeps the answer in its own synced settings (`addedShares`) when the server will not. Two things this cost, both worth remembering: the refusal arrives as a *successful* response, so the code that ignored `notUpdated` saw nothing wrong and the button simply did nothing; and it is invisible from the owner's account, so it took two browsers signed in as two accounts to find at all. The mock now refuses the same write for the same reason, since one that accepted it agreed with the belief that shipped.
-- **`shareWith` is not returned unless a client asks for it by name.** A `Calendar/get` or `AddressBook/get` with no `properties` comes back without the field at all — not null, not empty, absent — **confirmed live on 0.16.19 (2026-08-27)** against a calendar and an address book that were genuinely shared with another account: omit the list and there is no `shareWith`; name it and the sharee is right there. Every consequence was silent. Nothing was badged as shared, "Stop sharing" never appeared because nothing looked shared, and the share dialog opened on *"not shared with anyone yet"* over a live share — so the one screen that existed to manage sharing was the one most confidently wrong about it. Files never had this, because `fileNodeProps` had always named the property; calendars, address books and mail folders fetched everything and got less. Mail folders mattered in a way of their own: sharing one is withdrawn, and the only way to clear a share already made is a **Stop sharing** entry that appears when a folder looks shared — so without the property the escape hatch for the exact situation it was built for was invisible. The mock now omits it the same way, since one that hands it over unasked lets a client that never asks look correct everywhere except against a real server.
+- **`shareWith` is not returned unless a client asks for it by name.** A `Calendar/get` or `AddressBook/get` with no `properties` comes back without the field at all — not null, not empty, absent — **confirmed live on 0.16.19 (2026-08-27)** against a calendar and an address book that were genuinely shared with another account: omit the list and there is no `shareWith`; name it and the sharee is right there. Every consequence was silent. Nothing was badged as shared, "Stop sharing" never appeared because nothing looked shared, and the share dialog opened on *"not shared with anyone yet"* over a live share — so the one screen that existed to manage sharing was the one most confidently wrong about it. Files never had this, because `fileNodeProps` had always named the property; calendars, address books and mail folders fetched everything and got less. Mail folders mattered in a way of their own: sharing one is withdrawn, and the only way to clear a share already made is a **Stop sharing** entry that appears when a folder looks shared — so without the property the escape hatch for the exact situation it was built for was invisible. The mock omitted it the same way, since one that hands it over unasked lets a client that never asks look correct everywhere except against a real server. **0.16.21 fixed this for calendars and address books**: with `properties` omitted, `Calendar/get` and `AddressBook/get` now return every property, `shareWith` included — **confirmed live on 0.16.21 (2026-09-06)**. `Mailbox/get` on the same server still leaves it out, so the mock now hides it for mail folders alone, and ihasmail keeps naming the property everywhere.
+- **Stalwart's `x:PublicKey` registry works, and ihasmail deliberately does not expose it.** A Settings section for it has been built twice — [PR #67](https://github.com/Coffey-Labs/ihasmail/pull/67), closed 2026-08-26, and [PR #285](https://github.com/Coffey-Labs/ihasmail/pull/285) — and withdrawn both times, for a reason that has nothing to do with the server: **nothing in ihasmail signs, encrypts, decrypts or verifies with a key**, so a page for managing them is furniture rather than a feature. It ends up telling the reader, in its own footnote, that adding a key does nothing. The registry is written up here rather than in [ROADMAP.md](ROADMAP.md) because what follows is established fact about Stalwart that cost a live probe, and losing it twice to a closed pull request was how the second attempt came to exist at all. Everything below was **confirmed live on 0.16.20 (2026-09-05)** from a normal account with no administrative rights, and the full round trip — create, read back, rename, patch, destroy — succeeded for both formats.
+
+  - **An ordinary user may read *and* write their own keys**, whatever the permissions table says: Stalwart documents every `sysPublicKey*` permission as administrative, and the server granted them anyway. A create carrying a malformed key was refused with `invalidProperties` naming `key` rather than `forbidden` — a rejection of the key, not of the person. Had the documentation been right, any such feature would have been useless to everybody but an administrator, which is why this was probed first.
+  - **It takes S/MIME certificates as well as OpenPGP keys, and parses both.** A self-signed X.509 certificate carrying `emailProtection` and an `email:` SAN registered, read back and destroyed cleanly, and a malformed one is refused by a decoder of its own: *"Failed to decode X509 certificate: BER decoding error: Expected Tag { class: Universal, value: 16 } tag…"*. Worth checking rather than assuming, because every *other* message the registry returns names OpenPGP — including for input that is not OpenPGP at all — so the server reads as though OpenPGP were the only format it knows. It is not.
+  - **A key can parse perfectly and still be refused, and says something different when it is.** A sign-and-certify OpenPGP key with no encryption subkey — which is what `gpg --quick-generate-key` produces — comes back *"Could not find any suitable keys in OpenPGP public key"*, distinct from the parser's *"Failed to decode OpenPGP public key: Malformed packet: Malformed CTB…"*. Any client showing these must keep them apart: one says paste it again, the other says the key needs an encryption subkey and no amount of care with the clipboard will help. Certificates have no equivalent trap, since one issued for email use has key encipherment by construction.
+  - **`emailAddresses` comes back as `{}` when empty** — an object, where a JMAP list property should be an array. Nothing fails loudly: it is a plain `Get` response that type-checks against a hand-written interface and then throws in `join()` while a list renders. A client must check the shape rather than trust the type.
+  - **A create answers with the id alone**, no `createdAt`, so anything that reads the date back out of the create response gets `undefined`. **Patching `key` on an existing entry is allowed**, which is worth knowing and probably worth not doing: replacing a key by adding one and removing the old keeps `createdAt` meaning what it says.
+  - **`expiresAt` is the registry's own field and is not derived from the key.** A certificate valid for a year registers with `expiresAt: null`. Reading the real date means parsing the certificate, and a date a client extracted would disagree with the server's field the moment the two ever differed.
+
+- **Signature checking is done here, and its trust model is deliberately small.** Stalwart does not verify S/MIME or OpenPGP signatures and exposes no result for one, so ihasmail does it in the browser: raw message, MIME split, PKCS#7 parse, WebCrypto. What is worth knowing is what it does *not* do, because the gap is a design choice rather than an omission. **No chain of trust is validated** — a browser has no system trust store, no CA bundle is shipped, and revocation is not checked — so a verified signature on its own shows only that the sender held the key inside their own message, which anyone can self-sign. What carries the weight instead is trust on first use: the first signed message from an address pins its fingerprint in the account's settings, and a later message signed by a different certificate is reported loudly. That is why the interface never says the bare word "verified", why a first sighting is gray rather than green, and why a changed signer never overwrites the pin. Verified against real `openssl smime -sign` output rather than hand-built fixtures — RSA and ECDSA, plus a tampered copy — because a signed message written by hand only ever agrees with whatever the author believed the format to be.
+- **OpenPGP signatures cannot be checked at all, for a reason that is not effort.** A PGP signature carries no key, so verifying one needs the sender's public key in advance, and there is nowhere to get it: `x:PublicKey` holds the *account's own* keys, not correspondents'. Fetching from a keyserver or via WKD would tell a third party who you correspond with each time you opened a message — the same leak the image proxy exists to close — so it is not done. Such a message says so by name rather than failing as an unknown format, and it says *could not check* rather than *did not check out*, which is a distinction worth keeping: one is ignorance and the other is an accusation.
+- **Two signature shapes are declined rather than attempted.** SHA-1 signatures are refused outright — one nobody can forge in practice today is still not one to put a tick beside. RSA-PSS is declined because the salt length lives in parameters ihasmail does not read, and guessing wrong would report a perfectly good signature as *bad*, which is a far worse thing to say than "cannot check". Both are shown as uncheckable, not as broken.
 - **Read receipts are built here, not by the server** — JMAP has an extension for them, [RFC 9007](https://www.rfc-editor.org/rfc/rfc9007.html)'s `MDN/send`, and Stalwart does not implement it: `urn:ietf:params:jmap:mdn` is not among its capabilities. So ihasmail assembles the `multipart/report` itself and sends it the long way round — raw MIME uploaded as a blob, `Email/import`, then `EmailSubmission` — which is also why the receipt lands in Sent, where it honestly belongs. Non-ASCII parts are base64 rather than `8bit`, so nothing depends on 8BITMIME surviving every hop. There is deliberately no "always send" setting: a receipt confirms to whoever asked that the address is live and when it was read, to an address of the sender's choosing, so each one is a decision. Verified against the mock end to end (upload, import, submit, `$mdnsent`), and **confirmed live on 0.16.19 (2026-08-26)**: a receipt asked for by a real sender was assembled, uploaded, imported and submitted, landed in Sent, and set `$mdnsent` so a second look does not offer to send another.
 - **Where 0.16 advertises `urn:stalwart:jmap`** — not where a JMAP client would look, and this now decides whether a sign-in is allowed at all. Stalwart builds the session-level `capabilities` from a fixed list (`Session::new`, plus WebSocket) that has never contained this capability, in any 0.16.x from 0.16.0 to 0.16.19. It hands it out per-account instead, so it appears in `primaryAccounts` and in each account's `accountCapabilities`. ihasmail tested for it in `capabilities` alone, which made every real 0.16 server read as older than 0.16 — and that one check drove three things: self-service credentials fell back to `POST /api/account/auth`, which 0.16 removed, so password changes, 2FA and app passwords all failed with "this mail server does not offer self-service credential management"; About reported the wrong generation; and Files took the older code path. It now looks in all three places, and is covered by tests on each. Worth restating plainly, because the stakes went up when 0.15 support was dropped: there is no longer a fallback path for this check to be wrong *into*. Getting it wrong now refuses every sign-in against a perfectly good server — a loud failure rather than a quiet misrouting, which is the trade the removal was making.
 - **HTML signatures** — Stalwart caps a signature at 2047 **bytes** (`value.len() < 2048` on a Rust string, so UTF-8 bytes, not characters). ihasmail compacts pasted HTML, moves images to Files and, if still too large, keeps the full signature in Files behind a short marker; other clients see a text fallback. Confirmed live on 0.15.5 (2026-08-24): oversized, non-ASCII and inline-image signatures all save, and a test message arrived intact at Gmail with the logo inline.
-- **Settings live in the account's Files, not the browser** — every preference used to sit in `localStorage`, so none of them followed anyone between devices. The sharpest edge was the default identity: with none set the address that sorts first wins, so someone who set it at work found it unset at home and mail went out from an address the recipient might not recognise ([#54](https://github.com/Coffey-Labs/ihasmail/issues/54)). They are now a `settings.json` in the `ihasmail` folder in JMAP Files, beside the signature images already kept there — which keeps ihasmail itself stateless: no volume, no database, nothing to back up separately, and the settings are covered by whatever backs up the mail store. `x:AccountSettings` was the other candidate and does not fit; its schema is `locale`/`timeZone`/`description` with no free-form field, and writing it needs `sysAccountSettingsSet`, where the built-in user role carries only the `…Get` half. `localStorage` stays on as a *cache* rather than the source of truth, so the first frame paints from it and the file corrects it a moment later; a browser with no cache shows defaults for that one frame, which is the trade for not gating the whole app on a round trip. Settings that describe *this* screen or browser deliberately stay local — list-pane sizes, density, font size, sidebar state, and the notification toggles, which track a permission the browser grants per-device and would be a claim about somewhere else it cannot make. That split is written as a list of exceptions, so a setting added later syncs by default. Writes are coalesced behind a three-second debounce, since `update()` fires on every frame of a splitter drag, and a tab going away or a sign-out flushes first. The `ihasmail` folder is now hidden from the Files view, contents and all: hiding the folder alone would be worse than showing it, because the tree attaches a node whose parent is missing to the root, so the signature images — visible there since signatures shipped — would have spilled into the top level. **Confirmed live on 0.16.19 (2026-08-26)**: settings set in Chrome came back on a fresh login in Firefox and in an incognito session, both of which start with an empty cache, so each read the account's file rather than anything local. Confirmed again on the deployed instance rather than only a pre-deployment build. Requires 0.16, which ihasmail now requires everywhere — `FileNode/query` cannot see directories before that, and sign-in refuses an older server outright. Two limits worth knowing: conflicts are last-write-wins, and a change made on one device does not reach another that already has ihasmail open until it signs in again.
+- **Settings live in the account's Files, not the browser** — every preference used to sit in `localStorage`, so none of them followed anyone between devices. The sharpest edge was the default identity: with none set the address that sorts first wins, so someone who set it at work found it unset at home and mail went out from an address the recipient might not recognize ([#54](https://github.com/Coffey-Labs/ihasmail/issues/54)). They are now a `settings.json` in the `ihasmail` folder in JMAP Files, beside the signature images already kept there — which keeps ihasmail itself stateless: no volume, no database, nothing to back up separately, and the settings are covered by whatever backs up the mail store. `x:AccountSettings` was the other candidate and does not fit; its schema is `locale`/`timeZone`/`description` with no free-form field, and writing it needs `sysAccountSettingsSet`, where the built-in user role carries only the `…Get` half. `localStorage` stays on as a *cache* rather than the source of truth, so the first frame paints from it and the file corrects it a moment later; a browser with no cache shows defaults for that one frame, which is the trade for not gating the whole app on a round trip. Settings that describe *this* screen or browser deliberately stay local — list-pane sizes, density, font size, sidebar state, and the notification toggles, which track a permission the browser grants per-device and would be a claim about somewhere else it cannot make. That split is written as a list of exceptions, so a setting added later syncs by default. Writes are coalesced behind a three-second debounce, since `update()` fires on every frame of a splitter drag, and a tab going away or a sign-out flushes first. The `ihasmail` folder is now hidden from the Files view, contents and all: hiding the folder alone would be worse than showing it, because the tree attaches a node whose parent is missing to the root, so the signature images — visible there since signatures shipped — would have spilled into the top level. **Confirmed live on 0.16.19 (2026-08-26)**: settings set in Chrome came back on a fresh login in Firefox and in an incognito session, both of which start with an empty cache, so each read the account's file rather than anything local. Confirmed again on the deployed instance rather than only a pre-deployment build. Requires 0.16, which ihasmail now requires everywhere — `FileNode/query` cannot see directories before that, and sign-in refuses an older server outright. Two limits worth knowing: conflicts are last-write-wins, and a change made on one device does not reach another that already has ihasmail open until it signs in again.
 - **Files on 0.16** — the pre-0.16 quirks this entry used to describe are gone with the support for them: `FileNode/query` masking directories out of its own results, `nodeType` not existing, and rights being a single `mayWrite`. What is left is what has actually been exercised on 0.16.19. Finding and creating a folder, creating a node with `nodeType`, uploading and downloading its blob, and pointing an existing node at a new one all ran live on 2026-08-26, as a side effect of the settings file. Rename, move and delete are **confirmed live on 0.16.19 (2026-08-26)** as well, which closes this out: what had been confirmed on 0.15.5 (2026-08-24) was the older code path, and that path no longer exists. Two fallbacks went with the removal and are worth knowing about: `ensureFolder` and `findInFolder` now filter on `parentId`/`isTopLevel` alone and match names client-side, since `name` is not a filter Stalwart is known to implement and one it does not know fails the whole query; and a refused filter or sort no longer drops the view into fetching every node in the account, which would have hidden a real fault behind a performance cliff nobody would notice.
 - **Self-service credentials** — the registry path is **confirmed live** against Stalwart 0.16.19 (2026-08-25): app passwords created and revoked, password changed, 2FA enabled and disabled, with the browser session surviving the switch to an app password. The 0.15 REST path was confirmed live too, on 0.15.5 (2026-08-24), and has since been removed along with the rest of 0.15 support. The mock enforces the same rules the real server does (current password required, password policy, a TOTP code on every request once 2FA is on, app passwords exempt from it). Password changes are refused by Stalwart for accounts backed by an external directory (LDAP/SQL/OIDC); the server's own message is shown when that happens.
-- **Scheduled send needs one setting turned on, and says nothing when it is off.** Stalwart advertises the delay in the account's `urn:ietf:params:jmap:submission` capability — `maxDelayedSend: 2592000` (30 days) and `FUTURERELEASE` among its `submissionExtensions`, and note it is the *account* capability, not the session-level one, which is empty. But the MTA only honours a hold when `futureRelease` is set under the session's MTA extensions, and [that setting defaults to `false`](https://stalw.art/docs/ref/object/mta-extensions/). With it off, Stalwart takes the `HOLDUNTIL` parameter, skips the hold and sends the message immediately **without an error** — the capability still says thirty days. So set `futureRelease` (to the longest hold you want to allow) before relying on this; a value shorter than 30 days is fine, and a request past it is refused honestly, with a `forbiddenMailFrom` naming the limit. `npm run dev:mock:no-future-release` reproduces the silent-drop case. ihasmail asks for the delay the way JMAP requires — a `HOLDUNTIL` parameter on the envelope's `mailFrom`, since RFC 8621 makes `sendAt` read-only and server-derived — and files the held message in a **Scheduled** folder, because `onSuccessUpdateEmail` would otherwise drop it in Sent the moment the submission is created. Nothing moves it out when the hold expires, so ihasmail reconciles the folder on the way in: released messages to Sent, cancelled ones back to Drafts. Three fixes this depends on landed in **0.16.17**, below the live instance's 0.16.19: `HOLDUNTIL` taking RFC 3339 date-times again (0.16.16 had it wanting Unix timestamps), `EmailSubmission/query` on `undoStatus` agreeing with `/get` about held submissions, and `EmailSubmission/get` without `ids` iterating the right index. The hold itself is now **confirmed against the live 0.16.19** (2026-08-25), once `futureRelease` was set to `30d` there: a submission carrying a `HOLDUNTIL` ten minutes out came back `pending`, with `sendAt` equal to the time asked for and a `250 2.1.5 Queued` from the MTA, rather than going out at once. Worth repeating that the capability is no evidence either way — it advertised `maxDelayedSend: 2592000` and `FUTURERELEASE` while the setting was still off. Only a submission tells you. The rest of the journey is **confirmed live too (2026-08-26)**: a hold expired and was delivered, and the **Scheduled** folder reconciled on the way in — a released message moved to Sent, a cancelled one back to Drafts. Nothing in Stalwart does that moving, so if ihasmail is never opened again the message still goes out; it is only the folder that waits to be tidied.
-- **Stalwart 0.16 and RFC 8984 disagree about the calendar vocabulary, and the server only says so half the time.** A participant's address lives in `calendarAddress`, not RFC 8984's `sendTo`/`email`; the organizer is `organizerCalendarAddress`, not `replyTo`; and a recurrence is a single `recurrenceRule`, not a `recurrenceRules` array. Addressed the RFC's way, `CalendarEvent/set` **keeps the event and discards the whole participant map without an error** — guests disappeared on save and no invitation was ever sent, which is what [#26](https://github.com/Coffey-Labs/ihasmail/issues/26) reported. The array form of the rule is refused honestly, with `invalidProperties`, so recurring events could not be created at all and existing ones showed no repeat ([#30](https://github.com/Coffey-Labs/ihasmail/issues/30)). ihasmail now writes Stalwart's names and reads either, and the mock refuses what the real server refuses, since advertising the RFC spelling is precisely how this got as far as a live server. Verified against 0.16.19 on 2026-08-25, end to end: participants, organizer and rule all survive a create, an update and a re-read; an invitation to an external Gmail address arrived as an invite card, and the decline came back and was applied to the event (`needs-action` → `declined`, sequence 1). Cancelling the event notified the guest too. Adding guests to an event that had none, and clearing them again with `null`, both work on the update path, as does RSVP — which patches `participants/{key}/participationStatus` (and `participationComment`) rather than sending the whole map. That patch had to be aimed at the base event: through 0.16.19 `CalendarEvent/set` refused a synthetic id with *"Updating synthetic ids is not yet supported"*, which is why RSVP resolves `baseEventId` first. 0.16.20 accepts one, so that resolution is now a choice rather than the only option — an RSVP aimed at an occurrence would answer for that date alone. It still resolves the base, which is the answer people mean. Adding a *new* participant by patch is refused as well (`Patch operation failed`), so a changed guest list is written as the whole `participants` property. One more thing to know when reading this code: an expanded occurrence carries a `recurrenceId` but *no* rule of its own, and `baseEventId` is set on everything an expanded query returns — a one-off included, whose own id differs from its base — so neither is a test for recurrence.
+- **Scheduled send needs one setting turned on, and says nothing when it is off.** Stalwart advertises the delay in the account's `urn:ietf:params:jmap:submission` capability — `maxDelayedSend: 2592000` (30 days) and `FUTURERELEASE` among its `submissionExtensions`, and note it is the *account* capability, not the session-level one, which is empty. But the MTA only honors a hold when `futureRelease` is set under the session's MTA extensions, and [that setting defaults to `false`](https://stalw.art/docs/ref/object/mta-extensions/). With it off, Stalwart takes the `HOLDUNTIL` parameter, skips the hold and sends the message immediately **without an error** — the capability still says thirty days. So set `futureRelease` (to the longest hold you want to allow) before relying on this; a value shorter than 30 days is fine, and a request past it is refused honestly, with a `forbiddenMailFrom` naming the limit. `npm run dev:mock:no-future-release` reproduces the silent-drop case. ihasmail asks for the delay the way JMAP requires — a `HOLDUNTIL` parameter on the envelope's `mailFrom`, since RFC 8621 makes `sendAt` read-only and server-derived — and files the held message in a **Scheduled** folder, because `onSuccessUpdateEmail` would otherwise drop it in Sent the moment the submission is created. Nothing moves it out when the hold expires, so ihasmail reconciles the folder on the way in: released messages to Sent, canceled ones back to Drafts. Three fixes this depends on landed in **0.16.17**, below the live instance's 0.16.19: `HOLDUNTIL` taking RFC 3339 date-times again (0.16.16 had it wanting Unix timestamps), `EmailSubmission/query` on `undoStatus` agreeing with `/get` about held submissions, and `EmailSubmission/get` without `ids` iterating the right index. The hold itself is now **confirmed against the live 0.16.19** (2026-08-25), once `futureRelease` was set to `30d` there: a submission carrying a `HOLDUNTIL` ten minutes out came back `pending`, with `sendAt` equal to the time asked for and a `250 2.1.5 Queued` from the MTA, rather than going out at once. Worth repeating that the capability is no evidence either way — it advertised `maxDelayedSend: 2592000` and `FUTURERELEASE` while the setting was still off. Only a submission tells you. The rest of the journey is **confirmed live too (2026-08-26)**: a hold expired and was delivered, and the **Scheduled** folder reconciled on the way in — a released message moved to Sent, a canceled one back to Drafts. Nothing in Stalwart does that moving, so if ihasmail is never opened again the message still goes out; it is only the folder that waits to be tidied.
+- **Stalwart 0.16 and RFC 8984 disagree about the calendar vocabulary, and the server only says so half the time.** A participant's address lives in `calendarAddress`, not RFC 8984's `sendTo`/`email`; the organizer is `organizerCalendarAddress`, not `replyTo`; and a recurrence is a single `recurrenceRule`, not a `recurrenceRules` array. Addressed the RFC's way, `CalendarEvent/set` **keeps the event and discards the whole participant map without an error** — guests disappeared on save and no invitation was ever sent, which is what [#26](https://github.com/Coffey-Labs/ihasmail/issues/26) reported. The array form of the rule is refused honestly, with `invalidProperties`, so recurring events could not be created at all and existing ones showed no repeat ([#30](https://github.com/Coffey-Labs/ihasmail/issues/30)). ihasmail now writes Stalwart's names and reads either, and the mock refuses what the real server refuses, since advertising the RFC spelling is precisely how this got as far as a live server. Verified against 0.16.19 on 2026-08-25, end to end: participants, organizer and rule all survive a create, an update and a re-read; an invitation to an external Gmail address arrived as an invite card, and the decline came back and was applied to the event (`needs-action` → `declined`, sequence 1). Canceling the event notified the guest too. Adding guests to an event that had none, and clearing them again with `null`, both work on the update path, as does RSVP — which patches `participants/{key}/participationStatus` (and `participationComment`) rather than sending the whole map. That patch had to be aimed at the base event: through 0.16.19 `CalendarEvent/set` refused a synthetic id with *"Updating synthetic ids is not yet supported"*, which is why RSVP resolves `baseEventId` first. 0.16.20 accepts one, so that resolution is now a choice rather than the only option — an RSVP aimed at an occurrence would answer for that date alone. It still resolves the base, which is the answer people mean. Adding a *new* participant by patch is refused as well (`Patch operation failed`), so a changed guest list is written as the whole `participants` property. One more thing to know when reading this code: an expanded occurrence carries a `recurrenceId` but *no* rule of its own, and `baseEventId` is set on everything an expanded query returns — a one-off included, whose own id differs from its base — so neither is a test for recurrence. Since 0.16.22 the same event read by its *stored* id answers `baseEventId: null` rather than its own id, which changes nothing here: a one-off read through the synthetic id an expanded query gave it still carries a base.
 - **Free/busy between accounts needs no sharing, and calendar contents cannot be reached at all.** These are the two halves of the same finding, and the second is what makes the first safe. **Confirmed live on 0.16.20 (2026-09-01)** against the deployed instance: `Principal/getAvailability` was called for all seven principals the directory returns, none of whose calendars are shared with the calling account, and every one was answered — no `forbidden`, no error of any kind, from a server that refuses a malformed call instantly. It returns real data rather than a polite empty list: the caller's own principal reported one busy period against the one event in the next sixty days. And a `Principal` carries only `id`, `type`, `name`, `description` and `email` — **no `accountId`** — so there is no handle with which to ask for anybody's calendars. Free/busy is therefore not the weaker of two permissions, it is the only channel between two accounts, and it is open by default. That is the right posture and worth recording, because a client that assumed sharing was a precondition would hide a working feature behind a setting nobody needs to touch. **One thing this did not settle**: the other six principals reported nothing over a nine-month window, which is equally consistent with "those accounts have empty calendars" — likely, since the session reaches one account — and with "an unreadable principal answers with an empty list rather than an error". Distinguishing them needs a second account with an event in it, and until somebody has one, ihasmail assumes the pessimistic reading everywhere it matters: a participant it cannot read is drawn as unknown rather than as free.
 
-- **An override can move an occurrence, and then `start` and `recurrenceId` mean two different times.** The slot stays where the rule put it and only the clock time moves. **Confirmed live on 0.16.20 (2026-08-31)**: one occurrence of a weekly 09:00 series moved to 14:00 came back `start: 2027-06-14T14:00:00` with `recurrenceId` still `2027-06-14T09:00:00`. This is the right behaviour and it is the reason `recurrenceId` is the handle ihasmail holds: it is the one name for an instance that survives *both* a renumbering and a move, so a mutation can always be re-resolved from it. Worth recording because the mock got it wrong in the other direction — it overwrote an override's `start` with the slot time, so a moved occurrence did not move, and per-occurrence *time* editing looked broken against the mock and correct against the server. Found by asking a real server rather than by reading the mock, which is the only way this kind of disagreement ever surfaces.
+- **An override can move an occurrence, and then `start` and `recurrenceId` mean two different times.** The slot stays where the rule put it and only the clock time moves. **Confirmed live on 0.16.20 (2026-08-31)**: one occurrence of a weekly 09:00 series moved to 14:00 came back `start: 2027-06-14T14:00:00` with `recurrenceId` still `2027-06-14T09:00:00`. This is the right behavior and it is the reason `recurrenceId` is the handle ihasmail holds: it is the one name for an instance that survives *both* a renumbering and a move, so a mutation can always be re-resolved from it. Worth recording because the mock got it wrong in the other direction — it overwrote an override's `start` with the slot time, so a moved occurrence did not move, and per-occurrence *time* editing looked broken against the mock and correct against the server. Found by asking a real server rather than by reading the mock, which is the only way this kind of disagreement ever surfaces.
 
-- **A synthetic id is only true until the next write, and a stale one is wrong rather than invalid.** Stalwart's expanded-occurrence ids encode a position in the series, and writing a `recurrenceOverrides` entry adds a component that renumbers it. **Confirmed live on 0.16.20 (2026-08-31)**: a five-week series came back as `e i m q u` over 03-01 … 03-29; one override written to 03-08 left the *same five ids* addressing 03-01, 03-15, 03-29, 03-08 and 03-22. Nothing was rejected and nothing reported a change — `i` simply meant a week later than it had a moment earlier. So an id cached across a write silently points at another date, and a delete meant for one occurrence removes a different one. This is the second time the same shape of problem has cost a live debugging session, and it is worth saying plainly why it is dangerous: the failure is not a `notFound` a client would notice, it is a confident answer about the wrong day. ihasmail therefore never mutates an occurrence by an id it is holding. `recurrenceId` is the stable name for a slot in a series — it is the date — so `updateEvent` and `destroyEvent` look the current id up by it immediately before they act, and refuse outright if the date is no longer in the series rather than falling back to the id in hand. The mock renumbers too, by a different permutation to the real server's but with the property that matters, since a mock that kept ids stable would agree with precisely the belief that is wrong.
+- **A synthetic id was only true until the next write, through 0.16.20. Fixed in 0.16.21.** Stalwart's expanded-occurrence ids used to encode a position in the series, so writing a `recurrenceOverrides` entry renumbered them. **Confirmed live on 0.16.20 (2026-08-31)**: a five-week series came back as `e i m q u` over 03-01 … 03-29; one override written to 03-08 left the *same five ids* addressing 03-01, 03-15, 03-29, 03-08 and 03-22. Nothing was rejected and nothing reported a change — `i` simply meant a week later than it had a moment earlier, so an id cached across a write silently pointed at another date and a delete meant for one occurrence removed a different one. The failure was never a `notFound` a client would notice; it was a confident answer about the wrong day. **0.16.21 identifies an occurrence by its recurrence id, and confirming that was the point of re-running rather than reading the diff. Confirmed live on 0.16.21 (2026-09-06)**: the same shape of test — five weekly occurrences expanded, the third retitled through its own synthetic id, all five original ids re-read — left every id on its own date, with none renumbered and none `notFound`. A second override written through the interface behaved the same way. The defense stays regardless: ihasmail still never mutates an occurrence by an id it is holding, and `updateEvent` and `destroyEvent` still re-resolve by `recurrenceId` immediately before acting, because a date can still leave a series and because the client supports 0.16 as a whole rather than only its newest release. The mock follows the new behavior, and the test that pinned the old renumbering now pins the stability instead — rewritten rather than deleted, so the reversal stays on the record.
 
 - **A per-occurrence patch made only of inherited properties creates an override that loses the title.** The twelve properties 0.16.20 drops from a per-occurrence patch are dropped *after* it has decided to write an override, so a patch consisting only of them still writes one — and that override carries the `start` and `duration` the server fills in and nothing else. **Confirmed live on 0.16.20 (2026-08-31)**: `{"privacy": "private"}` aimed at one occurrence answered `updated`, left `privacy` untouched on the series, and left that date with no title at all. A successful response, a silently discarded change, and real data loss on a third property nobody mentioned. ihasmail narrows a per-occurrence patch before sending it and sends nothing when narrowing empties it, which was written as a point of principle — a request whose response could only be a meaningless "updated" is worse than no request — and turns out to prevent this. Worth remembering as the argument for the principle.
 

NOTICE

@@ -3,10 +3,10 @@
 ihasmail is licensed under the AGPL-3.0; see LICENSE. This file records work by
 other people that ships inside it and the terms it comes under.
 
-## Colour palettes
+## Color palettes
 
-Four of the palettes offered in Settings › Appearance are the work of their own
-projects and are used under the MIT licence. Only the published colour values
+Ten of the palettes offered in Settings › Appearance are the work of their own
+projects and are used under the MIT license. Only the published color values
 are used — no code, and nothing from anyone else's reimplementation of them.
 The values as fetched from each project are recorded in
 `.palette-sources/palettes-upstream.md`, and the shades between them are
@@ -16,28 +16,66 @@ not meet the contrast ihasmail claims.
 ### Dracula and Alucard
 
 Copyright (c) 2016 Dracula Theme — https://github.com/dracula/dracula-theme
-Licensed under the MIT licence. "Dracula" is the dark variant and "Alucard" the
+Licensed under the MIT license. "Dracula" is the dark variant and "Alucard" the
 light one; both are published in that repository's own "Color Palette (OSS)"
 section.
 
 ### Gruvbox
 
 Copyright (c) 2018 Pavel Pertsev — https://github.com/morhetz/gruvbox
-Licensed under the MIT licence.
+Licensed under the MIT license.
 
 ### Rosé Pine
 
 Copyright (c) 2021 Rosé Pine — https://github.com/rose-pine/rose-pine-theme
-Licensed under the MIT licence. The light variant is "Dawn".
+Licensed under the MIT license. The light variant is "Dawn".
 
 ### Tokyo Night
 
 Copyright (c) 2019 enkia — https://github.com/enkia/tokyo-night-vscode-theme
-Licensed under the MIT licence. The light variant is "Day".
+Licensed under the MIT license. The light variant is "Day".
+
+### Catppuccin
+
+Copyright (c) 2021 Catppuccin — https://github.com/catppuccin/palette
+Licensed under the MIT license. "Mocha" is the dark variant and "Latte" the
+light one; both are published in that repository's palette.json.
+
+### Solarized
+
+Copyright (c) 2011 Ethan Schoonover — https://github.com/altercation/solarized
+Licensed under the MIT license. Light and dark are both original to it, and
+share one set of accent values by design.
+
+### Ayu
+
+Copyright (c) Konstantin Pschera — https://github.com/ayu-theme/ayu-colors
+Licensed under the MIT license. The two signature accent colors come from the
+same author's ayu-theme/vscode-ayu, also MIT.
+
+### Kanagawa
+
+Copyright (c) 2021 Tommaso Laurenzi — https://github.com/rebelot/kanagawa.nvim
+Licensed under the MIT license. "Wave" is the dark variant and "Lotus" the
+light one. The theme takes its name from Hokusai's print.
+
+### Everforest
+
+Copyright (c) 2019 Sainnhe Park — https://github.com/sainnhe/everforest
+Licensed under the MIT license. The medium-contrast variant of each mode is
+the one used here.
+
+### Primer
+
+Copyright (c) GitHub, Inc. — https://github.com/primer/primitives
+Licensed under the MIT license, which covers the color values. "GitHub" and
+the Invertocat logo are trademarks of GitHub, Inc.; this palette is named
+"Primer" after the design system and is neither affiliated with nor endorsed
+by GitHub.
 
 ---
 
-The MIT licence, under which all four are used:
+The MIT license, under which all ten are used:
 
     Permission is hereby granted, free of charge, to any person obtaining a
     copy of this software and associated documentation files (the "Software"),

README.md

@@ -8,22 +8,21 @@
 </p>
 
 <p align="center">
-  <a href="LICENSE"><img alt="Licence: AGPL-3.0-or-later" src="https://img.shields.io/badge/licence-AGPL--3.0--or--later-2dd4bf?style=flat-square"></a>
-  <a href="https://stalw.art" target="_blank" rel="noreferrer"><img alt="Requires Stalwart 0.16 or newer; tested against 0.16.20" src="https://img.shields.io/badge/Stalwart-0.16.20-6366f1?style=flat-square"></a>
+  <a href="LICENSE"><img alt="License: AGPL-3.0-or-later" src="https://img.shields.io/badge/license-AGPL--3.0--or--later-2dd4bf?style=flat-square"></a>
+  <a href="https://stalw.art" target="_blank" rel="noreferrer"><img alt="Requires Stalwart 0.16 or newer; tested against 0.16.22" src="https://img.shields.io/badge/Stalwart-0.16.22-6366f1?style=flat-square"></a>
   <a href="https://docs.ihasmail.org" target="_blank" rel="noreferrer"><img alt="Documentation: docs.ihasmail.org" src="https://img.shields.io/badge/docs-docs.ihasmail.org-0ea5e9?style=flat-square"></a>
   <a href="https://coffeylabs.org" target="_blank" rel="noreferrer"><img alt="by Coffey Labs" src="https://img.shields.io/badge/by-Coffey%20Labs-0f766e?style=flat-square"></a>
 </p>
 
 # ihasmail
 
-**Immutable webmail for [Stalwart Mail Server](https://stalw.art) — a container
-with nothing to persist, and a Gmail-class client on top of it.**
+**Immutable webmail for [Stalwart Mail Server](https://stalw.art).** Mail,
+calendars, contacts, files and filters in one app that works as well on a phone
+as on a desktop — and a container with nothing to persist.
 
-Mail, calendars, contacts, files and filters in a responsive single-page app
-that works equally well on a desktop monitor and a phone. It talks only JMAP
-(plus Stalwart's blob/upload/EventSource endpoints) — no IMAP, no SMTP, no
-database, and with `IMMUTABLE=1` no writable filesystem either. Everything
-durable belongs to Stalwart; the container is disposable.
+ihasmail talks only JMAP to Stalwart. There is no database, no IMAP or SMTP,
+and with `IMMUTABLE=1` no writable filesystem either: everything durable,
+settings included, belongs to Stalwart, so the container is disposable.
 
 | | |
 | --- | --- |
@@ -33,47 +32,41 @@ durable belongs to Stalwart; the container is disposable.
 | 🧪 **[KNOWN-ISSUES.md](KNOWN-ISSUES.md)** | What was verified live, and where Stalwart departs from a spec |
 | 🛣 **[ROADMAP.md](ROADMAP.md)** | What ihasmail does not do, and why |
 
-This file is for people working *on* ihasmail. Everything about running it
-lives in the docs.
-
 ## Screenshots
 
-*Taken against the built-in mock server (`npm run dev:mock`) with sample data — no real mailbox involved.*
-
 | | |
 | --- | --- |
-| **Inbox & conversation (dark)** ![Inbox, dark theme](docs/screenshots/inbox-dark.jpg) | **Inbox & conversation (light)** ![Inbox, light theme](docs/screenshots/inbox-light.jpg) |
-| **Composer** ![Composer](docs/screenshots/compose.jpg) | **Calendar** ![Calendar](docs/screenshots/calendar.jpg) |
-| **Contacts** ![Contacts](docs/screenshots/contacts.jpg) | **Sieve filter builder** ![Filters](docs/screenshots/filters.jpg) |
+| **Inbox & conversation (dark)** ![Inbox, dark theme](screenshots/inbox-dark.jpg) | **Inbox & conversation (light)** ![Inbox, light theme](screenshots/inbox-light.jpg) |
+| **Composer** ![Composer](screenshots/compose.jpg) | **Calendar** ![Calendar](screenshots/calendar.jpg) |
+| **Contacts** ![Contacts](screenshots/contacts.jpg) | **Sieve filter builder** ![Filters](screenshots/filters.jpg) |
 
-More, including the mobile layout, on [ihasmail.org](https://ihasmail.org/#screenshots).
+Taken against the built-in mock with sample data. More, including the phone
+layout, on [ihasmail.org](https://ihasmail.org/#screenshots).
 
 ## What's in it
 
-- **Mail** — three-pane Gmail-style layout, conversation view, virtualised list, labels, undo, Gmail search operators and keyboard shortcuts, Sieve rules from a message's context menu, sanitised HTML with remote images blocked, read receipts, invitations and RSVP, an event made from a message with its guests already in it, multi-composer rich-text editing with signatures, scheduled send and undo send
-- **Calendar** — JMAP Calendars / JSCalendar: month/week/day/agenda, recurrence, attendees and free-busy, colour categories
-- **Contacts** — JMAP Contacts / JSContact: address books, groups, full editor, vCard import/export
-- **Files** — JMAP FileNode: browse, upload, download, rename, move, delete
-- **Settings that follow the account**, not the browser — kept in a `settings.json` in the account's own JMAP Files, so ihasmail itself stays stateless
-- **Runs read-only** — one optional write path, and with it switched off the container needs no volume and no writable root. `IMMUTABLE=1` is checked at startup rather than trusted, so a half-applied switch refuses to boot instead of failing quietly. See [Running immutably](#running-immutably)
-- **Nine new interface languages** — German, Spanish, French, Dutch, Portuguese (Brazil), Russian, Ukrainian, Simplified Chinese and Japanese, alongside English and separate from the date-and-time locale. Every one is marked **Beta**: they were made by AI and no native speaker has read them yet, which Settings says plainly, with a link for reporting anything wrong
-- **On a phone** — swipe a message to archive or delete it (either direction, your choice), hold one to select it, hold a folder for its menu, pull the list to refresh, swipe back from a conversation
-- **Platform** — installable PWA, Web Push with ihasmail closed, `mailto:` handler, no credentials in the browser, strict CSP, SSRF-safe image proxy
+- **Mail** — conversations, labels, search operators, keyboard shortcuts, scheduled and undo send, invitations and RSVP, filters made from a message
+- **Calendar** — month, week, day and agenda views, recurrence, attendees and free-busy
+- **Contacts** — address books, groups, vCard import and export
+- **Files** — browse, upload, move, share
+- **Signature checking** — S/MIME signed mail verified as you read it
+- **Settings that follow the account**, kept in the account's own storage on Stalwart
+- **On a phone** — swipe to archive or delete, pull to refresh, hold to select
+- **Administration** — a dashboard, accounts, groups, mailing lists, roles, tenants and domains, each shown only when the Stalwart role allows it
+- **Ten interface languages and twelve themes** — the nine translations are marked Beta until a native speaker has read them
+- **Platform** — installable PWA, Web Push, `mailto:` handler, no credentials in the browser, strict CSP
 
-The long version is on [ihasmail.org](https://ihasmail.org/#features); how to
-drive each one is in [Using ihasmail](https://docs.ihasmail.org/using/).
+The long version is [FEATURES.md](FEATURES.md) and
+[ihasmail.org](https://ihasmail.org/#features).
 
-## Requires Stalwart 0.16 or newer
+## Requirements
 
-Sign-in refuses anything older, by name. 0.16 replaced the REST management API
-with JMAP registry objects, changed the shape of `FileNode`, split its rights up
-and moved configuration into the store; supporting both generations meant a
-wrong guess had somewhere to fall back to, so it failed *quietly* — and that
-reached production. With one supported generation a wrong guess is a loud error
-on the first call.
+**Stalwart 0.16 or newer** — sign-in refuses anything older, by name. Tested
+against 0.16.22; what changed in each release is in
+[KNOWN-ISSUES.md](KNOWN-ISSUES.md).
 
-- Still on 0.15? The last release that runs on it is tagged [`stalwart-0.15-support`](https://github.com/Coffey-Labs/ihasmail/releases/tag/stalwart-0.15-support).
-- Upgrading? [stalwart-migrator](https://github.com/Coffey-Labs/stalwart-migrator) does it in place, checkpointing every phase and validating afterwards. The live instance moved 0.15.5 → 0.16.19 with eight seconds of downtime and nothing lost.
+- **No Stalwart yet?** [ihasmail-oneshot](https://github.com/Coffey-Labs/ihasmail-oneshot) deploys a new Stalwart and ihasmail together on one host, in one command.
+- **On Stalwart 0.15?** [stalwart-migrator](https://github.com/Coffey-Labs/stalwart-migrator) upgrades it in place, or stay on the [`stalwart-0.15-support`](https://github.com/Coffey-Labs/ihasmail/releases/tag/stalwart-0.15-support) release.
 
 ## Quick start (Docker)
 
@@ -81,326 +74,31 @@ on the first call.
 cp .env.example .env
 # edit: STALWART_URL=https://mail.example.com  and  APP_SECRET=$(openssl rand -base64 48)
 docker compose up --build -d
-# → http://localhost:8080  (put Caddy/nginx in front for TLS; see Caddyfile.example / nginx.example.conf)
+# → http://localhost:8080 — put a reverse proxy in front for TLS
 ```
 
-Users sign in with their Stalwart mailbox credentials. **An account with
+Or pull the published image, `registry.coffeylabs.org/coffey-labs/ihasmail`. Releases are
+weekly, so it is usually a few days behind `main`.
+
+People sign in with their Stalwart mailbox credentials. **An account with
 two-factor authentication needs an app password**, created in Stalwart's own
-settings — Stalwart accepts a TOTP code only through an OAuth flow and offers no
-password grant, so no client holding a username and password can exchange them
-plus a code for a token.
+settings.
 
-Full instructions, TLS, and every environment variable:
-[Installing](https://docs.ihasmail.org/install/) ·
-[Configuring](https://docs.ihasmail.org/configure/).
-
-### Container images
-
-Published to GHCR on every release, for `linux/amd64` and `linux/arm64`:
-
-```bash
-docker pull ghcr.io/coffey-labs/ihasmail:latest
-```
-
-| Tag | What it is |
-| --- | --- |
-| `latest` | The newest release. Prereleases never move it |
-| `2026.9.2-pr243` | One specific build — the [version](#version-numbers) with `+` written as `-`, because a Docker tag may not contain `+` |
-
-Pin the dated tag in anything you care about. `latest` is a moving target by
-definition, and rolling back to a named tag is a `docker run` rather than a
-rebuild.
-
-Building it yourself stays fully supported and is what `docker compose up
---build` above does — the image is a convenience, not a new requirement. If you
-build by hand, pass the version in, because `.dockerignore` excludes `.git` and
-the build cannot work out what it is:
-
-```bash
-docker build --build-arg IHASMAIL_VERSION="$(node scripts/version.mjs)" -t ihasmail:local .
-```
-
-### Running immutably
-
-The server writes to exactly one path, the optional `SESSION_FILE`. Clear it
-and there is nothing left to write, so the container can run with no writable
-filesystem at all:
-
-```bash
-docker run --read-only --tmpfs /tmp -e IMMUTABLE=1 -e SESSION_FILE= ...
-```
-
-`IMMUTABLE=1` is an assertion the server checks at startup rather than a switch
-that changes what it does: it refuses to start if `SESSION_FILE` is still set,
-or if the filesystem it is installed on turns out to be writable after all.
-Without it the same misconfiguration is silent — sessions are held in memory
-and persisting them is best-effort, so a read-only `/data` costs one warning at
-the first sign-in and nothing else until the instance is replaced and everyone
-is signed out.
-
-That sign-out is the standing cost of this mode today, since sessions have
-nowhere to live across a restart. Removing it means moving the session upstream
-into a token Stalwart itself issues and can revoke, which is what the OAuth work
-in [ROADMAP.md](ROADMAP.md) is for.
-
-### Several Stalwart servers
-
-One ihasmail can front more than one Stalwart, choosing by the domain somebody
-signs in with. **`STALWART_URL` stays required and stays the default**, so an
-installation that sets nothing else behaves exactly as it always has.
-
-```bash
--e STALWART_SERVERS_FILE=/etc/ihasmail/servers.json \
--v /srv/ihasmail/servers.json:/etc/ihasmail/servers.json:ro
-```
-
-```json
-{
-  "example.com": "https://mail.example.com",
-  "customer-b.test": "https://jmap.customer-b.test"
-}
-```
-
-[`stalwart-servers.example.json`](stalwart-servers.example.json) is that file
-with the rules written in it.
-
-A domain nobody listed — and a bare username, which Stalwart accepts and which
-has no domain at all — goes to `STALWART_URL`. **A listed domain never falls
-back.** If its server is unreachable that sign-in fails rather than retrying
-against the default, because falling back would authenticate somebody against a
-server their domain was deliberately routed away from; if the same account name
-existed there they would land in another tenant's mailbox.
-
-Read once at startup, so editing it means restarting the container. Malformed
-JSON, a duplicate domain once lower-cased, or a value that is not an `http(s)`
-URL stops the server rather than failing quietly at somebody's sign-in. The
-servers themselves are not contacted at boot — a mapping is a routing table,
-not a health check, and one customer's outage must not stop ihasmail starting
-for everybody else.
-
-This is one server per *person*, chosen at sign-in. Several servers at once for
-one person, with unified or cross-account views, is not supported: JMAP account
-ids are only unique within a server, so it would mean namespacing ids through
-the proxy. Reading somebody else's mail, calendars or files on the *same* server
-already works through JMAP sharing.
-
-### Settings the installation decides
-
-A deployment can seed and lock user settings, which is what a school wanting
-"warn about outside senders" on for three thousand pupils needs — asking three
-thousand pupils is not a plan.
-
-```bash
--e SETTINGS_DEFAULTS='{"externalSenderBanner":true}' \
--e SETTINGS_ENFORCED='{"externalRecipientConfirm":true}'
-```
-
-Three powers, and the differences between them matter:
-
-| Section | Applies to | Reader can change it |
-| --- | --- | --- |
-| `defaults` | accounts that have never had settings of their own | yes, at any time |
-| `enforced` | everyone, on every load | no — the control goes dead |
-| `changes` | everyone, **once each**, including existing accounts | yes, afterwards, and it stays changed |
-
-`changes` is the one that needs explaining. It turns something on for people who
-are *already here* — the reason a plain default is not enough — while still
-leaving them the last word. Each entry carries its own `version`, which every
-account remembers once it has had it, so the change is applied exactly once per
-person and a reader who turns it back off keeps it off. It is a schema migration
-in shape, and that is deliberately whose idea it was ([#207]).
-
-Nothing is configured by default: an installation that sets none of these
-behaves exactly as ihasmail always has.
-
-### Passing a policy to Docker
-
-Where a file is easier to manage than JSON quoted in a unit file — and it
-usually is once there are `changes` in it — mount one and name it:
-
-```bash
-docker run -d --name ihasmail \
-  -e STALWART_URL=https://mail.example.org \
-  -e APP_SECRET="$(openssl rand -hex 32)" \
-  -e SETTINGS_POLICY_FILE=/etc/ihasmail/policy.json \
-  -v /srv/ihasmail/policy.json:/etc/ihasmail/policy.json:ro \
-  -p 8080:8080 ghcr.io/coffey-labs/ihasmail:latest
-```
-
-```json
-{
-  "defaults": { "externalSenderBanner": true },
-  "enforced": { "externalRecipientConfirm": true },
-  "changes": [
-    { "version": "20260902084513", "settings": { "externalSenderBanner": true } },
-    { "version": "20261014091500", "settings": { "externalLinkWarning": true } }
-  ]
-}
-```
-
-[`settings-policy.example.json`](settings-policy.example.json) in this repo is
-that file with every section explained in it — copy it and delete what you do
-not want.
-
-Mount it read-only: the server only ever reads it, and `:ro` keeps that true
-under `--read-only` as well.
-
-Or without a file at all, which is what an immutable deployment with no volume
-wants:
-
-```bash
-docker run -d --name ihasmail --read-only --tmpfs /tmp \
-  -e IMMUTABLE=1 -e SESSION_FILE= \
-  -e STALWART_URL=https://mail.example.org \
-  -e APP_SECRET="$(openssl rand -hex 32)" \
-  -e SETTINGS_DEFAULTS='{"externalSenderBanner":true}' \
-  -e SETTINGS_ENFORCED='{"externalRecipientConfirm":true}' \
-  -e SETTINGS_CHANGES='[{"version":"20260902084513","settings":{"externalSenderBanner":true}}]' \
-  -p 8080:8080 ghcr.io/coffey-labs/ihasmail:latest
-```
-
-In `docker-compose.yml`:
-
-```yaml
-services:
-  ihasmail:
-    image: ghcr.io/coffey-labs/ihasmail:latest
-    environment:
-      SETTINGS_POLICY_FILE: /etc/ihasmail/policy.json
-    volumes:
-      - ./policy.json:/etc/ihasmail/policy.json:ro
-```
-
-A policy is read once at startup, so **editing it means restarting the
-container**. There is no reload signal, deliberately: an installation-wide
-setting changing under a running instance would be harder to reason about than
-one that changes when you say so.
-
-### Writing a policy
-
-Both sections take the same names and values a settings export uses, so
-`Settings → General → Export` on one account you have configured by hand is the
-quickest way to write one — copy the keys you care about out of the file.
-
-Three checks worth knowing about, because they fail loudly rather than quietly:
-
-- **Malformed JSON stops the server at startup.** A policy that silently did not
-  apply is indistinguishable from the feature not working.
-- **Every change needs a unique `version`.** Two changes sharing one, or a change
-  with no `version` or no `settings`, is a startup error.
-- **Keys this build does not have are dropped**, the same rule an imported
-  settings file gets. A `changes` entry whose keys are *all* unknown is dropped
-  whole rather than recorded as applied, so it still runs on an ihasmail that
-  does have the setting.
-
-Enforcement is applied in the settings store rather than only on the controls,
-so an imported settings file, a settings file synced from a device that predates
-the policy, and "reset to defaults" cannot get around it. Reset returns to your
-defaults, not to ihasmail's.
-
-[#207]: https://github.com/Coffey-Labs/ihasmail/issues/207
-
-## Architecture
-
-```
-browser  ──(same-origin /api/*)──►  ihasmail server (Node + Hono)  ──(JMAP over HTTPS)──►  Stalwart
-  React SPA                           • session cookie ⇄ Basic auth
-  JMAP client + stores                • /api/jmap, /api/blob, /api/upload, /api/events (SSE), /api/image
-```
-
-- `web/` — Vite + React 19 + TypeScript SPA. `src/jmap` (client, push, types), `src/store` (zustand: session, mail, compose, contacts, calendar, files, sieve, settings), `src/views`, `src/lib` (sanitiser, search parser, Sieve codec, locale-aware dates, vCard, …).
-- `server/` — Node/Hono backend: authenticates against Stalwart's JMAP session endpoint, seals the credentials with a key derived from the cookie secret, proxies JMAP/blob/SSE, serves the SPA under a strict CSP. `src/mock/` is an in-memory fake Stalwart for development and demos.
-
-Capabilities used: `core`, `mail`, `submission`, `vacationresponse`, `sieve`,
-`contacts`(+`parse`), `calendars`(+`parse`), `principals`(+`availability`),
-`quota`, `blob`, `filenode`, EventSource push, plus Stalwart's own
-`urn:stalwart:jmap` (read-only). Features degrade gracefully when one is
-missing.
-
-## Development
-
-Requirements: Node ≥ 20.10 (22 recommended), npm ≥ 10.
-
-```bash
-npm install
-
-npm run dev            # real Stalwart (STALWART_URL in .env) — server :8080, Vite :5173
-npm run dev:mock       # built-in mock Stalwart ([email protected] / demo), mock on :8788
-npm run dev:mock:no-future-release   # mock that advertises FUTURERELEASE and drops every hold
-
-npm run typecheck      # tsc for both packages
-npm test               # vitest (web) + node:test (server)
-npm run build          # web/dist + server/dist
-npm start              # serve the production build
-```
-
-Open http://localhost:5173 in dev, or http://localhost:8080 for the production
-build. Running it for real is covered in
+Everything else — TLS, running immutably, several Stalwart servers, settings
+the installation decides, every environment variable — is in
 [Installing](https://docs.ihasmail.org/install/) and
 [Configuring](https://docs.ihasmail.org/configure/).
 
-### The mock
-
-An in-memory fake Stalwart 0.16 — enough JMAP to develop and demo against
-without a real mailbox. It reproduces the things a naive fake would get wrong,
-because each cost a live debugging session: `urn:stalwart:jmap` advertised
-**per-account** rather than session-level, identity signatures capped at 2047
-**bytes**, and `CalendarEvent/set` speaking Stalwart's vocabulary rather than
-RFC 8984's. Two switches: `MOCK_NO_FUTURE_RELEASE=1` advertises FUTURERELEASE
-and then drops every hold; `MOCK_NO_REGISTRY=1` omits the Stalwart capability so
-the sign-in refusal can be tested.
-
-### Version numbers
-
-`ihasmail v2026.8.30+pr129` — the date of the commit this was built from, and
-the pull request that commit arrived through. A commit that did not arrive
-through one carries its short SHA instead: `2026.8.30+g1fa6578`. It all comes
-from git at build time; nothing writes a version into the tree, and
-`package.json` sits at `0.0.0` because it is no longer the source of anything.
-
-The date is the commit's own rather than today's, so rebuilding an old commit
-gives the version it had the first time.
+## Development
 
 ```bash
-node scripts/version.mjs        # the version for the current checkout
-docker build --build-arg IHASMAIL_VERSION="$(node scripts/version.mjs)" -t ihasmail:2026.8.30 .
+npm install
+npm run dev:mock     # built-in mock Stalwart ([email protected] / demo)
+npm test
 ```
 
-`.dockerignore` excludes `.git` deliberately, so an image build cannot work this
-out for itself — pass it in. Left out, the build reports `0.0.0`, which is meant
-to look wrong: a version with no `+pr` or `+g` means whoever built the image did
-not pass one.
-
-The version says nothing about Stalwart, deliberately. It used to: `2.16.x` had
-`16` for the 0.16 generation it targeted, which leaves nowhere to go once
-Stalwart reaches 1.0 — `2.1` sorts *below* the `2.16` already deployed, so every
-image and About screen would read as a downgrade. Which Stalwart a build needs is
-stated where it can be precise, in the badge at the top of this file and in
-[KNOWN-ISSUES.md](KNOWN-ISSUES.md), rather than compressed into one digit.
-
-The pull request lives after the `+`, as build metadata, because it is
-provenance rather than a rank: at the rate they merge here it climbs without
-bound and says nothing about how new a build is. Everything after the `+` is
-ignored when versions are compared, which is the right reading — two builds from
-the same day differ in where they came from, not in age. Nothing here depends on
-that comparison: images are pruned oldest-first by creation time, and a rollback
-names a git ref.
-
-### Deploying
-
-[`deploy.example.sh`](deploy.example.sh) is a single-host Docker deploy: it
-fetches, refuses anything held back by `.deploy-hold`, shows what is about to be
-introduced and asks, rebuilds with the right version baked in, replaces the
-container, waits for healthy, then prunes all but the newest
-`IHASMAIL_KEEP_VERSIONS` images — never the one actually running.
-
-```bash
-./deploy.sh                 # origin/main, asks before shipping new commits
-./deploy.sh --dry-run       # run the guards and stop
-./deploy.sh v2026.8.30 --yes  # a named ref, no prompt (there is no tty over ssh)
-```
-
-`--yes` does not override a hold; clearing one means deleting its line.
+Architecture, the mock's switches and how versions are numbered are in
+[CONTRIBUTING.md](CONTRIBUTING.md#development-setup).
 
 ## Contributing
 
@@ -409,14 +107,8 @@ container, waits for healthy, then prunes all but the newest
 
 ## License
 
-Copyright (C) 2026 Coffey Labs — AGPL-3.0-or-later. See
-[LICENSE](LICENSE).
+Copyright (C) 2026 Coffey Labs — AGPL-3.0-or-later. See [LICENSE](LICENSE).
 
-ihasmail was relicensed from GPL-3.0 to AGPL-3.0 on 2026-08-25: webmail is
-nearly always run as a network service rather than handed to anyone as a binary,
-and the AGPL's section 13 closes that gap.
-
-That offer has to point at *your* source, not this one. If you run a modified
-ihasmail, set `SOURCE_URL` to your own repository — the sign-in page and
-Settings › About both show it. See
+If you run a modified ihasmail, set `SOURCE_URL` to your own repository: the
+sign-in page and Settings › About both show it. See
 [Rebranding](https://docs.ihasmail.org/rebranding/).

ROADMAP.md

@@ -8,10 +8,26 @@ the rest is here because the answer is "no", not "not yet".
 
 See [KNOWN-ISSUES.md](KNOWN-ISSUES.md) for what is built but worth knowing about.
 
+- **More of Stalwart's directory in Administration.** The Administration menu opens on a dashboard and manages accounts, groups, mailing lists, tenants, roles and domains today — see [FEATURES.md](FEATURES.md#administration). DNS and ACME providers are Stalwart registry objects behind the same permission model, and each is a section to add rather than a design to invent; so is switching a domain's DNS, DKIM or certificate management, which is shown but not yet changed from ihasmail. The dashboard reads a handful of numbers and stops there. Managing queues, reading logs and changing server settings are not planned: they are operating the server, which is Stalwart's own interface's job, not managing the people on it.
 - **Sharing a mail folder.** Stalwart stores the share and never delivers it; see [KNOWN-ISSUES.md](KNOWN-ISSUES.md). Withdrawn until the server does something with it. Sharing files, calendars and address books is unaffected and works.
 - **A scheduling view of its own**, for asking "when is everyone free next week?" without an event in hand. The grid itself is built and lives in the event editor — a row per participant, steppable, and clickable to place the event — which is where the question gets asked while you are arranging something. What is not built is the same thing as a destination you can visit with nothing in progress. Came out of [#172](https://github.com/Coffey-Labs/ihasmail/issues/172), which asked for a separate view and is closed by the panel: the reasoning for putting it in the editor is that a separate surface can only ever tell you a time you then retype, whereas one beside the event can set it. It stays here rather than in the tracker because nobody has yet said they want to ask the question on its own.
 - **Per-message actions from the message list on a touchscreen.** Reply, Forward and compose-as-new are on the list row's context menu, which is a right-click — and holding a row on a phone starts selection instead, so none of them are reachable there. They are all available inside a thread, which is where the actions on a single message belong; what is missing is the shortcut from the list. Fixing it means deciding what a long press should do when it already means something, which is a bigger question than the actions themselves.
 - Snooze (nothing in JMAP or Stalwart supports it, and ihasmail never stores a password, so nothing could act on a mailbox while you are away)
 - **A translation anybody has checked.** The translations themselves shipped on 2026-08-31 and are no longer on this page: nine of them, alongside English, and the extraction that had always been the hard half is done — see [FEATURES.md](FEATURES.md#interface-language). What is *not* done is the other half, and it is the half that cannot be bought or automated. All nine were produced by AI against standard dictionaries and **not one has been read by anybody who speaks the language**, which is exactly where a bad translation does harm rather than merely looking untidy. They ship marked Beta, with that said in Settings and a link for reporting anything wrong, because shipping them quietly would ask people to trust text nobody has checked. A language loses the Beta mark when a speaker reads it and says so — a deliberate act by a person, not something a coverage percentage earns. If you speak one of them and are willing to read a few hundred strings, that is the single most useful thing anyone could contribute right now.
-- **Right-to-left languages.** Arabic, Hebrew and Persian are held back deliberately, and not for want of translators. RTL is bidi and layout work throughout — mirrored panes, gesture directions, icon sides, the message list's own geometry — and a catalogue without it produces a page that is translated and unusable. Adding one is not another entry in the picker.
+- **Right-to-left languages.** Arabic, Hebrew and Persian are held back deliberately, and not for want of translators. RTL is bidi and layout work throughout — mirrored panes, gesture directions, icon sides, the message list's own geometry — and a catalog without it produces a page that is translated and unusable. Adding one is not another entry in the picker.
 - **Two-factor sign-in.** Today an account with 2FA must use an app password (see [Quick start](README.md#quick-start-docker)), and Settings › Security offers no way to switch 2FA *on* — only off, for an account that already has it. Supporting a TOTP code directly means implementing OAuth: Stalwart offers the authorization-code and device flows and no password grant, so ihasmail would hand sign-in to Stalwart's own login and come back with a token. That is a better security posture than the sealed password it holds now — a refresh token rather than a credential — but it replaces ihasmail's own sign-in page for those users and may need an OAuth client registered. Came out of [#75](https://github.com/Coffey-Labs/ihasmail/issues/75), which is closed: what was reported there was a sign-in refused with nothing but "Invalid credentials", and that was fixed by saying what is actually happening and pointing at app passwords. The OAuth work it uncovered is tracked here rather than as an open issue, so there is no ticket to watch for it.
+- **Signing and encrypting mail.** *Reading* a signature is built: S/MIME signed mail is checked as it is read, and the signer is remembered so a change is called out — see [Checking a signature](FEATURES.md#checking-a-signature). What is not built is anything that produces a signature or touches ciphertext, and the reason is not Stalwart. This is client work over the message body: JMAP hands over the MIME blob and the rest is ours.
+
+  The blocker is a security model, not code, and it is the same one it has always been. Signing and decrypting need a **private** key in a page served by the same host that would handle it, which runs straight into two things ihasmail says about itself: that it never stores a credential, and that it runs immutably with nowhere to keep one. Verifying needed none of that — the certificate travels inside the message — which is exactly why it could be built first and why it went first.
+
+  **OpenPGP signatures are not checked, and this is a harder problem than it looks.** A PGP signature does not carry the key, so verifying one means having the sender's public key already. ihasmail has no source for it: `x:PublicKey` is the account's *own* registry, and fetching from a keyserver or WKD would tell a third party who you correspond with, which is precisely the leak the image proxy exists to close. A local store of correspondents' keys is possible and is not a small feature; nobody has asked for it yet.
+
+  *Managing* keys — publishing your own to `x:PublicKey` — has been built twice ([PR #67](https://github.com/Coffey-Labs/ihasmail/pull/67), [PR #285](https://github.com/Coffey-Labs/ihasmail/pull/285)) and withdrawn twice, because a Settings page for keys nothing uses is furniture. That reasoning is now partly spent: something does use a key. But what signature checking uses is the certificate inside the message, not anything in the registry, so publishing your own key remains a feature waiting for a consumer.
+
+  **Encryption at rest is refused rather than deferred.** Stalwart offers it as `encryptionAtRest`, a field on `x:AccountSettings` beside `description`, `locale` and `timeZone` — there is no `x:EncryptionAtRest` object whatever the docs suggest, and its value is a typed object (`{"@type": "Disabled"}`) rather than a bare string. It is self-service, needs no administrator, and would be easy to offer. It will not be: turning it *off does not decrypt what is already there*. Every message delivered while it was on stays encrypted on disk, readable only by a client holding the private key, so switching it on is a one-way door — and a toggle that reads as "make my mail safer" while quietly being irreversible is the wrong thing to hand an ordinary user.
+
+  **Why S/MIME rather than OpenPGP, and why neither is urgent.** End-to-end encrypted mail never reached the mainstream and is not on its way there: as a share of the world's email, PGP-encrypted messages are a rounding error, and the most successful use of OpenPGP is signing packages rather than sending mail. The reasons are structural rather than a matter of better tooling. Everyone in a thread has to take part, so the network effect works against it from the first reply. Key discovery was never solved — keyservers were unauthenticated and got weaponized in the 2019 certificate-flooding attacks, which made specific people's keys unusable by any client that fetched them, and WKD is better without being universal. There is no forward secrecy, so one compromised key retroactively opens everything ever received. The metadata stays in the clear: subject lines are cleartext in classic PGP/MIME, and who corresponded with whom is often the sensitive part. Losing a key loses the mail permanently. And it breaks the client — no server-side search, degraded spam filtering, awkward on a phone — while EFAIL showed in 2018 that the clients themselves were exploitable through MIME and HTML handling. Meanwhile the actual privacy win arrived invisibly and without anyone participating, in STARTTLS, MTA-STS and DANE.
+
+  So if one of the two gets built here it is S/MIME, because it is the one that is *more* deployed in the places that pay for software: native in Outlook and Apple Mail, and routine in defense, healthcare, finance and government, where a CA issues and revokes certificates that an IT department can actually administer. The web of trust never became something anybody could run at scale.
+
+  Expect the asking to be far out of proportion to the using. A self-hosted webmail for Stalwart draws self-hosters, privacy-minded users and European SMEs, which is about the densest concentration of PGP users left alive — so this will be requested much more often than it would be used, and that is an argument for keeping it here, described honestly, rather than either building it on the strength of the requests or refusing it outright.

deploy.example.sh

@@ -214,7 +214,23 @@ prune_old_images() {
   printf '%s\n' "$stale" | xargs -r docker rmi >/dev/null 2>&1 || true
 }
 
-VERSION="$(node scripts/version.mjs)"
+# The version is the same sum scripts/version.mjs does -- the commit's own
+# date, plus the pull request it arrived through or its short SHA -- done here
+# in shell because a host that only runs containers has git and docker and no
+# node. Given IHASMAIL_VERSION, use it as given, as the script would.
+version_from_git() {
+  local date subject sha y m d
+  date="$(git show -s --format=%cs HEAD)"
+  subject="$(git show -s --format=%s HEAD)"
+  sha="$(git rev-parse --short HEAD)"
+  IFS=- read -r y m d <<<"$date"
+  if [[ "$subject" =~ ^Merge\ pull\ request\ \#([0-9]+) ]]; then
+    printf '%d.%d.%d+pr%s\n' "$((10#$y))" "$((10#$m))" "$((10#$d))" "${BASH_REMATCH[1]}"
+  else
+    printf '%d.%d.%d+g%s\n' "$((10#$y))" "$((10#$m))" "$((10#$d))" "$sha"
+  fi
+}
+VERSION="${IHASMAIL_VERSION:-$(version_from_git)}"
 # A Docker tag may not contain "+", and every version has one now:
 # 2026.8.30+pr129, or +g1fa6578 for a commit that did not come through a pull
 # request. The image is tagged with the "+" turned into "-"; what the build is

docker-compose.yml

@@ -9,8 +9,21 @@ services:
         BASE_PATH: ${BASE_PATH:-}
     image: ihasmail:2
     restart: unless-stopped
+    # Loopback only: ihasmail expects a TLS reverse proxy in front of it. On
+    # every interface the app is reachable over plain HTTP, passwords and all,
+    # and with TRUST_PROXY any machine on a private network can set its own
+    # X-Forwarded-For. A proxy running in Docker can reach the service by name
+    # on the compose network and needs no published port at all.
     ports:
-      - "8080:8080"
+      - "127.0.0.1:8080:8080"
+    # The app needs no privileges and writes only to /data and /tmp.
+    read_only: true
+    tmpfs:
+      - /tmp
+    cap_drop:
+      - ALL
+    security_opt:
+      - no-new-privileges:true
     environment:
       STALWART_URL: ${STALWART_URL:?set STALWART_URL in .env}
       APP_SECRET: ${APP_SECRET:?set APP_SECRET in .env (openssl rand -base64 48)}

nginx.example.conf

@@ -6,6 +6,31 @@ server {
 
     client_max_body_size 60m;
 
+    # Compression. The bundle is the bulk of first load -- about 933 KB
+    # uncompressed against 311 KB gzipped -- and nginx passes through anything
+    # the upstream already encoded rather than re-encoding it, so this is
+    # correct whether or not ihasmail compresses on its own.
+    #
+    # text/event-stream is deliberately absent from gzip_types: the push stream
+    # must not be compressed or buffered, which is also why proxy_buffering is
+    # off below.
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_comp_level 5;
+    gzip_min_length 1024;
+    # text/javascript is listed explicitly: ihasmail serves scripts with that
+    # type rather than application/javascript, so a conventional gzip_types
+    # list compresses the stylesheet and leaves the largest asset alone.
+    gzip_types
+        application/javascript
+        application/json
+        application/manifest+json
+        image/svg+xml
+        text/css
+        text/javascript
+        text/plain;
+
     location / {
         proxy_pass http://127.0.0.1:8080;
         proxy_http_version 1.1;

package.json

@@ -10,7 +10,7 @@
     "web"
   ],
   "engines": {
-    "node": ">=20.10"
+    "node": ">=20.19"
   },
   "scripts": {
     "dev": "concurrently -n server,web -c blue,magenta \"npm run dev -w server\" \"npm run dev -w web\"",
@@ -23,11 +23,12 @@
     "dev:mock": "concurrently -n mock,server,web -c yellow,blue,magenta \"npm run mock -w server\" \"STALWART_URL=http://127.0.0.1:8788 npm run dev -w server\" \"npm run dev -w web\"",
     "dev:mock:no-future-release": "concurrently -n mock,server,web -c yellow,blue,magenta \"npm run mock:no-future-release -w server\" \"STALWART_URL=http://127.0.0.1:8788 npm run dev -w server\" \"npm run dev -w web\"",
     "i18n:coverage": "node scripts/i18n-coverage.mjs",
-    "i18n:check": "node scripts/i18n-catalog-check.mjs && node scripts/i18n-literals.mjs",
+    "i18n:check": "node scripts/i18n-catalog-check.mjs --check && node scripts/i18n-literals.mjs --check",
     "dev:mock:no-keyword-sort": "concurrently -n mock,server,web -c yellow,blue,magenta \"npm run mock:no-keyword-sort -w server\" \"STALWART_URL=http://127.0.0.1:8788 npm run dev -w server\" \"npm run dev -w web\""
   },
   "devDependencies": {
-    "concurrently": "^9.1.2",
-    "typescript": "^5.7.3"
+    "concurrently": "^10.0.5",
+    "typescript": "^7.0.2",
+    "typescript-ast": "npm:typescript@^5.9.3"
   }
 }

scripts/basePath.mjs

@@ -59,7 +59,7 @@ export function baseUrlOf(basePath) {
  *
  * The comparison is deliberately not `startsWith(base)`: that would let
  * `/mailbox` in under a `/mail` mount and serve it the app shell, which is
- * both wrong and a small open door for a neighbouring site on the same host.
+ * both wrong and a small open door for a neighboring site on the same host.
  */
 export function stripBasePath(basePath, pathname) {
   const base = normalizeBasePath(basePath);

scripts/build-palettes.py

@@ -2,15 +2,15 @@
 """
 Generate the palette CSS blocks in web/src/styles/app.css.
 
-Every colour here comes from the palette's own project (all MIT); the values
+Every color here comes from the palette's own project (all MIT); the values
 are recorded in .palette-sources/palettes-upstream.md. What this script adds is
 the *derivation*: ihasmail needs thirty-odd tokens and these projects publish
 between twelve and twenty, so the tiers in between are computed rather than
-guessed, and every text colour is then checked against the surface it sits on.
+guessed, and every text color is then checked against the surface it sits on.
 
 The check is the reason this is a script and not a hand-written block. ihasmail
 claims WCAG AA, and several of these palettes do not meet it as published --
-Dracula's comment grey on its own background is about 3.0:1, well under the 4.5
+Dracula's comment gray on its own background is about 3.0:1, well under the 4.5
 that normal text needs. Lifting those tiers by eye is how a claim quietly stops
 being true; here it is arithmetic, and the script fails loudly if a token it
 emitted would not pass.
@@ -30,7 +30,7 @@ BEGIN = "/* === generated palettes: begin === */"
 END = "/* === generated palettes: end === */"
 
 
-# ---------------------------------------------------------------- colour maths
+# ---------------------------------------------------------------- color maths
 
 def parse(hex_: str) -> tuple[float, float, float]:
     h = hex_.lstrip("#")
@@ -66,18 +66,18 @@ def rgba(hex_: str, alpha: float) -> str:
     return f"rgba({r}, {g}, {b}, {alpha})"
 
 
-def toward_contrast(colour: str, bg: str, target: float, dark_ui: bool) -> str:
-    """Nudge `colour` away from `bg` until it clears `target`.
+def toward_contrast(color: str, bg: str, target: float, dark_ui: bool) -> str:
+    """Nudge `color` away from `bg` until it clears `target`.
 
-    Towards white on a dark background and towards black on a light one, so a
-    lifted tier keeps its hue instead of washing out to grey.
+    Toward white on a dark background and toward black on a light one, so a
+    lifted tier keeps its hue instead of washing out to gray.
     """
-    if contrast(colour, bg) >= target:
-        return colour
+    if contrast(color, bg) >= target:
+        return color
     anchor = "#ffffff" if dark_ui else "#000000"
-    best = colour
+    best = color
     for i in range(1, 101):
-        candidate = mix(colour, anchor, i / 100)
+        candidate = mix(color, anchor, i / 100)
         best = candidate
         if contrast(candidate, bg) >= target:
             return candidate
@@ -90,7 +90,7 @@ def toward_contrast(colour: str, bg: str, target: float, dark_ui: bool) -> str:
 
 # ihasmail's own palette has a hand-written dark block further up the file --
 # it is the identity this project is painted in, and regenerating it would
-# quietly move colours nobody asked to move. Only its light half is derived
+# quietly move colors nobody asked to move. Only its light half is derived
 # here, which is why it appears in LIGHT_ONLY.
 LIGHT_ONLY = {"ihasmail"}
 
@@ -163,6 +163,90 @@ SOURCES = {
             q1="#006c86", q2="#385f0d", q3="#65359d",
         ),
     },
+    "catppuccin": {
+        "dark": dict(  # Mocha
+            bg="#1e1e2e", elev="#313244", sunken="#181825", line="#45475a",
+            fg="#cdd6f4", muted="#a6adc8", accent="#cba6f7", link="#89b4fa",
+            danger="#f38ba8", warn="#fab387", success="#a6e3a1", star="#f9e2af",
+            q1="#89b4fa", q2="#a6e3a1", q3="#f5c2e7",
+        ),
+        "light": dict(  # Latte
+            bg="#e6e9ef", elev="#eff1f5", sunken="#dce0e8", line="#ccd0da",
+            fg="#4c4f69", muted="#6c6f85", accent="#8839ef", link="#1e66f5",
+            danger="#d20f39", warn="#fe640b", success="#40a02b", star="#df8e1d",
+            q1="#1e66f5", q2="#40a02b", q3="#ea76cb",
+        ),
+    },
+    "solarized": {
+        "dark": dict(
+            bg="#002b36", elev="#073642", sunken="#001f28", line="#0d4552",
+            fg="#839496", muted="#586e75", accent="#268bd2", link="#2aa198",
+            danger="#dc322f", warn="#cb4b16", success="#859900", star="#b58900",
+            q1="#2aa198", q2="#859900", q3="#6c71c4",
+        ),
+        "light": dict(
+            bg="#fdf6e3", elev="#fffdf6", sunken="#eee8d5", line="#e6dfc8",
+            fg="#657b83", muted="#93a1a1", accent="#268bd2", link="#2aa198",
+            danger="#dc322f", warn="#cb4b16", success="#859900", star="#b58900",
+            q1="#2aa198", q2="#859900", q3="#6c71c4",
+        ),
+    },
+    "ayu": {
+        "dark": dict(
+            bg="#0d1017", elev="#10141c", sunken="#070a0f", line="#1b1f29",
+            fg="#bfbdb6", muted="#5a6378", accent="#e6b450", link="#59c2ff",
+            danger="#f07178", warn="#ff8f40", success="#aad94c", star="#ffb454",
+            q1="#39bae6", q2="#aad94c", q3="#d2a6ff",
+        ),
+        "light": dict(
+            bg="#f8f9fa", elev="#fcfcfc", sunken="#ebeef0", line="#dfe2e5",
+            fg="#5c6166", muted="#828e9f", accent="#f29718", link="#22a4e6",
+            danger="#f07171", warn="#fa8532", success="#86b300", star="#eba400",
+            q1="#55b4d4", q2="#86b300", q3="#a37acc",
+        ),
+    },
+    "kanagawa": {
+        "dark": dict(  # Wave
+            bg="#1f1f28", elev="#2a2a37", sunken="#16161d", line="#363646",
+            fg="#dcd7ba", muted="#727169", accent="#7e9cd8", link="#7fb4ca",
+            danger="#e82424", warn="#ff9e3b", success="#98bb6c", star="#e6c384",
+            q1="#7fb4ca", q2="#98bb6c", q3="#d27e99",
+        ),
+        "light": dict(  # Lotus
+            bg="#e5ddb0", elev="#f2ecbc", sunken="#dcd5ac", line="#d5cea3",
+            fg="#545464", muted="#716e61", accent="#624c83", link="#4d699b",
+            danger="#c84053", warn="#cc6d00", success="#6f894e", star="#77713f",
+            q1="#4d699b", q2="#6f894e", q3="#b35b79",
+        ),
+    },
+    "everforest": {
+        "dark": dict(  # medium
+            bg="#2d353b", elev="#343f44", sunken="#232a2e", line="#475258",
+            fg="#d3c6aa", muted="#859289", accent="#a7c080", link="#7fbbb3",
+            danger="#e67e80", warn="#e69875", success="#a7c080", star="#dbbc7f",
+            q1="#7fbbb3", q2="#a7c080", q3="#d699b6",
+        ),
+        "light": dict(  # medium
+            bg="#efebd4", elev="#fdf6e3", sunken="#e6e2cc", line="#bdc3af",
+            fg="#5c6a72", muted="#939f91", accent="#8da101", link="#3a94c5",
+            danger="#f85552", warn="#f57d26", success="#8da101", star="#dfa000",
+            q1="#3a94c5", q2="#8da101", q3="#df69ba",
+        ),
+    },
+    "primer": {
+        "dark": dict(
+            bg="#0d1117", elev="#151b23", sunken="#010409", line="#3d444d",
+            fg="#f0f6fc", muted="#9198a1", accent="#58a6ff", link="#79c0ff",
+            danger="#ff7b72", warn="#e3b341", success="#3fb950", star="#d29922",
+            q1="#79c0ff", q2="#56d364", q3="#d2a8ff",
+        ),
+        "light": dict(
+            bg="#f6f8fa", elev="#ffffff", sunken="#eff2f5", line="#d1d9e0",
+            fg="#25292e", muted="#59636e", accent="#0969da", link="#0550ae",
+            danger="#cf222e", warn="#9a6700", success="#1a7f37", star="#bf8700",
+            q1="#0550ae", q2="#116329", q3="#8250df",
+        ),
+    },
 }
 
 # What each token has to clear, and against which surface. Normal text is 4.5;
@@ -177,12 +261,21 @@ def build(pid: str, mode: str, src: dict[str, str]) -> tuple[dict[str, str], lis
     bg, fg = src["bg"], src["fg"]
     notes: list[str] = []
 
-    def lift(name: str, colour: str, target: float) -> str:
-        out = toward_contrast(colour, bg, target, dark)
-        if out != colour:
-            notes.append(f"{name} {colour} -> {out} ({contrast(colour, bg):.2f} -> {contrast(out, bg):.2f})")
+    def lift(name: str, color: str, target: float) -> str:
+        out = toward_contrast(color, bg, target, dark)
+        if out != color:
+            notes.append(f"{name} {color} -> {out} ({contrast(color, bg):.2f} -> {contrast(out, bg):.2f})")
         return out
 
+    # Body text is lifted like every other text tone rather than exempted.
+    # Most of these palettes publish a body color around 4.5:1 -- their own
+    # target -- and ihasmail asks 7:1 of the text a reader looks at all day.
+    # Rejecting a palette over that would have cost five of the six added in
+    # 2026-09; nudging the published color along its own hue costs nothing a
+    # reader can name, and the shift is recorded in the header of the
+    # generated block like every other one.
+    fg = lift("fg", fg, TEXT_ON_BG["fg"])
+
     muted = lift("muted", src["muted"], TEXT_ON_BG["muted"])
     # Between muted and the background, but still readable: this is timestamps
     # and counts, which are small and still prose.
@@ -272,11 +365,11 @@ def main() -> int:
         "/*",
         " * Written by scripts/build-palettes.py -- edit the sources there, not here.",
         " *",
-        " * Every colour is from the palette's own project (all MIT); the published",
+        " * Every color is from the palette's own project (all MIT); the published",
         " * values are recorded in .palette-sources/palettes-upstream.md. The tiers",
-        " * between them are derived, and every text colour is checked against the",
+        " * between them are derived, and every text color is checked against the",
         " * surface it sits on: 4.5:1 for prose, 3:1 for borders and marks. Several",
-        " * of these palettes do not meet that as published -- Dracula's comment grey",
+        " * of these palettes do not meet that as published -- Dracula's comment gray",
         " * is about 3.0:1 on its own background -- so those tiers are lifted, which",
         " * is why this is arithmetic rather than a hand-written block.",
         " */",

scripts/i18n-catalog-check.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /*
- * Check a catalogue against the strings the code actually asks for.
+ * Check a catalog against the strings the code actually asks for.
  *
  * Two failures, and only one of them is visible without this.
  *
@@ -8,24 +8,70 @@
  * as an untranslated word on screen, which somebody will eventually notice.
  *
  * A *stale* key -- one whose English no longer exists, usually because it was
- * mistyped when the catalogue was written -- is silent. The translation sits
+ * mistyped when the catalog was written -- is silent. The translation sits
  * in the file looking correct, is never looked up, and the app renders English
- * for ever. Nothing warns, because a catalogue is only ever read by key.
+ * for ever. Nothing warns, because a catalog is only ever read by key.
  */
-import ts from "typescript";
+/*
+ * The parser, not the compiler.
+ *
+ * TypeScript 7 is the native port: its package ships a `tsc` shim over a Go
+ * binary and nothing else, so `typescript` now exports `version` and
+ * `versionMajorMinor` and no compiler API at all. Every `ts.createSourceFile`
+ * in this directory started throwing "Cannot read properties of undefined
+ * (reading 'Latest')" the day the bump landed, and nothing noticed, because no
+ * workflow runs these.
+ *
+ * `typescript-ast` is an npm alias for the last TypeScript that carries the JS
+ * API (see package.json). It parses; `typescript` still type-checks and builds.
+ * Two entries, two jobs -- not a version someone forgot to remove.
+ */
+import ts from "typescript-ast";
 import { readFileSync, globSync } from "node:fs";
 
+/*
+ * Two sets, because there are two questions and they need different nets.
+ *
+ * `wanted` is what a catalog *owes*: the strings that actually reach t(),
+ * tc() or plural(). Coverage is measured against it, so it has to stay strict
+ * -- widening it would count every CSS class and JMAP method name as an
+ * untranslated string.
+ *
+ * `seen` is every string literal in the source, and answers only "is this
+ * catalog key still written down anywhere". Stale detection needs the wide
+ * net: a key reaches t() as a variable often enough that a strict set reports
+ * mostly false alarms.
+ */
 const wanted = new Set();
+const seen = new Set();
 for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("__tests__") && !f.includes("/locales/"))) {
   const src = ts.createSourceFile(file, readFileSync(file, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
   const visit = (n) => {
     /*
-     * Labels held in a constant and translated where they render -- t(s.label)
-     * -- reach t() as a variable, so there is no literal for this to find and
-     * every one of them looked "stale". They are collected from the constants
-     * instead: a `label:` property, or a value in an object of them. Without
-     * this the stale check cried wolf 33 times and would have been switched
-     * off, which is the only outcome worse than not having it.
+     * Anything held in a constant and translated where it renders -- t(s.label),
+     * t(b.description), t(group) -- reaches t() as a variable, so there is no
+     * literal at the call site and every one of them looked "stale".
+     *
+     * This used to chase the shapes one at a time: a `label:` property, then an
+     * object named *_LABELS. It still cried wolf, because the shapes kept
+     * coming -- `description:` and `group:` on keyboard bindings, the calendar's
+     * view names, the read-receipt refusals, the palette names. 41 reported,
+     * 10 of them real. A report that is three-quarters false is one nobody acts
+     * on, which is how these sat unread long enough to be worth a commit of
+     * their own.
+     *
+     * So: any string literal anywhere in the source counts as a use. That
+     * under-reports -- a literal that exists but is never passed to t() will not
+     * be flagged -- and that is the right way round. A missed stale key costs a
+     * line of dead translation; a false one costs the credibility of the whole
+     * check, and then every real finding with it.
+     */
+    if (ts.isStringLiteral(n) || ts.isNoSubstitutionTemplateLiteral(n)) seen.add(n.text);
+    if (ts.isJsxText(n)) { const text = n.text.trim(); if (text) seen.add(text); }
+    /*
+     * A `label:` in a constant is still a string somebody has to translate --
+     * it reaches t() one render later -- so it stays part of what a catalog
+     * owes, and out of coverage it would flatter the number.
      */
     if (ts.isPropertyAssignment(n) && n.name.getText(src) === "label" && ts.isStringLiteral(n.initializer)) wanted.add(n.initializer.text);
     if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name) && /_LABELS?$/.test(n.name.text)) {
@@ -35,15 +81,16 @@ for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("
     if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
       const fn = n.expression.text, a0 = n.arguments[0];
       if ((fn === "t" || fn === "translate" || fn === "tNode") && a0 && ts.isStringLiteral(a0)) wanted.add(a0.text);
-      // tc(context, source) keys the catalogue on both, joined by the same
+      // tc(context, source) keys the catalog on both, joined by the same
       // control character tc() uses. Without this the contextual entries all
       // looked stale, which is the checker's own false alarm rather than a
-      // catalogue problem.
+      // catalog problem.
       if (fn === "tc" && a0 && ts.isStringLiteral(a0) && n.arguments[1] && ts.isStringLiteral(n.arguments[1])) {
         // Only the contextual key is required. The plain one is tc()'s
         // fallback, not a second obligation -- asking for both would report
         // work that does not exist.
         wanted.add(`${a0.text}\u0004${n.arguments[1].text}`);
+        seen.add(`${a0.text}\u0004${n.arguments[1].text}`);
       }
       if (fn === "plural" && n.arguments[1] && ts.isObjectLiteralExpression(n.arguments[1])) {
         for (const p of n.arguments[1].properties) {
@@ -57,8 +104,8 @@ for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("
 }
 
 /*
- * A catalogue and a picker entry are two halves of one thing, and either half
- * alone is dead weight. A catalogue with no entry in UI_LANGUAGES never
+ * A catalog and a picker entry are two halves of one thing, and either half
+ * alone is dead weight. A catalog with no entry in UI_LANGUAGES never
  * reaches a reader -- it builds, it passes every test, and the language simply
  * is not offered. That happened to Dutch: the entry was added by a text
  * replacement anchored on a line that did not exist on that branch, so it was
@@ -66,17 +113,17 @@ for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("
  */
 const languagesSrc = readFileSync("web/src/lib/languages.ts", "utf8");
 const registered = new Set([...languagesSrc.matchAll(/tag:\s*"([\w-]+)"/g)].map((m) => m[1]));
-const catalogues = new Set(globSync("web/src/locales/*.ts").map((f) => f.split("/").pop().replace(".ts", "")));
+const catalogs = new Set(globSync("web/src/locales/*.ts").map((f) => f.split("/").pop().replace(".ts", "")));
 
 let failed = false;
-for (const tag of catalogues) {
+for (const tag of catalogs) {
   if (!registered.has(tag)) {
     failed = true;
     console.log(`!! ${tag}.ts exists but is not in UI_LANGUAGES — the language is never offered\n`);
   }
 }
 for (const tag of registered) {
-  if (tag !== "en" && !catalogues.has(tag)) {
+  if (tag !== "en" && !catalogs.has(tag)) {
     failed = true;
     console.log(`!! UI_LANGUAGES offers ${tag} but there is no ${tag}.ts — it would fall back to English\n`);
   }
@@ -91,15 +138,14 @@ for (const file of globSync("web/src/locales/*.ts")) {
     ts.forEachChild(n, visit);
   };
   visit(src);
-  const stale = [...have].filter((k) => !wanted.has(k) && !["one", "other", "few", "many", "zero", "two"].includes(k));
+  const stale = [...have].filter((k) => !seen.has(k) && !["one", "other", "few", "many", "zero", "two"].includes(k));
   const missing = [...wanted].filter((k) => !have.has(k));
   const pct = Math.round(((wanted.size - missing.length) / wanted.size) * 100);
   console.log(`${tag}: ${wanted.size - missing.length}/${wanted.size} translated (${pct}%), ${missing.length} falling back to English`);
   if (stale.length) {
     failed = true;
     console.log(`\n  ${stale.length} STALE key(s) — translated but never looked up, so they do nothing:`);
-    for (const k of stale.slice(0, 25)) console.log(`    ${JSON.stringify(k)}`);
-    if (stale.length > 25) console.log(`    …and ${stale.length - 25} more`);
+    for (const k of stale) console.log(`    ${JSON.stringify(k)}`);
   }
   if (process.argv.includes("--missing")) {
     console.log(`\n  missing:`);

scripts/i18n-coverage.mjs

@@ -11,7 +11,21 @@
  * exits non-zero only with --check, so CI can be told to fail on regressions
  * later, once the number is low enough for that to mean something.
  */
-import ts from "typescript";
+/*
+ * The parser, not the compiler.
+ *
+ * TypeScript 7 is the native port: its package ships a `tsc` shim over a Go
+ * binary and nothing else, so `typescript` now exports `version` and
+ * `versionMajorMinor` and no compiler API at all. Every `ts.createSourceFile`
+ * in this directory started throwing "Cannot read properties of undefined
+ * (reading 'Latest')" the day the bump landed, and nothing noticed, because no
+ * workflow runs these.
+ *
+ * `typescript-ast` is an npm alias for the last TypeScript that carries the JS
+ * API (see package.json). It parses; `typescript` still type-checks and builds.
+ * Two entries, two jobs -- not a version someone forgot to remove.
+ */
+import ts from "typescript-ast";
 import { readFileSync, globSync } from "node:fs";
 
 /** Attributes a person reads. `className` and `key` are not among them. */

scripts/i18n-extract.mjs

@@ -12,7 +12,21 @@
  *   node scripts/i18n-extract.mjs <file...>   rewrite in place
  *   node scripts/i18n-extract.mjs --dry <file...>
  */
-import ts from "typescript";
+/*
+ * The parser, not the compiler.
+ *
+ * TypeScript 7 is the native port: its package ships a `tsc` shim over a Go
+ * binary and nothing else, so `typescript` now exports `version` and
+ * `versionMajorMinor` and no compiler API at all. Every `ts.createSourceFile`
+ * in this directory started throwing "Cannot read properties of undefined
+ * (reading 'Latest')" the day the bump landed, and nothing noticed, because no
+ * workflow runs these.
+ *
+ * `typescript-ast` is an npm alias for the last TypeScript that carries the JS
+ * API (see package.json). It parses; `typescript` still type-checks and builds.
+ * Two entries, two jobs -- not a version someone forgot to remove.
+ */
+import ts from "typescript-ast";
 import { readFileSync, writeFileSync } from "node:fs";
 
 const ATTRS = new Set(["title", "aria-label", "placeholder", "alt", "label", "hint", "confirmLabel", "description"]);

scripts/i18n-literals.mjs

@@ -11,14 +11,28 @@
  * A string reaches a reader translated if either is true:
  *
  *   1. it is wrapped where it is written -- t(), tc(), tNode(), plural()
- *   2. it is a catalogue key, translated somewhere else
+ *   2. it is a catalog key, translated somewhere else
  *
  * The second case is a real convention here, not a loophole: constant tables
  * hold English and the render site calls `t(s.label)`. What this refuses is a
- * string that is neither -- one no catalogue has a key for, which therefore
+ * string that is neither -- one no catalog has a key for, which therefore
  * cannot be translated at all, however many languages ship.
  */
-import ts from "typescript";
+/*
+ * The parser, not the compiler.
+ *
+ * TypeScript 7 is the native port: its package ships a `tsc` shim over a Go
+ * binary and nothing else, so `typescript` now exports `version` and
+ * `versionMajorMinor` and no compiler API at all. Every `ts.createSourceFile`
+ * in this directory started throwing "Cannot read properties of undefined
+ * (reading 'Latest')" the day the bump landed, and nothing noticed, because no
+ * workflow runs these.
+ *
+ * `typescript-ast` is an npm alias for the last TypeScript that carries the JS
+ * API (see package.json). It parses; `typescript` still type-checks and builds.
+ * Two entries, two jobs -- not a version someone forgot to remove.
+ */
+import ts from "typescript-ast";
 import { readFileSync, globSync } from "node:fs";
 
 /* Where a string literal in this position is shown to somebody. */
@@ -26,7 +40,13 @@ const UI_PROPS = new Set([
   "title", "message", "label", "confirmLabel", "cancelLabel", "ariaLabel",
   "placeholder", "hint", "occurrenceLabel", "occurrenceHint", "seriesLabel", "seriesHint",
 ]);
-const UI_ATTRS = new Set(["title", "aria-label", "placeholder", "alt"]);
+/*
+ * A JSX attribute is shown whether it lands on an element or on a component:
+ * `<MenuItem label="Collapse all">` renders its label as given, exactly as
+ * `<button title="…">` does. Checking only the DOM spellings let every
+ * component prop through, so the props are checked here too.
+ */
+const UI_ATTRS = new Set(["title", "aria-label", "placeholder", "alt", ...UI_PROPS]);
 const TOASTS = new Set(["error", "success", "info", "show"]);
 const WRAPPERS = ["t", "tc", "tNode", "translate", "plural"];
 const EQUALITY = new Set([
@@ -36,7 +56,7 @@ const EQUALITY = new Set([
 
 /*
  * Product names, example addresses and URL scaffolding. These reach t() and
- * are deliberately absent from every catalogue -- translating "ihasmail" or
+ * are deliberately absent from every catalog -- translating "ihasmail" or
  * "[email protected]" would be a bug, not a feature -- so they would otherwise
  * be reported for ever.
  */
@@ -60,8 +80,15 @@ const keys = new Set();
 const found = [];
 for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("__tests__") && !f.includes("/locales/"))) {
   const src = ts.createSourceFile(file, readFileSync(file, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-  const report = (node, text) => {
-    if (!looksLikeUi(text) || keys.has(text) || NEVER_TRANSLATED.has(text)) return;
+  /*
+   * `strict` withdraws the catalog-key exemption. It exists for English held
+   * in a constant and translated where it renders; a literal written straight
+   * into a JSX attribute has no later render site to be translated at -- no
+   * component here passes its props through t() -- so being a key only means
+   * a translation exists that this string never reaches.
+   */
+  const report = (node, text, strict = false) => {
+    if (!looksLikeUi(text) || (!strict && keys.has(text)) || NEVER_TRANSLATED.has(text)) return;
     const { line } = src.getLineAndCharacterOfPosition(node.getStart(src));
     found.push({ file, line: line + 1, text });
   };
@@ -89,14 +116,33 @@ for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("
   mark(src);
   const wrapped = exempt;
 
+  /*
+   * English assembled around values: `aria-label={`Remove ${email}`}`.
+   *
+   * The literal cannot be a catalog key as written, so whether it is a key is
+   * not asked. Neither is looksLikeUi, which reads the opening of a sentence:
+   * `${name} — shared by ${owner}` opens with a value and its words come after.
+   * Any run of letters between the values counts. The only template literals
+   * that reach a UI attribute and are not prose are pure punctuation around
+   * values, like `${name} (${size})`, and those have none.
+   */
+  const reportTemplate = (x) => {
+    const parts = ts.isNoSubstitutionTemplateLiteral(x) ? [x.text] : [x.head.text, ...x.templateSpans.map((s) => s.literal.text)];
+    if (!/[A-Za-z]{2,}/.test(parts.join(""))) return;
+    const { line } = src.getLineAndCharacterOfPosition(x.getStart(src));
+    found.push({ file, line: line + 1, text: parts.join("{}") });
+  };
+  const isTemplate = (x) => ts.isTemplateExpression(x) || ts.isNoSubstitutionTemplateLiteral(x);
+
   const visit = (n) => {
-    if (ts.isPropertyAssignment(n) && ts.isStringLiteral(n.initializer) && !wrapped.has(n.initializer)
-        && UI_PROPS.has(n.name.getText(src).replace(/['"]/g, ""))) {
-      report(n.initializer, n.initializer.text);
+    if (ts.isPropertyAssignment(n) && UI_PROPS.has(n.name.getText(src).replace(/['"]/g, ""))) {
+      if (ts.isStringLiteral(n.initializer) && !wrapped.has(n.initializer)) report(n.initializer, n.initializer.text);
+      if (isTemplate(n.initializer)) reportTemplate(n.initializer);
     }
     if (ts.isJsxAttribute(n) && n.initializer && UI_ATTRS.has(n.name.getText(src))) {
       const walk = (x) => {
-        if (ts.isStringLiteral(x) && !wrapped.has(x)) report(x, x.text);
+        if (isTemplate(x)) reportTemplate(x);
+        if (ts.isStringLiteral(x) && !wrapped.has(x)) report(x, x.text, true);
         if (!ts.isCallExpression(x)) ts.forEachChild(x, walk);
       };
       walk(n.initializer);
@@ -105,7 +151,7 @@ for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("
         && n.expression.expression.getText(src) === "toast" && TOASTS.has(n.expression.name.text)) {
       const a0 = n.arguments[0];
       if (a0 && ts.isStringLiteral(a0) && !wrapped.has(a0)) report(a0, a0.text);
-      /* A template literal cannot be a catalogue key at all, so it is always a find. */
+      /* A template literal cannot be a catalog key at all, so it is always a find. */
       if (a0 && ts.isTemplateExpression(a0)) report(a0, a0.head.text + "{}");
     }
     ts.forEachChild(n, visit);
@@ -114,11 +160,11 @@ for (const file of globSync("web/src/**/*.{ts,tsx}").filter((f) => !f.includes("
 }
 
 if (!found.length) {
-  console.log("i18n literals: none -- every user-visible string is wrapped or has a catalogue key");
+  console.log("i18n literals: none -- every user-visible string is wrapped or has a catalog key");
   process.exit(0);
 }
-console.log(`${found.length} user-visible string(s) the extractor cannot see and no catalogue can translate:\n`);
+console.log(`${found.length} user-visible string(s) the extractor cannot see and no catalog can translate:\n`);
 for (const f of found) console.log(`  ${f.file}:${f.line}\n    ${JSON.stringify(f.text)}`);
 console.log("\nWrap them in t() / plural(), or -- for a label held in a constant and");
-console.log("translated where it renders -- make sure the English is a catalogue key.");
+console.log("translated where it renders -- make sure the English is a catalog key.");
 process.exit(process.argv.includes("--check") ? 1 : 0);

scripts/i18n-strings.mjs

@@ -1,15 +1,29 @@
 #!/usr/bin/env node
 /*
- * Every source string a catalogue needs, straight out of the calls.
+ * Every source string a catalog needs, straight out of the calls.
  *
- * The English text is the key, so the catalogue's keys are not a list somebody
+ * The English text is the key, so the catalog's keys are not a list somebody
  * maintains -- they are whatever t(), tNode() and plural() are actually asked
- * for. Reading them from the code means a catalogue can never drift out of
+ * for. Reading them from the code means a catalog can never drift out of
  * step with the app in the one direction that matters: a key that no longer
  * exists is dead weight, but a call with no key is an untranslated string
  * nobody noticed.
  */
-import ts from "typescript";
+/*
+ * The parser, not the compiler.
+ *
+ * TypeScript 7 is the native port: its package ships a `tsc` shim over a Go
+ * binary and nothing else, so `typescript` now exports `version` and
+ * `versionMajorMinor` and no compiler API at all. Every `ts.createSourceFile`
+ * in this directory started throwing "Cannot read properties of undefined
+ * (reading 'Latest')" the day the bump landed, and nothing noticed, because no
+ * workflow runs these.
+ *
+ * `typescript-ast` is an npm alias for the last TypeScript that carries the JS
+ * API (see package.json). It parses; `typescript` still type-checks and builds.
+ * Two entries, two jobs -- not a version someone forgot to remove.
+ */
+import ts from "typescript-ast";
 import { readFileSync, globSync } from "node:fs";
 
 const strings = new Set();

scripts/precompress.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/*
+ * Write a Brotli and a gzip copy beside every compressible file in a web build.
+ *
+ * The server used to gzip the bundle again on every request that asked for it,
+ * at a level chosen for speed. These are made once, at the level chosen for
+ * size, and `server/src/static.ts` hands one out when the browser accepts it.
+ * Brotli at 11 is about 15% smaller than gzip for this bundle, and too slow to
+ * do per request, which is why it was never offered.
+ *
+ *   node scripts/precompress.mjs web/dist
+ */
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, extname } from "node:path";
+import { brotliCompressSync, constants, gzipSync } from "node:zlib";
+
+const COMPRESSIBLE = new Set([".js", ".mjs", ".css", ".html", ".svg", ".json", ".webmanifest", ".txt", ".wasm"]);
+// Below this, the encoding costs more than it saves.
+const MIN_BYTES = 1024;
+
+function* files(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) yield* files(p);
+    else yield p;
+  }
+}
+
+const root = process.argv[2];
+if (!root) {
+  console.error("usage: precompress.mjs <dir>");
+  process.exit(2);
+}
+let count = 0;
+let before = 0;
+let after = 0;
+for (const p of files(root)) {
+  if (!COMPRESSIBLE.has(extname(p)) || statSync(p).size < MIN_BYTES) continue;
+  const data = readFileSync(p);
+  const br = brotliCompressSync(data, { params: { [constants.BROTLI_PARAM_QUALITY]: 11, [constants.BROTLI_PARAM_SIZE_HINT]: data.length } });
+  writeFileSync(`${p}.br`, br);
+  writeFileSync(`${p}.gz`, gzipSync(data, { level: 9 }));
+  count++;
+  before += data.length;
+  after += br.length;
+}
+console.log(`precompressed ${count} files: ${(before / 1024).toFixed(0)} KB -> ${(after / 1024).toFixed(0)} KB brotli`);

scripts/screenshots.mjs

@@ -5,8 +5,8 @@
  * images already use rather than whatever a window happens to be.
  *
  *   npm run dev:mock                       # in another terminal
- *   node docs/screenshots.mjs docs/screenshots
- *   node docs/screenshots-light.mjs docs/screenshots
+ *   node scripts/screenshots.mjs screenshots
+ *   node scripts/screenshots-light.mjs screenshots
  *
  * Restart the mock before a run. The filters shot creates rules, so a second
  * run against the same mock shows them twice.
@@ -30,7 +30,7 @@
  *   flip --bg to #f6f8fa. The compositor simply does not repaint everything a
  *   CSS-variable change touches while metrics are overridden. Launching Chrome
  *   at --window-size and never calling setDeviceMetricsOverride renders it
- *   correctly, which is what docs/screenshots-light.mjs does.
+ *   correctly, which is what scripts/screenshots-light.mjs does.
  *
  * assertTheme() stays either way: without it this script wrote a dark
  * screenshot under a light caption and reported success, and that is how the
@@ -128,7 +128,7 @@ const waitFor = async (jsExpr, what, ms = 15000) => {
  * capture — twice, silently, producing a "light" screenshot of the dark theme.
  * A MutationObserver puts it back faster than anything can take it away.
  *
- * The check is the rendered background colour: the attribute is what lied.
+ * The check is the rendered background color: the attribute is what lied.
  */
 const themeTest = (want) => want === "light"
   ? "parseInt(getComputedStyle(document.body).backgroundColor.match(/\\d+/)[0], 10) > 200"
@@ -226,7 +226,7 @@ try {
   await evaluate(`(() => { const c = [...document.querySelectorAll('button')].find(b => /close|discard/i.test(b.getAttribute('aria-label')||'')); if (c) c.click(); })()`);
   await sleep(800);
 
-  // (inbox-light is captured by docs/screenshots-light.mjs -- see the header)
+  // (inbox-light is captured by scripts/screenshots-light.mjs -- see the header)
 
 
   // --- calendar ---

server/package.json

@@ -16,12 +16,12 @@
     "mock:no-keyword-sort": "MOCK_NO_KEYWORD_SORT=1 tsx src/mock/index.ts"
   },
   "dependencies": {
-    "@hono/node-server": "^1.13.8",
-    "hono": "^4.7.4"
+    "@hono/node-server": "^2.1.1",
+    "hono": "^4.13.7"
   },
   "devDependencies": {
-    "@types/node": "^22.13.10",
-    "tsx": "^4.19.3",
-    "typescript": "^5.7.3"
+    "@types/node": "^26.5.1",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2"
   }
 }

server/src/account.test.ts

@@ -69,7 +69,7 @@ test("the registry reports an account with nothing set up yet", async () => {
 });
 
 test("app passwords are created, listed once with their secret, and revoked", async () => {
-  const created = await post("/api/account/app-passwords", { description: "Thunderbird" });
+  const created = await post("/api/account/app-passwords", { description: "Thunderbird", current: "demo-password" });
   assert.equal(created.status, 200);
   assert.match(created.body.secret, /^\$app\$/, "the server's generated secret is returned");
   assert.ok(created.body.id);
@@ -84,8 +84,86 @@ test("app passwords are created, listed once with their secret, and revoked", as
   assert.deepEqual((await call("/api/account/security")).body.appPasswords, []);
 });
 
+test("an app password needs the account password", async () => {
+  const missing = await post("/api/account/app-passwords", { description: "Stolen" });
+  assert.equal(missing.status, 400);
+  assert.equal(missing.body.error, "missing_fields");
+  const wrong = await post("/api/account/app-passwords", { description: "Stolen", current: "not-my-password" });
+  assert.equal(wrong.status, 403);
+  assert.equal(wrong.body.error, "invalid_credentials");
+  assert.deepEqual((await call("/api/account/security")).body.appPasswords, [], "nothing was created");
+});
+
+test("a checked session cannot mint one through the JMAP proxy instead", async () => {
+  // Signed in without "my own device", so the proxy reads every request.
+  const res = await call("/api/jmap", {
+    method: "POST",
+    body: JSON.stringify({ using: ["urn:ietf:params:jmap:core"], methodCalls: [["x:AppPassword/set", { create: { n: { description: "Stolen" } } }, "0"]] }),
+  });
+  assert.equal(res.status, 403);
+  assert.deepEqual((await call("/api/account/security")).body.appPasswords, []);
+});
+
+test("attachments are kept out of the disk cache of a device that is not the person's own", async () => {
+  const up = await app.request("/api/upload/a1", { method: "POST", headers: { "x-requested-with": "ihasmail", "content-type": "text/plain", cookie }, body: "hello" });
+  assert.equal(up.status, 200);
+  const { blobId } = (await up.json()) as { blobId: string };
+  const name = encodeURIComponent("Invoice_\u202Efdp.exe");
+  const res = await app.request(`/api/blob/a1/${blobId}/${name}?accept=text/plain`, { headers: { cookie } });
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("cache-control"), "no-store");
+  assert.equal(res.headers.get("content-disposition"), "attachment; filename*=UTF-8''Invoice_fdp.exe", "no direction override in the saved name");
+  await res.arrayBuffer();
+});
+
+test("a download passes a byte range through, for viewers that read in pieces", async () => {
+  const up = await app.request("/api/upload/a1", { method: "POST", headers: { "x-requested-with": "ihasmail", "content-type": "text/plain", cookie }, body: "hello world" });
+  const { blobId } = (await up.json()) as { blobId: string };
+  const url = `/api/blob/a1/${blobId}/greeting.txt?accept=text/plain`;
+  const part = await app.request(url, { headers: { cookie, range: "bytes=0-4" } });
+  assert.equal(part.status, 206);
+  assert.equal(part.headers.get("content-range"), "bytes 0-4/11");
+  assert.equal(part.headers.get("accept-ranges"), "bytes");
+  assert.equal(await part.text(), "hello");
+  const whole = await app.request(url, { headers: { cookie } });
+  assert.equal(whole.status, 200);
+  assert.equal(whole.headers.get("accept-ranges"), "bytes", "advertised even though Stalwart does not, so a PDF viewer asks");
+  assert.equal(await whole.text(), "hello world");
+  // Past the end, Stalwart sends the whole file rather than a 416.
+  const beyond = await app.request(url, { headers: { cookie, range: "bytes=50-60" } });
+  assert.equal(beyond.status, 200);
+  assert.equal(await beyond.text(), "hello world");
+  // Anything that is not a plain byte range is not passed on.
+  const odd = await app.request(url, { headers: { cookie, range: "items=0-4" } });
+  assert.equal(odd.status, 200);
+  await odd.arrayBuffer();
+});
+
+test("upstream caches let go of sessions that have aged out", async () => {
+  const { sweepUpstreamCaches, upstreamCacheSizes } = await import("./upstream.js");
+  // Signed in above, so this session has an entry.
+  assert.ok(upstreamCacheSizes().sessions >= 1);
+  sweepUpstreamCaches(Date.now() + 60 * 60_000);
+  assert.deepEqual(upstreamCacheSizes(), { sessions: 0, info: 0 });
+});
+
+test("the mock refuses a contact photo given as a blob id, as Stalwart does", async () => {
+  const jmap = (methodCalls: unknown[]) => call("/api/jmap", { method: "POST", body: JSON.stringify({ using: ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:contacts"], methodCalls }) });
+  const card = (media: unknown) => ({ "@type": "Card", version: "1.0", kind: "individual", name: { full: "Probe" }, addressBookIds: { ab1: true }, media });
+  const res = await jmap([["ContactCard/set", { accountId: "a1", create: {
+    blob: card({ p: { "@type": "Media", kind: "photo", blobId: "b1", mediaType: "image/jpeg" } }),
+    inline: card({ p: { "@type": "Media", kind: "photo", uri: "data:image/jpeg;base64,AA", mediaType: "image/jpeg" } }),
+  } }, "s"]]);
+  assert.equal(res.status, 200);
+  const set = res.body.methodResponses[0][1];
+  assert.equal(set.notCreated.blob.description, "blobIds in media is not supported.");
+  assert.deepEqual(set.notCreated.blob.properties, ["media"]);
+  assert.ok(set.created.inline.id, "a data URI is accepted");
+  await jmap([["ContactCard/set", { accountId: "a1", destroy: [set.created.inline.id] }, "d"]]);
+});
+
 test("an app password needs a name", async () => {
-  const res = await post("/api/account/app-passwords", { description: "   " });
+  const res = await post("/api/account/app-passwords", { description: "   ", current: "demo-password" });
   assert.equal(res.status, 400);
   assert.equal(res.body.error, "missing_fields");
 });
@@ -156,7 +234,7 @@ test("with 2FA on, a password change needs the current code too", async () => {
 test("2FA is switched off with the password and a current code", async () => {
   const state = await call("/api/account/security");
   assert.equal(state.body.otpEnabled, true);
-  // The enrolment secret is known only to the client, so disabling uses a code
+  // The enrollment secret is known only to the client, so disabling uses a code
   // from the authenticator - here, the one the mock stored.
   const stored = (mock as { account: { otpUrl: string | null } }).account.otpUrl;
   const params = parseOtpauthUrl(stored!);

server/src/account.ts

@@ -169,10 +169,10 @@ export async function revokeAppPassword(ctx: Ctx, id: string): Promise<void> {
 }
 
 /**
- * Start enrolment: mint a secret and hand back the URL to show as a QR code.
+ * Start enrollment: mint a secret and hand back the URL to show as a QR code.
  * Nothing is stored until the user proves they can produce a code from it.
  */
-export function beginOtpEnrolment(ctx: Ctx): { secret: string; url: string } {
+export function beginOtpEnrollment(ctx: Ctx): { secret: string; url: string } {
   const secret = generateSecret();
   return { secret, url: otpauthUrl({ secret, account: ctx.username, issuer: config.appName || "ihasmail" }) };
 }
@@ -184,7 +184,7 @@ export function beginOtpEnrolment(ctx: Ctx): { secret: string; url: string } {
  * the new secret, so without this an authenticator that was mistyped or out of
  * step would lock the user out of their mailbox at the next sign-in.
  */
-export function assertEnrolmentCode(url: string, code: string): void {
+export function assertEnrollmentCode(url: string, code: string): void {
   const params = parseOtpauthUrl(url);
   if (!params) throw new AccountError("That two-factor secret is not usable.", 400, "bad_otp_url");
   if (!verifyTotp(params, code)) {
@@ -193,7 +193,7 @@ export function assertEnrolmentCode(url: string, code: string): void {
 }
 
 export async function enableOtp(ctx: Ctx, opts: { url: string; code: string; current: string }): Promise<void> {
-  assertEnrolmentCode(opts.url, opts.code);
+  assertEnrollmentCode(opts.url, opts.code);
   const res = await jmap(ctx, [
     [
       "x:AccountPassword/set",

server/src/accountinfo.test.ts

@@ -33,8 +33,8 @@ test("an account with no locale set yields none, rather than a guess", () => {
 });
 
 test("neither answering leaves the locale unknown", () => {
-  assert.deepEqual(interpretAccountInfo([failed("s", "forbidden"), failed("a", "forbidden")]), { locale: null, edition: null });
-  assert.deepEqual(interpretAccountInfo([]), { locale: null, edition: null });
+  assert.deepEqual(interpretAccountInfo([failed("s", "forbidden"), failed("a", "forbidden")]), { locale: null, edition: null, permissions: [] });
+  assert.deepEqual(interpretAccountInfo([]), { locale: null, edition: null, permissions: [] });
 });
 
 test("locales that carry no language are dropped, not passed through", () => {
@@ -48,7 +48,7 @@ test("a server without the registry is not asked for anything", async () => {
   // fails the whole request rather than the one call.
   const session = { capabilities: { "urn:ietf:params:jmap:core": {}, "urn:ietf:params:jmap:mail": {} }, accounts: {}, primaryAccounts: {} };
   const info = await getAccountInfo("session-unsupported", "Basic x", session as never);
-  assert.deepEqual(info, { locale: null, edition: null });
+  assert.deepEqual(info, { locale: null, edition: null, permissions: [] });
 });
 
 test("no capabilities at all is treated the same way", async () => {
@@ -73,14 +73,14 @@ test("no capabilities at all is treated the same way", async () => {
 const STALWART = "urn:stalwart:jmap";
 const baseCaps = { "urn:ietf:params:jmap:core": {}, "urn:ietf:params:jmap:mail": {} };
 
-test("a 0.16 server is recognised from primaryAccounts, where it advertises itself", () => {
+test("a 0.16 server is recognized from primaryAccounts, where it advertises itself", () => {
   assert.equal(
     hasStalwartRegistry({ capabilities: baseCaps, accounts: {}, primaryAccounts: { [STALWART]: "a1" } }),
     true,
   );
 });
 
-test("a 0.16 server is recognised from an account's capabilities", () => {
+test("a 0.16 server is recognized from an account's capabilities", () => {
   assert.equal(
     hasStalwartRegistry({
       capabilities: baseCaps,
@@ -100,7 +100,7 @@ test("a server that advertises it nowhere is one we do not support", () => {
   assert.equal(hasStalwartRegistry(undefined), false);
 });
 
-test("a shared account carrying the capability is enough to recognise the server", () => {
+test("a shared account carrying the capability is enough to recognize the server", () => {
   assert.equal(
     hasStalwartRegistry({
       capabilities: baseCaps,
@@ -110,3 +110,32 @@ test("a shared account carrying the capability is enough to recognise the server
     true,
   );
 });
+
+/**
+ * With a domain mapped to its own Stalwart (#238), everything asked about the
+ * account has to go to that server. The locale lookup resolved Stalwart's
+ * `apiUrl` against the default server instead, so a mapped account's locale
+ * was requested from a server that had never heard of it.
+ */
+test("account info is asked of the server that issued the session", async () => {
+  const seen: string[] = [];
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = (async (input: string | URL | Request) => {
+    seen.push(String(input instanceof Request ? input.url : input));
+    return new Response(JSON.stringify({ methodResponses: [], edition: "oss" }), { status: 200, headers: { "content-type": "application/json" } });
+  }) as typeof fetch;
+  try {
+    const session = {
+      capabilities: baseCaps,
+      accounts: { a1: { accountCapabilities: { [STALWART]: {} } } },
+      primaryAccounts: { [STALWART]: "a1" },
+      apiUrl: "https://mail.mapped.test/jmap/",
+      baseUrl: "https://mail.mapped.test",
+    };
+    await getAccountInfo("session-mapped-domain", "Basic x", session as never);
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+  assert.ok(seen.length >= 2, "asks for both the locale and the edition");
+  for (const url of seen) assert.ok(url.startsWith("https://mail.mapped.test/"), `${url} went to the wrong server`);
+});

server/src/adminGate.test.ts

@@ -0,0 +1,86 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { administrationAllowed, gateAdministration, grantsAdministration, mayNameRegistryMethod } from "./adminGate.js";
+
+const req = (...methods: string[]) => JSON.stringify({ using: ["urn:ietf:params:jmap:core"], methodCalls: methods.map((m, i) => [m, {}, `c${i}`]) });
+
+/**
+ * With ADMINISTRATION=0 an administrator's browser must not be a way round the
+ * operator's decision. Hiding the menu would leave the proxy forwarding the
+ * very calls the menu made.
+ */
+test("mail, calendars and the rest pass untouched", () => {
+  const r = gateAdministration(req("Email/query", "Mailbox/get", "CalendarEvent/set", "FileNode/get", "Principal/getAvailability"));
+  assert.equal(r.ok, true);
+});
+
+test("the account's own registry objects can be read", () => {
+  assert.equal(gateAdministration(req("x:AccountSettings/get", "x:AppPassword/get", "x:PublicKey/get", "x:MaskedEmail/query")).ok, true);
+});
+
+test("but not written: a credential minted here would outlive a borrowed session", () => {
+  for (const m of ["x:AppPassword/set", "x:AccountPassword/set", "x:MaskedEmail/set"]) {
+    assert.deepEqual(gateAdministration(req("x:AccountSettings/get", m)), { ok: false, method: m });
+  }
+});
+
+test("API keys are not the account's to reach from here at all", () => {
+  assert.deepEqual(gateAdministration(req("x:ApiKey/get")), { ok: false, method: "x:ApiKey/get" });
+});
+
+test("directory and server objects are refused, and named", () => {
+  for (const m of ["x:Account/get", "x:Domain/set", "x:Role/query", "x:Tenant/get", "x:SystemSettings/set", "x:DkimSignature/get"]) {
+    assert.deepEqual(gateAdministration(req("Email/get", m)), { ok: false, method: m });
+  }
+});
+
+test("a body that could name a registry method and cannot be read is refused rather than forwarded", () => {
+  assert.deepEqual(gateAdministration('{"methodCalls": [["x:Account/get"'), { ok: false, method: null });
+  assert.deepEqual(gateAdministration(JSON.stringify({ methodCalls: "x:Account/get" })), { ok: false, method: null });
+  assert.deepEqual(gateAdministration(JSON.stringify({ methodCalls: [[{}, {}, "c"]], note: "x:" })), { ok: false, method: null });
+});
+
+test("a body that cannot name a registry method is forwarded exactly as it came", () => {
+  // Most traffic from a session that may not administer: no parse, no rewrite.
+  const raw = '{"using":["urn:ietf:params:jmap:core"],"methodCalls":[["Email/get",{"ids":["a"]},"c"]]}';
+  assert.equal(mayNameRegistryMethod(raw), false);
+  assert.deepEqual(gateAdministration(raw), { ok: true, body: raw });
+});
+
+test("a method name hidden behind a unicode escape is still found", () => {
+  // JSON.parse and the server both read \u0078 as "x"; a substring check alone would not.
+  const raw = '{"methodCalls":[["\\u0078:Account/get",{},"c"]]}';
+  assert.equal(mayNameRegistryMethod(raw), true);
+  assert.deepEqual(gateAdministration(raw), { ok: false, method: "x:Account/get" });
+});
+
+/**
+ * The operator's rule: administration only from a session signed in with
+ * "This is my own device" ticked, and never when the installation turned it off.
+ */
+test("administration needs both the installation and a device marked as the person's own", () => {
+  assert.equal(administrationAllowed(true, true), true);
+  assert.equal(administrationAllowed(true, false), false);
+  assert.equal(administrationAllowed(false, true), false);
+});
+
+test("an account counts as an administrator by the same test the menu makes", () => {
+  assert.equal(grantsAdministration(["sysAccountQuery", "sysAccountGet"]), true);
+  assert.equal(grantsAdministration(["sysDomainQuery", "sysDomainGet"]), true);
+  // The dashboard opens on less than a list: a count is only a query.
+  assert.equal(grantsAdministration(["sysAccountQuery"]), true);
+  assert.equal(grantsAdministration(["sysQueuedMessageQuery"]), true);
+  assert.equal(grantsAdministration(["sysMetricQuery", "sysMetricGet"]), true);
+  assert.equal(grantsAdministration(["sysMetricQuery"]), false);
+  assert.equal(grantsAdministration(["sysAccountGet", "sysDomainGet"]), false);
+  assert.equal(grantsAdministration(["jmapEmailGet", "sysAccountSettingsGet"]), false);
+});
+
+test("what is forwarded is what was checked", () => {
+  // A duplicate key is read one way by JSON.parse; forwarding the parsed form
+  // means the server cannot read it the other way.
+  const raw = '{"methodCalls":[["x:Account/get",{},"a"]],"methodCalls":[["Email/get",{},"b"]]}';
+  const r = gateAdministration(raw);
+  assert.equal(r.ok, true);
+  if (r.ok) assert.equal(r.body, JSON.stringify({ methodCalls: [["Email/get", {}, "b"]] }));
+});

server/src/adminGate.ts

@@ -0,0 +1,97 @@
+/**
+ * What the JMAP proxy lets through for a session that may not administer:
+ * the operator turned it off (`ADMINISTRATION=0`), or the session was signed
+ * in without "This is my own device".
+ *
+ * Hiding the menu is not turning it off. `/api/jmap` forwards any method the
+ * browser sends, and Stalwart's registry answers whatever the credential's role
+ * allows -- so without this, an administrator could still manage accounts, or
+ * the whole server, from the browser console of an installation whose operator
+ * said no. With it off, the proxy refuses every `x:` method except the few that
+ * are about the signed-in account itself.
+ *
+ * An allowlist rather than a list of administrative objects, because the
+ * registry has dozens of them -- listeners, stores, tracers, system settings --
+ * and a new release adds more. An object not named here is refused, which errs
+ * toward the operator's decision.
+ *
+ * The standard JMAP methods (mail, calendars, contacts, files, sharing) are not
+ * touched: they act on what the account can already reach.
+ */
+const SELF_SERVICE = new Set(["AccountSettings", "AccountPassword", "AppPassword", "PublicKey", "MaskedEmail"]);
+
+export type GateResult = { ok: true; body: string } | { ok: false; method: string | null };
+
+/**
+ * Whether a session may administer at all: the installation allows it, and
+ * the person signing in said the device is their own.
+ *
+ * The second half is the operator's rule, not Stalwart's. A borrowed laptop or
+ * a library machine is exactly where a session should not be able to reset a
+ * password or remove a domain, and "This is my own device" is the one thing
+ * the sign-in form already asks that says where it is being used. An untrusted
+ * session is also signed out when idle and wipes its local data, so nothing
+ * about it suits an administrator's work.
+ */
+export function administrationAllowed(enabled: boolean, remember: boolean): boolean {
+  return enabled && remember;
+}
+
+/**
+ * Whether an account's permissions would put Administration in its menu --
+ * the same test the client makes, so the server can say why it is missing
+ * without handing over the permissions themselves.
+ *
+ * The client's test is whether any section opens, and the dashboard opens on
+ * less than a list does: a count needs only the query, the metric history its
+ * query and get. The account and domain lists need more than their counts, so
+ * they add nothing here.
+ */
+export function grantsAdministration(permissions: readonly string[]): boolean {
+  const has = new Set(permissions);
+  return has.has("sysAccountQuery") || has.has("sysDomainQuery") || has.has("sysQueuedMessageQuery") || (has.has("sysMetricQuery") && has.has("sysMetricGet"));
+}
+
+/**
+ * Whether a body could hold a registry method name at all, so the common case
+ * -- mail, calendars, contacts from a session that may not administer -- skips
+ * the parse. A method name is a JSON string starting `x:`, which appears in the
+ * text as `"x:` unless written with a `\u` escape; a body with neither cannot
+ * contain one, and is forwarded exactly as it came.
+ */
+export function mayNameRegistryMethod(raw: string): boolean {
+  return raw.includes('"x:') || raw.includes("\\u");
+}
+
+/**
+ * Check a JMAP request body. On success, hands back the body to forward --
+ * serialized from what was inspected, so the server can never be sent
+ * something different from what was checked (a duplicate key, say, read one
+ * way here and another way there).
+ */
+export function gateAdministration(raw: string): GateResult {
+  if (!mayNameRegistryMethod(raw)) return { ok: true, body: raw };
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { ok: false, method: null };
+  }
+  const calls = (parsed as { methodCalls?: unknown } | null)?.methodCalls;
+  if (!Array.isArray(calls)) return { ok: false, method: null };
+  for (const call of calls) {
+    const name = Array.isArray(call) ? call[0] : undefined;
+    if (typeof name !== "string") return { ok: false, method: null };
+    if (!name.startsWith("x:")) continue;
+    const [object = "", op = ""] = name.slice(2).split("/");
+    /*
+     * Read, never write. The browser sends none of these itself -- password,
+     * app-password and 2FA changes go through /api/account, which checks the
+     * account password first -- so a write here could only come from
+     * somebody working the console of a session on a borrowed machine, and
+     * `x:AppPassword/set` would hand them a credential that outlives it.
+     */
+    if (!SELF_SERVICE.has(object) || op === "set") return { ok: false, method: name };
+  }
+  return { ok: true, body: JSON.stringify(parsed) };
+}

server/src/adminurl.test.ts

@@ -0,0 +1,75 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const dir = mkdtempSync(join(tmpdir(), "ihasmail-servers-"));
+const file = join(dir, "servers.json");
+writeFileSync(
+  file,
+  JSON.stringify({
+    _comment: ["A note, as the example file has."],
+    "plain.test": "https://mail.plain.test/",
+    "Linked.Test.": { url: "https://mail.linked.test", adminUrl: "https://admin.linked.test/" },
+  }),
+);
+process.env.STALWART_URL = "https://default.example";
+process.env.STALWART_ADMIN_URL = "https://admin.default.example/";
+process.env.STALWART_SERVERS_FILE = file;
+
+const { adminPrefixFrom, adminUrlFor, advertisedOrigin, upstreamFor } = await import("./upstream.js");
+const { config, parseStalwartServers } = await import("./config.js");
+
+/**
+ * Where the dashboard's "Open Stalwart admin" points. STALWART_URL is how this
+ * server reaches Stalwart; STALWART_ADMIN_URL is where a browser opens its
+ * administration, and follows the same domain routing.
+ */
+test("a servers file entry may name its administration as well as its server, and a note is not a domain", () => {
+  assert.deepEqual(config.stalwartServers, { "plain.test": "https://mail.plain.test", "linked.test": "https://mail.linked.test" });
+  assert.deepEqual(config.stalwartAdminUrls, { "linked.test": "https://admin.linked.test" });
+  assert.equal(upstreamFor("[email protected]"), "https://mail.linked.test");
+});
+
+test("an unmapped domain and a bare username open the default administration", () => {
+  assert.equal(adminUrlFor("[email protected]"), "https://admin.default.example");
+  assert.equal(adminUrlFor("demo"), "https://admin.default.example");
+});
+
+test("a routed domain opens its own server's administration, and never the default's", () => {
+  assert.equal(adminUrlFor("[email protected]"), "https://admin.linked.test");
+  // Routed away, with no adminUrl of its own and nothing found: no link rather than the wrong server.
+  assert.equal(adminUrlFor("[email protected]"), null);
+});
+
+test("what the operator configured wins over what was found, and what was found fills the gap", () => {
+  assert.equal(adminUrlFor("[email protected]", "https://found.example/admin/"), "https://admin.default.example");
+  assert.equal(adminUrlFor("[email protected]", "https://found.example/admin/"), "https://admin.linked.test");
+  // The routed domain without an adminUrl takes what its own server said.
+  assert.equal(adminUrlFor("[email protected]", "https://mail.plain.test/admin/"), "https://mail.plain.test/admin/");
+});
+
+/** Finding the administration on the server itself, as production's answered on 2026-09-15. */
+test("the web interface's prefix is read from the applications Stalwart has installed", () => {
+  const got = (list: unknown[]) => adminPrefixFrom([["x:Application/query", { ids: ["a"] }, "q"], ["x:Application/get", { list }, "g"]]);
+  assert.equal(got([{ enabled: true, description: "Stalwart Web Interface", urlPrefix: { "/admin": true, "/account": true } }]), "/admin");
+  assert.equal(got([{ enabled: false, urlPrefix: { "/admin": true } }]), null);
+  assert.equal(got([{ enabled: true, urlPrefix: { "/console": true } }]), null);
+  assert.equal(got([]), null);
+  // May not read applications: not an answer, so Stalwart's own default.
+  assert.equal(adminPrefixFrom([["error", { type: "forbidden" }, "q"], ["error", { type: "forbidden" }, "g"]]), "/admin");
+});
+
+test("the origin is the one Stalwart advertises, even when it is reached on a private address", () => {
+  assert.equal(advertisedOrigin({ apiUrl: "https://mail.example.com/jmap/", baseUrl: "http://127.0.0.1:8080" }), "https://mail.example.com");
+  assert.equal(advertisedOrigin({ apiUrl: "/jmap/", baseUrl: "https://mail.example.com" }), "https://mail.example.com");
+});
+
+test("the shipped example loads through the parser that reads it", () => {
+  const example = new URL("../../stalwart-servers.example.json", import.meta.url);
+  const parsed = parseStalwartServers(JSON.parse(readFileSync(example, "utf8")), "example");
+  assert.ok(Object.keys(parsed.urls).length > 0);
+  assert.ok(!("_comment" in parsed.urls));
+  assert.equal(Object.keys(parsed.adminUrls).length, 1);
+});

server/src/app.ts

@@ -1,11 +1,20 @@
 import { Hono } from "hono";
 import type { Context, MiddlewareHandler } from "hono";
 import { getCookie, setCookie, deleteCookie } from "hono/cookie";
+import { bodyLimit } from "hono/body-limit";
+import { compress } from "hono/compress";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
+import { attach as pushAttach, attachRelay as pushAttachRelay, prepare as pushPrepare, receive as pushReceive, pushStatus } from "./push.js";
 import { getConnInfo } from "@hono/node-server/conninfo";
 import { config } from "./config.js";
-import { SessionStore, type SessionBackend, type LiveSession } from "./sessions.js";
+import { fetchPermissions } from "./permissionSchema.js";
+import { administrationAllowed, gateAdministration, grantsAdministration } from "./adminGate.js";
+import { SessionStore, accountKey, type SessionBackend, type LiveSession } from "./sessions.js";
 import { RateLimiter } from "./ratelimit.js";
-import { resolveClientIp } from "./clientip.js";
+import { rateLimitKey, resolveClientIp } from "./clientip.js";
+import { safeEqual } from "./crypto.js";
 import {
   type AccountInfo,
   UpstreamError,
@@ -17,12 +26,13 @@ import {
   getAccountInfo,
   getUpstreamSession,
   upstreamFor,
+  adminUrlFor,
   localizeSession,
 } from "./upstream.js";
 import {
   AccountError,
-  assertEnrolmentCode,
-  beginOtpEnrolment,
+  assertEnrollmentCode,
+  beginOtpEnrollment,
   changePassword,
   createAppPassword,
   disableOtp,
@@ -59,6 +69,19 @@ const loginFloodLimiter = new RateLimiter(config.loginRateLimit * 20, 15 * 60_00
  * cannot get the whole deployment banned.
  */
 const accountLimiter = new RateLimiter(10, 15 * 60_000);
+const apiLimiter = new RateLimiter(config.apiRateLimit, 60_000);
+
+/** Per-session budget on the data path. See config.apiRateLimit. */
+const apiRateLimited: MiddlewareHandler<Env> = async (c, next) => {
+  if (config.apiRateLimit > 0) {
+    const session = c.get("session");
+    if (session && !apiLimiter.check(session.id)) {
+      c.header("Retry-After", String(apiLimiter.retryAfterSeconds(session.id)));
+      return c.json({ error: "rate_limited" }, 429);
+    }
+  }
+  await next();
+};
 
 const HOP_BY_HOP = new Set([
   "connection",
@@ -109,6 +132,72 @@ const securityHeaders: MiddlewareHandler = async (c, next) => {
 };
 
 /** CSRF: require our custom header on all API calls; reject cross-site fetches. */
+/**
+ * Routes that forward somebody else's bytes rather than producing our own.
+ *
+ * Compression is right for the app shell, the bundle and our JSON; it is not
+ * worth the risk on the proxy paths. Those carry a content-length copied from
+ * upstream under the rules in `forwardedContentLength`, and issue #76 was a
+ * silent truncation caused by exactly that header disagreeing with the body.
+ * Re-encoding them would be safe in principle -- the length is dropped and the
+ * response goes out chunked -- but the payloads are attachments, images and
+ * calendar data that are already compressed or too small to matter, so there
+ * is nothing to win and a scar to respect.
+ *
+ * `/api/events` needs no entry here: Hono skips `text/event-stream` by content
+ * type. It is listed anyway, because a future change to that route's type
+ * should not quietly start buffering the push stream.
+ */
+const UNCOMPRESSED_ROUTES = [
+  "/api/blob/",
+  "/api/image",
+  "/api/ics",
+  "/api/upload/",
+  "/api/events",
+  /*
+   * The liveness probe, which is small enough that gzip makes it bigger: 53
+   * bytes becomes 73. Hono's size threshold cannot catch this on its own,
+   * because it only applies when the response carries a content-length and
+   * `c.json()` does not set one. Every other JSON route is left compressed --
+   * a JMAP response can run to hundreds of kilobytes and its length is just as
+   * unknown -- so this is the one place worth naming.
+   */
+  "/api/health",
+];
+
+/**
+ * gzip for what we generate.
+ *
+ * The bundle ships uncompressed otherwise: 915 KB on the wire where 307 KB
+ * would do, on every first load. `Caddyfile.example` and
+ * `nginx.example.conf` both compress at the proxy, but that only helps the
+ * deployments that use them, and the default should not depend on reading the
+ * examples.
+ *
+ * Hono's middleware declines anything already carrying `Content-Encoding` or
+ * `Transfer-Encoding`, so a proxy compressing in front of us wins and we do
+ * not double-encode.
+ */
+function compressResponses(basePath: string): MiddlewareHandler {
+  const inner = compress({ threshold: 1024 });
+  const skip = UNCOMPRESSED_ROUTES.map((r) => `${basePath}${r}`);
+  if (!config.compressJmap) skip.push(`${basePath}/api/jmap`);
+  const offersEncoding = /\b(gzip|deflate)\b/i;
+  return async (c, next) => {
+    /*
+     * A client that did not ask for an encoding must not pay for one. Hono's
+     * middleware still inspects and re-labels every compressible response it
+     * declines -- setting Vary forces a streamed passthrough to be rebuilt off
+     * its fast path -- and that was measured at 1.2 ms per JMAP call, on a
+     * 1.9 ms operation, for a request that never sent Accept-Encoding.
+     */
+    if (!offersEncoding.test(c.req.header("accept-encoding") ?? "")) return next();
+    const path = new URL(c.req.url).pathname;
+    if (skip.some((prefix) => path.startsWith(prefix))) return next();
+    return inner(c, next);
+  };
+}
+
 const csrfGuard: MiddlewareHandler = async (c, next) => {
   const site = c.req.header("sec-fetch-site");
   if (site && site !== "same-origin" && site !== "none") {
@@ -122,6 +211,22 @@ const csrfGuard: MiddlewareHandler = async (c, next) => {
   await next();
 };
 
+/**
+ * The largest body an API route that reads JSON will take.
+ *
+ * Hono reads a JSON body whole, and before this nothing bounded it: a few
+ * unauthenticated sign-in attempts carrying hundreds of megabytes each could
+ * run the process out of memory, and a restart signs everybody out. What
+ * these routes actually receive is a username and password, or a code.
+ *
+ * JMAP and uploads carry real payloads and bound themselves as they stream;
+ * the push callback has its own limit ahead of this one.
+ */
+const MAX_SMALL_BODY = 64 * 1024;
+const LARGE_BODY_ROUTE = /\/api\/(jmap$|upload\/)/;
+const limitSmallBody = bodyLimit({ maxSize: MAX_SMALL_BODY, onError: (c) => c.json({ error: "too_large" }, 413) });
+const smallBodies: MiddlewareHandler = (c, next) => (LARGE_BODY_ROUTE.test(c.req.path) ? next() : limitSmallBody(c, next));
+
 const requireSession: MiddlewareHandler<Env> = async (c, next) => {
   const cookie = getCookie(c, config.cookieName);
   const session = sessions.resolve(cookie);
@@ -178,11 +283,29 @@ function upstreamFailure(c: Context, err: unknown) {
 export function createApp(basePath = config.basePath): Hono<Env> {
   const app = new Hono<Env>();
   app.use("*", securityHeaders);
+  app.use("*", compressResponses(basePath));
 
   const api = new Hono<Env>();
   api.use("*", csrfGuard);
+  api.use("*", smallBodies);
+
+  api.get("/health", (c) => c.json({ ok: true, name: config.appName, version: config.version, push: pushStatus() }));
+
+  /*
+   * Stalwart's push delivery. Authenticated by the token in the path -- 32
+   * random bytes, one per account, known only to us and to Stalwart -- and by
+   * nothing else, since Stalwart carries no credential when it POSTs. An
+   * unknown token is a 404 that looks like any other. See push.ts.
+   */
+  app.post(`${basePath}/api/push/:token`, async (c) => {
+    if (!(c.req.header("content-type") ?? "").toLowerCase().startsWith("application/json")) return c.body(null, 415);
+    const len = Number(c.req.header("content-length") ?? "0");
+    if (!len || len > 64 * 1024) return c.body(null, 413);
+    let body: unknown;
+    try { body = await c.req.json(); } catch { return c.body(null, 400); }
+    return c.body(null, (await pushReceive(c.req.param("token"), body)) as 200 | 400 | 404 | 500);
+  });
 
-  api.get("/health", (c) => c.json({ ok: true, name: config.appName, version: config.version }));
 
   api.get("/config", (c) =>
     c.json({
@@ -199,6 +322,13 @@ export function createApp(basePath = config.basePath): Hono<Env> {
   // ---------- Auth ----------
   api.post("/auth/login", async (c) => {
     const ip = clientIp(c);
+    // What the limits count under: the address, or its /64 for IPv6.
+    const rateIp = rateLimitKey(ip);
+    // The flood ceiling needs nothing from the body, so it goes before reading one.
+    if (!loginFloodLimiter.check(rateIp)) {
+      c.header("Retry-After", String(loginFloodLimiter.retryAfterSeconds(rateIp)));
+      return c.json({ error: "rate_limited", message: "Too many login attempts. Please wait and try again." }, 429);
+    }
     let body: { username?: string; password?: string; totp?: string; remember?: boolean };
     try {
       body = await c.req.json();
@@ -214,7 +344,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
     /*
      * Three checks, answering different questions.
      *
-     * `limitKey` is this username from this address, and `ip` is any username
+     * `limitKey` is this username from this address, and `rateIp` is any username
      * from it -- both guard guessing, and both are given back when the upstream
      * never got as far as judging the password. Refunding only the first would
      * not fix #239: ten retries through an outage would still spend the address
@@ -224,12 +354,8 @@ export function createApp(basePath = config.basePath): Hono<Env> {
      * The flood ceiling is the one that is never refunded, and it is the reason
      * the other two safely can be.
      */
-    const limitKey = `${ip}|${username.toLowerCase()}`;
-    if (!loginFloodLimiter.check(ip)) {
-      c.header("Retry-After", String(loginFloodLimiter.retryAfterSeconds(ip)));
-      return c.json({ error: "rate_limited", message: "Too many login attempts. Please wait and try again." }, 429);
-    }
-    if (!loginLimiter.check(limitKey) || !loginLimiter.check(ip)) {
+    const limitKey = `${rateIp}|${username.toLowerCase()}`;
+    if (!loginLimiter.check(limitKey) || !loginLimiter.check(rateIp)) {
       c.header("Retry-After", String(loginLimiter.retryAfterSeconds(limitKey)));
       return c.json({ error: "rate_limited", message: "Too many login attempts. Please wait and try again." }, 429);
     }
@@ -247,7 +373,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
         // The credentials were accepted; only the server is too old. Not an
         // attempt worth counting against them.
         loginLimiter.refund(limitKey);
-        loginLimiter.refund(ip);
+        loginLimiter.refund(rateIp);
         return c.json(
           {
             error: "unsupported_server",
@@ -260,12 +386,17 @@ export function createApp(basePath = config.basePath): Hono<Env> {
       loginLimiter.reset(limitKey);
       const { cookie, session } = sessions.create({
         username,
+        account: accountKey(upstreamFor(username), upstream.username || username),
         password: effectivePassword,
         remember: Boolean(body.remember),
         userAgent: c.req.header("user-agent") ?? "",
         ip,
       });
       setSessionCookie(c, cookie, session.remember);
+      // Start the account's push subscription now, so it is usually verified
+      // by the time the browser opens its stream. See push.ts.
+      const mailAccount = upstream.primaryAccounts?.["urn:ietf:params:jmap:mail"];
+      if (mailAccount) pushPrepare(session.username, mailAccount, session.authorization);
       const info = await getAccountInfo(session.id, session.authorization, upstream);
       return c.json(localizeSession(upstream, sessionExtras(session, info)));
     } catch (err) {
@@ -296,14 +427,14 @@ export function createApp(basePath = config.basePath): Hono<Env> {
         );
       }
       /*
-       * A 401 is a judgement about the password and stays counted. Anything
+       * A 401 is a judgment about the password and stays counted. Anything
        * else -- refused, timed out, DNS, TLS -- is the upstream failing to
        * answer, which says nothing about the credentials and must not spend
        * somebody's attempts while they wait for it to come back (#239).
        */
       if (!(err instanceof UpstreamError && err.status === 401)) {
         loginLimiter.refund(limitKey);
-        loginLimiter.refund(ip);
+        loginLimiter.refund(rateIp);
       }
       return upstreamFailure(c, err);
     }
@@ -337,12 +468,12 @@ export function createApp(basePath = config.basePath): Hono<Env> {
 
   api.get("/auth/sessions", requireSession, (c) => {
     const session = c.get("session");
-    return c.json({ current: session.id, sessions: sessions.listForUser(session.username) });
+    return c.json({ current: session.id, sessions: sessions.listForUser(session.account) });
   });
 
   api.post("/auth/sessions/revoke-others", requireSession, (c) => {
     const session = c.get("session");
-    const n = sessions.destroyAllForUser(session.username, session.id);
+    const n = sessions.destroyAllForUser(session.account, session.id);
     return c.json({ revoked: n });
   });
 
@@ -354,7 +485,11 @@ export function createApp(basePath = config.basePath): Hono<Env> {
    */
   const accountCtx = async (c: Context<Env>) => {
     const session = c.get("session");
-    const upstream = await getUpstreamSession(session.id, session.authorization);
+    // The account's own server. Without it, the first fetch after the cached
+    // session expires goes to STALWART_URL -- which, for a domain mapped
+    // elsewhere, either refuses the password or knows a different account by
+    // the same name (#238).
+    const upstream = await getUpstreamSession(session.id, session.authorization, upstreamFor(session.username));
     return { authorization: session.authorization, session: upstream, username: session.username };
   };
 
@@ -366,8 +501,8 @@ export function createApp(basePath = config.basePath): Hono<Env> {
   };
 
   /** Guard the endpoints that check a password against brute-forcing. */
-  const guarded = (c: Context<Env>): Response | null => {
-    const key = `account|${c.get("session").username.toLowerCase()}`;
+  const guarded = (c: Context<Env>, scope = "account"): Response | null => {
+    const key = `${scope}|${c.get("session").username.toLowerCase()}`;
     if (accountLimiter.check(key)) return null;
     c.header("Retry-After", String(accountLimiter.retryAfterSeconds(key)));
     return c.json({ error: "rate_limited", message: "Too many attempts. Please wait and try again." }, 429);
@@ -405,7 +540,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
     const otpCode = body.otpCode?.trim();
     sessions.reseal(getCookie(c, config.cookieName), otpCode ? `${next}$${otpCode}` : next);
     forgetUpstreamSession(session.id);
-    const revoked = sessions.destroyAllForUser(session.username, session.id);
+    const revoked = sessions.destroyAllForUser(session.account, session.id);
     return c.json({ ok: true, revokedSessions: revoked });
   });
 
@@ -419,12 +554,26 @@ export function createApp(basePath = config.basePath): Hono<Env> {
     }
   });
 
+  /*
+   * An app password is a credential that outlives this session, a password
+   * change and a sign-out -- so minting one asks for the account password, as
+   * changing the password does. Otherwise a session left open on somebody
+   * else's machine is enough to take a permanent key away from it.
+   */
   api.post("/account/app-passwords", requireSession, async (c) => {
+    // A budget of its own: guessing here never reaches Stalwart (see confirmsPassword).
+    const limited = guarded(c, "app-password");
+    if (limited) return limited;
     const session = c.get("session");
-    const body = await readJson<{ description?: string }>(c);
+    const body = await readJson<{ description?: string; current?: string }>(c);
     if (!body) return c.json({ error: "bad_request" }, 400);
     const description = (body.description ?? "").trim().slice(0, 120);
     if (!description) return c.json({ error: "missing_fields", message: "Give the app password a name." }, 400);
+    const current = body.current ?? "";
+    if (!current || current.length > 1024) return c.json({ error: "missing_fields", message: "Enter your current password." }, 400);
+    if (!(await confirmsPassword(session, current))) {
+      return c.json({ error: "invalid_credentials", message: "That password is not correct." }, 403);
+    }
     try {
       return c.json(await createAppPassword(await accountCtx(c), { description }));
     } catch (err) {
@@ -447,7 +596,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
   api.post("/account/2fa/begin", requireSession, async (c) => {
     try {
       // Nothing is stored yet; the client hands the URL back to confirm.
-      return c.json(beginOtpEnrolment(await accountCtx(c)));
+      return c.json(beginOtpEnrollment(await accountCtx(c)));
     } catch (err) {
       return accountFailure(c, err);
     }
@@ -472,7 +621,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
      * the moment 2FA is enabled this session can no longer authenticate at all.
      */
     try {
-      assertEnrolmentCode(body.url, code);
+      assertEnrollmentCode(body.url, code);
     } catch (err) {
       return accountFailure(c, err);
     }
@@ -499,7 +648,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
       if (sessionKept) forgetUpstreamSession(session.id);
     }
     // Other sessions still hold the bare password and will be refused.
-    const revoked = sessions.destroyAllForUser(session.username, session.id);
+    const revoked = sessions.destroyAllForUser(session.account, session.id);
     return c.json({ ok: true, sessionKept, revokedSessions: revoked });
   });
 
@@ -522,12 +671,51 @@ export function createApp(basePath = config.basePath): Hono<Env> {
   });
 
   // ---------- JMAP API proxy ----------
-  api.post("/jmap", requireSession, async (c) => {
+  api.post("/jmap", requireSession, apiRateLimited, async (c) => {
     const session = c.get("session");
     const ct = c.req.header("content-type") ?? "";
     if (!ct.toLowerCase().startsWith("application/json")) {
       return c.json({ error: "unsupported_media_type" }, 415);
     }
+    /*
+     * For a session that may not administer -- administration switched off, or
+     * a device not marked as the person's own -- the body is read and checked
+     * before it goes anywhere. A session that may streams straight through as
+     * it always has, and pays nothing for this.
+     */
+    let body: ReadableStream<Uint8Array> | string | null = c.req.raw.body;
+    if (!administrationAllowed(config.administration, session.remember)) {
+      const held = gatedReads.get(session.id) ?? 0;
+      if (held >= MAX_GATED_PER_SESSION) {
+        c.header("Retry-After", "1");
+        return c.json({ error: "rate_limited" }, 429);
+      }
+      gatedReads.set(session.id, held + 1);
+      let raw: string;
+      try {
+        if (Number(c.req.header("content-length") ?? "0") > MAX_GATED_REQUEST) return c.json({ error: "too_large" }, 413);
+        // Counted as it arrives: a chunked body carries no length to refuse up front.
+        raw = c.req.raw.body ? await readGated(c.req.raw.body) : "";
+      } catch (err) {
+        if (err instanceof GatedBudgetError) {
+          c.header("Retry-After", "1");
+          return c.json({ error: "busy" }, 503);
+        }
+        return c.json({ error: "too_large" }, 413);
+      } finally {
+        const left = (gatedReads.get(session.id) ?? 1) - 1;
+        if (left > 0) gatedReads.set(session.id, left);
+        else gatedReads.delete(session.id);
+      }
+      const gate = gateAdministration(raw);
+      if (!gate.ok) {
+        if (!gate.method) return c.json({ error: "bad_request", message: "Not a JMAP request." }, 400);
+        return config.administration
+          ? c.json({ error: "administration_needs_own_device", message: `Administration is only available when signed in on a device marked as your own (${gate.method}).` }, 403)
+          : c.json({ error: "administration_disabled", message: `Administration is turned off on this installation (${gate.method}).` }, 403);
+      }
+      body = gate.body;
+    }
     try {
       const upstream = await getUpstreamSession(session.id, session.authorization, upstreamFor(session.username));
       const res = await fetch(absoluteUpstream(upstream.apiUrl, upstream.baseUrl), {
@@ -537,7 +725,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
           "content-type": "application/json",
           accept: "application/json",
         },
-        body: c.req.raw.body,
+        body,
         duplex: "half",
         signal: AbortSignal.timeout(config.upstreamTimeout),
       });
@@ -553,6 +741,30 @@ export function createApp(basePath = config.basePath): Hono<Env> {
     }
   });
 
+  // ---------- Administration: Stalwart's permission list ----------
+  /*
+   * The one administration read that is not a JMAP call: the labeled list of
+   * permissions from Stalwart's schema, for the Roles picker. Behind the same
+   * two gates as the registry methods, so a session that may not administer
+   * learns nothing from it.
+   */
+  api.get("/admin/permissions", requireSession, apiRateLimited, async (c) => {
+    const session = c.get("session");
+    if (!administrationAllowed(config.administration, session.remember)) {
+      return config.administration
+        ? c.json({ error: "administration_needs_own_device" }, 403)
+        : c.json({ error: "administration_disabled" }, 403);
+    }
+    try {
+      const upstream = await getUpstreamSession(session.id, session.authorization, upstreamFor(session.username));
+      const permissions = await fetchPermissions(session.authorization, upstream.baseUrl);
+      if (!permissions) return c.json({ error: "upstream_error" }, 502);
+      return c.json({ permissions });
+    } catch (err) {
+      return upstreamFailure(c, err);
+    }
+  });
+
   // ---------- Blob upload ----------
   api.post("/upload/:accountId", requireSession, async (c) => {
     const session = c.get("session");
@@ -583,7 +795,7 @@ export function createApp(basePath = config.basePath): Hono<Env> {
   });
 
   // ---------- Blob download ----------
-  api.get("/blob/:accountId/:blobId/:name", requireSession, async (c) => {
+  api.get("/blob/:accountId/:blobId/:name", requireSession, apiRateLimited, async (c) => {
     const session = c.get("session");
     const { accountId, blobId, name } = c.req.param();
     const accept = c.req.query("accept") ?? "application/octet-stream";
@@ -591,23 +803,37 @@ export function createApp(basePath = config.basePath): Hono<Env> {
     try {
       const upstream = await getUpstreamSession(session.id, session.authorization, upstreamFor(session.username));
       const url = absoluteUpstream(expandTemplate(upstream.downloadUrl, { accountId, blobId, name, type: accept }), upstream.baseUrl);
+      // A PDF viewer or a video element asks for pieces; pass that on. A server
+      // that ignores it answers with the whole file, as it did before.
+      const range = c.req.header("range");
       const res = await fetch(url, {
         // Ask for the bytes as they are. undici would otherwise negotiate gzip
         // on our behalf and hand back a decompressed body whose content-length
         // header still describes the compressed one -- see forwardedContentLength.
-        headers: { authorization: session.authorization, "accept-encoding": "identity" },
+        headers: { authorization: session.authorization, "accept-encoding": "identity", ...(range && /^bytes=[\d,\s-]+$/.test(range) ? { range } : {}) },
         signal: AbortSignal.timeout(Math.max(config.upstreamTimeout, 5 * 60_000)),
       });
+      if (res.status === 416) return c.body(null, 416);
       if (!res.ok) return c.json({ error: "not_found" }, res.status === 404 ? 404 : 502);
       const headers = new Headers();
       const type = sanitizeContentType(res.headers.get("content-type") ?? accept);
       headers.set("Content-Type", type);
       const cl = forwardedContentLength(res.headers);
       if (cl) headers.set("Content-Length", cl);
+      const partial = res.status === 206 && res.headers.get("content-range");
+      if (partial) headers.set("Content-Range", partial);
+      /*
+       * Said here because Stalwart does not say it. It honors a single byte
+       * range but sends no `Accept-Ranges` (0.16.22, checked live on
+       * 2026-09-16), and Chrome's PDF viewer only reads a file in pieces when
+       * the first response advertises it. A server that ignores a range sends
+       * the whole file, which the browser takes just as well.
+       */
+      headers.set("Accept-Ranges", "bytes");
       const safeInline = inline && isInlineSafe(type);
       headers.set(
         "Content-Disposition",
-        `${safeInline ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(name)}`,
+        `${safeInline ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(withoutBidiControls(name))}`,
       );
       headers.set("X-Content-Type-Options", "nosniff");
       // Sandbox everything except the browser's built-in PDF viewer (which needs scripts to render).
@@ -626,8 +852,15 @@ export function createApp(basePath = config.basePath): Hono<Env> {
       } else {
         headers.set("Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'; img-src data:");
       }
-      headers.set("Cache-Control", "private, max-age=3600");
-      return new Response(res.body, { status: 200, headers });
+      // Kept out of the browser's disk cache on a device that is not the
+      // person's own: signing out wipes what the app stores, not that.
+      /*
+       * A blob id names its content -- the same id is the same bytes for good
+       * -- so on the reader's own device there is nothing to revalidate. On
+       * anyone else's, nothing is left in the disk cache at all.
+       */
+      headers.set("Cache-Control", session.remember ? "private, max-age=31536000, immutable" : "no-store");
+      return new Response(res.body, { status: partial ? 206 : 200, headers });
     } catch (err) {
       return upstreamFailure(c, err);
     }
@@ -642,6 +875,18 @@ export function createApp(basePath = config.basePath): Hono<Env> {
     try {
       const upstream = await getUpstreamSession(session.id, session.authorization, upstreamFor(session.username));
       const url = absoluteUpstream(expandTemplate(upstream.eventSourceUrl, { types, closeafter, ping }), upstream.baseUrl);
+      // Subscribe mode: if this account's subscription is verified, the tab is
+      // served by fan-out and holds nothing upstream. Otherwise it gets its own
+      // relay, and is moved to fan-out the moment the account verifies.
+      const accountId = upstream.primaryAccounts?.["urn:ietf:params:jmap:mail"];
+      const out = (c.env as { outgoing: import("node:http").ServerResponse }).outgoing;
+      if (accountId && pushAttach(session.username, accountId, session.authorization, out)) {
+        out.writeHead(200, SSE_HEADERS);
+        out.flushHeaders();
+        out.write(": subscribed\n\n");
+        return RESPONSE_ALREADY_SENT;
+      }
+      if (config.rawPushRelay) return relayPushRaw(c, url, session.authorization, session.username);
       const controller = new AbortController();
       c.req.raw.signal.addEventListener("abort", () => controller.abort());
       const res = await fetch(url, {
@@ -662,10 +907,10 @@ export function createApp(basePath = config.basePath): Hono<Env> {
   });
 
   // ---------- Remote image privacy proxy ----------
-  api.get("/image", requireSession, imageProxyHandler);
+  api.get("/image", requireSession, apiRateLimited, imageProxyHandler);
 // Behind the session for the same reason the image proxy is: an open fetcher
 // on someone else's server is a gift to whoever finds it.
-api.get("/ics", requireSession, icsProxyHandler);
+api.get("/ics", requireSession, apiRateLimited, icsProxyHandler);
 
   api.notFound((c) => c.json({ error: "not_found" }, 404));
   api.onError((err, c) => {
@@ -700,6 +945,43 @@ async function readJson<T>(c: Context): Promise<T | null> {
   }
 }
 
+/**
+ * Is `candidate` the password of the account this session is signed in to?
+ *
+ * Compared with the credential the session holds first, which costs nothing
+ * and tells Stalwart nothing -- its auto-ban counts failures against the
+ * proxy's address, which every user shares. That credential is the password,
+ * with a TOTP code after a `$` when one was given at sign-in. A session that
+ * turning on 2FA moved onto an app password (Stalwart's secrets start
+ * `$app$`) holds something else, and only then is the candidate put to the
+ * server.
+ */
+async function confirmsPassword(session: LiveSession, candidate: string): Promise<boolean> {
+  const decoded = Buffer.from(session.authorization.replace(/^Basic /, ""), "base64").toString("utf8");
+  const held = decoded.slice(decoded.indexOf(":") + 1);
+  if (safeEqual(held, candidate)) return true;
+  const withoutCode = held.replace(/\$\d{6,8}$/, "");
+  if (withoutCode !== held && safeEqual(withoutCode, candidate)) return true;
+  // Holding the password, the comparison above is the answer, and a wrong
+  // guess never reaches the server's auto-ban.
+  if (!held.startsWith("$app$")) return false;
+  try {
+    const authorization = `Basic ${Buffer.from(`${session.username}:${candidate}`, "utf8").toString("base64")}`;
+    await fetchUpstreamSession(authorization, upstreamFor(session.username));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Direction overrides and isolates, which can make `Invoice_\u202Efdp.exe`
+ * read as a PDF in the downloads list. A filename has no use for them.
+ */
+function withoutBidiControls(name: string): string {
+  return name.replace(/[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "");
+}
+
 /** Name the app password after the browser it will live in. */
 function appPasswordName(c: Context): string {
   const ua = c.req.header("user-agent") ?? "";
@@ -707,7 +989,7 @@ function appPasswordName(c: Context): string {
   return `${config.appName} (${browser})`;
 }
 
-function sessionExtras(session: LiveSession, info: AccountInfo = { locale: null, edition: null }) {
+function sessionExtras(session: LiveSession, info: AccountInfo = { locale: null, edition: null, permissions: [] }) {
   return {
     ihasmail: {
       appName: config.appName,
@@ -719,8 +1001,35 @@ function sessionExtras(session: LiveSession, info: AccountInfo = { locale: null,
       remember: session.remember,
       /** Locale configured for the account in Stalwart's directory, if readable. */
       userLocale: info.locale,
-      /** What the upstream server would tell us about itself. */
-      server: { edition: info.edition },
+      /**
+       * What the upstream server would tell us about itself, and -- for a
+       * session that may administer -- where the operator says its own
+       * administration is.
+       */
+      server: {
+        edition: info.edition,
+        adminUrl: administrationAllowed(config.administration, session.remember) ? adminUrlFor(session.username, info.adminUrl ?? null) : null,
+        /** SHOW_ENTERPRISE_NOTICES: say "Enterprise feature" on Enterprise too, as the demo does. */
+        enterpriseNotices: config.showEnterpriseNotices,
+      },
+      /**
+       * Whether this session may administer: the installation offers it
+       * (ADMINISTRATION) and the person signed in on a device marked as their own.
+       */
+      administration: administrationAllowed(config.administration, session.remember),
+      /**
+       * An administrator signed in on a device not marked as their own, so the
+       * menu can say why Administration is unavailable rather than lose it
+       * without a word. Says only that the account administers, never what it
+       * may do.
+       */
+      administrationNeedsOwnDevice: config.administration && !session.remember && grantsAdministration(info.permissions),
+      /**
+       * The account's permissions on that server, so the client can offer
+       * administration to those who have it. Stalwart still decides every call.
+       * Withheld from a session that may not administer: nothing in it needs them.
+       */
+      permissions: administrationAllowed(config.administration, session.remember) ? info.permissions : [],
     },
   };
 }
@@ -730,8 +1039,132 @@ function sessionExtras(session: LiveSession, info: AccountInfo = { locale: null,
  * denylist: everything else it might set — cookies, auth challenges, CORS
  * grants — would be landing on *our* origin, where it means something else.
  */
+/**
+ * The largest JMAP request read into memory for the administration check.
+ *
+ * Only sessions that may not administer come this way, and what the client
+ * sends is small: attachments and pasted images go through `/upload`, and the
+ * composer turns inline images into uploads before a draft is saved. Stalwart
+ * would take up to its `maxSizeRequest` (10 MB by default), but a request is
+ * held here as a string, parsed and serialized again, so each one costs
+ * several times its size; 4 MB is far past anything the client sends.
+ */
+const MAX_GATED_REQUEST = 4 * 1024 * 1024;
+/**
+ * How many checked requests one session may have in flight at once. Matches
+ * the `maxConcurrentRequests` Stalwart advertises by default, which the client
+ * already stays within.
+ */
+const MAX_GATED_PER_SESSION = 4;
+/**
+ * The bytes all checked requests together may hold at once. Counted as they
+ * arrive rather than reserved up front, so a slow body that has sent little
+ * holds little, and a burst of large ones is turned away with a 503 instead of
+ * taking the process down.
+ */
+const GATED_BUDGET = 32 * 1024 * 1024;
+const gatedReads = new Map<string, number>();
+let gatedBytes = 0;
+
+class GatedBudgetError extends Error {}
+
+async function readGated(stream: ReadableStream<Uint8Array>): Promise<string> {
+  let mine = 0;
+  const counted = new TransformStream<Uint8Array, Uint8Array>({
+    transform(chunk, controller) {
+      mine += chunk.byteLength;
+      gatedBytes += chunk.byteLength;
+      if (mine > MAX_GATED_REQUEST) controller.error(new Error("request too large"));
+      else if (gatedBytes > GATED_BUDGET) controller.error(new GatedBudgetError("gated read budget spent"));
+      else controller.enqueue(chunk);
+    },
+  });
+  try {
+    return await new Response(stream.pipeThrough(counted)).text();
+  } finally {
+    gatedBytes -= mine;
+  }
+}
+
 const PASSTHROUGH_HEADERS = new Set(["content-type", "content-disposition", "content-language", "etag", "last-modified", "retry-after"]);
 
+/**
+ * Hold a push stream open with the least machinery that will do it.
+ *
+ * The fetch() version above builds an undici Response, a web ReadableStream,
+ * a reader, and Hono's stream-to-Node bridge for every tab, and keeps all of
+ * it alive for as long as the tab is open. Measured against a real Stalwart
+ * that is about 44 KiB of JavaScript heap per tab -- twelve times what the
+ * session itself costs -- and a signed-in tab is otherwise nothing but this
+ * one held connection. Here the upstream socket is piped straight into the
+ * Node response, so what stays resident per tab is two sockets and their
+ * small IncomingMessage/ServerResponse pair.
+ *
+ * Returns a Response Hono treats as already sent: the raw bindings are
+ * written to directly, and the returned value is never serialized.
+ */
+const SSE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache, no-transform",
+  connection: "keep-alive",
+  "x-accel-buffering": "no",
+} as const;
+
+function relayPushRaw(c: Context<Env>, url: string, authorization: string, username?: string): Response {
+  const out = (c.env as { outgoing: import("node:http").ServerResponse }).outgoing;
+  const target = new URL(url);
+  const req = (target.protocol === "https:" ? httpsRequest : httpRequest)(target, {
+    method: "GET",
+    headers: { authorization, accept: "text/event-stream" },
+  });
+  const signal = c.req.raw.signal;
+  const abort = () => req.destroy();
+  signal.addEventListener("abort", abort);
+  out.on("close", abort);
+  const fail = () => {
+    if (!out.headersSent) {
+      out.writeHead(502, { "content-type": "application/json", "cache-control": "no-store" });
+      out.end(JSON.stringify({ error: "upstream_error" }));
+    } else {
+      out.end();
+    }
+  };
+  /*
+   * Once this account's subscription verifies, the upstream request goes and
+   * the browser stream below is served by fan-out instead. Three things have
+   * to be true for that to be seamless: the browser must already have its
+   * headers (verification can beat the upstream response); nothing may treat
+   * the torn-down upstream as an error; and nothing may keep a reference to
+   * it -- the request, its response and this handler's context are exactly
+   * the per-tab weight the subscription exists to shed.
+   */
+  let migrated = false;
+  const migrate = () => {
+    migrated = true;
+    if (!out.headersSent) { out.writeHead(200, SSE_HEADERS); out.flushHeaders(); }
+    signal.removeEventListener("abort", abort);
+    out.removeListener("close", abort);
+    req.removeAllListeners();
+    req.on("error", () => {});
+    req.destroy();
+  };
+  if (username) pushAttachRelay(username, out, migrate);
+  req.on("response", (res) => {
+    if (migrated) { res.destroy(); return; }
+    if (res.statusCode !== 200) { res.resume(); fail(); return; }
+    if (!out.headersSent) { out.writeHead(200, SSE_HEADERS); out.flushHeaders(); }
+    // end: false -- the browser stream outlives the upstream if we migrate.
+    res.pipe(out, { end: false });
+    res.on("end", () => { if (!migrated) out.end(); });
+    res.on("error", () => { if (!migrated) out.end(); });
+  });
+  req.on("error", () => { if (!migrated) fail(); });
+  req.end();
+  // Tells @hono/node-server the raw ServerResponse has been written to and
+  // must be left alone.
+  return RESPONSE_ALREADY_SENT;
+}
+
 function passthrough(res: Response): Response {
   const headers = new Headers();
   res.headers.forEach((v, k) => {

server/src/clientip.test.ts

@@ -77,7 +77,7 @@ test("junk in the chain is discarded rather than used as a key", () => {
   assert.equal(resolveClientIp("127.0.0.1", { forwardedFor: "" }, cfg), "127.0.0.1");
 });
 
-test("bracketed and IPv4-mapped forms are normalised", () => {
+test("bracketed and IPv4-mapped forms are normalized", () => {
   assert.equal(resolveClientIp("::1", { forwardedFor: "[2001:db8::5]" }, cfg), "2001:db8::5");
   assert.equal(resolveClientIp("::1", { forwardedFor: "::ffff:198.51.100.7" }, cfg), "198.51.100.7");
 });

server/src/clientip.ts

@@ -97,3 +97,21 @@ export function resolveClientIp(peer: string, headers: ForwardHeaders, cfg: Trus
   const real = headers.realIp?.trim();
   return real && isIP(real) !== 0 ? real : peer;
 }
+
+/**
+ * The key a rate limit counts an address under.
+ *
+ * An IPv4 address is the key as it is. An IPv6 address is cut to its /64: that
+ * is the smallest block an ISP or a VPS hands out, so anyone who holds one
+ * address holds 2^64 of them, and a limit keyed on the full address is no
+ * limit. Everyone behind one /64 shares a budget, which is the same bargain an
+ * IPv4 NAT already makes.
+ */
+export function rateLimitKey(ip: string): string {
+  if (isIP(ip) !== 6) return ip;
+  const bits = toBits(ip);
+  if (!bits) return ip;
+  const prefix = bits.value >> 64n;
+  const groups = [48n, 32n, 16n, 0n].map((s) => ((prefix >> s) & 0xffffn).toString(16));
+  return `${groups.join(":")}::/64`;
+}

server/src/compress.test.ts

@@ -0,0 +1,107 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/*
+ * A static root of our own, built before the app is imported.
+ *
+ * CI runs `npm test` before `npm run build`, so `web/dist` does not exist when
+ * these run: pointing at it would serve the "web build not found" fallback,
+ * which is short, plain text and rightly uncompressed. That failure looked
+ * exactly like compression being broken.
+ */
+const root = mkdtempSync(join(tmpdir(), "ihasmail-compress-"));
+mkdirSync(join(root, "assets"));
+const script = `/* ${"x".repeat(40_000)} */\n`;
+writeFileSync(join(root, "assets", "app.js"), script);
+writeFileSync(join(root, "index.html"), `<!doctype html><title>t</title>${"<p>hello</p>".repeat(400)}`);
+
+process.env.STATIC_DIR = root;
+process.env.STALWART_URL = "http://127.0.0.1:1";
+const { createApp } = await import("./app.js");
+
+test("an asset is gzipped when the client asks for it", async () => {
+  const res = await createApp().request("/assets/app.js", { headers: { "accept-encoding": "gzip" } });
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("content-encoding"), "gzip");
+  assert.match(res.headers.get("vary") ?? "", /accept-encoding/i);
+});
+
+test("a client that does not ask for gzip does not get it", async () => {
+  const res = await createApp().request("/assets/app.js", { headers: { "accept-encoding": "identity" } });
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("content-encoding"), null);
+});
+
+test("gzip actually makes the asset smaller", async () => {
+  const plain = await (await createApp().request("/assets/app.js", { headers: { "accept-encoding": "identity" } })).arrayBuffer();
+  const gz = await (await createApp().request("/assets/app.js", { headers: { "accept-encoding": "gzip" } })).arrayBuffer();
+  assert.ok(gz.byteLength < plain.byteLength / 2, `${gz.byteLength} should be well under ${plain.byteLength}`);
+});
+
+test("a gzipped response decodes to the bytes we would have sent plain", async () => {
+  const plain = await (await createApp().request("/assets/app.js", { headers: { "accept-encoding": "identity" } })).arrayBuffer();
+  const res = await createApp().request("/assets/app.js", { headers: { "accept-encoding": "gzip" } });
+  const decoded = await new Response(res.body!.pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+  assert.deepEqual(Buffer.from(decoded), Buffer.from(plain));
+});
+
+test("the app shell is gzipped", async () => {
+  const res = await createApp().request("/", { headers: { "accept-encoding": "gzip" } });
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("content-encoding"), "gzip");
+});
+
+test("proxy routes that forward upstream bytes are never compressed", async () => {
+  // Unauthenticated, so these stop at 401 -- enough to prove the middleware
+  // declines the path, which is what issue #76 was about.
+  const app = createApp();
+  for (const path of ["/api/blob/a/b/c.pdf", "/api/image?url=https://example.com/x.png", "/api/ics?url=https://example.com/x.ics"]) {
+    const res = await app.request(path, { headers: { "accept-encoding": "gzip" } });
+    assert.equal(res.headers.get("content-encoding"), null, `${path} must not be compressed`);
+  }
+});
+
+test("the push stream is never compressed", async () => {
+  const res = await createApp().request("/api/events", { headers: { "accept-encoding": "gzip" } });
+  assert.equal(res.headers.get("content-encoding"), null);
+});
+
+test("the liveness probe is not compressed, since gzip would make it bigger", async () => {
+  const res = await createApp().request("/api/health", { headers: { "accept-encoding": "gzip" } });
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("content-encoding"), null);
+});
+
+test("advertised upstream URLs are pinned to the configured origin", async () => {
+  const { absoluteUpstream } = await import("./upstream.js");
+  const pinned = absoluteUpstream("https://mail.public.example/jmap/eventsource/?types=*", "http://stalwart:8080");
+  assert.equal(pinned, "http://stalwart:8080/jmap/eventsource/?types=*");
+  // A relative URL still resolves against the base, as before.
+  assert.equal(absoluteUpstream("/jmap/", "http://stalwart:8080/"), "http://stalwart:8080/jmap/");
+});
+
+test("the data path is rate limited per session, and login stays on its own budget", async () => {
+  // No session: every call is refused before the limiter, so it must never 429.
+  const app = createApp();
+  for (let i = 0; i < 5; i++) {
+    const res = await app.request("/api/jmap", { method: "POST",
+      headers: { "content-type": "application/json", "x-requested-with": "ihasmail" }, body: "{}" });
+    assert.equal(res.status, 401);
+  }
+  // The limiter itself: a fresh key gets its budget and nothing more.
+  const { RateLimiter } = await import("./ratelimit.js");
+  const l = new RateLimiter(3, 60_000);
+  assert.deepEqual([l.check("s1"), l.check("s1"), l.check("s1"), l.check("s1")], [true, true, true, false]);
+  assert.ok(l.retryAfterSeconds("s1") >= 1);
+  assert.equal(l.check("s2"), true, "another session is not affected");
+});
+
+test("a response to a client that offered no encoding is not touched by the compressor", async () => {
+  const res = await createApp().request("/assets/app.js");   // no Accept-Encoding at all
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("content-encoding"), null);
+  assert.equal(res.headers.get("vary"), null, "no Vary: the middleware never ran");
+});

server/src/config.ts

@@ -202,9 +202,9 @@ function readSettingsPolicy(): { defaults: Record<string, unknown>; enforced: Re
  * having an outage would take the other four down with it. What happens when
  * one is unreachable is a sign-in question, answered in #239.
  */
-function readStalwartServers(): Record<string, string> {
+function readStalwartServers(): { urls: Record<string, string>; adminUrls: Record<string, string> } {
   const file = process.env.STALWART_SERVERS_FILE;
-  if (!file) return {};
+  if (!file) return { urls: {}, adminUrls: {} };
   if (!existsSync(file)) throw new Error(`STALWART_SERVERS_FILE does not exist: ${file}`);
 
   let raw: unknown;
@@ -213,33 +213,55 @@ function readStalwartServers(): Record<string, string> {
   } catch (err) {
     throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): ${(err as Error).message}`);
   }
+  return parseStalwartServers(raw, file);
+}
+
+/** The servers file's contents, checked. Exported so the shipped example is tested by the parser that reads it. */
+export function parseStalwartServers(raw: unknown, file: string): { urls: Record<string, string>; adminUrls: Record<string, string> } {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): expected an object of domain to URL`);
   }
 
   const out: Record<string, string> = {};
-  for (const [rawDomain, rawUrl] of Object.entries(raw as Record<string, unknown>)) {
+  const adminUrls: Record<string, string> = {};
+  for (const [rawDomain, rawValue] of Object.entries(raw as Record<string, unknown>)) {
+    /* The example file explains itself in a `_comment` key, and a copy of it
+       used to stop the server as "not a URL". No mail domain starts with an
+       underscore, so a key that does is a note, not a mapping. */
+    if (rawDomain.startsWith("_")) continue;
     /* Lower-cased and stripped of the root dot, because that is how a domain
        taken off a username will arrive and comparing them any other way means
        a mapping that silently never matches. */
     const domain = rawDomain.trim().toLowerCase().replace(/\.$/, "");
     if (!domain) throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): a domain key is empty`);
-    if (domain in out) throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" appears twice once normalised`);
-    if (typeof rawUrl !== "string") throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" is not a URL`);
+    if (domain in out) throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" appears twice once normalized`);
+    /* A domain's value is its server's URL, or an object that also names where
+       that server's own administration is: `{"url": …, "adminUrl": …}`. */
+    const value = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) ? (rawValue as Record<string, unknown>) : { url: rawValue };
+    if (typeof value.url !== "string") throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" is not a URL`);
+    out[domain] = httpUrl(value.url, `STALWART_SERVERS_FILE (${file}): "${domain}"`);
+    if (value.adminUrl !== undefined) {
+      if (typeof value.adminUrl !== "string") throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" adminUrl is not a URL`);
+      adminUrls[domain] = httpUrl(value.adminUrl, `STALWART_SERVERS_FILE (${file}): "${domain}" adminUrl`);
+    }
+  }
+  return { urls: out, adminUrls };
+}
+
+/** An absolute http(s) URL without its trailing slash, or a startup error naming where it came from. */
+function httpUrl(raw: string, where: string): string {
   let parsed: URL;
   try {
-      parsed = new URL(rawUrl);
+    parsed = new URL(raw);
   } catch {
-      throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" is not an absolute URL`);
+    throw new Error(`Invalid ${where}: not an absolute URL`);
   }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      throw new Error(`Invalid STALWART_SERVERS_FILE (${file}): "${domain}" must be http or https`);
-    }
-    out[domain] = rawUrl.replace(/\/+$/, "");
-  }
-  return out;
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Invalid ${where}: must be http or https`);
+  return raw.replace(/\/+$/, "");
 }
 
+const stalwartServers = readStalwartServers();
+
 export const config = {
   isProd,
   appName: env("APP_NAME", "ihasmail"),
@@ -275,7 +297,23 @@ export const config = {
    */
   basePath: normalizeBasePath(process.env.BASE_PATH),
   stalwartUrl,
-  stalwartServers: readStalwartServers(),
+  stalwartServers: stalwartServers.urls,
+  /**
+   * Where an administrator reaches Stalwart's own administration, for the
+   * pointer on ihasmail's dashboard. Optional, and separate from STALWART_URL,
+   * which is how *this server* reaches Stalwart -- often an address no browser
+   * can open. Unset, the dashboard names Stalwart's administration without a
+   * link. A domain routed elsewhere takes its server's `adminUrl` instead.
+   */
+  stalwartAdminUrl: process.env.STALWART_ADMIN_URL ? httpUrl(process.env.STALWART_ADMIN_URL, "STALWART_ADMIN_URL") : "",
+  stalwartAdminUrls: stalwartServers.adminUrls,
+  /**
+   * Say that an Enterprise-only section is Enterprise-only even on an
+   * Enterprise server. Off, as a real installation wants it; the public demo
+   * turns it on, because it reports Enterprise to show those sections and
+   * should not suggest they come without the license.
+   */
+  showEnterpriseNotices: bool("SHOW_ENTERPRISE_NOTICES", false),
   appSecret,
   trustProxy: bool("TRUST_PROXY", true),
   /**
@@ -295,9 +333,41 @@ export const config = {
   upstreamTimeout: int("UPSTREAM_TIMEOUT", 30_000),
   maxUploadBytes: int("MAX_UPLOAD_BYTES", 50 * 1024 * 1024),
   imageProxy: bool("IMAGE_PROXY", true),
+  /*
+   * Whether ihasmail offers administration to accounts whose Stalwart role
+   * allows it. Off means off: no menu, no permissions sent to the browser, and
+   * the JMAP proxy refuses registry methods beyond the account's own -- see
+   * adminGate.ts. Stalwart's own interface is unaffected either way.
+   */
+  administration: bool("ADMINISTRATION", true),
   cookieName: env("COOKIE_NAME", "ihm_session"),
   staticDir: process.env.STATIC_DIR ?? fileURLToPath(new URL("../../web/dist", import.meta.url)),
   loginRateLimit: int("LOGIN_RATE_LIMIT", 10),
+  /*
+   * Requests per minute one session may make on the data path -- JMAP, blobs,
+   * the image and calendar proxies. The proxy is one Node process and saturates
+   * a core at roughly 2,000 operations a second, so without this a single
+   * signed-in user can deny service to everyone else. 1,200 a minute is twenty
+   * a second sustained: well above what a busy tab does, and an order of
+   * magnitude below where one tab starts to hurt the rest. 0 disables it.
+   */
+  apiRateLimit: int("API_RATE_LIMIT", 1200),
+  /* Whether JMAP responses are gzipped. Measured: see the bake-off rerun. */
+  compressJmap: process.env.COMPRESS_JMAP !== "0",
+  /*
+   * How push reaches the browser. "relay" holds one upstream stream per tab
+   * (today's behavior). "subscribe" registers one JMAP PushSubscription per
+   * account and fans Stalwart's POSTs out to that account's tabs, holding no
+   * upstream connection at all -- see push.ts. It needs PUSH_URL: the https
+   * origin Stalwart can reach ihasmail at, with a certificate it trusts.
+   * An account that cannot be verified stays on the relay.
+   */
+  pushMode: (process.env.PUSH_MODE === "relay" ? "relay" : "subscribe") as "relay" | "subscribe",
+  pushUrl: process.env.PUSH_URL || "",
+  /* See relayPushRaw(): pipe the push stream socket-to-socket instead of through fetch(). */
+  rawPushRelay: process.env.RAW_PUSH_RELAY !== "0",
+  /* See absoluteUpstream(): follow Stalwart's advertised origin instead of pinning to ours. */
+  followAdvertisedUrls: process.env.STALWART_FOLLOW_ADVERTISED_URLS === "1",
 };
 
 export type Config = typeof config;

server/src/domainrouting.test.ts

@@ -45,7 +45,7 @@ test("an unmapped domain still goes to the default while others are mapped", ()
 });
 
 test("the domain is matched however it was typed", () => {
-  // Keys are normalised on load; the username has to be normalised the same
+  // Keys are normalized on load; the username has to be normalized the same
   // way or a mapping silently never matches.
   config.stalwartServers["mapped.test"] = "https://mail.mapped.test";
   try {

server/src/imageproxy.test.ts

@@ -15,7 +15,7 @@ const { createApp } = await import("./app.js");
  * it is pointed at.
  */
 
-test("addresses we must never reach are recognised", () => {
+test("addresses we must never reach are recognized", () => {
   for (const a of [
     "127.0.0.1", "10.1.2.3", "172.16.0.1", "172.31.255.255", "192.168.1.1",
     "169.254.169.254", // cloud metadata, the classic SSRF target

server/src/imageproxy.ts

@@ -217,7 +217,8 @@ export async function imageProxyHandler(c: Context) {
   res.on("close", done);
   const headers = new Headers({
     "Content-Type": type,
-    "Cache-Control": "private, max-age=86400",
+    // As for attachments: nothing left in the disk cache of a device that is not the person's own.
+    "Cache-Control": (c.get("session") as { remember?: boolean } | undefined)?.remember ? "private, max-age=86400" : "no-store",
     "X-Content-Type-Options": "nosniff",
     "Content-Security-Policy": "sandbox; default-src 'none'",
     "Cross-Origin-Resource-Policy": "same-origin",

server/src/mock/auth.ts

@@ -0,0 +1,9 @@
+import { account } from "./config.js";
+import { parseOtpauthUrl, verifyTotp } from "../totp.js";
+
+/* Shared by the HTTP layer and by the handlers that re-check a code. */
+export function checkOtp(code: string | undefined): boolean {
+  if (!account.otpUrl) return true;
+  const params = parseOtpauthUrl(account.otpUrl);
+  return Boolean(code && params && verifyTotp(params, code));
+}

server/src/mock/config.ts

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+
+
+export const PERMISSION_SNAPSHOT = (JSON.parse(readFileSync(new URL("../../../web/src/locales/permissions/source.json", import.meta.url), "utf8")) as { permissions: Array<{ name: string; label: string }> }).permissions;
+
+export const PORT = Number(process.env.MOCK_PORT ?? 8788);
+/**
+ * Omit `urn:stalwart:jmap` from the session, so a sign-in can be tested
+ * against a server ihasmail does not support. This is only that: the rest of
+ * the mock still behaves like 0.16. Emulating 0.15 properly went with the
+ * support for it.
+ */
+export const NO_REGISTRY = process.env.MOCK_NO_REGISTRY === "1";
+/**
+ * Stalwart advertises FUTURERELEASE in the session but only honors it when
+ * the MTA's own `futureRelease` setting is on -- and that setting defaults to
+ * off, in which case the hold is dropped without a word and the message goes
+ * out at once. Set MOCK_NO_FUTURE_RELEASE=1 to reproduce that trap.
+ */
+export const NO_FUTURE_RELEASE = process.env.MOCK_NO_FUTURE_RELEASE === "1";
+/** What the session advertises, matching Stalwart's own 30 days. */
+export const MAX_DELAYED_SEND = 86400 * 30;
+export const ACCOUNT = "a1";
+/** How long a push subscription lives before the server drops it. */
+export const PUSH_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** An account somebody has shared with the demo user. See the session below. */
+export const SHARED_ACCOUNT = "a2";
+export const SHARED_CAPS: Obj = {
+  "urn:ietf:params:jmap:mail": {}, "urn:ietf:params:jmap:submission": {}, "urn:ietf:params:jmap:vacationresponse": {},
+  "urn:ietf:params:jmap:sieve": {}, "urn:ietf:params:jmap:calendars": {}, "urn:ietf:params:jmap:contacts": {},
+  "urn:ietf:params:jmap:principals": {}, "urn:ietf:params:jmap:quota": {}, "urn:ietf:params:jmap:filenode": {},
+};
+export const USER = process.env.MOCK_USER ?? "[email protected]";
+/** Locale the fake directory reports for the account (POSIX style, as Stalwart does). */
+export const MOCK_LOCALE = process.env.MOCK_LOCALE ?? "en_US";
+/** What /api/account reports. Tenants are managed only on "enterprise"; MOCK_EDITION=enterprise to develop them. */
+export const MOCK_EDITION = process.env.MOCK_EDITION ?? "oss";
+export const PASS = process.env.MOCK_PASS ?? "demo";
+/**
+ * Credential state, mutable so the self-service flows can be exercised against
+ * the mock the way they run against a real 0.16 server: the password changes,
+ * 2FA starts demanding a code on every request, and app passwords keep working
+ * without one.
+ */
+export const account = { password: PASS, otpUrl: null as string | null, appPasswords: [] as Obj[] };
+export const MASKED = "[********]";
+
+export type Obj = Record<string, unknown>;
+export const state = { n: 1 };
+export const nextState = () => String(state.n++);
+

server/src/mock/data.ts

@@ -0,0 +1,415 @@
+import { randomUUID } from "node:crypto";
+import { signedMessage, type SIGNED_MESSAGES } from "./signedMessages.js";
+import { Obj, SHARED_ACCOUNT, USER, account } from "./config.js";
+
+/* ---------- data ---------- */
+/*
+ * The names are Stalwart's own defaults, which follow the Exchange convention:
+ * "Deleted Items" and "Sent Items", not "Trash" and "Sent". The mock used the
+ * short forms, so anything built from a folder's name read differently here
+ * than in production -- "Empty Trash" against the mock, "Empty Deleted Items"
+ * against a real server -- and every screenshot in the README showed a folder
+ * list no user has. The role is what the client branches on; the name is only
+ * ever displayed, which is exactly why it has to look right.
+ */
+/** Push subscriptions, as a fresh account has none. */
+export const pushSubscriptions: Obj[] = [];
+
+export const mailboxes: Obj[] = [
+  mb("inbox", "Inbox", "inbox"),
+  mb("drafts", "Drafts", "drafts"),
+  mb("sent", "Sent Items", "sent"),
+  mb("junk", "Junk Mail", "junk"),
+  mb("trash", "Deleted Items", "trash"),
+  mb("archive", "Archive", "archive"),
+  mb("work", "Work", null),
+  mb("work-inv", "Invoices", null, "work"),
+  mb("news", "Newsletters", null),
+];
+export function mb(id: string, name: string, role: string | null, parentId: string | null = null): Obj {
+  return { id, name, parentId, role, sortOrder: 0, totalEmails: 0, unreadEmails: 0, totalThreads: 0, unreadThreads: 0, isSubscribed: true, myRights: { mayReadItems: true, mayAddItems: true, mayRemoveItems: true, maySetSeen: true, maySetKeywords: true, mayCreateChild: true, mayRename: true, mayDelete: true, maySubmit: true } };
+}
+
+export const blobs = new Map<string, { type: string; data: Buffer }>();
+export function putBlob(data: Buffer | string, type: string): string {
+  const id = `b${randomUUID().slice(0, 8)}`;
+  blobs.set(id, { type, data: Buffer.isBuffer(data) ? data : Buffer.from(data) });
+  return id;
+}
+
+export const people = [
+  ["Ada Lovelace", "[email protected]"], ["Grace Hopper", "[email protected]"], ["Linus Torvalds", "[email protected]"],
+  ["Margaret Hamilton", "[email protected]"], ["Alan Turing", "[email protected]"], ["GitHub", "[email protected]"],
+  ["Stalwart Labs", "[email protected]"], ["Weekly Digest", "[email protected]"], ["Finance Team", "[email protected]"],
+];
+export const subjects = [
+  "Re: Q3 planning document", "Your invoice #4821 is ready", "Welcome to Stalwart!", "Lunch on Thursday?", "[PR] Fix push reconnect backoff",
+  "Weekly digest: 12 new articles", "Photos from the hike", "Deployment window this weekend", "Contract draft v3 attached", "Can you review my slides?",
+  "Reminder: dentist appointment", "Flight confirmation – BOS → SFO", "Team offsite agenda", "Re: Re: budget approval", "Security notice: new sign-in",
+];
+export const emails: Obj[] = [];
+export const seq = { counter: 1 };
+/**
+ * A real TNEF blob, built to the format description, so the winmail.dat
+ * decoder has something to open that is not a hand-made fixture in its own
+ * test file. Two files inside, one of them carrying a long name in the MAPI
+ * stream behind an 8.3 title -- which is the case the decoder exists for.
+ */
+export function winmailDat(): Buffer {
+  const u16 = (v: number) => Buffer.from([v & 0xff, (v >> 8) & 0xff]);
+  const u32 = (v: number) => Buffer.from([v & 0xff, (v >> 8) & 0xff, (v >> 16) & 0xff, (v >>> 24) & 0xff]);
+  const sum = (b: Buffer) => { let n = 0; for (const x of b) n = (n + x) & 0xffff; return n; };
+  const attr = (level: number, id: number, data: Buffer) => Buffer.concat([Buffer.from([level]), u32(id), u32(data.length), data, u16(sum(data))]);
+  const asciiProp = (id: number, value: string) => {
+    const bytes = Buffer.concat([Buffer.from(value, "latin1"), Buffer.from([0])]);
+    const pad = Buffer.alloc((4 - (bytes.length % 4)) % 4);
+    return Buffer.concat([u32(((id & 0xffff) << 16) | 0x001e), u32(bytes.length), bytes, pad]);
+  };
+  const mapi = (props: Buffer[]) => Buffer.concat([u32(props.length), ...props]);
+
+  const renddata = Buffer.alloc(14);
+  const title = (n: string) => Buffer.concat([Buffer.from(n, "latin1"), Buffer.from([0])]);
+  const notes = Buffer.from("Numbers pulled from the mock, not from anywhere real.\n", "latin1");
+  const csv = Buffer.from("quarter,revenue\nQ1,120\nQ2,145\n", "latin1");
+
+  return Buffer.concat([
+    u32(0x223e9f78), u16(0x1234),
+    attr(1, 0x00089006, u32(0x00010000)), // attTnefVersion
+    attr(2, 0x00069002, renddata),
+    attr(2, 0x00018010, title("QUARTE~1.CSV")),
+    attr(2, 0x00069005, mapi([asciiProp(0x3707, "Quarterly Revenue Final.csv"), asciiProp(0x370e, "text/csv")])),
+    attr(2, 0x0006800f, csv),
+    attr(2, 0x00069002, renddata),
+    attr(2, 0x00018010, title("notes.txt")),
+    attr(2, 0x0006800f, notes),
+  ]);
+}
+
+/**
+ * A really signed message, served as the raw blob a client verifies against.
+ *
+ * The signature is over exact bytes, so this deliberately does not go through
+ * addEmail: that builds a message out of parts and would hand back a body it
+ * had assembled rather than the one that was signed. Here the blob *is* the
+ * fixture, byte for byte, and the JMAP metadata is arranged around it.
+ *
+ * `bodyStructure` says multipart/signed because that is what the client checks
+ * before deciding to download anything -- a mock that omitted it would leave
+ * the whole path unreachable while every stored byte was still correct.
+ */
+export function addSignedEmail(o: { which: keyof typeof SIGNED_MESSAGES; from: [string, string]; subject: string; daysAgo: number; mailbox: string; unread?: boolean }) {
+  const id = `e${seq.counter++}`;
+  const raw = signedMessage(o.which);
+  const received = new Date(Date.now() - o.daysAgo * 86400_000).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const body = "The Analytical Engine has no pretensions whatever to originate anything.";
+  const textBlob = putBlob(body, "text/plain");
+  const e: Obj = {
+    id,
+    blobId: putBlob(raw, "message/rfc822"),
+    threadId: `t${id}`,
+    mailboxIds: { [o.mailbox]: true },
+    keywords: o.unread ? {} : { $seen: true },
+    size: raw.length,
+    receivedAt: received,
+    sentAt: received,
+    messageId: [`${id}@mock`],
+    inReplyTo: null,
+    references: null,
+    from: [{ name: o.from[0], email: o.from[1] }],
+    to: [{ name: "Demo User", email: USER }],
+    cc: null, bcc: null, replyTo: null, sender: null,
+    subject: o.subject,
+    hasAttachment: false,
+    preview: body.slice(0, 120),
+    textBody: [{ partId: "1", blobId: textBlob, size: body.length, name: null, type: "text/plain", charset: "utf-8", disposition: null, cid: null }],
+    // `htmlBody` is derived (RFC 8621 4.1.4): a message with no HTML
+    // alternative still gets one, holding the text/plain part. Checked against
+    // Stalwart 0.16.21 on 2026-09-10 -- see hasHtmlAlternative() in the client,
+    // which reads the part's type rather than trusting this list to be empty.
+    htmlBody: [{ partId: "1", blobId: textBlob, size: body.length, name: null, type: "text/plain", charset: "utf-8", disposition: null, cid: null }],
+    attachments: [],
+    bodyValues: { "1": { value: body, isEncodingProblem: false, isTruncated: false } },
+    bodyStructure: {
+      partId: null, blobId: null, size: raw.length, type: "multipart/signed", name: null, charset: null, disposition: null, cid: null,
+      subParts: [
+        { partId: "1", blobId: textBlob, size: body.length, type: "text/plain", name: null, charset: "utf-8", disposition: null, cid: null },
+        { partId: "2", blobId: null, size: 0, type: "application/x-pkcs7-signature", name: "smime.p7s", charset: null, disposition: "attachment", cid: null },
+      ],
+    },
+  };
+  emails.push(e);
+  return e;
+}
+
+/*
+ * A marketing template of the shape #290 was reported against.
+ *
+ * Nothing in it is unusual — an outer 600px wrapper on `bgcolor="#ffffff"`, a
+ * `<style>` block, a colored call to action, a gray footer — and that is the
+ * point. Every one of those is enough to make `htmlDeclaresColors` true, so a
+ * mock without one could not show what "apply the theme to messages too" does
+ * to the mail people actually receive: nothing at all.
+ */
+export const STYLED_MARKETING_HTML = `<html><head><style>
+  a { color:#1155CC; text-decoration:underline }
+  .h { font-size:20px; color:#111111 }
+</style></head><body style="margin:0;background-color:#f4f4f4">
+<table width="100%" bgcolor="#f4f4f4" cellpadding="0" cellspacing="0"><tr><td align="center">
+  <table width="600" bgcolor="#ffffff" cellpadding="0" cellspacing="0" style="background-color:#ffffff">
+    <tr><td style="padding:24px"><p class="h">Your order is on its way</p>
+      <p style="color:#333333">Thanks for shopping with us. Your parcel left the warehouse this morning.</p>
+      <table cellpadding="0" cellspacing="0"><tr>
+        <td bgcolor="#1155CC" style="border-radius:4px;padding:12px 20px">
+          <a href="https://example.com/track" style="color:#FFFFFF;text-decoration:none">Track your parcel</a>
+        </td></tr></table>
+      <p style="color:#666666;font-size:12px">Order #4471 &middot; placed 2 September</p>
+    </td></tr>
+    <tr><td bgcolor="#222222" style="padding:16px;color:#dddddd;font-size:12px">
+      You are receiving this because you bought something. <a href="https://example.com/x" style="color:#88bbff">Unsubscribe</a>
+    </td></tr>
+  </table>
+</td></tr></table></body></html>`;
+
+export function addEmail(o: { from: [string, string]; to?: string; subject: string; daysAgo: number; mailbox: string; threadId?: string; unread?: boolean; flagged?: boolean; html?: boolean; styled?: boolean; attach?: boolean; winmail?: boolean; inReplyTo?: string }) {
+  const id = `e${seq.counter++}`;
+  const received = new Date(Date.now() - o.daysAgo * 86400_000 - Math.random() * 3600_000 * 5).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const text = `Hi,\n\nThis is a sample message about "${o.subject}". It was generated by the ihasmail mock server so you can try the interface without a real mailbox.\n\nSome highlights:\n- Keyboard shortcuts (press ? )\n- Conversation view\n- Drag & drop to folders\n\nCheers,\n${o.from[0]}\n\n> On Monday, someone wrote:\n> This is the quoted part of an earlier message.\n> It should be collapsed by default.`;
+  const html = `<html><body style="font-family:Arial"><p>Hi,</p><p>This is a <b>sample HTML message</b> about “${o.subject}”. It was generated by the ihasmail mock server.</p><ul><li>Keyboard shortcuts (press ?)</li><li>Conversation view</li><li><a href="https://stalw.art">Drag &amp; drop</a> to folders</li></ul><p><img src="https://example.com/tracker.gif" width="1" height="1" alt=""> <img src="cid:logo@mock" width="120" alt="logo"></p><p>Cheers,<br>${o.from[0]}</p><div class="gmail_quote">On Monday, someone wrote:<blockquote>This is the quoted part of an earlier message. It should be collapsed by default.</blockquote></div></body></html>`;
+  const textBlob = putBlob(text, "text/plain");
+  const htmlBlob = putBlob(o.styled ? STYLED_MARKETING_HTML : html, "text/html");
+  const attachments: Obj[] = [];
+  if (o.attach) {
+    attachments.push({ partId: "3", blobId: putBlob("%PDF-1.4 mock", "application/pdf"), size: 48213, name: "contract-v3.pdf", type: "application/pdf", charset: null, disposition: "attachment", cid: null });
+    attachments.push({ partId: "4", blobId: putBlob(Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64"), "image/png"), size: 68, name: "pixel.png", type: "image/png", charset: null, disposition: "attachment", cid: null });
+  }
+  if (o.winmail) {
+    const dat = winmailDat();
+    attachments.push({ partId: "6", blobId: putBlob(dat, "application/ms-tnef"), size: dat.length, name: "winmail.dat", type: "application/ms-tnef", charset: null, disposition: "attachment", cid: null });
+  }
+  if (o.html) attachments.push({ partId: "5", blobId: putBlob(Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP4z8DwHwAFAAH/q842iQAAAABJRU5ErkJggg==", "base64"), "image/png"), size: 68, name: "logo.png", type: "image/png", charset: null, disposition: "inline", cid: "logo@mock" });
+  const e: Obj = {
+    id, blobId: putBlob(`From: ${o.from[0]} <${o.from[1]}>\r\nTo: ${USER}\r\nSubject: ${o.subject}\r\nDate: ${received}\r\nMessage-ID: <${id}@mock>\r\n\r\n${text}`, "message/rfc822"),
+    threadId: o.threadId ?? `t${id}`, mailboxIds: { [o.mailbox]: true },
+    keywords: { ...(o.unread ? {} : { $seen: true }), ...(o.flagged ? { $flagged: true } : {}) },
+    size: 4000 + Math.floor(Math.random() * 20000), receivedAt: received, sentAt: received,
+    messageId: [`${id}@mock`], inReplyTo: o.inReplyTo ? [o.inReplyTo] : null, references: o.inReplyTo ? [o.inReplyTo] : null,
+    from: [{ name: o.from[0], email: o.from[1] }], to: [{ name: "Demo User", email: o.to ?? USER }], cc: null, bcc: null, replyTo: null, sender: null,
+    subject: o.subject, hasAttachment: Boolean(o.attach), preview: text.slice(0, 120).replace(/\n/g, " "),
+    textBody: [{ partId: "1", blobId: textBlob, size: text.length, name: null, type: "text/plain", charset: "utf-8", disposition: null, cid: null }],
+    // No HTML alternative means `htmlBody` names the text part, not nothing. See addSignedEmail.
+    htmlBody: o.html ? [{ partId: "2", blobId: htmlBlob, size: (o.styled ? STYLED_MARKETING_HTML : html).length, name: null, type: "text/html", charset: "utf-8", disposition: null, cid: null }] : [{ partId: "1", blobId: textBlob, size: text.length, name: null, type: "text/plain", charset: "utf-8", disposition: null, cid: null }],
+    attachments,
+    bodyValues: { "1": { value: text, isEncodingProblem: false, isTruncated: false }, ...(o.html ? { "2": { value: o.styled ? STYLED_MARKETING_HTML : html, isEncodingProblem: false, isTruncated: false } } : {}) },
+    bodyStructure: { partId: null, blobId: null, size: 0, type: "multipart/mixed", name: null, charset: null, disposition: null, cid: null, subParts: [{ partId: "1", blobId: textBlob, size: text.length, type: "text/plain", name: null, charset: "utf-8", disposition: null, cid: null }, ...(o.html ? [{ partId: "2", blobId: htmlBlob, size: (o.styled ? STYLED_MARKETING_HTML : html).length, type: "text/html", name: null, charset: "utf-8", disposition: null, cid: null }] : []), ...attachments] },
+    "header:List-Unsubscribe:asText": o.from[1].includes("newsletter") ? "<mailto:[email protected]?subject=unsubscribe>, <https://newsletter.example/unsub>" : null,
+    "header:X-Priority:asText": o.subject.startsWith("Security") ? "1 (Highest)" : null,
+    // Stalwart's spam filter writes the SpamAssassin-shaped set at delivery, so
+    // delivered mail carries it and mail this account wrote does not.
+    "header:X-Spam-Status:asText":
+      o.mailbox === "junk"
+        ? "Yes, score=14.2 required=5.0 tests=[BAYES_99=3.5, URIBL_BLOCKED=2.7, HTML_IMAGE_ONLY=1.4, SUBJ_ALL_CAPS=1.2, FROM_FREEMAIL=0.4] autolearn=no"
+        : o.mailbox === "inbox"
+          ? "No, score=-1.8 required=5.0 tests=[BAYES_00=-1.9, DKIM_VALID=-0.7, SPF_PASS=-0.1, HTML_MESSAGE=0.9]"
+          : null,
+  };
+  emails.push(e);
+  return e;
+}
+// Seed
+for (let i = 0; i < 45; i++) {
+  const p = people[i % people.length]!;
+  const subj = subjects[i % subjects.length]!;
+  const e = addEmail({ from: [p[0]!, p[1]!], subject: subj, daysAgo: i * 0.7, mailbox: i % 9 === 8 ? "news" : i % 11 === 10 ? "work" : "inbox", unread: i % 3 === 0, flagged: i % 7 === 0, html: i % 2 === 0, attach: i % 5 === 0 });
+  if (i % 4 === 0) {
+    // thread replies
+    addEmail({ from: ["Demo User", USER], to: p[1]!, subject: `Re: ${subj}`, daysAgo: i * 0.7 - 0.2, mailbox: "sent", threadId: e.threadId as string, inReplyTo: `${e.id}@mock`, html: true });
+    addEmail({ from: [p[0]!, p[1]!], subject: `Re: ${subj}`, daysAgo: i * 0.7 - 0.4, mailbox: "inbox", threadId: e.threadId as string, unread: i % 8 === 0, inReplyTo: `${e.id}@mock`, html: i % 3 === 0 });
+  }
+}
+addEmail({ from: ["Shop Updates", "[email protected]"], subject: "Your order is on its way", daysAgo: 0.3, mailbox: "inbox", html: true, styled: true });
+addEmail({ from: ["Demo User", USER], to: "[email protected]", subject: "Draft: ideas for the retreat", daysAgo: 0.1, mailbox: "drafts", html: true }).keywords = { $draft: true, $seen: true };
+
+/*
+ * Three signed messages, so every branch of the signature banner can be seen
+ * without staging a certificate authority. Read "A note" first: that pins Ada's
+ * certificate, after which the other two have something to disagree with.
+ */
+addSignedEmail({ which: "good", from: ["Ada Lovelace", "[email protected]"], subject: "A note", daysAgo: 0.2, mailbox: "inbox", unread: true });
+addSignedEmail({ which: "tampered", from: ["Ada Lovelace", "[email protected]"], subject: "A note (altered in transit)", daysAgo: 0.25, mailbox: "inbox", unread: true });
+addSignedEmail({ which: "imposter", from: ["Ada Lovelace", "[email protected]"], subject: "A note (signed by somebody else)", daysAgo: 0.3, mailbox: "inbox", unread: true });
+addEmail({ from: ["Spammy", "[email protected]"], subject: "You have WON!!!", daysAgo: 2, mailbox: "junk", unread: true });
+addEmail({ from: ["Outlook User", "[email protected]"], subject: "Q3 figures (sent from Outlook)", daysAgo: 1, mailbox: "inbox", unread: true, winmail: true });
+addEmail({ from: ["Finance Team", "[email protected]"], subject: "Invoice 2201 approved", daysAgo: 1, mailbox: "work-inv", unread: true });
+addEmail({ from: ["Finance Team", "[email protected]"], subject: "Invoice 2202 pending", daysAgo: 2, mailbox: "work-inv", unread: true });
+// A thread whose unread message is not the last one: someone's server queued
+// their reply for hours, so it landed after messages that answer it and sits in
+// the middle of the conversation. Opening this thread at the newest message
+// left that reply above the fold until the mark-read timer swept it (#87).
+{
+  const subj = "Compiler timings for the release";
+  const t = addEmail({ from: ["Grace Hopper", "[email protected]"], subject: subj, daysAgo: 6, mailbox: "inbox", html: true });
+  const tid = t.threadId as string;
+  const reply = (o: { from: [string, string]; daysAgo: number; mailbox: string; to?: string; unread?: boolean; html?: boolean }) =>
+    addEmail({ ...o, subject: `Re: ${subj}`, threadId: tid, inReplyTo: `${t.id}@mock` });
+  reply({ from: ["Alan Turing", "[email protected]"], daysAgo: 5.5, mailbox: "inbox", unread: true });
+  // Long enough after the unread one that the thread scrolls: opening at the
+  // bottom put four messages between the reader and the mail they had not read.
+  reply({ from: ["Demo User", USER], to: "[email protected]", daysAgo: 5, mailbox: "sent", html: true });
+  reply({ from: ["Grace Hopper", "[email protected]"], daysAgo: 4.5, mailbox: "inbox" });
+  reply({ from: ["Margaret Hamilton", "[email protected]"], daysAgo: 4, mailbox: "inbox", html: true });
+  reply({ from: ["Demo User", USER], to: "[email protected]", daysAgo: 3.5, mailbox: "sent" });
+  reply({ from: ["Grace Hopper", "[email protected]"], daysAgo: 3, mailbox: "inbox", html: true });
+}
+// Invitation email
+{
+  const ics = `BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//mock//EN\r\nMETHOD:REQUEST\r\nBEGIN:VEVENT\r\nUID:inv-1@mock\r\nDTSTAMP:20260820T100000Z\r\nDTSTART:20260825T140000Z\r\nDTEND:20260825T150000Z\r\nSUMMARY:Project kickoff\r\nORGANIZER;CN=Ada Lovelace:mailto:[email protected]\r\nATTENDEE;CN=Demo User;RSVP=TRUE;PARTSTAT=NEEDS-ACTION:mailto:${USER}\r\nLOCATION:Room 4B\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n`;
+  const e = addEmail({ from: ["Ada Lovelace", "[email protected]"], subject: "Invitation: Project kickoff", daysAgo: 0.3, mailbox: "inbox", unread: true });
+  const b = putBlob(ics, "text/calendar");
+  (e.bodyStructure as Obj).subParts = [...((e.bodyStructure as Obj).subParts as Obj[]), { partId: "9", blobId: b, size: ics.length, type: "text/calendar", name: "invite.ics", charset: "utf-8", disposition: "attachment", cid: null }];
+  (e.attachments as Obj[]).push({ partId: "9", blobId: b, size: ics.length, type: "text/calendar", name: "invite.ics", charset: "utf-8", disposition: "attachment", cid: null });
+  e.hasAttachment = true;
+}
+
+export const identities: Obj[] = [
+  { id: "i1", name: "Demo User", email: USER, replyTo: null, bcc: null, textSignature: "-- \nDemo User\nihasmail", htmlSignature: "<div>-- <br><b>Demo User</b><br>ihasmail</div>", mayDelete: false },
+  { id: "i2", name: "Demo (alias)", email: "[email protected]", replyTo: null, bcc: null, textSignature: "", htmlSignature: "", mayDelete: true },
+];
+export const vacationBox: { current: Obj } = { current: { id: "singleton", isEnabled: false, fromDate: null, toDate: null, subject: null, textBody: null, htmlBody: null } };
+export const sieveScripts: Obj[] = [];
+/* A calendar in the shared account, so "Shared with me" and a colleague's
+   events appearing in the grid can be exercised. Read-only, as a share is. */
+export const sharedCalendars: Obj[] = [{ id: "c9", name: "Grace — Work", description: null, color: "#c084fc", sortOrder: 0, isSubscribed: false, isVisible: true, isDefault: true, includeInAvailability: "all", defaultAlertsWithTime: null, defaultAlertsWithoutTime: null, timeZone: "UTC", shareWith: {}, myRights: { mayReadFreeBusy: true, mayReadItems: true, mayWriteAll: false, mayWriteOwn: false, mayUpdatePrivate: false, mayRSVP: false, mayShare: false, mayDelete: false } }];
+export const sharedEvents: Obj[] = [];
+export const eventsFor = (accountId: unknown): Obj[] => (accountId === SHARED_ACCOUNT ? sharedEvents : events);
+export const calendarsFor = (accountId: unknown): Obj[] => (accountId === SHARED_ACCOUNT ? sharedCalendars : calendars);
+export const calendars: Obj[] = [{ id: "c1", name: "Personal", description: null, color: "#0f766e", sortOrder: 0, isSubscribed: true, isVisible: true, isDefault: true, includeInAvailability: "all", defaultAlertsWithTime: null, defaultAlertsWithoutTime: null, timeZone: "UTC", shareWith: null, myRights: rightsCal() }, { id: "c2", name: "Work", description: null, color: "#2563eb", sortOrder: 1, isSubscribed: true, isVisible: true, isDefault: false, includeInAvailability: "all", defaultAlertsWithTime: null, defaultAlertsWithoutTime: null, timeZone: "UTC", shareWith: null, myRights: rightsCal() }];
+export function rightsCal() { return { mayReadFreeBusy: true, mayReadItems: true, mayWriteAll: true, mayWriteOwn: true, mayUpdatePrivate: true, mayRSVP: true, mayShare: true, mayDelete: true }; }
+export const events: Obj[] = [];
+{
+  const now = new Date();
+  const d = (dayOff: number, h: number) => { const x = new Date(now.getFullYear(), now.getMonth(), now.getDate() + dayOff, h, 0, 0); return x; };
+  const local = (x: Date) => `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, "0")}-${String(x.getDate()).padStart(2, "0")}T${String(x.getHours()).padStart(2, "0")}:00:00`;
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  events.push({ id: "ev1", calendarIds: { c1: true }, "@type": "Event", uid: "ev1", title: "Standup", start: local(d(0, 9)), timeZone: tz, duration: "PT30M", recurrenceRule: { "@type": "RecurrenceRule", frequency: "weekly", byDay: [{ day: "mo" }, { day: "tu" }, { day: "we" }, { day: "th" }, { day: "fr" }] }, showWithoutTime: false, status: "confirmed", freeBusyStatus: "busy", privacy: "public" });
+  events.push({ id: "ev2", calendarIds: { c2: true }, "@type": "Event", uid: "ev2", title: "Design review", start: local(d(1, 14)), timeZone: tz, duration: "PT1H30M", showWithoutTime: false, locations: { l: { "@type": "Location", name: "Room 2" } }, participants: { me: { "@type": "Participant", name: "Demo User", calendarAddress: `mailto:${USER}`, roles: { owner: true, attendee: true }, participationStatus: "accepted" }, p2: { "@type": "Participant", name: "Ada Lovelace", calendarAddress: "mailto:[email protected]", roles: { attendee: true, required: true }, participationStatus: "needs-action", expectReply: true } }, organizerCalendarAddress: `mailto:${USER}` });
+  events.push({ id: "ev3", calendarIds: { c1: true }, "@type": "Event", uid: "ev3", title: "Conference", start: local(d(3, 0)).slice(0, 10) + "T00:00:00", duration: "P2D", showWithoutTime: true, timeZone: null });
+  /*
+   * One event in a zone that is not the reader's, because every other fixture
+   * here uses the machine's own and so cannot tell a correct conversion from
+   * no conversion at all. Dragging this one is what proves a move keeps the
+   * time the event says it happens at.
+   */
+  events.push({ id: "ev9", calendarIds: { c1: true }, "@type": "Event", uid: "ev9", title: "Tokyo sync", start: local(d(2, 15)), timeZone: "Asia/Tokyo", duration: "PT1H", showWithoutTime: false, color: "#7c3aed" });
+  events.push({ id: "ev4", calendarIds: { c1: true }, "@type": "Event", uid: "ev4", title: "Lunch with Grace", start: local(d(2, 12)), timeZone: tz, duration: "PT1H", showWithoutTime: false, color: "#db2777" });
+  // Two in the shared account, so a colleague's calendar has something in it.
+  sharedEvents.push({ id: "sv1", calendarIds: { c9: true }, "@type": "Event", uid: "sv1", title: "Grace: release planning", start: local(d(1, 10)), timeZone: tz, duration: "PT1H", showWithoutTime: false, status: "confirmed", freeBusyStatus: "busy", privacy: "public" });
+  sharedEvents.push({ id: "sv2", calendarIds: { c9: true }, "@type": "Event", uid: "sv2", title: "Grace: on leave", start: local(d(4, 0)).slice(0, 10) + "T00:00:00", duration: "P1D", showWithoutTime: true, timeZone: null });
+}
+export const participantIdentities: Obj[] = [{ id: "pi1", name: "Demo User", calendarAddress: `mailto:${USER}`, sendTo: { imip: `mailto:${USER}` }, isDefault: true }];
+export const abRights = (write = true) => ({ mayRead: true, mayWrite: write, mayShare: write, mayDelete: write });
+export const addressBooks: Obj[] = [{ id: "ab1", name: "Personal", description: null, sortOrder: 0, isDefault: true, isSubscribed: true, shareWith: {}, myRights: abRights() }];
+/* A book in the shared account, so "Shared with me" and addressing a message
+   from somebody else's contacts can be exercised at all. Read-only, which is
+   what a share usually is. */
+export const sharedAddressBooks: Obj[] = [{ id: "ab9", name: "Team contacts", description: null, sortOrder: 0, isDefault: true, isSubscribed: false, shareWith: {}, myRights: abRights(false) }];
+export const sharedCards: Obj[] = [
+  { id: "sc1", addressBookIds: { ab9: true }, name: { full: "Katherine Johnson" }, emails: { e1: { address: "[email protected]", contexts: {} } }, phones: {}, organizations: {}, nicknames: {}, addresses: {}, notes: {}, updated: new Date().toISOString() },
+  { id: "sc2", addressBookIds: { ab9: true }, name: { full: "Dorothy Vaughan" }, emails: { e1: { address: "[email protected]", contexts: {} } }, phones: {}, organizations: {}, nicknames: {}, addresses: {}, notes: {}, updated: new Date().toISOString() },
+];
+/**
+ * One sort property, as Email/query defines them. `hasKeyword` sorts a
+ * boolean, and false comes before true -- which is what makes "unread first"
+ * an *ascending* sort on $seen.
+ */
+export function compareBy(x: Obj, y: Obj, property: string, keyword?: string): number {
+  const addr = (v: unknown) => String(((v as Obj[] | undefined)?.[0] as Obj | undefined)?.email ?? "");
+  switch (property) {
+    case "receivedAt": return String(x.receivedAt).localeCompare(String(y.receivedAt));
+    case "sentAt": return String(x.sentAt ?? x.receivedAt).localeCompare(String(y.sentAt ?? y.receivedAt));
+    case "size": return Number(x.size ?? 0) - Number(y.size ?? 0);
+    case "subject": return String(x.subject ?? "").localeCompare(String(y.subject ?? ""));
+    case "from": return addr(x.from).localeCompare(addr(y.from));
+    case "to": return addr(x.to).localeCompare(addr(y.to));
+    case "hasKeyword": {
+      const has = (e: Obj) => (keyword && (e.keywords as Obj | undefined)?.[keyword] ? 1 : 0);
+      return has(x) - has(y);
+    }
+    default: return 0;
+  }
+}
+
+/** A server that does not implement sorting on keywords, so the fallback can be developed against. */
+export const NO_KEYWORD_SORT = process.env.MOCK_NO_KEYWORD_SORT === "1";
+
+/** The floor Stalwart puts under a requested EventSource ping interval. */
+export const PING_FLOOR_SECONDS = 30;
+
+/*
+ * An account that may not send calendar invitations.
+ *
+ * 0.16.21 rejects a `CalendarEvent/set` that asks for scheduling messages when
+ * the account lacks the `calendarSchedulingSend` permission, rather than
+ * accepting the write and quietly sending nothing. **Confirmed live on 0.16.21
+ * (2026-09-06)** against an account holding a role with that permission
+ * disabled: `sendSchedulingMessages: true` came back `notCreated` with
+ * `forbidden` and the text below, while the identical request with the flag
+ * false was created normally. Set MOCK_NO_SCHEDULING_SEND=1 to develop against
+ * that account.
+ */
+export const NO_SCHEDULING_SEND = process.env.MOCK_NO_SCHEDULING_SEND === "1";
+export const SCHEDULING_FORBIDDEN = "This account is not allowed to send calendar scheduling messages.";
+
+export const booksFor = (accountId: unknown): Obj[] => (accountId === SHARED_ACCOUNT ? sharedAddressBooks : addressBooks);
+/** One per contact, by index; a gap means that card has no birthday. */
+export const BIRTHDAYS: Array<{ year?: number; month: number; day: number } | null> = [
+  { year: 1815, month: 12, day: 10 },
+  { month: 6, day: 9 }, // no year: the common case
+  { year: 1912, month: 6, day: 23 },
+  null,
+  { year: 2000, month: 2, day: 29 }, // lands on the 28th in a non-leap year
+  { year: 1918, month: 8, day: 26 },
+];
+
+export const cards: Obj[] = people.slice(0, 6).map((p, i) => {
+  const [given, surname] = p[0]!.split(" ");
+  return { id: `cc${i}`, addressBookIds: { ab1: true }, "@type": "Card", version: "1.0", uid: `uid-cc${i}`, kind: "individual", name: { components: [{ kind: "given", value: given }, { kind: "surname", value: surname ?? "" }], isOrdered: true }, emails: { e1: { address: p[1], contexts: { work: true } } }, phones: i % 2 ? { p1: { number: `+1 555 010${i}`, features: { mobile: true } } } : undefined, organizations: i % 3 ? { o1: { name: "Example Corp" } } : undefined,
+    /*
+     * Birthdays on most but not all of them, and one with no year, because a
+     * card that records only a day and month is the common case rather than
+     * the exceptional one.
+     */
+    anniversaries: BIRTHDAYS[i] ? { a1: { "@type": "Anniversary", kind: "birth", date: { "@type": "PartialDate", ...BIRTHDAYS[i] } } } : undefined };
+});
+export const principals: Obj[] = people.slice(0, 5).map((p, i) => ({ id: `pr${i}`, type: "individual", name: p[0], description: null, email: p[1], timeZone: "UTC" }));
+export const fileNodes: Obj[] = [
+  { id: "f1", parentId: null, nodeType: "directory", blobId: null, size: null, name: "Documents", type: null, created: new Date().toISOString(), modified: new Date().toISOString(), myRights: fr(), shareWith: {}, role: "documents" },
+  { id: "f2", parentId: "f1", nodeType: "file", blobId: putBlob("hello world", "text/plain"), size: 11, name: "notes.txt", type: "text/plain", created: new Date().toISOString(), modified: new Date().toISOString(), myRights: fr(), shareWith: {} },
+  { id: "f3", parentId: null, nodeType: "file", blobId: putBlob("%PDF-1.4 mock", "application/pdf"), size: 14, name: "report.pdf", type: "application/pdf", created: new Date().toISOString(), modified: new Date().toISOString(), myRights: fr(), shareWith: {} },
+];
+
+/* What the shared account holds. Its own nodes, so opening the share in Files
+   shows something different from the reader's own folders rather than the same
+   list under another name. */
+export const sharedFileNodes: Obj[] = [
+  { id: "s1", parentId: null, nodeType: "directory", blobId: null, size: null, name: "Team plans", type: null, created: new Date().toISOString(), modified: new Date().toISOString(), myRights: fr(), shareWith: {} },
+  { id: "s2", parentId: "s1", nodeType: "file", blobId: putBlob("shared notes", "text/plain"), size: 12, name: "roadmap.txt", type: "text/plain", created: new Date().toISOString(), modified: new Date().toISOString(), myRights: fr(), shareWith: {} },
+];
+/** The node list an account owns. */
+export const nodesFor = (accountId: unknown): Obj[] => (accountId === SHARED_ACCOUNT ? sharedFileNodes : fileNodes);
+
+export function fr() {
+  return { mayRead: true, mayAddChildren: true, mayRename: true, mayDelete: true, mayModifyContent: true, mayShare: true };
+}
+
+export function recount() {
+  for (const m of mailboxes) {
+    const inBox = emails.filter((e) => (e.mailboxIds as Obj)[m.id as string]);
+    m.totalEmails = inBox.length;
+    m.unreadEmails = inBox.filter((e) => !(e.keywords as Obj).$seen).length;
+    const threads = new Set(inBox.map((e) => e.threadId));
+    m.totalThreads = threads.size;
+    m.unreadThreads = new Set(inBox.filter((e) => !(e.keywords as Obj).$seen).map((e) => e.threadId)).size;
+  }
+}
+recount();
+

server/src/mock/directory.test.ts

@@ -0,0 +1,302 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createDirectory, permissionsFor, type MockRole } from "./directory.js";
+
+class Refused extends Error {
+  constructor(readonly type: string, description?: string) { super(description ?? type); }
+}
+
+const make = (role: MockRole, extra: { metricsOff?: boolean; now?: Date } = {}) => createDirectory({ accountId: "a1", user: "[email protected]", locale: "en_US", role, fail: (t, d) => new Refused(t, d), ...extra });
+
+/**
+ * The mock stands in for a server that decides what each account may do, so
+ * the client's administration can be developed against refusals as well as
+ * successes. These pin the refusals.
+ */
+test("an ordinary user is refused the directory outright", () => {
+  const dir = make("user");
+  assert.throws(() => dir.handlers["x:Account/query"]!({}), (e: Refused) => e.type === "forbidden");
+  assert.ok(!permissionsFor("user").some((p) => p.startsWith("sysAccountQuery")));
+});
+
+test("helpdesk may read and edit but not create or delete", () => {
+  const dir = make("helpdesk");
+  const { ids } = dir.handlers["x:Account/query"]!({ filter: { "@type": "User" } }) as { ids: string[] };
+  assert.ok(ids.length > 20);
+  assert.throws(() => dir.handlers["x:Account/set"]!({ create: { n: { name: "x", domainId: "d1" } } }), (e: Refused) => e.type === "forbidden");
+  assert.throws(() => dir.handlers["x:Account/set"]!({ destroy: [ids[0]] }), (e: Refused) => e.type === "forbidden");
+});
+
+test("queries page, count and match text the way the client asks", () => {
+  const dir = make("admin");
+  const all = dir.handlers["x:Account/query"]!({ filter: { "@type": "User" }, calculateTotal: true }) as { ids: string[]; total: number };
+  const page = dir.handlers["x:Account/query"]!({ filter: { "@type": "User" }, position: 10, limit: 5, calculateTotal: true }) as { ids: string[]; total: number };
+  assert.equal(page.total, all.total);
+  assert.deepEqual(page.ids, all.ids.slice(10, 15));
+  const ada = dir.handlers["x:Account/query"]!({ filter: { "@type": "User", text: "lovelace" } }) as { ids: string[] };
+  assert.equal(ada.ids.length, 1);
+  assert.throws(() => dir.handlers["x:Account/query"]!({ filter: { operator: "OR", conditions: [] } }), (e: Refused) => e.type === "unsupportedFilter");
+});
+
+test("an address already used as an alias cannot be taken", () => {
+  const dir = make("admin");
+  const res = dir.handlers["x:Account/set"]!({ create: { n: { "@type": "User", name: "postmaster", domainId: "d1", credentials: { "0": { "@type": "Password", secret: "long enough secret" } }, roles: { "@type": "User" } } } }) as { notCreated?: Record<string, { type: string }> };
+  assert.equal(res.notCreated?.n?.type, "primaryKeyViolation");
+});
+
+test("a password is set through its credential's pointer, and a weak one is refused", () => {
+  const dir = make("admin");
+  const set = dir.handlers["x:Account/set"]!;
+  assert.equal((set({ update: { a1: { "credentials/0/secret": "short" } } }) as { notUpdated?: Record<string, { properties: string[] }> }).notUpdated?.a1?.properties[0], "secret");
+  assert.deepEqual((set({ update: { a1: { "credentials/0/secret": "a much longer secret" } } }) as { updated: object }).updated, { a1: null });
+  const got = dir.handlers["x:Account/get"]!({ ids: ["a1"], properties: ["credentials"] }) as { list: Array<{ credentials: Record<string, { secret: string }> }> };
+  assert.equal(got.list[0]!.credentials["0"]!.secret, "[********]", "never echoed back");
+});
+
+test("a grant the caller does not hold is refused", () => {
+  const dir = make("helpdesk");
+  const res = dir.handlers["x:Account/set"]!({ update: { u101: { roles: { "@type": "Admin" } } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(res.notUpdated?.u101?.type, "forbidden");
+});
+
+test("an administrator can delete an account, and a group with members is kept", () => {
+  const dir = make("admin");
+  const set = dir.handlers["x:Account/set"]!;
+  assert.deepEqual((set({ destroy: ["u101"] }) as { destroyed: string[] }).destroyed, ["u101"]);
+  assert.equal((set({ destroy: ["g1"] }) as { notDestroyed?: Record<string, { type: string }> }).notDestroyed?.g1?.type, "objectIsLinked");
+});
+
+test("a domain in use is kept, and names what uses it", () => {
+  const dir = make("admin");
+  const set = dir.handlers["x:Domain/set"]!;
+  const res = set({ destroy: ["d1"] }) as { notDestroyed?: Record<string, { type: string; linkedObjects: Array<{ object: string }> }> };
+  assert.equal(res.notDestroyed?.d1?.type, "objectIsLinked");
+  const kinds = new Set(res.notDestroyed?.d1?.linkedObjects.map((o) => o.object));
+  assert.deepEqual([...kinds].sort(), ["Account", "DkimSignature"]);
+});
+
+test("an unused domain goes once its keys do", () => {
+  const dir = make("admin");
+  const created = dir.handlers["x:Domain/set"]!({ create: { n: { name: "fresh.example.net" } } }) as { created: Record<string, { id: string }> };
+  const id = created.created.n!.id;
+  const keys = dir.handlers["x:DkimSignature/query"]!({ filter: { domainId: id } }) as { ids: string[] };
+  assert.equal(keys.ids.length, 1, "automatic DKIM makes a key straight away");
+  assert.equal((dir.handlers["x:Domain/set"]!({ destroy: [id] }) as { notDestroyed?: object }).notDestroyed !== undefined, true);
+  dir.handlers["x:DkimSignature/set"]!({ destroy: keys.ids });
+  assert.deepEqual((dir.handlers["x:Domain/set"]!({ destroy: [id] }) as { destroyed: string[] }).destroyed, [id]);
+});
+
+test("a domain's zone file is computed on read, with long keys split as the server splits them", () => {
+  const dir = make("admin");
+  const got = dir.handlers["x:Domain/get"]!({ ids: ["d1"], properties: ["name", "dnsZoneFile"] }) as { list: Array<{ dnsZoneFile: string }> };
+  const zone = got.list[0]!.dnsZoneFile;
+  assert.match(zone, /IN MX 10 /);
+  assert.match(zone, /_domainkey\.example\.com\. IN TXT \(\n {4}"/);
+});
+
+test("a filter on a name the registry does not index is refused, as the live server refuses it", () => {
+  const dir = make("admin");
+  // Seen on a live 0.16 server: "x:Account/query: unsupportedFilter - type".
+  assert.throws(() => dir.handlers["x:Account/query"]!({ filter: { type: "User" } }), (e: Refused) => e.type === "unsupportedFilter" && e.message === "type");
+  assert.doesNotThrow(() => dir.handlers["x:Account/query"]!({ filter: { "@type": "Group", domainId: "d1", text: "x" } }));
+});
+
+test("the domain validators refuse what the live server refused, in its words", () => {
+  const dir = make("admin");
+  const set = dir.handlers["x:Domain/set"]!;
+  const created = set({ create: { n: { name: "admin-test.example" } } }) as { notCreated?: Record<string, { type: string; description: string }> };
+  assert.deepEqual([created.notCreated?.n?.type, created.notCreated?.n?.description], ["invalidPatch", "Invalid domain name"]);
+  const updated = set({ update: { d2: { catchAllAddress: "postmaster" } } }) as { notUpdated?: Record<string, { type: string; description: string }> };
+  assert.deepEqual([updated.notUpdated?.d2?.type, updated.notUpdated?.d2?.description], ["invalidPatch", "Invalid email address"]);
+});
+
+/** The dashboard's feeds: counts, the queue, and the metric history. */
+test("counts come back with no ids when the client asks for a total and no page", () => {
+  const dir = make("admin");
+  const r = dir.handlers["x:QueuedMessage/query"]!({ limit: 0, calculateTotal: true }) as { ids: string[]; total: number };
+  assert.deepEqual(r.ids, []);
+  assert.equal(r.total, 9);
+});
+
+test("the metric history answers the filter the dashboard sends, newest first", () => {
+  const dir = make("admin", { now: new Date("2026-09-15T14:25:00Z") });
+  const q = dir.handlers["x:Metric/query"]!({
+    filter: { timestampIsGreaterThanOrEqual: "2026-09-14T14:25:00Z", metric: ["server.memory"] },
+    sort: [{ property: "timestamp", isAscending: false }],
+  }) as { ids: string[] };
+  const { list } = dir.handlers["x:Metric/get"]!({ ids: q.ids }) as { list: Array<{ metric: string; timestamp: string }> };
+  assert.equal(list.length, 24);
+  assert.ok(list.every((m) => m.metric === "server.memory"));
+  const newest = (dir.handlers["x:Metric/get"]!({ ids: [q.ids[0]] }) as { list: Array<{ timestamp: string }> }).list[0]!;
+  const next = (dir.handlers["x:Metric/get"]!({ ids: [q.ids[1]] }) as { list: Array<{ timestamp: string }> }).list[0]!;
+  assert.equal(newest.timestamp, "2026-09-15T14:00:00Z");
+  assert.ok(newest.timestamp > next.timestamp);
+  // A bare timestamp is what a live server refuses.
+  assert.throws(() => dir.handlers["x:Metric/query"]!({ filter: { timestamp: "2026-09-15T00:00:00Z" } }), (e: Refused) => e.type === "unsupportedFilter");
+});
+
+test("a tenant administrator gets the queue but not the history, and Community refuses the history", () => {
+  const tenant = make("tenant-admin");
+  assert.equal((tenant.handlers["x:QueuedMessage/query"]!({ calculateTotal: true }) as { total: number }).total, 9);
+  assert.throws(() => tenant.handlers["x:Metric/query"]!({}), (e: Refused) => e.type === "forbidden");
+  const community = make("admin", { metricsOff: true });
+  assert.throws(() => community.handlers["x:Metric/query"]!({}), (e: Refused) => e.type === "forbidden" && /Enterprise/.test(e.message));
+});
+
+test("helpdesk may count domains, which is what the demo's helpdesk may do", () => {
+  assert.ok(permissionsFor("helpdesk").includes("sysDomainQuery"));
+  assert.ok(!permissionsFor("helpdesk").includes("sysMetricQuery"));
+});
+
+/** Groups: accounts of type Group, whose members carry the membership. */
+test("a group's members are the users whose memberships name it", () => {
+  const dir = make("admin");
+  const r = dir.handlers["x:Account/query"]!({ filter: { "@type": "User", memberGroupIds: "g2" }, calculateTotal: true }) as { ids: string[]; total: number };
+  assert.ok(r.total >= 2);
+  const { list } = dir.handlers["x:Account/get"]!({ ids: r.ids, properties: ["memberGroupIds"] }) as { list: Array<{ memberGroupIds: Record<string, boolean> }> };
+  assert.ok(list.every((a) => a.memberGroupIds.g2));
+});
+
+test("a membership pointer moves only that membership, and a group cannot join one", () => {
+  const dir = make("admin");
+  const [ada] = (dir.handlers["x:Account/query"]!({ filter: { "@type": "User", text: "lovelace" } }) as { ids: string[] }).ids;
+  dir.handlers["x:Account/set"]!({ update: { [ada!]: { "memberGroupIds/g1": true } } });
+  const read = () => ((dir.handlers["x:Account/get"]!({ ids: [ada], properties: ["memberGroupIds"] }) as { list: Array<{ memberGroupIds: Record<string, boolean> }> }).list[0]!.memberGroupIds);
+  assert.deepEqual(Object.keys(read()).sort(), ["g1", "g2"]);
+  dir.handlers["x:Account/set"]!({ update: { [ada!]: { "memberGroupIds/g2": null } } });
+  assert.deepEqual(Object.keys(read()), ["g1"]);
+  const nested = dir.handlers["x:Account/set"]!({ update: { g1: { "memberGroupIds/g2": true } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(nested.notUpdated?.g1?.type, "invalidProperties");
+  const bogus = dir.handlers["x:Account/set"]!({ update: { [ada!]: { "memberGroupIds/u1": true } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(bogus.notUpdated?.[ada!]?.type, "invalidForeignKey");
+});
+
+test("a group is kept while members name it, and goes once they are out", () => {
+  const dir = make("admin");
+  const refused = dir.handlers["x:Account/set"]!({ destroy: ["g2"] }) as { notDestroyed?: Record<string, { type: string; linkedObjects: Array<{ object: string }> }> };
+  assert.equal(refused.notDestroyed?.g2?.type, "objectIsLinked");
+  assert.ok(refused.notDestroyed!.g2!.linkedObjects.every((l) => l.object === "Account"));
+  const members = (dir.handlers["x:Account/query"]!({ filter: { "@type": "User", memberGroupIds: "g2" } }) as { ids: string[] }).ids;
+  dir.handlers["x:Account/set"]!({ update: Object.fromEntries(members.map((id) => [id, { "memberGroupIds/g2": null }])) });
+  const done = dir.handlers["x:Account/set"]!({ destroy: ["g2"] }) as { destroyed: string[] };
+  assert.deepEqual(done.destroyed, ["g2"]);
+});
+
+test("a group is created without a password, with Default roles", () => {
+  const dir = make("admin");
+  const r = dir.handlers["x:Account/set"]!({ create: { n: { "@type": "Group", name: "sales", domainId: "d1", roles: { "@type": "Default" }, permissions: { "@type": "Inherit" }, quotas: {}, aliases: {} } } }) as { created: Record<string, { id: string }> };
+  const id = r.created.n!.id;
+  const { list } = dir.handlers["x:Account/get"]!({ ids: [id] }) as { list: Array<Record<string, unknown>> };
+  assert.equal(list[0]!["@type"], "Group");
+  assert.ok(!("memberGroupIds" in list[0]!));
+});
+
+/** Mailing lists: their own object, with a set of recipient addresses. */
+test("a list is created, found by text, and read back with its address", () => {
+  const dir = make("admin");
+  const r = dir.handlers["x:MailingList/set"]!({ create: { n: { name: "team", domainId: "d1", recipients: { "[email protected]": true }, aliases: {} } } }) as { created: Record<string, { id: string }> };
+  const id = r.created.n!.id;
+  const q = dir.handlers["x:MailingList/query"]!({ filter: { text: "team" }, calculateTotal: true }) as { ids: string[] };
+  assert.deepEqual(q.ids, [id]);
+  const { list } = dir.handlers["x:MailingList/get"]!({ ids: [id] }) as { list: Array<{ emailAddress: string; recipients: Record<string, boolean> }> };
+  assert.match(list[0]!.emailAddress, /^team@/);
+  assert.deepEqual(list[0]!.recipients, { "[email protected]": true });
+});
+
+test("a recipient pointer moves one address, and a bad one is refused", () => {
+  const dir = make("admin");
+  dir.handlers["x:MailingList/set"]!({ update: { l2: { "recipients/[email protected]": true, "recipients/[email protected]": null } } });
+  const read = () => (dir.handlers["x:MailingList/get"]!({ ids: ["l2"] }) as { list: Array<{ recipients: Record<string, boolean> }> }).list[0]!.recipients;
+  assert.deepEqual(Object.keys(read()).sort(), ["[email protected]", "[email protected]"]);
+  const bad = dir.handlers["x:MailingList/set"]!({ update: { l2: { "recipients/not-an-address": true } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(bad.notUpdated?.l2?.type, "invalidPatch");
+});
+
+test("a list's address cannot be one an account already has, and a role without the permission is refused", () => {
+  const dir = make("admin");
+  const clash = dir.handlers["x:MailingList/set"]!({ create: { n: { name: "demo", domainId: "d1" } } }) as { notCreated?: Record<string, { type: string }> };
+  assert.equal(clash.notCreated?.n?.type, "primaryKeyViolation");
+  assert.throws(() => make("helpdesk").handlers["x:MailingList/query"]!({}), (e: Refused) => e.type === "forbidden");
+});
+
+/** Roles: Stalwart's grant check, loops, and a role still in use. */
+test("a role is refused a permission the caller does not hold, directly or through a base", () => {
+  const helpdesk = make("helpdesk");
+  // Helpdesk cannot create roles at all.
+  assert.throws(() => helpdesk.handlers["x:Role/set"]!({ create: { n: { description: "x" } } }), (e: Refused) => e.type === "forbidden");
+  const tenant = make("tenant-admin");
+  const direct = tenant.handlers["x:Role/set"]!({ create: { n: { description: "Too much", enabledPermissions: { sysTenantCreate: true } } } }) as { notCreated?: Record<string, { type: string; description: string }> };
+  assert.equal(direct.notCreated?.n?.type, "forbidden");
+  assert.match(direct.notCreated!.n!.description, /not authorized to grant/);
+  const fine = tenant.handlers["x:Role/set"]!({ create: { n: { description: "Accounts only", enabledPermissions: { sysAccountGet: true }, roleIds: { r1: true } } } }) as { created: Record<string, { id: string }> };
+  assert.ok(fine.created.n!.id);
+});
+
+test("a role cannot build on itself through another, and one in use is kept", () => {
+  const dir = make("admin");
+  const loop = dir.handlers["x:Role/set"]!({ update: { r1: { "roleIds/r3": true } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(loop.notUpdated?.r1?.type, "invalidPatch");
+  const inUse = dir.handlers["x:Role/set"]!({ destroy: ["r1"] }) as { notDestroyed?: Record<string, { type: string; linkedObjects: Array<{ object: string }> }> };
+  assert.equal(inUse.notDestroyed?.r1?.type, "objectIsLinked");
+  assert.deepEqual([...new Set(inUse.notDestroyed!.r1!.linkedObjects.map((l) => l.object))].sort(), ["Authentication", "Role"]);
+  const free = dir.handlers["x:Role/set"]!({ destroy: ["r4"] }) as { destroyed: string[] };
+  assert.deepEqual(free.destroyed, ["r4"]);
+});
+
+test("the default roles are read from the authentication settings", () => {
+  const { list } = make("admin").handlers["x:Authentication/get"]!({ ids: ["singleton"] }) as { list: Array<{ defaultUserRoleIds: Record<string, boolean> }> };
+  assert.deepEqual(list[0]!.defaultUserRoleIds, { r1: true });
+  assert.throws(() => make("tenant-admin").handlers["x:Authentication/get"]!({}), (e: Refused) => e.type === "forbidden");
+});
+
+test("a permission name Stalwart does not know fails the whole change", () => {
+  const dir = make("admin");
+  const r = dir.handlers["x:Role/set"]!({ update: { r4: { "enabledPermissions/notARealPermission": true, description: "Renamed" } } }) as { notUpdated?: Record<string, { type: string; properties: string[] }> };
+  assert.equal(r.notUpdated?.r4?.type, "invalidPatch");
+  assert.deepEqual(r.notUpdated!.r4!.properties, ["enabledPermissions/notARealPermission"]);
+});
+
+/** Tenants: what they hold is whatever names them, and only an administrator outside one may move things in. */
+test("a tenant's members are found by memberTenantId, and it is kept while it has any", () => {
+  const dir = make("admin");
+  const accounts = dir.handlers["x:Account/query"]!({ filter: { "@type": "User", memberTenantId: "t1" }, calculateTotal: true, limit: 0 }) as { total: number };
+  const domains = dir.handlers["x:Domain/query"]!({ filter: { memberTenantId: "t1" }, calculateTotal: true }) as { ids: string[] };
+  assert.equal(accounts.total, 1);
+  assert.deepEqual(domains.ids, ["d3"]);
+  const refused = dir.handlers["x:Tenant/set"]!({ destroy: ["t1"] }) as { notDestroyed?: Record<string, { type: string; linkedObjects: Array<{ object: string }> }> };
+  assert.equal(refused.notDestroyed?.t1?.type, "objectIsLinked");
+  assert.deepEqual([...new Set(refused.notDestroyed!.t1!.linkedObjects.map((l) => l.object))].sort(), ["Account", "Domain"]);
+});
+
+test("a tenant is created with quotas, a domain moves into it, and an empty one is deleted", () => {
+  const dir = make("admin");
+  const c = dir.handlers["x:Tenant/set"]!({ create: { n: { name: "Globex", quotas: { maxAccounts: 5, maxDiskQuota: 1024 } } } }) as { created: Record<string, { id: string }> };
+  const id = c.created.n!.id;
+  const bad = dir.handlers["x:Tenant/set"]!({ update: { [id]: { "quotas/maxWidgets": 3 } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(bad.notUpdated?.[id]?.type, "invalidPatch");
+  dir.handlers["x:Domain/set"]!({ update: { d4: { memberTenantId: id } } });
+  assert.equal((dir.handlers["x:Domain/query"]!({ filter: { memberTenantId: id }, calculateTotal: true }) as { total: number }).total, 1);
+  dir.handlers["x:Domain/set"]!({ update: { d4: { memberTenantId: null } } });
+  assert.deepEqual((dir.handlers["x:Tenant/set"]!({ destroy: [id] }) as { destroyed: string[] }).destroyed, [id]);
+});
+
+test("a tenant administrator cannot move anything into a tenant", () => {
+  const dir = make("tenant-admin");
+  const r = dir.handlers["x:Domain/set"]!({ update: { d4: { memberTenantId: "t1" } } }) as { notUpdated?: Record<string, { type: string; description: string }> };
+  assert.equal(r.notUpdated?.d4?.type, "invalidPatch");
+  assert.match(r.notUpdated!.d4!.description, /memberTenantId/);
+});
+
+test("something in a tenant has to be on a domain in it, and something in none may be anywhere", () => {
+  const dir = make("admin");
+  const outside = dir.handlers["x:MailingList/set"]!({ create: { n: { name: "stray", domainId: "d1", memberTenantId: "t1" } } }) as { notCreated?: Record<string, { type: string; objectId: { object: string } }> };
+  assert.equal(outside.notCreated?.n?.type, "invalidForeignKey");
+  assert.equal(outside.notCreated!.n!.objectId.object, "Domain");
+  const inside = dir.handlers["x:MailingList/set"]!({ create: { n: { name: "team", domainId: "d3", memberTenantId: "t1" } } }) as { created?: Record<string, { id: string }> };
+  assert.ok(inside.created?.n?.id);
+  const none = dir.handlers["x:MailingList/set"]!({ create: { n: { name: "open", domainId: "d3" } } }) as { created?: Record<string, { id: string }> };
+  assert.ok(none.created?.n?.id);
+  const [someone] = (dir.handlers["x:Account/query"]!({ filter: { "@type": "User", domainId: "d1" } }) as { ids: string[] }).ids;
+  const move = dir.handlers["x:Account/set"]!({ update: { [someone!]: { memberTenantId: "t1" } } }) as { notUpdated?: Record<string, { type: string }> };
+  assert.equal(move.notUpdated?.[someone!]?.type, "invalidForeignKey");
+});

server/src/mock/directory.ts

@@ -0,0 +1,735 @@
+/**
+ * Enough of Stalwart 0.16's directory registry to develop administration
+ * against: `x:Account`, `x:Domain` and `x:Role`, gated by permission names the
+ * way the real server gates them.
+ *
+ * Shapes follow the 0.16.22 source rather than the documentation, which has
+ * been wrong about both before:
+ *
+ * - a `List<T>` (credentials, aliases) is an object keyed by index -- `{"0": …}`
+ *   -- and a `Set` (memberGroupIds, enabledPermissions) is `{"id": true}`;
+ * - an account's `name` is the local part only, and it lives on a domain by id;
+ * - secrets come back masked, and a new one is written through the password
+ *   credential's own pointer, `credentials/<index>/secret`;
+ * - `x:Account/query` understands AND and nothing else.
+ *
+ * It also answers the two feeds Administration's dashboard reads: a short
+ * outbound queue (`x:QueuedMessage`) and a day and a bit of hourly metric
+ * history (`x:Metric`), dated from when the mock started. MOCK_METRICS=off
+ * refuses the history the way a Community server does.
+ *
+ * Tenants are there for a system administrator to manage -- one tenant holding a
+ * domain and an account, `memberTenantId` filters on the queries, and the rule
+ * that only an administrator outside every tenant may move things into one. What
+ * it does not reproduce is a tenant administrator's scoping: every caller sees
+ * every record. The real server scopes those queries, and nothing in the client
+ * relies on seeing more or less than it is given.
+ *
+ * MOCK_ROLE picks who the demo user is: `admin` (the default), `tenant-admin`,
+ * `helpdesk` (a custom role that may view and edit accounts but not create or
+ * delete them) or `user`.
+ */
+
+import { readFileSync } from "node:fs";
+
+type Obj = Record<string, unknown>;
+
+/** Every permission Stalwart 0.16.22 knows, from the snapshot the translations are checked against. */
+const KNOWN_PERMISSIONS = new Set(
+  (JSON.parse(readFileSync(new URL("../../../web/src/locales/permissions/source.json", import.meta.url), "utf8")) as { permissions: Array<{ name: string }> }).permissions.map((p) => p.name),
+);
+
+export type MockRole = "admin" | "tenant-admin" | "helpdesk" | "user";
+
+const OPS = ["Get", "Query", "Create", "Update", "Destroy"] as const;
+const all = (...objects: string[]) => objects.flatMap((o) => OPS.map((op) => `sys${o}${op}`));
+
+/** What the dashboard reads beyond the directory. */
+const READ_SERVER = ["sysQueuedMessageGet", "sysQueuedMessageQuery", "sysMetricGet", "sysMetricQuery", "sysApplicationGet", "sysApplicationQuery"];
+
+/** A few of the ordinary ones, so the list looks like what a server sends. */
+const USER_PERMISSIONS = ["jmapEmailGet", "jmapEmailUpdate", "jmapMailboxGet", "sysAccountSettingsGet"];
+
+export function permissionsFor(role: MockRole): string[] {
+  switch (role) {
+    case "admin":
+      return [...USER_PERMISSIONS, ...all("Account", "Domain", "Role", "MailingList", "DkimSignature", "DnsServer", "Tenant"), ...READ_SERVER, "sysAuthenticationGet", "impersonate"];
+    case "tenant-admin":
+      // The queue but not the metric history: Stalwart scopes the one to a
+      // tenant's domains, and the other has no tenant to scope it by.
+      return [...USER_PERMISSIONS, ...all("Account", "Domain", "Role", "MailingList", "DkimSignature", "DnsServer"), "sysQueuedMessageGet", "sysQueuedMessageQuery"];
+    case "helpdesk":
+      return [...USER_PERMISSIONS, "sysAccountGet", "sysAccountQuery", "sysAccountUpdate", "sysDomainGet", "sysDomainQuery"];
+    default:
+      return USER_PERMISSIONS;
+  }
+}
+
+export function mockRole(raw: string | undefined): MockRole {
+  return raw === "tenant-admin" || raw === "helpdesk" || raw === "user" ? raw : "admin";
+}
+
+const MASKED = "[********]";
+const GIB = 1024 ** 3;
+
+interface Options {
+  /** The demo user's JMAP account id, which is also its registry id. */
+  accountId: string;
+  /** The demo user's address. */
+  user: string;
+  locale: string;
+  role: MockRole;
+  /** Build the error a method fails with; the mock server owns the type. */
+  fail: (type: string, description?: string) => Error;
+  /** Refuse the metric history, as a Community server does. */
+  metricsOff?: boolean;
+  /** When the history ends; the newest hour is the one this falls in. */
+  now?: Date;
+}
+
+export function createDirectory(opts: Options) {
+  const permissions = new Set(permissionsFor(opts.role));
+  const [userLocal, userDomain] = splitAddress(opts.user);
+  let counter = 100;
+
+  const managed = (dns: boolean, dkim: boolean, certs: boolean) => ({
+    dnsManagement: dns ? { "@type": "Automatic", dnsServerId: "ns1", origin: null, publishRecords: {} } : { "@type": "Manual" },
+    dkimManagement: dkim ? { "@type": "Automatic", algorithms: { Dkim1Ed25519Sha256: true, Dkim1RsaSha256: true }, selectorTemplate: "v{version}-{algorithm}-{date-%Y%m%d}" } : { "@type": "Manual" },
+    certificateManagement: certs ? { "@type": "Automatic", acmeProviderId: "acme1", subjectAlternativeNames: {} } : { "@type": "Manual" },
+  });
+  const domain = (id: string, name: string, extra: Obj = {}): Obj => ({
+    id, name, aliases: {}, isEnabled: true, createdAt: "2026-06-01T09:00:00Z", description: null, logo: null,
+    ...managed(false, true, false), memberTenantId: null, directoryId: null, catchAllAddress: null,
+    subAddressing: { "@type": "Enabled" }, allowRelaying: false, reportAddressUri: "mailto:postmaster", allowScimProvisioning: false, ...extra,
+  });
+  const domains: Obj[] = [
+    domain("d1", userDomain, { ...managed(true, true, true), aliases: { [`mail.${userDomain}`]: true }, description: "Main domain" }),
+    domain("d2", userDomain === "example.org" ? "example.net" : "example.org", { catchAllAddress: `postmaster@${userDomain}` }),
+    domain("d3", "old-brand.example", { ...managed(false, false, false), description: "No longer used", subAddressing: { "@type": "Custom", customRule: "..." }, memberTenantId: "t1" }),
+    domain("d4", "spare.example", { description: "Waiting for a tenant" }),
+  ];
+  const dkimKeys: Obj[] = [
+    { id: "k1", "@type": "Dkim1Ed25519Sha256", domainId: "d1", selector: "v1-ed25519-20260601", stage: "active", createdAt: "2026-06-01T09:00:00Z", nextTransitionAt: "2026-08-30T09:00:00Z", memberTenantId: null },
+    { id: "k2", "@type": "Dkim1RsaSha256", domainId: "d1", selector: "v1-rsa-20260601", stage: "active", createdAt: "2026-06-01T09:00:00Z", nextTransitionAt: "2026-08-30T09:00:00Z", memberTenantId: null },
+    { id: "k3", "@type": "Dkim1Ed25519Sha256", domainId: "d2", selector: "v1-ed25519-20260710", stage: "active", createdAt: "2026-07-10T09:00:00Z", nextTransitionAt: null, memberTenantId: null },
+  ];
+  /** What Stalwart's BIND serializer writes, including a TXT long enough to be split. */
+  const zoneFile = (d: Obj): string => {
+    const n = String(d.name);
+    const lines = [
+      `${n}. IN MX 10 mail.${userDomain}.`,
+      `${n}. IN TXT "v=spf1 mx ra=postmaster -all"`,
+    ];
+    for (const k of dkimKeys.filter((k) => k.domainId === d.id && k.stage !== "retired")) {
+      if (String(k["@type"]).includes("Rsa")) {
+        const p = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA" + "x".repeat(300) + "IDAQAB";
+        const txt = `v=DKIM1; k=rsa; h=sha256; p=${p}`;
+        lines.push(`${k.selector}._domainkey.${n}. IN TXT (`, ...(txt.match(/.{1,255}/g) ?? []).map((c) => `    "${c}"`), ")");
+      } else {
+        lines.push(`${k.selector}._domainkey.${n}. IN TXT "v=DKIM1; k=ed25519; h=sha256; p=11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo="`);
+      }
+    }
+    lines.push(
+      `_dmarc.${n}. IN TXT "v=DMARC1; p=reject; rua=mailto:postmaster@${n}; ruf=mailto:postmaster@${n}"`,
+      `_jmap._tcp.${n}. IN SRV 0 1 443 mail.${userDomain}.`,
+      `_submissions._tcp.${n}. IN SRV 0 1 465 mail.${userDomain}.`,
+      `_imaps._tcp.${n}. IN SRV 0 1 993 mail.${userDomain}.`,
+      `mta-sts.${n}. IN CNAME mail.${userDomain}.`,
+      `_mta-sts.${n}. IN TXT "v=STSv1; id=16837364213434767412"`,
+      `_smtp._tls.${n}. IN TXT "v=TLSRPTv1; rua=mailto:postmaster@${n}"`,
+      `autoconfig.${n}. IN CNAME mail.${userDomain}.`,
+      `${n}. IN CAA 0 issue "letsencrypt.org"`,
+    );
+    return lines.join("\n") + "\n";
+  };
+
+  const roles: Obj[] = [
+    { id: "r1", description: "User", enabledPermissions: flags(USER_PERMISSIONS), disabledPermissions: {}, roleIds: {}, memberTenantId: null },
+    { id: "r2", description: "Helpdesk", enabledPermissions: flags(permissionsFor("helpdesk").filter((p) => p.startsWith("sys"))), disabledPermissions: {}, roleIds: { r1: true } },
+    { id: "r3", description: "Directory manager", enabledPermissions: flags(all("Account")), disabledPermissions: {}, roleIds: { r1: true } },
+    { id: "r4", description: "Read-only auditor", enabledPermissions: flags(["sysAccountGet", "sysAccountQuery", "sysDomainGet", "sysDomainQuery", "sysLogGet"]), disabledPermissions: flags(["jmapEmailUpdate"]), roleIds: { r1: true } },
+  ];
+  /** Stalwart's defaults: which roles an account gets when it is given no others. */
+  const authentication: Record<string, Obj> = { defaultUserRoleIds: { r1: true }, defaultGroupRoleIds: {}, defaultTenantRoleIds: {}, defaultAdminRoleIds: {} };
+
+  const ownRoles = opts.role === "admin" || opts.role === "tenant-admin" ? { "@type": "Admin" } : opts.role === "helpdesk" ? { "@type": "Custom", roleIds: { r2: true } } : { "@type": "User" };
+
+  const accounts: Obj[] = [];
+  const user = (o: { id?: string; name: string; domain?: string; description: string; roles?: Obj; used?: number; quota?: number; aliases?: string[]; groups?: string[]; password?: boolean; tenant?: string }) => {
+    const domainId = o.domain === "d2" || o.domain === "d3" ? o.domain : "d1";
+    const row: Obj = {
+      id: o.id ?? `u${counter++}`,
+      "@type": "User",
+      name: o.name,
+      domainId,
+      description: o.description,
+      credentials: o.password === false ? {} : { "0": { "@type": "Password", credentialId: "0", secret: MASKED, otpAuth: null, expiresAt: null, allowedIps: {} } },
+      createdAt: new Date(Date.now() - counter * 86_400_000).toISOString().replace(/\.\d{3}Z$/, "Z"),
+      memberGroupIds: flags(o.groups ?? []),
+      memberTenantId: o.tenant ?? null,
+      roles: o.roles ?? { "@type": "User" },
+      permissions: { "@type": "Inherit" },
+      quotas: o.quota ? { maxDiskQuota: o.quota * GIB } : {},
+      usedDiskQuota: Math.round((o.used ?? 0) * GIB),
+      aliases: Object.fromEntries((o.aliases ?? []).map((name, i) => [String(i), { enabled: true, name, domainId, description: null }])),
+      locale: opts.locale,
+      timeZone: null,
+    };
+    accounts.push(row);
+    return row;
+  };
+  // A group's roles are Default or Custom, not a person's User or Admin.
+  const group = (id: string, name: string, description: string) =>
+    accounts.push({ id, "@type": "Group", name, domainId: "d1", description, memberTenantId: null, roles: { "@type": "Default" }, permissions: { "@type": "Inherit" }, quotas: {}, usedDiskQuota: 0, aliases: {}, createdAt: "2026-08-01T09:00:00Z" });
+
+  group("g1", "support", "Support");
+  group("g2", "office", "Office");
+  user({ id: opts.accountId, name: userLocal, description: "Demo User", roles: ownRoles, used: 1.4, quota: 10, aliases: ["postmaster"], groups: ["g1"] });
+  user({ name: "ada", domain: "d2", description: "Ada Lovelace", used: 3.2, quota: 5, groups: ["g2"] });
+  user({ name: "grace", domain: "d2", description: "Grace Hopper", used: 4.7, quota: 5, groups: ["g2"] });
+  user({ name: "wile", domain: "d3", description: "Wile E. Coyote", roles: { "@type": "Admin" }, used: 2.1, quota: 5, tenant: "t1" });
+  user({ name: "alan", domain: "d2", description: "Alan Turing", roles: { "@type": "Custom", roleIds: { r2: true } }, used: 0.8, quota: 5, groups: ["g1"] });
+  user({ name: "margaret", description: "Margaret Hamilton", roles: { "@type": "Admin" }, used: 2.1, quota: 20 });
+  user({ name: "katherine", description: "Katherine Johnson", roles: { "@type": "Custom", roleIds: { r3: true } }, used: 0.4, quota: 5 });
+  user({ name: "sso.only", description: "Signs in with SSO", password: false, used: 0.1 });
+  const people = ["Edsger Dijkstra", "Barbara Liskov", "Donald Knuth", "Frances Allen", "John Backus", "Radia Perlman", "Ken Thompson", "Hedy Lamarr", "Dennis Ritchie", "Karen Spärck Jones", "Tim Berners-Lee", "Sophie Wilson", "Niklaus Wirth", "Jean Sammet", "Leslie Lamport", "Mary Kenneth Keller", "Tony Hoare", "Evelyn Berezin", "Butler Lampson", "Shafi Goldwasser", "Whitfield Diffie", "Adele Goldberg", "Vint Cerf", "Anita Borg", "Bob Kahn", "Lynn Conway", "Charles Babbage", "Annie Easley"];
+  people.forEach((description, i) => {
+    const name = description.toLowerCase().split(" ")[0]!.normalize("NFD").replace(/[^a-z]/g, "");
+    user({ name, domain: i % 3 === 0 ? "d2" : "d1", description, used: (i % 7) * 0.6, quota: i % 4 === 0 ? 0 : 5 });
+  });
+
+  // Nine messages waiting, which is what a small live server had queued on the
+  // day this was written: a few retries and the odd report.
+  const queue: Obj[] = Array.from({ length: 9 }, (_, i) => ({ id: `q${i + 1}`, createdAt: new Date(Date.UTC(2026, 8, 15, 6 + i)).toISOString(), size: 2400 + i * 310, priority: 0, flags: {} }));
+
+  /**
+   * Thirty hours of history ending in the current hour: a Counter per hour for
+   * what was queued, and a memory Gauge. Counters that would be zero are left
+   * out, as Stalwart leaves them out.
+   */
+  const metrics: Obj[] = [];
+  {
+    const hour = 3600_000;
+    const end = Math.floor((opts.now ?? new Date()).getTime() / hour) * hour;
+    for (let h = 29; h >= 0; h--) {
+      const at = end - h * hour;
+      const timestamp = new Date(at).toISOString().replace(/\.\d{3}Z$/, "Z");
+      const seq = (29 - h) * 10;
+      const push = (n: number, type: string, metric: string, count: number) => {
+        if (type === "Counter" && !count) return;
+        metrics.push({ id: `m${String(seq + n).padStart(4, "0")}`, "@type": type, metric, count, timestamp });
+      };
+      push(0, "Gauge", "server.memory", 360_000_000 + ((h * 7_919_000) % 40_000_000));
+      push(1, "Counter", "queue.message-queued", (h * 5 + 3) % 9);
+      push(2, "Counter", "queue.authenticated-message-queued", h % 3);
+      push(3, "Counter", "queue.dsn-queued", h % 11 === 0 ? 1 : 0);
+      push(4, "Counter", "queue.report-queued", h % 4 === 1 ? 2 : 0);
+    }
+  }
+  const applications: Obj[] = [{ id: "app1", description: "Stalwart Web Interface", enabled: true, urlPrefix: { "/admin": true, "/account": true } }];
+
+  /** Tenants: a name, limits, and whatever names them in its memberTenantId. */
+  const tenants: Obj[] = [
+    { id: "t1", name: "Acme Corp", logo: null, roles: { "@type": "Default" }, permissions: { "@type": "Inherit" }, quotas: { maxAccounts: 25, maxDomains: 2, maxDiskQuota: 50 * GIB }, createdAt: "2026-07-01T09:00:00Z" },
+  ];
+  const tenantUsage = (id: string) => accounts.filter((x) => x.memberTenantId === id).reduce((n, x) => n + Number(x.usedDiskQuota ?? 0), 0);
+  /**
+   * Something in a tenant has to be on a domain in that tenant; something in no
+   * tenant may be on anyone's domain. Both as the live server answered
+   * (2026-09-15), including the shape of the refusal.
+   */
+  const domainTenantRefused = (o: Obj): Obj | null => {
+    const tenant = o.memberTenantId ?? null;
+    const domain = domains.find((d) => d.id === o.domainId);
+    if (!tenant || !domain || (domain.memberTenantId ?? null) === tenant) return null;
+    return { type: "invalidForeignKey", objectId: { object: "Domain", id: domain.id } };
+  };
+  /** Only an administrator outside every tenant may put things in one; Stalwart refuses anyone else. */
+  const tenantRefused = (patch: Obj): Obj | null =>
+    "memberTenantId" in patch && opts.role !== "admin" ? setError("invalidPatch", "Cannot modify memberTenantId property", ["memberTenantId"]) : null;
+
+  const refuseMetrics = () => {
+    if (opts.metricsOff) throw opts.fail("forbidden", "This feature is only available in the Enterprise edition of Stalwart.");
+  };
+
+  /**
+   * Mailing lists: an address and the addresses it passes mail on to. The
+   * recipient set's shape is the live server's (2026-09-15).
+   */
+  const lists: Obj[] = [
+    { id: "l1", name: "announce", domainId: "d1", description: "Announcements", recipients: flags([opts.user, "[email protected]", "[email protected]", "[email protected]"]), aliases: {}, memberTenantId: null },
+    { id: "l2", name: "board", domainId: "d2", description: "Board", recipients: flags(["[email protected]", "[email protected]"]), aliases: {}, memberTenantId: null },
+  ];
+  const addressOk = (a: unknown) => typeof a === "string" && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(a);
+
+  const demand = (perm: string) => {
+    if (!permissions.has(perm)) throw opts.fail("forbidden", `You do not have the ${perm} permission.`);
+  };
+  const domainName = (id: unknown) => domains.find((d) => d.id === id)?.name as string | undefined;
+  const addressOf = (o: Obj) => `${o.name}@${domainName(o.domainId) ?? "invalid"}`;
+  /** Every address in use, primary and alias, across accounts and mailing lists. */
+  const addressTaken = (address: string, except?: string) =>
+    [...accounts, ...lists].some((a) => a.id !== except && (addressOf(a) === address || Object.values((a.aliases as Obj) ?? {}).some((al) => `${(al as Obj).name}@${domainName((al as Obj).domainId)}` === address)));
+
+  const view = (o: Obj, properties: unknown): Obj => {
+    const full: Obj = { ...o };
+    if (accounts.includes(o) || lists.includes(o)) full.emailAddress = addressOf(o);
+    if (domains.includes(o)) full.dnsZoneFile = zoneFile(o);
+    if (full.credentials) {
+      full.credentials = Object.fromEntries(Object.entries(full.credentials as Obj).map(([k, c]) => [k, { ...(c as Obj), secret: MASKED }]));
+    }
+    if (!Array.isArray(properties)) return full;
+    const out: Obj = { id: o.id };
+    for (const p of properties as string[]) if (p in full) out[p] = full[p];
+    return out;
+  };
+
+  const get = (list: Obj[], perm: string) => (a: Obj) => {
+    demand(perm);
+    const ids = a.ids as string[] | null | undefined;
+    const found = ids ? list.filter((x) => ids.includes(x.id as string)) : list;
+    return { accountId: opts.accountId, state: "1", list: found.map((x) => view(x, a.properties)), notFound: ids ? ids.filter((id) => !list.some((x) => x.id === id)) : [] };
+  };
+
+  /**
+   * A query, filtered only on what the real server indexes for that object.
+   * Any other name is refused the way Stalwart refuses it -- `unsupportedFilter`
+   * with the name as the whole description -- because a mock that took
+   * `{"type": "User"}` let exactly that ship, and the live server answers it
+   * with "unsupportedFilter - type".
+   */
+  const query = (list: () => Obj[], perm: string, filterable: string[], match: (o: Obj, filter: Obj) => boolean) => (a: Obj) => {
+    demand(perm);
+    const filter = (a.filter as Obj | undefined) ?? {};
+    if ("operator" in filter) throw opts.fail("unsupportedFilter", "Only AND is supported in filters");
+    const unknown = Object.keys(filter).find((k) => !filterable.includes(k));
+    if (unknown) throw opts.fail("unsupportedFilter", unknown);
+    // Stalwart's default order is newest first, by id.
+    const rows = list().filter((o) => match(o, filter)).sort((x, y) => String(y.id).localeCompare(String(x.id), undefined, { numeric: true }));
+    const position = Math.max(0, Number(a.position ?? 0));
+    const limit = a.limit == null ? rows.length : Number(a.limit);
+    return {
+      accountId: opts.accountId,
+      queryState: "1",
+      canCalculateChanges: false,
+      position,
+      ids: rows.slice(position, position + limit).map((o) => o.id),
+      ...(a.calculateTotal ? { total: rows.length } : {}),
+    };
+  };
+
+  const matchText = (o: Obj, text: unknown) => {
+    if (typeof text !== "string" || !text.trim()) return true;
+    const needle = text.trim().toLowerCase();
+    return [o.name, o.description, addressOf(o)].some((v) => typeof v === "string" && v.toLowerCase().includes(needle));
+  };
+
+  const setError = (type: string, description: string, properties?: string[]) => ({ type, description, ...(properties ? { properties } : {}) });
+
+  /** The password checks, roughly as strict as a default Stalwart. */
+  const weakPassword = (secret: unknown) => (typeof secret !== "string" || secret.length < 8 ? "Password must be at least 8 characters long." : null);
+
+  /** Stalwart checks a grant against the caller's own permissions. */
+  const grantRefused = (roles: unknown): string | null => {
+    const r = roles as Obj | undefined;
+    if (!r) return null;
+    if (r["@type"] === "Admin" && opts.role !== "admin" && opts.role !== "tenant-admin") return "You are not authorized to grant permissions: administrator.";
+    if (r["@type"] === "Custom") {
+      for (const id of Object.keys((r.roleIds as Obj) ?? {})) {
+        const role = roles_(id);
+        if (!role) return "Role does not exist.";
+        const missing = Object.keys((role.enabledPermissions as Obj) ?? {}).filter((p) => !permissions.has(p));
+        if (missing.length) return `You are not authorized to grant permissions: ${missing.join(", ")}.`;
+      }
+    }
+    return null;
+  };
+  const roles_ = (id: string) => roles.find((r) => r.id === id);
+
+  const handlers: Record<string, (a: Obj) => Obj> = {
+    "x:Account/get": get(accounts, "sysAccountGet"),
+    "x:Account/query": query(() => accounts, "sysAccountQuery", ["text", "@type", "domainId", "externalId", "memberGroupIds", "memberTenantId", "name"], (o, f) =>
+      (f["@type"] === undefined || o["@type"] === f["@type"]) && (f.domainId === undefined || o.domainId === f.domainId) &&
+      (f.memberGroupIds === undefined || Boolean((o.memberGroupIds as Obj | undefined)?.[f.memberGroupIds as string])) &&
+      (f.memberTenantId === undefined || o.memberTenantId === f.memberTenantId) && matchText(o, f.text) && matchText(o, f.name)),
+    "x:Account/set": (a) => {
+      const created: Obj = {};
+      const notCreated: Obj = {};
+      const updated: Obj = {};
+      const notUpdated: Obj = {};
+      const destroyed: string[] = [];
+      const notDestroyed: Obj = {};
+      for (const [cid, raw] of Object.entries((a.create as Obj) ?? {})) {
+        demand("sysAccountCreate");
+        const o = { ...(raw as Obj) };
+        if (typeof o.name !== "string" || !/^[a-z0-9._-]+$/i.test(o.name)) { notCreated[cid] = setError("invalidProperties", "Invalid account name.", ["name"]); continue; }
+        if (!domainName(o.domainId)) { notCreated[cid] = setError("invalidForeignKey", "Domain does not exist.", ["domainId"]); continue; }
+        if (addressTaken(`${o.name}@${domainName(o.domainId)}`)) { notCreated[cid] = setError("primaryKeyViolation", "An account or alias with this email address already exists."); continue; }
+        const refused = grantRefused(o.roles);
+        if (refused) { notCreated[cid] = setError("forbidden", refused); continue; }
+        if (o.memberTenantId) {
+          const refusedTenant = tenantRefused(o) ?? domainTenantRefused(o);
+          if (refusedTenant) { notCreated[cid] = refusedTenant; continue; }
+        }
+        const password = Object.values((o.credentials as Obj) ?? {})[0] as Obj | undefined;
+        const weak = password ? weakPassword(password.secret) : null;
+        if (weak) { notCreated[cid] = setError("invalidProperties", weak, ["secret"]); continue; }
+        const id = `u${counter++}`;
+        accounts.push({ ...(o["@type"] === "Group" ? {} : { memberGroupIds: {} }), aliases: {}, quotas: {}, permissions: { "@type": "Inherit" }, ...o, id, memberTenantId: null, usedDiskQuota: 0, createdAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"), locale: opts.locale, timeZone: null });
+        created[cid] = { id, emailAddress: `${o.name}@${domainName(o.domainId)}` };
+      }
+      for (const [id, raw] of Object.entries((a.update as Obj) ?? {})) {
+        demand("sysAccountUpdate");
+        const target = accounts.find((x) => x.id === id);
+        if (!target) { notUpdated[id] = setError("notFound", "Account not found."); continue; }
+        const patch = raw as Obj;
+        const next = structuredClone(target);
+        let failure: Obj | null = tenantRefused(patch);
+        for (const [path, value] of Object.entries(patch)) {
+          if (path === "id" || path === "@type" || path === "usedDiskQuota" || path === "emailAddress") { failure = setError("invalidProperties", `Property ${path} cannot be changed.`, [path]); break; }
+          if (path.endsWith("/secret")) {
+            const weak = weakPassword(value);
+            if (weak) { failure = setError("invalidProperties", weak, ["secret"]); break; }
+          }
+          if (path.startsWith("credentials/") && value && typeof value === "object") {
+            const weak = weakPassword((value as Obj).secret);
+            if (weak) { failure = setError("invalidProperties", weak, ["secret"]); break; }
+          }
+          setPointer(next, path, value);
+        }
+        // Memberships name groups, and only a person has them: groups do not nest.
+        if (!failure && Object.keys(patch).some((p) => p === "memberGroupIds" || p.startsWith("memberGroupIds/"))) {
+          if (target["@type"] === "Group") failure = setError("invalidProperties", "Groups cannot be members of other groups.", ["memberGroupIds"]);
+          else if (Object.keys((next.memberGroupIds as Obj) ?? {}).some((g) => accounts.find((x) => x.id === g)?.["@type"] !== "Group")) failure = setError("invalidForeignKey", "Group does not exist.", ["memberGroupIds"]);
+        }
+        if (!failure && "memberTenantId" in patch) failure = domainTenantRefused(next);
+        if (!failure && ("roles" in patch || "permissions" in patch)) {
+          const refused = grantRefused(next.roles);
+          if (refused) failure = setError("forbidden", refused);
+        }
+        if (!failure) {
+          for (const al of Object.values((next.aliases as Obj) ?? {})) {
+            const address = `${(al as Obj).name}@${domainName((al as Obj).domainId)}`;
+            if (!domainName((al as Obj).domainId)) { failure = setError("invalidForeignKey", "Domain does not exist.", ["aliases"]); break; }
+            if (addressTaken(address, id)) { failure = setError("primaryKeyViolation", "An account or alias with this email address already exists."); break; }
+          }
+        }
+        if (failure) { notUpdated[id] = failure; continue; }
+        // Secrets are stored hashed; the mock just stops echoing them.
+        for (const c of Object.values((next.credentials as Obj) ?? {})) (c as Obj).secret = MASKED;
+        Object.assign(target, next);
+        updated[id] = null;
+      }
+      for (const id of (a.destroy as string[]) ?? []) {
+        demand("sysAccountDestroy");
+        const i = accounts.findIndex((x) => x.id === id);
+        if (i < 0) { notDestroyed[id] = setError("notFound", "Account not found."); continue; }
+        if (accounts[i]!["@type"] === "Group" && accounts.some((x) => (x.memberGroupIds as Obj | undefined)?.[id])) {
+          // Every member's memberGroupIds names the group, which is a link the
+          // registry will not delete through. The shape is the live server's,
+          // from a throwaway group on 2026-09-15.
+          notDestroyed[id] = { type: "objectIsLinked", objectId: { object: "Account", id }, linkedObjects: accounts.filter((x) => (x.memberGroupIds as Obj | undefined)?.[id]).map((x) => ({ object: "Account", id: x.id })) };
+          continue;
+        }
+        accounts.splice(i, 1);
+        destroyed.push(id);
+      }
+      return { accountId: opts.accountId, oldState: "1", newState: "2", created, updated, destroyed, ...(Object.keys(notCreated).length ? { notCreated } : {}), ...(Object.keys(notUpdated).length ? { notUpdated } : {}), ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}) };
+    },
+    "x:Domain/get": get(domains, "sysDomainGet"),
+    "x:Domain/query": query(() => domains, "sysDomainQuery", ["text", "aliases", "memberTenantId", "name"], (o, f) => (f.memberTenantId === undefined || o.memberTenantId === f.memberTenantId) && matchText(o, f.text) && matchText(o, f.name)),
+    "x:Domain/set": (a) => {
+      const created: Obj = {};
+      const notCreated: Obj = {};
+      const updated: Obj = {};
+      const notUpdated: Obj = {};
+      const destroyed: string[] = [];
+      const notDestroyed: Obj = {};
+      const taken = (name: string, except?: string) => domains.some((d) => d.id !== except && (d.name === name || Object.keys((d.aliases as Obj) ?? {}).includes(name)));
+      for (const [cid, raw] of Object.entries((a.create as Obj) ?? {})) {
+        demand("sysDomainCreate");
+        const o = raw as Obj;
+        const name = String(o.name ?? "");
+        // Live on 2026-09-13: a reserved TLD is refused by the registry's
+        // domain validator, as invalidPatch with the validator's own words.
+        if (!/^([a-z0-9-]+\.)+[a-z0-9-]{2,}$/.test(name) || /\.(example|test|invalid|localhost)$/.test(name)) { notCreated[cid] = setError("invalidPatch", "Invalid domain name", ["name"]); continue; }
+        if (taken(name)) { notCreated[cid] = setError("primaryKeyViolation", "A domain with this name already exists.", ["name"]); continue; }
+        const id = `d${counter++}`;
+        domains.push(domain(id, name, { ...o, id, createdAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z") }));
+        // Automatic DKIM, the default, makes its keys straight away.
+        dkimKeys.push({ id: `k${counter++}`, "@type": "Dkim1Ed25519Sha256", domainId: id, selector: "v1-ed25519-20260913", stage: "active", createdAt: new Date().toISOString(), nextTransitionAt: null, memberTenantId: null });
+        created[cid] = { id };
+      }
+      for (const [id, raw] of Object.entries((a.update as Obj) ?? {})) {
+        demand("sysDomainUpdate");
+        const target = domains.find((d) => d.id === id);
+        if (!target) { notUpdated[id] = setError("notFound", "Domain not found."); continue; }
+        const refusedTenant = tenantRefused(raw as Obj);
+        if (refusedTenant) { notUpdated[id] = refusedTenant; continue; }
+        if ((raw as Obj).memberTenantId && !tenants.some((x) => x.id === (raw as Obj).memberTenantId)) { notUpdated[id] = setError("invalidForeignKey", "Tenant does not exist.", ["memberTenantId"]); continue; }
+        const next = structuredClone(target);
+        for (const [path, value] of Object.entries(raw as Obj)) setPointer(next, path, value);
+        // Live on 2026-09-13: a catch-all that is not a whole address.
+        if (typeof next.catchAllAddress === "string" && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(next.catchAllAddress)) { notUpdated[id] = setError("invalidPatch", "Invalid email address", ["catchAllAddress"]); continue; }
+        const clash = Object.keys((next.aliases as Obj) ?? {}).find((alias) => alias === next.name || taken(alias, id));
+        if (clash) { notUpdated[id] = setError("primaryKeyViolation", `The name ${clash} is already in use.`, ["aliases"]); continue; }
+        Object.assign(target, next);
+        updated[id] = null;
+      }
+      for (const id of (a.destroy as string[]) ?? []) {
+        demand("sysDomainDestroy");
+        const i = domains.findIndex((d) => d.id === id);
+        if (i < 0) { notDestroyed[id] = setError("notFound", "Domain not found."); continue; }
+        const linked = [
+          ...accounts.filter((x) => x.domainId === id || Object.values((x.aliases as Obj) ?? {}).some((al) => (al as Obj).domainId === id)).map((x) => ({ object: "Account", id: x.id })),
+          ...dkimKeys.filter((k) => k.domainId === id).map((k) => ({ object: "DkimSignature", id: k.id })),
+        ];
+        if (linked.length) { notDestroyed[id] = { ...setError("objectIsLinked", "Object is linked to other objects."), linkedObjects: linked }; continue; }
+        domains.splice(i, 1);
+        destroyed.push(id);
+      }
+      return { accountId: opts.accountId, oldState: "1", newState: "2", created, updated, destroyed, ...(Object.keys(notCreated).length ? { notCreated } : {}), ...(Object.keys(notUpdated).length ? { notUpdated } : {}), ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}) };
+    },
+    "x:DkimSignature/get": get(dkimKeys, "sysDkimSignatureGet"),
+    "x:DkimSignature/query": query(() => dkimKeys, "sysDkimSignatureQuery", ["domainId", "memberTenantId"], (o, f) =>
+      (f.domainId === undefined || o.domainId === f.domainId) && (f.memberTenantId === undefined || (o.memberTenantId ?? null) === f.memberTenantId)),
+    "x:DkimSignature/set": (a) => {
+      const destroyed: string[] = [];
+      for (const id of (a.destroy as string[]) ?? []) {
+        demand("sysDkimSignatureDestroy");
+        const i = dkimKeys.findIndex((k) => k.id === id);
+        if (i >= 0) { dkimKeys.splice(i, 1); destroyed.push(id); }
+      }
+      if (a.create) throw opts.fail("forbidden", "The mock does not generate DKIM keys; automatic management does that.");
+      return { accountId: opts.accountId, oldState: "1", newState: "2", created: {}, updated: {}, destroyed };
+    },
+    "x:DnsServer/get": (a) => {
+      demand("sysDnsServerGet");
+      return { accountId: opts.accountId, state: "1", list: ((a.ids as string[]) ?? ["ns1"]).filter((id) => id === "ns1").map((id) => ({ id, "@type": "Cloudflare", description: "Cloudflare (main zone)" })), notFound: [] };
+    },
+    "x:QueuedMessage/get": get(queue, "sysQueuedMessageGet"),
+    "x:QueuedMessage/query": query(() => queue, "sysQueuedMessageQuery", [], () => true),
+    "x:Metric/get": (a) => {
+      refuseMetrics();
+      return get(metrics, "sysMetricGet")(a);
+    },
+    // Ids sort the way timestamps do, so the helper's newest-first order is the
+    // `timestamp` descending the dashboard asks for.
+    "x:Metric/query": (a) => {
+      refuseMetrics();
+      return query(() => metrics, "sysMetricQuery", ["timestampIsGreaterThanOrEqual", "timestampIsLessThanOrEqual", "metric"], (o, f) =>
+        (f.timestampIsGreaterThanOrEqual === undefined || String(o.timestamp) >= String(f.timestampIsGreaterThanOrEqual)) &&
+        (f.timestampIsLessThanOrEqual === undefined || String(o.timestamp) <= String(f.timestampIsLessThanOrEqual)) &&
+        (!Array.isArray(f.metric) || (f.metric as string[]).includes(o.metric as string)))(a);
+    },
+    "x:MailingList/get": get(lists, "sysMailingListGet"),
+    "x:MailingList/query": query(() => lists, "sysMailingListQuery", ["text", "memberTenantId"], (o, f) => (f.memberTenantId === undefined || o.memberTenantId === f.memberTenantId) && matchText(o, f.text)),
+    "x:MailingList/set": (a) => {
+      const created: Obj = {};
+      const notCreated: Obj = {};
+      const updated: Obj = {};
+      const notUpdated: Obj = {};
+      const destroyed: string[] = [];
+      const notDestroyed: Obj = {};
+      const check = (o: Obj, id?: string): Obj | null => {
+        if (typeof o.name !== "string" || !/^[a-z0-9._-]+$/i.test(o.name)) return setError("invalidProperties", "Invalid email local part", ["name"]);
+        if (!domainName(o.domainId)) return setError("invalidForeignKey", "Domain does not exist.", ["domainId"]);
+        if (addressTaken(`${o.name}@${domainName(o.domainId)}`, id)) return setError("primaryKeyViolation", "An account or alias with this email address already exists.");
+        if (Object.keys((o.recipients as Obj) ?? {}).some((r) => !addressOk(r))) return setError("invalidProperties", "Invalid email address", ["recipients"]);
+        return null;
+      };
+      for (const [cid, raw] of Object.entries((a.create as Obj) ?? {})) {
+        demand("sysMailingListCreate");
+        const o: Obj = { recipients: {}, aliases: {}, description: null, ...(raw as Obj) };
+        const failure = check(o) ?? (o.memberTenantId ? (tenantRefused(o) ?? domainTenantRefused(o)) : null);
+        if (failure) { notCreated[cid] = failure; continue; }
+        const id = `l${counter++}`;
+        lists.push({ memberTenantId: null, ...o, id });
+        created[cid] = { id, emailAddress: `${o.name}@${domainName(o.domainId)}` };
+      }
+      for (const [id, raw] of Object.entries((a.update as Obj) ?? {})) {
+        demand("sysMailingListUpdate");
+        const target = lists.find((x) => x.id === id);
+        if (!target) { notUpdated[id] = setError("notFound", "Mailing list not found."); continue; }
+        const next = structuredClone(target);
+        for (const [path, value] of Object.entries(raw as Obj)) setPointer(next, path, value);
+        const failure = check(next, id);
+        if (failure) { notUpdated[id] = { ...failure, type: failure.type === "invalidProperties" ? "invalidPatch" : failure.type }; continue; }
+        Object.assign(target, next);
+        updated[id] = null;
+      }
+      for (const id of (a.destroy as string[]) ?? []) {
+        demand("sysMailingListDestroy");
+        const i = lists.findIndex((x) => x.id === id);
+        if (i < 0) { notDestroyed[id] = setError("notFound", "Mailing list not found."); continue; }
+        lists.splice(i, 1);
+        destroyed.push(id);
+      }
+      return { accountId: opts.accountId, oldState: "1", newState: "2", created, updated, destroyed, ...(Object.keys(notCreated).length ? { notCreated } : {}), ...(Object.keys(notUpdated).length ? { notUpdated } : {}), ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}) };
+    },
+    // Which roles Stalwart hands out by default. Its own settings object; the
+    // Roles screen reads it to warn before a default role is changed.
+    "x:Authentication/get": (a) => {
+      demand("sysAuthenticationGet");
+      const ids = (a.ids as string[] | null | undefined) ?? ["singleton"];
+      return { accountId: opts.accountId, state: "1", list: ids.filter((id) => id === "singleton").map((id) => ({ id, ...authentication })), notFound: ids.filter((id) => id !== "singleton") };
+    },
+    "x:Role/set": (a) => {
+      const created: Obj = {};
+      const notCreated: Obj = {};
+      const updated: Obj = {};
+      const notUpdated: Obj = {};
+      const destroyed: string[] = [];
+      const notDestroyed: Obj = {};
+      /** Stalwart refuses a role whose permissions -- its own or inherited -- the caller does not hold. */
+      const check = (o: Obj, id?: string): Obj | null => {
+        if (typeof o.description !== "string" || !o.description.trim()) return setError("invalidProperties", "String cannot be empty", ["description"]);
+        const seen = new Set<string>();
+        const walk = (rid: string): boolean => {
+          if (rid === id) return false;
+          if (seen.has(rid)) return true;
+          seen.add(rid);
+          const r = roles_(rid);
+          return !!r && Object.keys((r.roleIds as Obj) ?? {}).every(walk);
+        };
+        if (!Object.keys((o.roleIds as Obj) ?? {}).every(walk)) return setError("invalidProperties", "A role cannot inherit from itself or from a role that does not exist.", ["roleIds"]);
+        // A name that is not a permission fails the whole change, as the live server does.
+        for (const set of ["enabledPermissions", "disabledPermissions"]) {
+          const bad = Object.keys((o[set] as Obj) ?? {}).find((p) => !KNOWN_PERMISSIONS.has(p));
+          if (bad) return setError("invalidProperties", "Invalid value for object property", [`${set}/${bad}`]);
+        }
+        const granted = new Set(Object.keys((o.enabledPermissions as Obj) ?? {}));
+        for (const rid of seen) for (const p of Object.keys((roles_(rid)!.enabledPermissions as Obj) ?? {})) granted.add(p);
+        const missing = [...granted].filter((p) => !permissions.has(p));
+        if (missing.length) return setError("forbidden", `You are not authorized to grant permissions: ${missing.slice(0, 5).join(", ")}.`);
+        return null;
+      };
+      for (const [cid, raw] of Object.entries((a.create as Obj) ?? {})) {
+        demand("sysRoleCreate");
+        const o: Obj = { enabledPermissions: {}, disabledPermissions: {}, roleIds: {}, ...(raw as Obj) };
+        const failure = check(o);
+        if (failure) { notCreated[cid] = failure; continue; }
+        const id = `r${counter++}`;
+        roles.push({ ...o, id, memberTenantId: null });
+        created[cid] = { id };
+      }
+      for (const [id, raw] of Object.entries((a.update as Obj) ?? {})) {
+        demand("sysRoleUpdate");
+        const target = roles_(id);
+        if (!target) { notUpdated[id] = setError("notFound", "Role not found."); continue; }
+        const next = structuredClone(target);
+        for (const [path, value] of Object.entries(raw as Obj)) setPointer(next, path, value);
+        const failure = check(next, id);
+        if (failure) { notUpdated[id] = failure.type === "invalidProperties" ? { ...failure, type: "invalidPatch" } : failure; continue; }
+        Object.assign(target, next);
+        updated[id] = null;
+      }
+      for (const id of (a.destroy as string[]) ?? []) {
+        demand("sysRoleDestroy");
+        if (!roles_(id)) { notDestroyed[id] = setError("notFound", "Role not found."); continue; }
+        const linked = [
+          ...accounts.filter((x) => ((x.roles as Obj | undefined)?.roleIds as Obj | undefined)?.[id]).map((x) => ({ object: "Account", id: x.id })),
+          ...roles.filter((x) => (x.roleIds as Obj | undefined)?.[id]).map((x) => ({ object: "Role", id: x.id })),
+          ...(Object.values(authentication).some((set) => (set as Obj)[id]) ? [{ object: "Authentication", id: "singleton" }] : []),
+        ];
+        if (linked.length) { notDestroyed[id] = { type: "objectIsLinked", objectId: { object: "Role", id }, linkedObjects: linked }; continue; }
+        roles.splice(roles.findIndex((x) => x.id === id), 1);
+        destroyed.push(id);
+      }
+      return { accountId: opts.accountId, oldState: "1", newState: "2", created, updated, destroyed, ...(Object.keys(notCreated).length ? { notCreated } : {}), ...(Object.keys(notUpdated).length ? { notUpdated } : {}), ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}) };
+    },
+    "x:Tenant/get": (a) => {
+      demand("sysTenantGet");
+      for (const x of tenants) x.usedDiskQuota = tenantUsage(x.id as string);
+      return get(tenants, "sysTenantGet")(a);
+    },
+    "x:Tenant/query": query(() => tenants, "sysTenantQuery", ["text"], (o, f) => matchText(o, f.text)),
+    "x:Tenant/set": (a) => {
+      const created: Obj = {};
+      const notCreated: Obj = {};
+      const updated: Obj = {};
+      const notUpdated: Obj = {};
+      const destroyed: string[] = [];
+      const notDestroyed: Obj = {};
+      const check = (o: Obj): Obj | null => {
+        if (typeof o.name !== "string" || !o.name.trim()) return setError("invalidProperties", "String cannot be empty", ["name"]);
+        for (const [k, v] of Object.entries((o.quotas as Obj) ?? {})) {
+          if (!["maxAccounts", "maxGroups", "maxDomains", "maxMailingLists", "maxRoles", "maxOauthClients", "maxDkimKeys", "maxDnsServers", "maxDirectories", "maxAcmeProviders", "maxDiskQuota"].includes(k) || typeof v !== "number" || v < 0) {
+            return setError("invalidProperties", "Invalid value for object property", [`quotas/${k}`]);
+          }
+        }
+        return grantRefused(o.roles) ? setError("forbidden", grantRefused(o.roles)!) : null;
+      };
+      for (const [cid, raw] of Object.entries((a.create as Obj) ?? {})) {
+        demand("sysTenantCreate");
+        const o: Obj = { logo: null, roles: { "@type": "Default" }, permissions: { "@type": "Inherit" }, quotas: {}, ...(raw as Obj) };
+        const failure = check(o);
+        if (failure) { notCreated[cid] = failure; continue; }
+        const id = `t${counter++}`;
+        tenants.push({ ...o, id, createdAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z") });
+        created[cid] = { id };
+      }
+      for (const [id, raw] of Object.entries((a.update as Obj) ?? {})) {
+        demand("sysTenantUpdate");
+        const target = tenants.find((x) => x.id === id);
+        if (!target) { notUpdated[id] = setError("notFound", "Tenant not found."); continue; }
+        const next = structuredClone(target);
+        for (const [path, value] of Object.entries(raw as Obj)) setPointer(next, path, value);
+        const failure = check(next);
+        if (failure) { notUpdated[id] = failure.type === "invalidProperties" ? { ...failure, type: "invalidPatch" } : failure; continue; }
+        Object.assign(target, next);
+        updated[id] = null;
+      }
+      for (const id of (a.destroy as string[]) ?? []) {
+        demand("sysTenantDestroy");
+        if (!tenants.some((x) => x.id === id)) { notDestroyed[id] = setError("notFound", "Tenant not found."); continue; }
+        const linked = [
+          ...accounts.filter((x) => x.memberTenantId === id).map((x) => ({ object: "Account", id: x.id })),
+          ...domains.filter((x) => x.memberTenantId === id).map((x) => ({ object: "Domain", id: x.id })),
+          ...lists.filter((x) => x.memberTenantId === id).map((x) => ({ object: "MailingList", id: x.id })),
+          ...roles.filter((x) => x.memberTenantId === id).map((x) => ({ object: "Role", id: x.id })),
+        ];
+        if (linked.length) { notDestroyed[id] = { type: "objectIsLinked", objectId: { object: "Tenant", id }, linkedObjects: linked }; continue; }
+        tenants.splice(tenants.findIndex((x) => x.id === id), 1);
+        destroyed.push(id);
+      }
+      return { accountId: opts.accountId, oldState: "1", newState: "2", created, updated, destroyed, ...(Object.keys(notCreated).length ? { notCreated } : {}), ...(Object.keys(notUpdated).length ? { notUpdated } : {}), ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}) };
+    },
+    // Stalwart's web interface is an installed application; ihasmail reads its
+    // prefix to link the dashboard to it.
+    "x:Application/query": query(() => applications, "sysApplicationQuery", ["text"], () => true),
+    "x:Application/get": get(applications, "sysApplicationGet"),
+    "x:Role/get": get(roles, "sysRoleGet"),
+    "x:Role/query": query(() => roles, "sysRoleQuery", ["text", "description", "memberTenantId"], (o, f) => (f.memberTenantId === undefined || (o.memberTenantId ?? null) === f.memberTenantId) && matchText(o, f.description)),
+  };
+
+  return { handlers, permissions: [...permissions], accounts };
+}
+
+function flags(names: string[]): Obj {
+  return Object.fromEntries(names.map((n) => [n, true]));
+}
+
+function splitAddress(address: string): [string, string] {
+  const at = address.lastIndexOf("@");
+  return at < 0 ? [address, "example.com"] : [address.slice(0, at), address.slice(at + 1)];
+}
+
+/**
+ * Apply one JMAP patch entry. A path walks into nested objects; `null` at the
+ * end removes the key, which is how an alias or a quota is taken away.
+ */
+function setPointer(obj: Obj, path: string, value: unknown): void {
+  const parts = path.split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+  let node = obj;
+  for (const part of parts.slice(0, -1)) {
+    if (!node[part] || typeof node[part] !== "object") node[part] = {};
+    node = node[part] as Obj;
+  }
+  const last = parts[parts.length - 1]!;
+  // A top-level property set to null reads back as null -- deleting it here
+  // would leave the old value in place when the change is merged back. A
+  // nested pointer to null takes the entry out of its set or map.
+  if (value === null && parts.length > 1) delete node[last];
+  else node[last] = value;
+}

server/src/mock/engine.ts

@@ -0,0 +1,442 @@
+import { randomUUID } from "node:crypto";
+import { eventGetView, expandOccurrences, occurrenceAt, occurrenceView, parseSyntheticId, splitOccurrencePatch, syntheticId, type Occurrence } from "./recurrence.js";
+import { holdUntilOf, undoStatusOf } from "./futurerelease.js";
+import { createDirectory, mockRole } from "./directory.js";
+import { ACCOUNT, MOCK_LOCALE, Obj, USER, account, nextState, state } from "./config.js";
+import { NO_SCHEDULING_SEND, SCHEDULING_FORBIDDEN, blobs, events, mailboxes } from "./data.js";
+
+/* ---------- helpers ---------- */
+export function pick(o: Obj, props?: string[] | null): Obj {
+  if (!props) return o;
+  const out: Obj = { id: o.id };
+  for (const p of props) if (p in o) out[p] = o[p];
+  else if (p.startsWith("header:")) out[p] = null;
+  return out;
+}
+export function resolveRefs(args: Obj, responses: [string, Obj, string][], creations: Record<string, string>): Obj {
+  const out: Obj = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (k.startsWith("#")) {
+      const r = v as { resultOf: string; name: string; path: string };
+      const resp = responses.find((x) => x[2] === r.resultOf && x[0] === r.name);
+      out[k.slice(1)] = resp ? jsonPointer(resp[1], r.path) : [];
+    } else out[k] = resolveCreationIds(v, creations, k);
+  }
+  return out;
+}
+
+/**
+ * Creation references (RFC 8620 5.3): a `#creationId` anywhere a real id would
+ * go, pointing at something created earlier in the same request. Sending a
+ * message uses one -- `EmailSubmission/set` names the email as `#m` -- so
+ * without this the mock quietly declines to create any submission at all.
+ *
+ * `onSuccessUpdateEmail` is left alone: its keys are creation ids by design and
+ * the method that receives them resolves them itself.
+ */
+export function resolveCreationIds(value: unknown, creations: Record<string, string>, key?: string): unknown {
+  if (key === "onSuccessUpdateEmail") return value;
+  if (typeof value === "string") {
+    return value.startsWith("#") && creations[value.slice(1)] ? creations[value.slice(1)]! : value;
+  }
+  if (Array.isArray(value)) return value.map((v) => resolveCreationIds(v, creations));
+  if (value && typeof value === "object") {
+    const out: Obj = {};
+    for (const [k, v] of Object.entries(value as Obj)) {
+      const nk = k.startsWith("#") && creations[k.slice(1)] ? creations[k.slice(1)]! : k;
+      out[nk] = resolveCreationIds(v, creations, k);
+    }
+    return out;
+  }
+  return value;
+}
+export function jsonPointer(obj: unknown, path: string): unknown {
+  const parts = path.split("/").filter(Boolean);
+  let cur: unknown = obj;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i]!;
+    if (p === "*") {
+      const rest = parts.slice(i + 1).join("/");
+      const arr = (cur as unknown[]).flatMap((x) => { const v = jsonPointer(x, "/" + rest); return Array.isArray(v) ? v : [v]; });
+      return arr;
+    }
+    cur = (cur as Obj)?.[p];
+  }
+  return cur;
+}
+export function matchFilter(e: Obj, f: Obj | undefined): boolean {
+  if (!f) return true;
+  if (f.operator) {
+    const conds = (f.conditions as Obj[]).map((c) => matchFilter(e, c));
+    return f.operator === "AND" ? conds.every(Boolean) : f.operator === "OR" ? conds.some(Boolean) : !conds.some(Boolean);
+  }
+  const kw = e.keywords as Obj;
+  if (f.inMailbox && !(e.mailboxIds as Obj)[f.inMailbox as string]) return false;
+  if (f.hasKeyword && !kw[f.hasKeyword as string]) return false;
+  if (f.notKeyword && kw[f.notKeyword as string]) return false;
+  if (f.hasAttachment !== undefined && Boolean(e.hasAttachment) !== f.hasAttachment) return false;
+  const hay = `${e.subject} ${JSON.stringify(e.from)} ${JSON.stringify(e.to)} ${e.preview}`.toLowerCase();
+  for (const k of ["text", "subject", "from", "to", "body"]) if (f[k] && !hay.includes(String(f[k]).toLowerCase())) return false;
+  if (f.before && String(e.receivedAt) >= String(f.before)) return false;
+  if (f.after && String(e.receivedAt) < String(f.after)) return false;
+  if (f.minSize && Number(e.size) < Number(f.minSize)) return false;
+  if (f.maxSize && Number(e.size) > Number(f.maxSize)) return false;
+  return true;
+}
+export function applyPatch(obj: Obj, patch: Obj) {
+  for (const [k, v] of Object.entries(patch)) {
+    if (k.includes("/")) {
+      const [root, ...rest] = k.split("/");
+      const key = rest.join("/");
+      const target = (obj[root!] as Obj) ?? {};
+      if (v === null) delete target[key];
+      else target[key] = v;
+      obj[root!] = target;
+    } else obj[k] = v;
+  }
+}
+
+/* ---------- method handlers ---------- */
+export type Handler = (args: Obj) => Obj | [string, Obj][];
+/** A method-level failure, surfaced as ["error", {type, description}, id]. */
+export class MethodError extends Error {
+  constructor(
+    public readonly type: string,
+    description?: string,
+  ) {
+    super(description ?? type);
+  }
+}
+
+export const MAX_OBJECTS = 500;
+
+/**
+ * Stalwart refuses a whole method call that carries more objects than it will
+ * process at once - it does not quietly handle the first 500. Enforce the same
+ * ceiling the session advertises, so an unbatched client fails here too.
+ */
+export function enforceLimits(name: string, args: Obj): void {
+  const tooLarge = () => {
+    throw new MethodError("requestTooLarge", "The number of ids requested by the client exceeds the maximum number the server is willing to process in a single method call.");
+  };
+  if (name.endsWith("/get")) {
+    const ids = args.ids as unknown[] | null | undefined;
+    if (Array.isArray(ids) && ids.length > MAX_OBJECTS) tooLarge();
+  }
+  if (name.endsWith("/set")) {
+    const n =
+      Object.keys((args.create as Obj) ?? {}).length +
+      Object.keys((args.update as Obj) ?? {}).length +
+      ((args.destroy as unknown[] | undefined)?.length ?? 0);
+    if (n > MAX_OBJECTS) tooLarge();
+  }
+}
+
+export const setResp = (extra: Obj = {}): Obj => ({ accountId: ACCOUNT, oldState: "1", newState: nextState(), created: {}, updated: {}, destroyed: [], ...extra });
+
+/*
+ * `Mailbox/get` does not return `shareWith` unless a client asks for it by
+ * name: a `/get` with no `properties` comes back without the field at all.
+ * Confirmed on 0.16.19 (2026-08-27) against a mailbox that really was shared.
+ * The mock handing it over unasked meant a client that never asked still saw
+ * every share, and the one place that did not -- the real server -- showed
+ * nothing shared at all.
+ *
+ * Calendars and address books used to behave the same way and no longer do.
+ * 0.16.21 fixed `Calendar/get` and `AddressBook/get` to return every property
+ * when `properties` is omitted or null, `shareWith` included. **Confirmed live
+ * on 0.16.21 (2026-09-06):** both come back with the full set, while
+ * `Mailbox/get` on the same server still omits it — so this stays, and it
+ * stays applied to mailboxes alone.
+ */
+export function hideShareWithUnlessAsked(a: Obj, res: { list: Obj[] }): { list: Obj[] } {
+  if (a.properties) return res;
+  return { ...res, list: res.list.map(({ shareWith: _drop, ...rest }) => rest) };
+}
+
+export function genericGet(list: Obj[]) {
+  return (a: Obj) => {
+    const ids = a.ids as string[] | null | undefined;
+    const found = ids ? ids.map((id) => list.find((x) => x.id === id)).filter(Boolean) as Obj[] : list;
+    return { accountId: ACCOUNT, state: String(state.n), list: found.map((x) => pick(x, a.properties as string[] | null)), notFound: ids ? ids.filter((id) => !list.some((x) => x.id === id)) : [] };
+  };
+}
+/**
+ * An id, as either a stored event or one occurrence of one.
+ *
+ * A synthetic id whose base is gone, or whose date the rule no longer
+ * generates (excluded, or past a `count`), resolves to nothing — `notFound`,
+ * the way the server answers for an occurrence that is not there any more.
+ */
+export function resolveEvent(list: Obj[], id: string): { base: Obj; occ?: Occurrence } | null {
+  const direct = list.find((x) => x.id === id);
+  if (direct) return { base: direct };
+  const parsed = parseSyntheticId(id);
+  if (!parsed) return null;
+  const base = list.find((x) => x.id === parsed.baseId);
+  if (!base) return null;
+  const occ = occurrenceAt(base, parsed.recurrenceId);
+  return occ ? { base, occ } : null;
+}
+
+/** Thrown from an onCreate hook to refuse a create the way a real server would. */
+export class SetError extends Error {
+  constructor(readonly type: string, readonly description: string, readonly properties?: string[]) { super(description); }
+  toJSON(): Obj { return { type: this.type, description: this.description, ...(this.properties ? { properties: this.properties } : {}) }; }
+}
+
+export function genericSet(list: Obj[], prefix: string, onCreate?: (o: Obj) => void) {
+  return (a: Obj) => {
+    const created: Obj = {};
+    const updated: Obj = {};
+    const destroyed: string[] = [];
+    const notCreated: Obj = {};
+    for (const [cid, obj] of Object.entries((a.create as Obj) ?? {})) {
+      const id = `${prefix}${randomUUID().slice(0, 6)}`;
+      const o = { ...(obj as Obj), id };
+      try {
+        onCreate?.(o);
+      } catch (err) {
+        if (!(err instanceof SetError)) throw err;
+        notCreated[cid] = err.toJSON();
+        continue;
+      }
+      list.push(o);
+      created[cid] = { id };
+    }
+    for (const [id, patch] of Object.entries((a.update as Obj) ?? {})) {
+      const o = list.find((x) => x.id === id);
+      if (o) { applyPatch(o, patch as Obj); updated[id] = null; }
+    }
+    for (const id of (a.destroy as string[]) ?? []) {
+      const i = list.findIndex((x) => x.id === id);
+      if (i >= 0) { list.splice(i, 1); destroyed.push(id); }
+    }
+    return setResp({ created, updated, destroyed, ...(Object.keys(notCreated).length ? { notCreated } : {}) });
+  };
+}
+
+/* ---------- calendar events ---------- */
+
+/**
+ * `CalendarEvent/set`, including the synthetic-id handling 0.16.20 added.
+ *
+ * An update or destroy aimed at an occurrence does not touch the series: it
+ * writes a `recurrenceOverrides` entry keyed by that date, exactly as Stalwart
+ * does — `{ excluded: true }` for a destroy, the patch merged in for an update.
+ *
+ * The refusals are the point of reproducing this at all:
+ *
+ * - a base event and one of its instances in the same request is refused, both
+ *   ids at once, because the server cannot apply them in a defined order;
+ * - the same id twice is "Duplicate event id.";
+ * - the ten event-level properties are refused with `invalidProperties`;
+ * - and the twelve inherited ones are dropped in silence, with the response
+ *   still saying the update succeeded. A mock that applied them would let a
+ *   client that sends them look correct everywhere except a real server.
+ */
+/**
+ * Enough of an iCalendar reader to stand in for Stalwart's.
+ *
+ * It reads per VEVENT rather than across the whole file, because a file is the
+ * case an emailed invitation never was: an export carries a year of them, and a
+ * regex over the whole text would find the first DTSTART and call that the
+ * answer. One event still comes back as a bare object, the shape this returned
+ * when an invitation was all it had to handle.
+ *
+ * The synthetic organizer and attendee only go on events that arrived with a
+ * METHOD. Those are scheduling messages, which is what the invitation fixtures
+ * are; a plain export is not addressed to anyone, and inventing participants
+ * for it would make imported events look like invitations nobody sent.
+ */
+export function calendarEventParse(a: Obj) {
+  const parsed: Obj = {};
+  const notParsable: string[] = [];
+  for (const b of a.blobIds as string[]) {
+    const blob = blobs.get(b);
+    if (!blob) { notParsable.push(b); continue; }
+    const text = blob.data.toString();
+    const field = (src: string, k: string) => new RegExp(`^${k}[^:\r\n]*:(.*)$`, "m").exec(src)?.[1]?.trim();
+    const method = field(text, "METHOD");
+    const bodies = text.match(/BEGIN:VEVENT[\s\S]*?END:VEVENT/g) ?? [];
+    const events = bodies.map((body) => {
+      const g = (k: string) => field(body, k);
+      const ds = g("DTSTART") ?? "20260101T000000Z";
+      const de = g("DTEND") ?? ds;
+      const toLocal = (s: string) => `${s.slice(0, 4)}-${s.slice(4, 6)}-${s.slice(6, 8)}T${s.slice(9, 11)}:${s.slice(11, 13)}:00`;
+      const start = new Date(`${toLocal(ds)}Z`);
+      const end = new Date(`${toLocal(de)}Z`);
+      return {
+        "@type": "Event",
+        uid: g("UID"),
+        title: g("SUMMARY"),
+        start: toLocal(ds),
+        timeZone: "Etc/UTC",
+        duration: `PT${Math.round((end.getTime() - start.getTime()) / 60000)}M`,
+        method,
+        locations: g("LOCATION") ? { l: { name: g("LOCATION") } } : undefined,
+        participants: method
+          ? {
+              org: { name: "Ada Lovelace", calendarAddress: "mailto:[email protected]", roles: { owner: true } },
+              me: { name: "Demo User", calendarAddress: `mailto:${USER}`, roles: { attendee: true, required: true }, participationStatus: "needs-action" },
+            }
+          : undefined,
+      };
+    });
+    if (!events.length) { notParsable.push(b); continue; }
+    parsed[b] = events.length === 1 ? events[0] : events;
+  }
+  return { accountId: ACCOUNT, parsed, notParsable };
+}
+
+export function calendarEventSet(a: Obj) {
+  const created: Obj = {};
+  const updated: Obj = {};
+  const destroyed: string[] = [];
+  const notCreated: Obj = {};
+  const notUpdated: Obj = {};
+  const notDestroyed: Obj = {};
+
+  /*
+   * An account that may not send invitations refuses the whole request the
+   * moment it asks for them, and refuses it per object rather than as a method
+   * error. Confirmed live on 0.16.21 for all three of create, update and
+   * destroy; the same requests with the flag absent or false went through.
+   * The flag alone decides it — the server does not first check whether the
+   * event has anyone to notify.
+   */
+  if (NO_SCHEDULING_SEND && a.sendSchedulingMessages === true) {
+    const denied = () => new SetError("forbidden", SCHEDULING_FORBIDDEN).toJSON();
+    for (const cid of Object.keys((a.create as Obj) ?? {})) notCreated[cid] = denied();
+    for (const id of Object.keys((a.update as Obj) ?? {})) notUpdated[id] = denied();
+    for (const id of ((a.destroy as string[]) ?? [])) notDestroyed[id] = denied();
+    return setResp({
+      created, updated, destroyed,
+      ...(Object.keys(notCreated).length ? { notCreated } : {}),
+      ...(Object.keys(notUpdated).length ? { notUpdated } : {}),
+      ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}),
+    });
+  }
+
+  for (const [cid, obj] of Object.entries((a.create as Obj) ?? {})) {
+    const o: Obj = { ...(obj as Obj), id: `ev${randomUUID().slice(0, 6)}` };
+    // Stalwart 0.16 rejects the RFC 8984 array outright and silently discards
+    // participants addressed the RFC 8984 way. The mock did neither, which is
+    // how #26 and #30 reached a live server unnoticed — so it does both.
+    if (o.recurrenceRules) { notCreated[cid] = new SetError("invalidProperties", "Invalid property.", ["recurrenceRules"]).toJSON(); continue; }
+    const parts = o.participants as Record<string, Obj> | undefined;
+    if (parts && Object.values(parts).some((p) => !p.calendarAddress)) delete o.participants;
+    if (o.replyTo && !o.organizerCalendarAddress) delete o.replyTo;
+    o.uid = o.uid ?? randomUUID();
+    events.push(o);
+    created[cid] = { id: o.id };
+  }
+
+  const updates = Object.entries((a.update as Obj) ?? {});
+  const destroys = ((a.destroy as string[]) ?? []).slice();
+  const seen = new Set<string>();
+
+  /* A base and one of its instances cannot be settled in the same request. */
+  const baseOf = (id: string): string | null => {
+    const r = resolveEvent(events, id);
+    return r ? (r.base.id as string) : null;
+    };
+  const touched = new Map<string, { base: string[]; instance: string[] }>();
+  for (const id of [...updates.map(([id]) => id), ...destroys]) {
+    const b = baseOf(id);
+    if (!b) continue;
+    const entry = touched.get(b) ?? { base: [], instance: [] };
+    (parseSyntheticId(id) ? entry.instance : entry.base).push(id);
+    touched.set(b, entry);
+  }
+  const conflicted = new Set<string>();
+  for (const [, e] of touched) {
+    if (e.base.length && e.instance.length) for (const id of [...e.base, ...e.instance]) conflicted.add(id);
+  }
+  const conflict = () => new SetError("invalidProperties", "A base event and its instances cannot be modified in the same request.", ["id"]).toJSON();
+
+  for (const [id, patch] of updates) {
+    if (conflicted.has(id)) { notUpdated[id] = conflict(); continue; }
+    if (seen.has(id)) { notUpdated[id] = new SetError("invalidProperties", "Duplicate event id.", ["id"]).toJSON(); continue; }
+    seen.add(id);
+    const resolved = resolveEvent(events, id);
+    if (!resolved) { notUpdated[id] = { type: "notFound" }; continue; }
+    if (!resolved.occ) { applyPatch(resolved.base, patch as Obj); updated[id] = null; continue; }
+    const { rejected, applied } = splitOccurrencePatch(patch as Obj);
+    if (rejected) { notUpdated[id] = new SetError("invalidProperties", "This property cannot be modified on a single occurrence.", [rejected]).toJSON(); continue; }
+    writeOverride(resolved.base, resolved.occ, applied);
+    updated[id] = null;
+  }
+
+  for (const id of destroys) {
+    if (conflicted.has(id)) { notDestroyed[id] = conflict(); continue; }
+    const resolved = resolveEvent(events, id);
+    if (!resolved) { notDestroyed[id] = { type: "notFound" }; continue; }
+    if (resolved.occ) {
+      // One date off a series, which is an override rather than a deletion.
+      writeOverride(resolved.base, resolved.occ, { excluded: true }, true);
+      destroyed.push(id);
+      continue;
+    }
+    const i = events.findIndex((x) => x.id === id);
+    if (i >= 0) { events.splice(i, 1); destroyed.push(id); }
+  }
+
+  return setResp({
+    created, updated, destroyed,
+    ...(Object.keys(notCreated).length ? { notCreated } : {}),
+    ...(Object.keys(notUpdated).length ? { notUpdated } : {}),
+    ...(Object.keys(notDestroyed).length ? { notDestroyed } : {}),
+  });
+}
+
+/**
+ * Merge a patch into the override for one date.
+ *
+ * Stalwart fills `start` and `duration` in when the patch leaves them out, so
+ * an override always carries its own timing; the mock does the same, or a
+ * client could depend on inheriting them and be right only here.
+ */
+export function writeOverride(base: Obj, occ: Occurrence, patch: Obj, replace = false) {
+  const overrides = (base.recurrenceOverrides as Record<string, Obj> | undefined) ?? {};
+  const existing = replace ? {} : (overrides[occ.recurrenceId] ?? {});
+  const next: Obj = { ...existing };
+  if (!replace) {
+    if (!("start" in next)) next.start = occ.start;
+    if (!("duration" in next) && base.duration) next.duration = base.duration;
+  }
+  applyPatch(next, patch);
+  overrides[occ.recurrenceId] = next;
+  base.recurrenceOverrides = overrides;
+}
+
+/* ---------- submissions ---------- */
+/**
+ * Held messages, the way Stalwart models them: `sendAt` is derived from the
+ * envelope's FUTURERELEASE parameter rather than set by the client, and
+ * `undoStatus` reports whether the message is still in the queue.
+ */
+export const submissions: Obj[] = [];
+
+export function submissionView(sub: Obj): Obj {
+  return { ...sub, undoStatus: undoStatusOf(sub, Date.now()) };
+}
+
+export function matchSubmissionFilter(sub: Obj, f: Obj | undefined): boolean {
+  if (!f) return true;
+  if (f.undoStatus && undoStatusOf(sub, Date.now()) !== f.undoStatus) return false;
+  if (Array.isArray(f.emailIds) && !(f.emailIds as string[]).includes(sub.emailId as string)) return false;
+  if (Array.isArray(f.identityIds) && !(f.identityIds as string[]).includes(sub.identityId as string)) return false;
+  return true;
+}
+
+/** Who the demo user is, for administration. See mock/directory.ts. */
+export const directory = createDirectory({
+  accountId: ACCOUNT,
+  user: USER,
+  locale: MOCK_LOCALE,
+  role: mockRole(process.env.MOCK_ROLE),
+  metricsOff: process.env.MOCK_METRICS === "off",
+  fail: (type, description) => new MethodError(type, description),
+});
+

server/src/mock/events.ts

@@ -0,0 +1,36 @@
+import type { ServerResponse } from "node:http";
+import { ACCOUNT, state } from "./config.js";
+
+/*
+ * The server-sent-events fan-out and the Email/changes ring buffer.
+ *
+ * Separate from index.ts because the JMAP handlers raise these events and
+ * index.ts imports the handlers -- leaving them in index.ts makes that a
+ * cycle. Separate from data.ts because a live HTTP response is not fixture
+ * data.
+ */
+export const sseClients = new Set<ServerResponse>();
+/** What changed and when, so `Email/changes` can answer honestly. */
+export const emailChanges: Array<{ state: number; created: string[]; updated: string[]; destroyed: string[] }> = [];
+export function recordEmailChange(change: { created?: string[]; updated?: string[]; destroyed?: string[] }) {
+  emailChanges.push({ state: state.n, created: change.created ?? [], updated: change.updated ?? [], destroyed: change.destroyed ?? [] });
+  // A window is plenty; the client refetches from scratch if it falls behind.
+  if (emailChanges.length > 200) emailChanges.splice(0, emailChanges.length - 200);
+}
+
+/** The same for contact cards, so `ContactCard/changes` can answer too. */
+export const cardChanges: Array<{ state: number; created: string[]; updated: string[]; destroyed: string[] }> = [];
+/** Changes at or below this state have been dropped from the log, so a client that far behind cannot be answered. */
+export const cardLog = { floor: 0 };
+export function recordCardChange(change: { created?: string[]; updated?: string[]; destroyed?: string[] }) {
+  cardChanges.push({ state: state.n, created: change.created ?? [], updated: change.updated ?? [], destroyed: change.destroyed ?? [] });
+  if (cardChanges.length > 200) {
+    const dropped = cardChanges.splice(0, cardChanges.length - 200);
+    cardLog.floor = dropped[dropped.length - 1]!.state;
+  }
+}
+
+export function broadcast(types: string[]) {
+  const payload = `event: state\ndata: ${JSON.stringify({ "@type": "StateChange", changed: { [ACCOUNT]: Object.fromEntries(types.map((t) => [t, String(state.n)])) } })}\n\n`;
+  for (const c of sseClients) c.write(payload);
+}

server/src/mock/handlers.ts

@@ -0,0 +1,516 @@
+import { checkOtp } from "./auth.js";
+import { cardChanges, cardLog, emailChanges, recordCardChange, recordEmailChange, broadcast } from "./events.js";
+import { randomUUID } from "node:crypto";
+import { eventGetView, expandOccurrences, occurrenceAt, occurrenceView, parseSyntheticId, splitOccurrencePatch, syntheticId, type Occurrence } from "./recurrence.js";
+import { holdUntilOf, undoStatusOf } from "./futurerelease.js";
+import { ACCOUNT, MASKED, MAX_DELAYED_SEND, MOCK_LOCALE, NO_FUTURE_RELEASE, Obj, PUSH_TTL_MS, SHARED_ACCOUNT, account, nextState, state } from "./config.js";
+import { NO_KEYWORD_SORT, abRights, blobs, booksFor, calendarsFor, cards, compareBy, emails, eventsFor, fileNodes, fr, identities, mailboxes, mb, nodesFor, participantIdentities, principals, pushSubscriptions, putBlob, recount, rightsCal, seq, sharedCards, sieveScripts, vacationBox } from "./data.js";
+import { Handler, MethodError, applyPatch, calendarEventParse, calendarEventSet, directory, genericGet, genericSet, hideShareWithUnlessAsked, matchFilter, matchSubmissionFilter, pick, resolveEvent, setResp, submissionView, submissions } from "./engine.js";
+
+/** Stalwart's limit per account (0.16.22). */
+const MAX_PUSH_SUBSCRIPTIONS = 15;
+/** What an empty or missing `types` list is taken to mean: everything. */
+const ALL_PUSH_TYPES = ["Email", "EmailDelivery", "Mailbox", "Thread", "Identity", "EmailSubmission", "VacationResponse", "CalendarEvent", "Calendar", "ContactCard", "AddressBook", "FileNode", "Quota", "SieveScript", "PushSubscription"];
+
+export const handlers: Record<string, Handler> = {
+  // 0.16 exposes the account locale here, under a permission ordinary users
+  // actually have (unlike x:Account below, which needs sysAccountGet).
+  "x:AccountSettings/get": (a) => {
+    const ids = (a.ids as string[] | null) ?? ["singleton"];
+    const list = ids.filter((id) => id === "singleton").map((id) => ({ id, locale: MOCK_LOCALE, timeZone: null, description: null }));
+    return { accountId: ACCOUNT, state: String(state.n), list: list.map((x) => pick(x, a.properties as string[] | null)), notFound: ids.filter((id) => id !== "singleton") };
+  },
+  // Stalwart's directory registry: accounts, domains and roles, behind the
+  // same permissions as the real thing. The locale fallback reads x:Account
+  // too, and is refused here exactly when a real server would refuse it.
+  ...directory.handlers,
+  "Mailbox/get": (a) => hideShareWithUnlessAsked(a, genericGet(mailboxes)(a) as { list: Obj[] }) as never,
+  "Mailbox/set": (a) => { const r = genericSet(mailboxes, "m", (o) => Object.assign(o, { ...mb(o.id as string, o.name as string, null, (o.parentId as string) ?? null), ...o }))(a); recount(); return r; },
+  "Mailbox/changes": () => ({ accountId: ACCOUNT, oldState: "1", newState: String(state.n), hasMoreChanges: false, created: [], updated: [], destroyed: [] }),
+  "Email/query": (a) => {
+    let list = emails.filter((e) => matchFilter(e, a.filter as Obj));
+    /*
+     * Honor the sort rather than always answering newest-first. This used to
+     * ignore it entirely, which reproduced a server that silently returns a
+     * different order from the one asked for -- the one shape of wrongness a
+     * client cannot detect.
+     */
+    const sort = (a.sort as Obj[] | undefined) ?? [{ property: "receivedAt", isAscending: false }];
+    if (NO_KEYWORD_SORT && sort.some((c) => String(c.property) === "hasKeyword")) {
+      // A method-level failure, the way a real server refuses an optional sort:
+      // the whole call fails rather than the sort being quietly dropped.
+      throw new MethodError("unsupportedSort", "Sorting on hasKeyword is not supported.");
+    }
+    list.sort((x, y) => {
+      for (const c of sort) {
+        const asc = c.isAscending !== false;
+        const cmp = compareBy(x, y, String(c.property), c.keyword as string | undefined);
+        if (cmp !== 0) return asc ? cmp : -cmp;
+      }
+      return 0;
+    });
+    if (a.collapseThreads) {
+      const seen = new Set<string>();
+      list = list.filter((e) => { const t = e.threadId as string; if (seen.has(t)) return false; seen.add(t); return true; });
+    }
+    const pos = Number(a.position ?? 0);
+    const limit = Number(a.limit ?? 50);
+    return { accountId: ACCOUNT, queryState: String(state.n), canCalculateChanges: false, position: pos, ids: list.slice(pos, pos + limit).map((e) => e.id), total: list.length, limit };
+  },
+  "Email/get": (a) => genericGet(emails)(a),
+  /*
+   * Real changes, not an empty answer.
+   *
+   * This used to return three empty arrays whatever had happened, so the
+   * client's whole reconciliation path -- `Email/changes`, then deciding what
+   * to do with what came back -- never ran against the mock. A bug living in
+   * that path could not be reproduced here at all, which is how one reached
+   * production and survived being "fixed" once (#100). The log below is what
+   * the real server can answer from.
+   */
+  "Email/changes": (a) => {
+    const since = Number(a.sinceState ?? 0);
+    const relevant = emailChanges.filter((c) => c.state > since);
+    const pick = (k: "created" | "updated" | "destroyed") => [...new Set(relevant.flatMap((c) => c[k]))];
+    return { accountId: ACCOUNT, oldState: String(a.sinceState ?? "1"), newState: String(state.n), hasMoreChanges: false, created: pick("created"), updated: pick("updated"), destroyed: pick("destroyed") };
+  },
+  "Email/set": (a) => {
+    const r = genericSet(emails, "e", (o) => {
+      const bv = (o.bodyValues as Record<string, { value: string }>) ?? {};
+      const walk = (p: Obj | undefined, acc: Obj[]) => { if (!p) return; if (p.partId && bv[p.partId as string]) acc.push({ ...p, blobId: putBlob(bv[p.partId as string]!.value, p.type as string), size: bv[p.partId as string]!.value.length }); (p.subParts as Obj[] | undefined)?.forEach((s) => walk(s, acc)); };
+      const parts: Obj[] = [];
+      walk(o.bodyStructure as Obj, parts);
+      o.textBody = parts.filter((p) => p.type === "text/plain");
+      o.htmlBody = parts.filter((p) => p.type === "text/html");
+      o.attachments = [];
+      const collect = (p: Obj | undefined) => { if (!p) return; if (p.blobId && !p.partId && p.type !== "multipart/mixed") (o.attachments as Obj[]).push({ ...p, size: p.size ?? 0 }); (p.subParts as Obj[] | undefined)?.forEach(collect); };
+      collect(o.bodyStructure as Obj);
+      o.hasAttachment = (o.attachments as Obj[]).length > 0;
+      o.threadId = o.inReplyTo ? (emails.find((e) => (e.messageId as string[] | null)?.[0] === (o.inReplyTo as string[])[0])?.threadId ?? `t${o.id}`) : `t${o.id}`;
+      o.receivedAt = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+      o.size = 2000;
+      o.preview = (bv.text?.value ?? "").slice(0, 100);
+      o.messageId = [`${o.id}@mock`];
+      o.blobId = putBlob(`Subject: ${o.subject}\r\n\r\n${bv.text?.value ?? ""}`, "message/rfc822");
+    })(a);
+    recount();
+    nextState();
+    recordEmailChange({
+      created: Object.values((r.created ?? {}) as Record<string, { id: string }>).map((x) => x.id),
+      updated: Object.keys((a.update as Obj) ?? {}),
+      destroyed: (r.destroyed as string[] | undefined) ?? [],
+    });
+    /* A real server pushes a state change after a set, and the client acts on
+       it -- `Email/changes` runs and the store reconciles what came back. The
+       mock stayed silent, so that whole path never ran here and a bug living
+       in it could not be reproduced: marking a message read went round the
+       server and back on the live instance, and did nothing at all on the mock
+       (#100). Announced now, the way Stalwart does. */
+    broadcast(["Email", "Mailbox", "Thread"]);
+    return r;
+  },
+  "Email/import": (a) => { const created: Obj = {}; for (const [cid, spec] of Object.entries((a.emails as Obj) ?? {})) { const id = `e${seq.counter++}`; emails.push({ id, blobId: (spec as Obj).blobId, threadId: `t${id}`, mailboxIds: (spec as Obj).mailboxIds, keywords: (spec as Obj).keywords ?? {}, size: 100, receivedAt: new Date().toISOString(), subject: "(imported message)", from: [{ name: null, email: "import@example" }], to: null, preview: "", hasAttachment: false, textBody: [], htmlBody: [], attachments: [], bodyValues: {} }); created[cid] = { id }; } recount(); return setResp({ created }); },
+  "Thread/get": (a) => { const ids = a.ids as string[]; const list = ids.map((id) => ({ id, emailIds: emails.filter((e) => e.threadId === id).sort((x, y) => String(x.receivedAt).localeCompare(String(y.receivedAt))).map((e) => e.id) })).filter((t) => t.emailIds.length); return { accountId: ACCOUNT, state: String(state.n), list, notFound: ids.filter((id) => !list.some((t) => t.id === id)) }; },
+  // Stalwart 0.16 registry objects backing self-service credentials.
+  "x:AccountPassword/get": () => ({
+    accountId: ACCOUNT,
+    state: String(state.n),
+    list: [{ id: "singleton", otpAuth: { otpUrl: account.otpUrl ? MASKED : null, otpCode: null } }],
+    notFound: [],
+  }),
+  "x:AccountPassword/set": (a) => {
+    const patch = ((a.update as Obj) ?? {})["singleton"] as Obj | undefined;
+    if (!patch) return setResp({ updated: {} });
+    const current = patch.currentSecret as string | undefined;
+    const code = (patch["otpAuth/otpCode"] ?? (patch.otpAuth as Obj | undefined)?.otpCode) as string | undefined;
+    if (!current) {
+      return setResp({ notUpdated: { singleton: { type: "forbidden", description: "Current secret must be provided to change the password or OTP auth." } } });
+    }
+    if (current !== account.password) {
+      return setResp({ notUpdated: { singleton: { type: "forbidden", description: "Current secret is incorrect." } } });
+    }
+    if (account.otpUrl && !code) {
+      return setResp({ notUpdated: { singleton: { type: "forbidden", description: "Current OTP code is required to change the password or OTP auth." } } });
+    }
+    if (account.otpUrl && !checkOtp(code!)) {
+      return setResp({ notUpdated: { singleton: { type: "forbidden", description: "Current secret is incorrect." } } });
+    }
+    const secret = patch.secret as string | undefined;
+    if (secret !== undefined && secret !== MASKED) {
+      if (secret.length < 8) {
+        return setResp({ notUpdated: { singleton: { type: "invalidProperties", properties: ["secret"], description: "Password must be at least 8 characters long." } } });
+      }
+      account.password = secret;
+    }
+    if ("otpAuth/otpUrl" in patch) {
+      const url = patch["otpAuth/otpUrl"] as string | null;
+      if (url !== MASKED) account.otpUrl = url;
+    }
+    state.n++;
+    return setResp({ updated: { singleton: null } });
+  },
+  /*
+   * Push subscriptions. The JMAP half can be modeled; delivery cannot -- that
+   * runs through the browser vendor's real push service, so nothing local will
+   * ever make a notification appear.
+   *
+   * What is worth reproducing is the handshake, because it is the part that
+   * fails quietly: a subscription is created unverified and stays silent until
+   * the client echoes back a code the server pushed. A mock that marked one
+   * verified on creation would let a client ship without ever implementing
+   * that, and the symptom in production is "registered, and no notifications".
+   */
+  "PushSubscription/get": (a) => {
+    const ids = (a.ids as string[] | null) ?? pushSubscriptions.map((s) => s.id as string);
+    const list = pushSubscriptions.filter((s) => ids.includes(s.id as string));
+    // `keys` is write-only in JMAP: the server never hands it back.
+    return { accountId: ACCOUNT, state: String(state.n), list: list.map((s) => { const { keys: _drop, ...rest } = s; return rest; }), notFound: ids.filter((i) => !list.some((s) => s.id === i)) };
+  },
+  "PushSubscription/set": (a) => {
+    const created: Obj = {};
+    const notCreated: Obj = {};
+    const updated: Obj = {};
+    const notUpdated: Obj = {};
+    const destroyed: string[] = [];
+    for (const [cid, obj] of Object.entries((a.create as Obj) ?? {})) {
+      const o = obj as Obj;
+      const keys = (o.keys ?? {}) as Obj;
+      // Stalwart 0.16 was fixed to accept the unpadded base64url the W3C Push
+      // API produces; padding it would be the client inventing a shape.
+      for (const k of ["p256dh", "auth"]) {
+        const v = String(keys[k] ?? "");
+        if (!v) { notCreated[cid] = { type: "invalidProperties", properties: ["keys"], description: `Missing ${k}.` }; break; }
+        if (v.includes("=") || v.includes("+") || v.includes("/")) {
+          notCreated[cid] = { type: "invalidProperties", properties: ["keys"], description: `${k} must be unpadded base64url.` };
+          break;
+        }
+      }
+      if (notCreated[cid]) continue;
+      if (!String(o.url ?? "").startsWith("https://")) {
+        notCreated[cid] = { type: "invalidProperties", properties: ["url"], description: "Push endpoint must be https." };
+        continue;
+      }
+      // A filter condition with a null value is not a filter -- the real server
+      // answers "Invalid filter" and refuses the whole subscription. ihasmail
+      // shipped `inMailbox: null` meaning "the inbox", which meant nothing at
+      // all here, and the mock accepted it happily. It does not any more.
+      const badFilter = Object.entries((o.emailPush ?? {}) as Obj).find(([, cfg]) => {
+        const f = ((cfg as Obj)?.filter ?? {}) as Obj;
+        return Object.values(f).some((v) => v === null || v === undefined);
+      });
+      if (badFilter) {
+        notCreated[cid] = { type: "invalidArguments", properties: ["emailPush"], description: "Invalid filter." };
+        continue;
+      }
+      /*
+       * As Stalwart does (checked live on 0.16.22, 2026-09-16): a repeated
+       * deviceClientId is a second subscription, not a replacement -- this mock
+       * used to replace, which is how the client's pile-up never showed here
+       * (#375) -- and an account holds at most fifteen.
+       */
+      const deviceId = String(o.deviceClientId ?? "");
+      if (pushSubscriptions.length >= MAX_PUSH_SUBSCRIPTIONS) {
+        notCreated[cid] = { type: "overQuota", description: "There are too many subscriptions, please delete some before adding a new one." };
+        continue;
+      }
+      const id = `ps${randomUUID().slice(0, 6)}`;
+      /*
+       * A subscription expires, and this used to hand back `expires: null`.
+       * That is the one shape that makes the client's real problem invisible in
+       * development: JMAP puts a ceiling of seven days on a push subscription
+       * and expects the client to re-register before it lapses, so a client
+       * that never renews works perfectly against a mock that never expires
+       * anything and goes silent a week after being deployed. Seven days here,
+       * so "does this client renew?" is a question the mock can answer.
+       */
+      const expires = new Date(Date.now() + PUSH_TTL_MS).toISOString();
+      // An empty or missing list means every type, not none.
+      const types = Array.isArray(o.types) && o.types.length ? o.types : ALL_PUSH_TYPES;
+      pushSubscriptions.push({ id, deviceClientId: deviceId, url: o.url, types, emailPush: o.emailPush ?? null, expires, keys, verified: false, code: `v${randomUUID().slice(0, 8)}` });
+      created[cid] = { id, expires };
+      state.n++;
+    }
+    for (const [id, patch] of Object.entries((a.update as Obj) ?? {})) {
+      const s = pushSubscriptions.find((x) => x.id === id);
+      if (!s) { notUpdated[id] = { type: "notFound" }; continue; }
+      const code = (patch as Obj).verificationCode;
+      if (code !== undefined) {
+        if (code !== s.code) { notUpdated[id] = { type: "invalidProperties", properties: ["verificationCode"], description: "Verification code does not match." }; continue; }
+        s.verified = true;
+      }
+      // An expiry can be extended, up to the same seven days a new one gets.
+      const wanted = (patch as Obj).expires;
+      if (typeof wanted === "string") {
+        const at = Math.min(Date.parse(wanted), Date.now() + PUSH_TTL_MS);
+        if (Number.isNaN(at)) { notUpdated[id] = { type: "invalidProperties", properties: ["expires"] }; continue; }
+        s.expires = new Date(at).toISOString();
+      }
+      updated[id] = null;
+      state.n++;
+    }
+    for (const id of (a.destroy as string[]) ?? []) {
+      const i = pushSubscriptions.findIndex((x) => x.id === id);
+      if (i >= 0) { pushSubscriptions.splice(i, 1); destroyed.push(id); state.n++; }
+    }
+    return setResp({ created, notCreated, updated, notUpdated, destroyed });
+  },
+  "x:AppPassword/get": (a) => genericGet(account.appPasswords)(a),
+  "x:AppPassword/set": (a) => {
+    const created: Obj = {};
+    const destroyed: string[] = [];
+    for (const [cid, obj] of Object.entries((a.create as Obj) ?? {})) {
+      const id = `ap${randomUUID().slice(0, 6)}`;
+      // Real app passwords carry their credential id, so the server can spot
+      // one by its shape alone. Mirror that.
+      const secret = `$app$${id}$${randomUUID().replace(/-/g, "").slice(0, 20)}`;
+      const row: Obj = { id, description: (obj as Obj).description ?? "App password", createdAt: new Date().toISOString(), expiresAt: null, secret };
+      account.appPasswords.push(row);
+      created[cid] = { id, secret, createdAt: row.createdAt };
+    }
+    for (const id of (a.destroy as string[]) ?? []) {
+      const i = account.appPasswords.findIndex((x) => x.id === id);
+      if (i >= 0) { account.appPasswords.splice(i, 1); destroyed.push(id); }
+    }
+    state.n++;
+    return setResp({ created, destroyed });
+  },
+  "Identity/get": genericGet(identities),
+  "Identity/set": (a) => {
+    // Stalwart's cap is `value.len() < 2048` on a Rust string: 2047 bytes of
+    // UTF-8, not characters. Anything longer is refused by name.
+    for (const [where, entries] of [["notCreated", (a.create as Obj) ?? {}], ["notUpdated", (a.update as Obj) ?? {}]] as const) {
+      for (const [key, obj] of Object.entries(entries)) {
+        const over = ["htmlSignature", "textSignature"].find((prop) => {
+          const v = (obj as Obj)[prop];
+          return typeof v === "string" && Buffer.byteLength(v, "utf8") > 2047;
+        });
+        if (over) return setResp({ [where]: { [key]: { type: "invalidProperties", properties: [over], description: "Invalid property." } } });
+      }
+    }
+    return genericSet(identities, "i", (o) => Object.assign(o, { replyTo: null, bcc: null, textSignature: "", htmlSignature: "", mayDelete: true, ...o }))(a);
+  },
+  "EmailSubmission/get": (a) => {
+    const ids = a.ids as string[] | null | undefined;
+    const found = ids ? ids.map((id) => submissions.find((x) => x.id === id)).filter(Boolean) as Obj[] : submissions;
+    return { accountId: ACCOUNT, state: String(state.n), list: found.map((x) => pick(submissionView(x), a.properties as string[] | null)), notFound: ids ? ids.filter((id) => !submissions.some((x) => x.id === id)) : [] };
+  },
+  "EmailSubmission/query": (a) => {
+    const list = submissions.filter((s) => matchSubmissionFilter(s, a.filter as Obj | undefined));
+    list.sort((x, y) => String(x.sendAt).localeCompare(String(y.sendAt)));
+    const pos = Number(a.position ?? 0);
+    const limit = Number(a.limit ?? 50);
+    return { accountId: ACCOUNT, queryState: String(state.n), canCalculateChanges: false, position: pos, ids: list.slice(pos, pos + limit).map((s) => s.id), total: list.length, limit };
+  },
+  "EmailSubmission/set": (a) => {
+    const created: Obj = {};
+    const notCreated: Obj = {};
+    const updated: Obj = {};
+    const notUpdated: Obj = {};
+    for (const [cid, raw] of Object.entries((a.create as Obj) ?? {})) {
+      const sub = raw as Obj;
+      const emailId = sub.emailId as string;
+      const e = emails.find((x) => x.id === emailId);
+      if (!e) {
+        notCreated[cid] = { type: "invalidProperties", properties: ["emailId"], description: "Blob for email not found." };
+        continue;
+      }
+      const hold = holdUntilOf(sub.envelope as Obj | undefined, Date.now());
+      if (Number.isNaN(hold)) {
+        notCreated[cid] = { type: "invalidProperties", properties: ["envelope"], description: "Failed to parse mailFrom parameters." };
+        continue;
+      }
+      // Stalwart rejects MAIL FROM outright past its own limit.
+      if (hold !== null && hold > Date.now() + MAX_DELAYED_SEND * 1000) {
+        notCreated[cid] = { type: "forbiddenMailFrom", description: `Server rejected MAIL-FROM: 501 5.5.4 Requested release time exceeds maximum of ${new Date(Date.now() + MAX_DELAYED_SEND * 1000).toISOString()}.` };
+        continue;
+      }
+      // With the MTA extension off, the hold is dropped in silence.
+      const sendAt = hold !== null && !NO_FUTURE_RELEASE ? hold : Date.now();
+      const rec: Obj = {
+        id: `s${randomUUID().slice(0, 6)}`,
+        identityId: sub.identityId ?? null,
+        emailId,
+        threadId: e.threadId ?? null,
+        envelope: sub.envelope ?? null,
+        sendAt: new Date(sendAt).toISOString(),
+        undoStatus: null,
+        deliveryStatus: null,
+      };
+      submissions.push(rec);
+      created[cid] = { id: rec.id, sendAt: rec.sendAt, undoStatus: undoStatusOf(rec, Date.now()) };
+      const patch = ((a.onSuccessUpdateEmail as Obj) ?? {})[`#${cid}`] as Obj | undefined;
+      if (patch) applyPatch(e, patch);
+    }
+    for (const [id, raw] of Object.entries((a.update as Obj) ?? {})) {
+      const patch = raw as Obj;
+      const sub = submissions.find((x) => x.id === id);
+      if (!sub) { notUpdated[id] = { type: "notFound" }; continue; }
+      if (patch.undoStatus !== "canceled") {
+        notUpdated[id] = { type: "invalidProperties", properties: ["undoStatus"], description: "Only cancellation is supported." };
+        continue;
+      }
+      const status = undoStatusOf(sub, Date.now());
+      if (status !== "pending") {
+        notUpdated[id] = { type: "cannotUnsend", description: status === "canceled" ? "The message was already canceled." : "The message has already been sent." };
+        continue;
+      }
+      sub.undoStatus = "canceled";
+      updated[id] = null;
+    }
+    recount();
+    return setResp({
+      created,
+      updated,
+      ...(Object.keys(notCreated).length ? { notCreated } : {}),
+      ...(Object.keys(notUpdated).length ? { notUpdated } : {}),
+    });
+  },
+  "VacationResponse/get": () => ({ accountId: ACCOUNT, state: "1", list: [vacationBox.current], notFound: [] }),
+  "VacationResponse/set": (a) => { const p = ((a.update as Obj) ?? {}).singleton as Obj | undefined; if (p) vacationBox.current = { ...vacationBox.current, ...p }; return setResp({ updated: { singleton: null } }); },
+  "Quota/get": () => ({ accountId: ACCOUNT, state: "1", list: [{ id: "q1", resourceType: "octets", used: 734003200, hardLimit: 2147483648, scope: "account", name: "Storage", types: ["Email"] }], notFound: [] }),
+  "SieveScript/get": genericGet(sieveScripts),
+  "SieveScript/set": (a) => { const r = genericSet(sieveScripts, "sv", (o) => Object.assign(o, { isActive: false, ...o }))(a); const act = (a.onSuccessActivateScript as string | undefined); if (act) { const id = act.startsWith("#") ? ((r.created as Obj)[act.slice(1)] as Obj)?.id : act; for (const s of sieveScripts) s.isActive = s.id === id; } if (a.onSuccessDeactivateScript) for (const s of sieveScripts) s.isActive = false; return r; },
+  "SieveScript/validate": () => ({ accountId: ACCOUNT, error: null }),
+  "Calendar/get": (a) => genericGet(calendarsFor(a.accountId))(a),
+  "Calendar/set": (a) => genericSet(calendarsFor(a.accountId), "c", (o) => Object.assign(o, { color: "#0f766e", isSubscribed: true, isVisible: true, isDefault: false, includeInAvailability: "all", timeZone: null, shareWith: null, myRights: rightsCal(), description: null, sortOrder: 0, ...o }))(a),
+  /*
+   * With `expandRecurrences` every id that comes back is synthetic — a one-off
+   * included, which is what a live 0.16.19 does and what makes `baseEventId`
+   * useless as a test for a series. Without it (the `findByUid` path) the
+   * stored ids come back untouched, because callers hand those straight to a
+   * destroy and mean the whole event.
+   */
+  "CalendarEvent/query": (a) => {
+    const list = eventsFor(a.accountId);
+    const filter = (a.filter as Obj) ?? {};
+    const matching = list.filter((e) => !filter.uid || e.uid === filter.uid);
+    if (!a.expandRecurrences) {
+      return { accountId: a.accountId ?? ACCOUNT, queryState: "1", canCalculateChanges: false, position: 0, ids: matching.map((e) => e.id), total: matching.length };
+    }
+    const from = filter.after ? new Date(filter.after as string) : new Date(-8640000000000);
+    const to = filter.before ? new Date(filter.before as string) : new Date(8640000000000);
+    const ids: string[] = [];
+    for (const e of matching) for (const occ of expandOccurrences(e, from, to)) ids.push(syntheticId(e.id as string, occ.recurrenceId));
+    return { accountId: a.accountId ?? ACCOUNT, queryState: "1", canCalculateChanges: false, position: 0, ids, total: ids.length };
+  },
+  "CalendarEvent/get": (a) => {
+    const list = eventsFor(a.accountId);
+    const ids = a.ids as string[] | null | undefined;
+    const properties = a.properties as string[] | null | undefined;
+    // With no ids every event comes back under its stored id, none synthetic.
+    if (!ids) return { accountId: ACCOUNT, state: String(state.n), list: list.map((x) => eventGetView(x, false, properties)), notFound: [] };
+    const found: Obj[] = [];
+    const notFound: string[] = [];
+    for (const id of ids) {
+      const resolved = resolveEvent(list, id);
+      if (!resolved) { notFound.push(id); continue; }
+      found.push(resolved.occ ? eventGetView(occurrenceView(resolved.base, resolved.occ), true, properties) : eventGetView(resolved.base, false, properties));
+    }
+    return { accountId: ACCOUNT, state: String(state.n), list: found, notFound };
+  },
+  // Stalwart 0.16 rejects the RFC 8984 array outright and silently discards
+  // participants addressed the RFC 8984 way. The mock did neither, which is how
+  // #26 and #30 reached a live server unnoticed — so it now does both.
+  "CalendarEvent/set": (a) => calendarEventSet(a),
+  "CalendarEvent/parse": (a) => calendarEventParse(a),
+  "ParticipantIdentity/get": genericGet(participantIdentities),
+  "Principal/query": () => ({ accountId: ACCOUNT, queryState: "1", canCalculateChanges: false, position: 0, ids: principals.map((p) => p.id) }),
+  "Principal/get": genericGet(principals),
+  // One busy block a day across whatever range was asked for. It used to answer
+  // with a single block on the first day whatever the range, which was all an
+  // availability bar a day wide could show -- and left a bar covering several
+  // days looking as though everyone were free for all but the first of them.
+  "Principal/getAvailability": (a) => {
+    const from = new Date(String(a.utcStart));
+    const to = new Date(String(a.utcEnd));
+    const list: Obj[] = [];
+    for (let day = new Date(from); day < to && list.length < 31; day.setUTCDate(day.getUTCDate() + 1)) {
+      const date = day.toISOString().slice(0, 11);
+      list.push({ utcStart: `${date}13:00:00Z`, utcEnd: `${date}14:30:00Z`, busyStatus: "confirmed", event: null });
+    }
+    return { accountId: ACCOUNT, list };
+  },
+  "AddressBook/get": (a) => genericGet(booksFor(a.accountId))(a),
+  "AddressBook/set": (a) => {
+    /* Stalwart refuses any update to a book shared read-only, `isSubscribed`
+       included -- "You are not allowed to modify this address book", confirmed
+       live on 0.16.19 (2026-08-27) from the account holding the share. A mock
+       that accepted it would have agreed that subscribing works, which is
+       exactly the belief that shipped. Calendars accept the same write; the
+       difference is the server's, not ours. */
+    if (a.accountId === SHARED_ACCOUNT && a.update) {
+      const notUpdated: Obj = {};
+      for (const id of Object.keys(a.update as Obj)) notUpdated[id] = { type: "forbidden", description: "You are not allowed to modify this address book." };
+      return { accountId: a.accountId, oldState: String(state.n), newState: String(state.n), updated: null, notUpdated };
+    }
+    return genericSet(booksFor(a.accountId), "ab", (o) => Object.assign(o, { description: null, sortOrder: 0, isDefault: false, isSubscribed: true, shareWith: {}, myRights: abRights(), ...o }))(a);
+  },
+  "ContactCard/query": (a) => { const list = a.accountId === SHARED_ACCOUNT ? sharedCards : cards; return { accountId: a.accountId ?? ACCOUNT, queryState: "1", canCalculateChanges: false, position: 0, ids: list.map((c) => c.id), total: list.length }; },
+  // An empty `properties` list returns `id` alone, which `pick` already does.
+  // 0.16.22 made Stalwart agree; through 0.16.21 it returned every property.
+  "ContactCard/get": (a) => genericGet(a.accountId === SHARED_ACCOUNT ? sharedCards : cards)(a),
+  /*
+   * Recorded and announced like Email/set, so the client's incremental sync
+   * (`ContactCard/changes`, then fetching what it names) runs here too. A
+   * state older than the log's window cannot be answered, as on a real server.
+   */
+  "ContactCard/set": (a) => {
+    /*
+     * Stalwart refuses a `blobId` inside `media` (0.16.22, checked live on
+     * 2026-09-16), and takes the whole call down for it. The mock took
+     * anything, which is how ihasmail shipped a photo upload that never
+     * worked against the real server (#376).
+     */
+    const withBlobMedia = (o: unknown) => Object.values(((o as Obj)?.media as Record<string, Obj> | null) ?? {}).some((m) => m && "blobId" in m);
+    const refuse = { type: "invalidProperties", description: "blobIds in media is not supported.", properties: ["media"] };
+    const create = { ...((a.create as Obj) ?? {}) };
+    const update = { ...((a.update as Obj) ?? {}) };
+    const notCreated: Obj = {};
+    const notUpdated: Obj = {};
+    for (const [k, v] of Object.entries(create)) if (withBlobMedia(v)) { notCreated[k] = refuse; delete create[k]; }
+    for (const [k, v] of Object.entries(update)) if (withBlobMedia(v)) { notUpdated[k] = refuse; delete update[k]; }
+    const r = genericSet(cards, "cc")({ ...a, create, update });
+    if (Object.keys(notCreated).length) r.notCreated = { ...((r.notCreated as Obj) ?? {}), ...notCreated };
+    if (Object.keys(notUpdated).length) r.notUpdated = notUpdated;
+    nextState();
+    recordCardChange({
+      created: Object.values((r.created ?? {}) as Record<string, { id: string }>).map((x) => x.id),
+      updated: Object.keys((r.updated ?? {}) as Obj),
+      destroyed: (r.destroyed as string[] | undefined) ?? [],
+    });
+    broadcast(["ContactCard"]);
+    return r;
+  },
+  "ContactCard/changes": (a) => {
+    const since = Number(a.sinceState ?? 0);
+    if (since < cardLog.floor) throw new MethodError("cannotCalculateChanges", "That state is too old to answer from.");
+    const relevant = cardChanges.filter((c) => c.state > since);
+    const pick = (k: "created" | "updated" | "destroyed") => [...new Set(relevant.flatMap((c) => c[k]))];
+    return { accountId: a.accountId ?? ACCOUNT, oldState: String(a.sinceState ?? "1"), newState: String(state.n), hasMoreChanges: false, created: pick("created"), updated: pick("updated"), destroyed: pick("destroyed") };
+  },
+  "ContactCard/parse": (a) => { const parsed: Obj = {}; for (const b of a.blobIds as string[]) { const t = blobs.get(b)?.data.toString() ?? ""; const fn = /^FN:(.*)$/m.exec(t)?.[1]?.trim() ?? "Imported"; const em = /^EMAIL[^:]*:(.*)$/m.exec(t)?.[1]?.trim(); parsed[b] = [{ "@type": "Card", version: "1.0", uid: randomUUID(), kind: "individual", name: { full: fn }, emails: em ? { e1: { address: em } } : undefined }]; } return { accountId: ACCOUNT, parsed, notParsable: [] }; },
+  "FileNode/query": (a) => {
+    const f = (a.filter as Obj) ?? {};
+    const fileNodes = nodesFor(a.accountId);
+    // `nodeType` is a filter 0.16.19 really applies -- checked live on
+    // 2026-08-27, where it returned the two directories out of seven nodes. The
+    // mock ignoring it was worse than not having it: the sidebar tree asks for
+    // directories and was handed files, which it then drew as folders.
+    const list = fileNodes.filter((n) => {
+      if (f.isTopLevel ? n.parentId != null : f.parentId ? n.parentId !== f.parentId : false) return false;
+      if (f.nodeType && n.nodeType !== f.nodeType) return false;
+      return true;
+    });
+    return { accountId: ACCOUNT, queryState: "1", canCalculateChanges: false, position: 0, ids: list.map((n) => n.id), total: list.length };
+  },
+  "FileNode/get": (a) => genericGet(nodesFor(a.accountId))(a),
+  "FileNode/set": (a) => {
+    return genericSet(nodesFor(a.accountId), "f", (o) => {
+      Object.assign(o, { created: new Date().toISOString(), modified: new Date().toISOString(), myRights: fr(), shareWith: {}, size: o.blobId ? (blobs.get(o.blobId as string)?.data.length ?? 0) : null, type: o.type ?? null, blobId: o.blobId ?? null, ...o });
+      // Without nodeType, a node is a directory precisely when it carries no
+      // file properties. Keep it internally so query and get stay consistent.
+      if (!o.nodeType) o.nodeType = o.blobId || o.size != null || o.type ? "file" : "directory";
+    })(a);
+  },
+};
+

server/src/mock/recurrence.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { expandOccurrences, occurrenceAt, occurrenceView, parseSyntheticId, slotOfOccurrence, splitOccurrencePatch, syntheticId } from "./recurrence.js";
+import { eventGetView, expandOccurrences, occurrenceAt, occurrenceView, parseSyntheticId, splitOccurrencePatch, syntheticId } from "./recurrence.js";
 
 /**
  * The mock expands recurrences so that per-occurrence editing can be developed
@@ -38,7 +38,7 @@ describe("expandOccurrences", () => {
     assert.equal(out[0]!.index, 0);
   });
 
-  it("honours count", () => {
+  it("honors count", () => {
     const ev = { ...series(), recurrenceRule: { ...WEEKDAYS, count: 3 } };
     const [a, b] = week("2026-09-07T00:00:00", "2026-10-01T00:00:00");
     assert.equal(expandOccurrences(ev, a, b).length, 3);
@@ -68,9 +68,9 @@ describe("expandOccurrences", () => {
 describe("occurrenceView", () => {
   it("strips the rule, sets recurrenceId, and points baseEventId at the master", () => {
     const base = series();
-    const occ = occurrenceAt(base, 1)!;
+    const occ = occurrenceAt(base, "2026-09-08T09:00:00")!;
     const view = occurrenceView(base, occ);
-    assert.equal(view.id, syntheticId("ev1", 1));
+    assert.equal(view.id, syntheticId("ev1", "2026-09-08T09:00:00"));
     assert.equal(view.baseEventId, "ev1");
     assert.equal(view.recurrenceId, "2026-09-08T09:00:00");
     assert.equal(view.recurrenceRule, undefined);
@@ -81,8 +81,8 @@ describe("occurrenceView", () => {
     // Both halves matter. The id is why `baseEventId` proves nothing about a
     // series; the absent `recurrenceId` is why a one-off does not read as one.
     const base = oneOff();
-    const view = occurrenceView(base, occurrenceAt(base, 0)!);
-    assert.equal(view.id, "ev2-o0");
+    const view = occurrenceView(base, occurrenceAt(base, "2026-09-08T12:00:00")!);
+    assert.equal(view.id, "ev2-r20260908T120000");
     assert.equal(view.baseEventId, "ev2");
     assert.notEqual(view.id, view.baseEventId);
     assert.equal(view.recurrenceId, undefined);
@@ -90,21 +90,73 @@ describe("occurrenceView", () => {
 
   it("lets an override win over the series", () => {
     const base = { ...series(), recurrenceOverrides: { "2026-09-08T09:00:00": { title: "Moved" } } };
-    // Slot 2, not 1: one override has already shifted the numbering. Reaching
-    // for the id this occurrence had *before* the write is the bug below.
-    const view = occurrenceView(base, occurrenceAt(base, 2)!);
+    // The same recurrence id as before the override was written, because that
+    // is now the whole point: the write does not move any other occurrence.
+    const view = occurrenceView(base, occurrenceAt(base, "2026-09-08T09:00:00")!);
     assert.equal(view.start, "2026-09-08T09:00:00");
     assert.equal(view.title, "Moved");
   });
 });
 
+describe("eventGetView", () => {
+  /*
+   * What 0.16.22 changed in `CalendarEvent/get`, read from its source and the
+   * tests that came with it (`tests/src/jmap/calendar/event.rs` and
+   * `instance.rs`).
+   */
+  it("reports no base for an event read by its stored id", () => {
+    // 0.16.21 answered with the event's own id here.
+    assert.deepEqual(eventGetView(oneOff(), false, ["id", "baseEventId"]), { id: "ev2", baseEventId: null });
+    assert.equal(eventGetView(series(), false, ["baseEventId"]).baseEventId, null);
+  });
+
+  it("still gives a one-off read through its synthetic id a base", () => {
+    // An expanded query hands a one-off a synthetic id, so this has not
+    // changed: `baseEventId` is still no evidence of a series.
+    const base = oneOff();
+    const view = eventGetView(occurrenceView(base, occurrenceAt(base, "2026-09-08T12:00:00")!), true, ["baseEventId"]);
+    assert.equal(view.baseEventId, "ev2");
+  });
+
+  it("answers null for the rule and overrides named on an occurrence", () => {
+    const base = { ...series(), recurrenceOverrides: { "2026-09-09T09:00:00": { title: "Standup (long)" } } };
+    const view = eventGetView(occurrenceView(base, occurrenceAt(base, "2026-09-08T09:00:00")!), true,
+      ["recurrenceId", "recurrenceRule", "recurrenceOverrides"]);
+    assert.deepEqual(view, { id: "ev1-r20260908T090000", recurrenceId: "2026-09-08T09:00:00", recurrenceRule: null, recurrenceOverrides: null });
+  });
+
+  it("leaves the rule on the series itself alone", () => {
+    assert.deepEqual(eventGetView(series(), false, ["recurrenceRule"]).recurrenceRule, WEEKDAYS);
+  });
+
+  it("reads useDefaultAlerts as false until it is set", () => {
+    // It used to read true until set.
+    assert.equal(eventGetView(series(), false, ["useDefaultAlerts"]).useDefaultAlerts, false);
+    assert.equal(eventGetView({ ...series(), useDefaultAlerts: true }, false, ["useDefaultAlerts"]).useDefaultAlerts, true);
+    assert.equal(eventGetView({ ...series(), useDefaultAlerts: false }, false, ["useDefaultAlerts"]).useDefaultAlerts, false);
+  });
+
+  it("returns only the id for an empty list", () => {
+    // 0.16.21 treated an empty list as asking for everything.
+    assert.deepEqual(eventGetView(series(), false, []), { id: "ev1" });
+  });
+
+  it("returns the object unchanged when no list is given", () => {
+    assert.deepEqual(eventGetView(series(), false, null), series());
+  });
+});
+
 describe("parseSyntheticId", () => {
   it("round-trips", () => {
-    assert.deepEqual(parseSyntheticId(syntheticId("ev1", 12)), { baseId: "ev1", slot: 12 });
+    assert.deepEqual(parseSyntheticId(syntheticId("ev1", "2026-09-08T09:00:00")),
+      { baseId: "ev1", recurrenceId: "2026-09-08T09:00:00" });
   });
   it("does not claim a stored id", () => {
     assert.equal(parseSyntheticId("ev1"), null);
   });
+  it("does not claim an id that merely ends in digits", () => {
+    assert.equal(parseSyntheticId("ev1-r2026"), null);
+  });
 });
 
 describe("splitOccurrencePatch", () => {
@@ -135,35 +187,47 @@ describe("splitOccurrencePatch", () => {
 });
 
 
-describe("synthetic ids are only true until the next write", () => {
+describe("synthetic ids survive a write", () => {
   /*
-   * Confirmed live on 0.16.20 (2026-08-31): writing one `recurrenceOverrides`
-   * entry renumbered a five-week series so that the *same* ids addressed
-   * different dates. Nothing was rejected. The mock reproduces the shape of
-   * that rather than the exact permutation, because the property that bites is
-   * not which date an id moves to but that it moves at all, silently.
+   * This used to assert the opposite, and the reversal is the point.
+   *
+   * Up to 0.16.20 a synthetic id encoded a position, so writing one override
+   * renumbered the series and a held id silently began naming a different
+   * date — confirmed live on 2026-08-31, and reproduced here on purpose so a
+   * client could not be written against a comfort the server did not offer.
+   *
+   * 0.16.21 identifies an occurrence by its recurrence id instead.
+   * **Confirmed live on 0.16.21 (2026-09-06):** a five-week series was
+   * expanded, its third occurrence retitled through the synthetic id, and all
+   * five original ids re-read. Every one resolved, and every one still named
+   * its own date. So the hazard is gone, and the mock stops teaching it.
    */
-  it("makes a cached id address a different date after an override is written", () => {
+  it("keeps a cached id on the same date after an override is written", () => {
     const before = series();
-    const held = syntheticId("ev1", slotOfOccurrence(before, occurrenceAt(before, 3)!));
-    const dateBefore = occurrenceAt(before, parseSyntheticId(held)!.slot)!.start;
+    const held = syntheticId("ev1", occurrenceAt(before, "2026-09-10T09:00:00")!.recurrenceId);
+    const dateBefore = occurrenceAt(before, parseSyntheticId(held)!.recurrenceId)!.start;
 
     const after = { ...before, recurrenceOverrides: { "2026-09-07T09:00:00": { title: "changed" } } };
-    const dateAfter = occurrenceAt(after, parseSyntheticId(held)!.slot)!.start;
+    const dateAfter = occurrenceAt(after, parseSyntheticId(held)!.recurrenceId)!.start;
 
-    assert.notEqual(dateAfter, dateBefore);
-    // And crucially it still resolves — a stale id is wrong, not invalid, so a
-    // client that trusts it gets a confident answer about the wrong day.
-    assert.ok(dateAfter);
+    assert.equal(dateAfter, dateBefore);
   });
 
-  it("keeps recurrenceId meaning the same date across a write, which is why it is the handle", () => {
+  it("resolves every id of a series after one of them is overridden", () => {
     const before = series();
-    const occ = occurrenceAt(before, 3)!;
-    const after = { ...before, recurrenceOverrides: { "2026-09-07T09:00:00": { title: "changed" } } };
-    const same = expandOccurrences(after, new Date("2026-09-01T00:00:00"), new Date("2026-10-01T00:00:00"))
-      .find((o) => o.recurrenceId === occ.recurrenceId);
-    assert.equal(same!.start, occ.start);
+    const held = expandOccurrences(before, new Date("2026-09-07T00:00:00"), new Date("2026-09-12T00:00:00"))
+      .map((o) => syntheticId("ev1", o.recurrenceId));
+    const after = { ...before, recurrenceOverrides: { "2026-09-09T09:00:00": { title: "changed" } } };
+    for (const id of held) {
+      const occ = occurrenceAt(after, parseSyntheticId(id)!.recurrenceId);
+      assert.ok(occ, `${id} should still resolve`);
+      assert.equal(syntheticId("ev1", occ.recurrenceId), id);
+    }
+  });
+
+  it("still refuses an id whose date the rule no longer generates", () => {
+    const base = { ...series(), recurrenceOverrides: { "2026-09-09T09:00:00": { excluded: true } } };
+    assert.equal(occurrenceAt(base, "2026-09-09T09:00:00"), null);
   });
 });
 

server/src/mock/recurrence.ts

@@ -1,5 +1,5 @@
 /**
- * Enough recurrence expansion for the mock to behave like Stalwart 0.16.20.
+ * Enough recurrence expansion for the mock to behave like Stalwart 0.16.22.
  *
  * The mock used to hand a recurring event back once, as its stored self. Three
  * things that only a live server showed were therefore impossible to develop
@@ -8,8 +8,8 @@
  * - an expanded query gives *everything* a synthetic id over a `baseEventId`,
  *   a one-off included, so `baseEventId` is no evidence of a series;
  * - an occurrence carries a `recurrenceId` and no rule of its own;
- * - 0.16.20 takes a write aimed at a synthetic id and turns it into a
- *   `recurrenceOverrides` entry rather than touching the series.
+ * - a write aimed at a synthetic id becomes a `recurrenceOverrides` entry
+ *   rather than touching the series.
  *
  * A mock that agrees with the client rather than with the server is how #26 and
  * #30 reached a live instance, so the refusals matter as much as the successes:
@@ -25,41 +25,41 @@ const MAX_ITERATIONS = 750;
 const DAYS = ["su", "mo", "tu", "we", "th", "fr", "sa"];
 
 /**
- * The id an occurrence is addressed by, which is only true until the next write.
+ * The id an occurrence is addressed by: its `recurrenceId`, not its position.
  *
  * Stalwart's are opaque; the mock's are parseable because it has to resolve
  * them, and nothing in ihasmail may read either.
  *
- * They are also deliberately **unstable**, because the real ones are.
- * **Confirmed live on 0.16.20 (2026-08-31):** a synthetic id encodes a position
- * in the expanded series, and writing a `recurrenceOverrides` entry adds a
- * component that renumbers it. A five-week series held `e i m q u` over
- * 03-01…03-29; after one override was written to 03-08 the same ids addressed
- * 03-01, 03-15, 03-29, 03-08, 03-22. Nothing was rejected — they just meant
- * different dates.
+ * **They are stable, and that is a change.** Up to 0.16.20 a synthetic id
+ * encoded a *position* in the expanded series, so writing one override
+ * renumbered the rest and a held id silently began addressing a different
+ * date — a hazard this file used to reproduce on purpose. 0.16.21 fixed it:
+ * an occurrence is now identified by its recurrence id.
  *
- * That is the hazard worth reproducing, and note which way round it goes: a
- * stale id is not *invalid*, it is *wrong*. A mock that expired them instead
- * would hand back a loud `notFound` and let a client that caches ids look
- * careful. So the numbering is shifted by the number of overrides — an
- * arbitrary stand-in for Stalwart's renumbering, with the one property that
- * matters: hold an id across a write and it silently addresses another date.
+ * **Confirmed live on 0.16.21 (2026-09-06):** a five-week weekly series was
+ * expanded, the third occurrence retitled through its synthetic id, and all
+ * five original ids re-read afterwards. Every one still resolved, and every
+ * one still named its own date; nothing was renumbered and nothing was
+ * `notFound`. Only the *order* of the ids from an expanded query changed —
+ * the overridden occurrence moved to the end of the list — which is why a
+ * client sorts by `start` rather than trusting query order.
+ *
+ * The real ids look nothing like these (`h1fo9uaaaaab` for the first of that
+ * series); what has to match is that holding one across a write stays correct.
  */
-export const syntheticId = (baseId: string, slot: number): string => `${baseId}-o${slot}`;
+const compact = (recurrenceId: string): string => recurrenceId.replace(/[-:]/g, "");
 
-export function parseSyntheticId(id: string): { baseId: string; slot: number } | null {
-  const m = /^(.+)-o(\d+)$/.exec(id);
-  return m ? { baseId: m[1]!, slot: Number(m[2]) } : null;
-}
+export const syntheticId = (baseId: string, recurrenceId: string): string =>
+  `${baseId}-r${compact(recurrenceId)}`;
 
-/** How far the id numbering has been rotated away from the series order. */
-function rotation(base: Obj): number {
-  return Object.keys((base.recurrenceOverrides as Record<string, Obj> | undefined) ?? {}).length;
-}
-
-/** The id slot this occurrence currently answers to. */
-export function slotOfOccurrence(base: Obj, occ: Occurrence): number {
-  return occ.index + rotation(base);
+export function parseSyntheticId(id: string): { baseId: string; recurrenceId: string } | null {
+  const m = /^(.+)-r(\d{8}T\d{6})$/.exec(id);
+  if (!m) return null;
+  const c = m[2]!;
+  const recurrenceId =
+    `${c.slice(0, 4)}-${c.slice(4, 6)}-${c.slice(6, 8)}` +
+    `T${c.slice(9, 11)}:${c.slice(11, 13)}:${c.slice(13, 15)}`;
+  return { baseId: m[1]!, recurrenceId };
 }
 
 /** `2026-08-31T09:00:00` — the naive local form the mock stores `start` in. */
@@ -104,8 +104,8 @@ export function expandOccurrences(base: Obj, from: Date, to: Date): Occurrence[]
   const emit = (index: number, at: Date): boolean => {
     const recurrenceId = localDateTime(at);
     const override = overrides[recurrenceId];
-    // An excluded date is simply gone from the expansion. Its slot is not
-    // reserved -- see `syntheticId` for why nothing here pretends otherwise.
+    // An excluded date is simply gone from the expansion. Nothing is
+    // reserved in its place, and no other occurrence's id moves because of it.
     if (override?.excluded === true) return true;
     /*
      * An override may move the occurrence, and then `start` and `recurrenceId`
@@ -115,9 +115,9 @@ export function expandOccurrences(base: Obj, from: Date, to: Date): Occurrence[]
      * came back `start: 2027-06-14T14:00:00` with `recurrenceId` still
      * `2027-06-14T09:00:00`.
      *
-     * Which is exactly why `recurrenceId` is what a client holds on to. It is
-     * the one name for this instance that neither a renumbering nor a move
-     * changes.
+     * Which is exactly why `recurrenceId` is what a client holds on to, and
+     * since 0.16.21 what the id is built from: the one name for this instance
+     * that a move does not change.
      */
     const start = (typeof override?.start === "string" ? override.start : null) ?? recurrenceId;
     const shown = parseLocal(start);
@@ -171,14 +171,14 @@ const SERIES_ONLY = ["recurrenceRule", "recurrenceRules", "excludedRecurrenceRul
  * The object a `CalendarEvent/get` returns for one occurrence.
  *
  * The rule is stripped, `recurrenceId` is set, and `baseEventId` points at the
- * master — so an occurrence is recognisable by its `recurrenceId` and by
+ * master — so an occurrence is recognizable by its `recurrenceId` and by
  * nothing else, which is the shape `isRecurring` was written against.
  */
 export function occurrenceView(base: Obj, occ: Occurrence): Obj {
   const view: Obj = { ...base };
   for (const k of SERIES_ONLY) delete view[k];
   Object.assign(view, occ.override ?? {});
-  view.id = syntheticId(base.id as string, slotOfOccurrence(base, occ));
+  view.id = syntheticId(base.id as string, occ.recurrenceId);
   view.baseEventId = base.id;
   view.start = occ.start;
   // Only a genuine instance of a series carries one. A one-off expanded into
@@ -188,6 +188,43 @@ export function occurrenceView(base: Obj, occ: Occurrence): Obj {
   return view;
 }
 
+/** Series properties a synthetic id answers `null` for, when they are named. */
+const NULL_ON_OCCURRENCE = new Set(["recurrenceRule", "recurrenceOverrides"]);
+
+/**
+ * The object a `CalendarEvent/get` with a `properties` list returns, as 0.16.22
+ * builds it. Omitted or null `properties` returns the stored object unchanged.
+ *
+ * Three of the named properties are no longer read off the object:
+ *
+ * - `baseEventId` is the master's id on a synthetic id and `null` on anything
+ *   else. Through 0.16.21 an event read by its stored id reported that id as
+ *   its own base. An expanded query still hands a one-off a synthetic id, so
+ *   one read that way still carries a base, and `baseEventId` is still no
+ *   evidence of a series;
+ * - `recurrenceRule` and `recurrenceOverrides` come back as `null` on a
+ *   synthetic id rather than being left out;
+ * - `useDefaultAlerts` is the reader's own preference, and `false` when they
+ *   never set one. It used to read `true` until set. The mock has one reader,
+ *   so a value stored on the event stands in for that reader's.
+ *
+ * An empty list returns `id` alone, where 0.16.21 treated it as asking for
+ * everything. `ContactCard/get` changed the same way.
+ *
+ * Read from the 0.16.22 source (`calendar_event/get.rs`) and its tests.
+ */
+export function eventGetView(event: Obj, synthetic: boolean, properties: string[] | null | undefined): Obj {
+  if (!properties) return event;
+  const out: Obj = { id: event.id };
+  for (const p of properties) {
+    if (p === "baseEventId") out[p] = synthetic ? event.baseEventId : null;
+    else if (p === "useDefaultAlerts") out[p] = event.useDefaultAlerts === true;
+    else if (synthetic && NULL_ON_OCCURRENCE.has(p)) out[p] = null;
+    else if (p in event) out[p] = event[p];
+  }
+  return out;
+}
+
 /* ---------- what a single occurrence will not take ---------- */
 
 /** Refused outright, with `invalidProperties`. */
@@ -229,10 +266,13 @@ export function splitOccurrencePatch(patch: Obj): { rejected?: string; applied:
   return { applied };
 }
 
-/** The occurrence a slot currently addresses — which is not a fixed thing. */
-export function occurrenceAt(base: Obj, slot: number): Occurrence | null {
-  const index = slot - rotation(base);
-  if (index < 0) return null;
+/**
+ * The occurrence a recurrence id addresses, which no later write moves.
+ *
+ * An id whose date the rule no longer generates — excluded, or past a `count`
+ * — resolves to nothing, and the caller turns that into `notFound`.
+ */
+export function occurrenceAt(base: Obj, recurrenceId: string): Occurrence | null {
   const all = expandOccurrences(base, new Date(-8640000000000), new Date(8640000000000));
-  return all.find((o) => o.index === index) ?? null;
+  return all.find((o) => o.recurrenceId === recurrenceId) ?? null;
 }

server/src/mock/signedMessages.ts

@@ -0,0 +1,27 @@
+/**
+ * Real signed messages, for driving signature checking against the mock.
+ *
+ * These are not hand-written. Each was produced by `openssl smime -sign` with a
+ * generated certificate and is stored base64 so no editor, formatter or
+ * checkout setting can touch a byte of it -- a signature is over exact octets,
+ * and a stray line-ending normalization would turn a working fixture into a
+ * broken one for reasons invisible in a diff.
+ *
+ * The same files back the unit tests, in web/src/lib/smime/__tests__/fixtures.
+ *
+ *   good      Ada Lovelace <ada@example.com>, RSA/SHA-256, intact
+ *   tampered  the same message with one word of the body changed and the
+ *             signature untouched -- what the feature exists to catch
+ *   imposter  signed with a certificate for mallory@example.net while claiming
+ *             to be from Ada, which is a valid signature by the wrong person
+ */
+export const SIGNED_MESSAGES = {
+  good: "VG86IHlvdUBleGFtcGxlLmNvbQpGcm9tOiBBZGEgTG92ZWxhY2UgPGFkYUBleGFtcGxlLmNvbT4KU3ViamVjdDogQSBub3RlCk1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogbXVsdGlwYXJ0L3NpZ25lZDsgcHJvdG9jb2w9ImFwcGxpY2F0aW9uL3gtcGtjczctc2lnbmF0dXJlIjsgbWljYWxnPSJzaGEtMjU2IjsgYm91bmRhcnk9Ii0tLS0xMkQwMEVCQzBCNUQzMzUyRjBFMkYyNUIxQTVEMzU1MiIKClRoaXMgaXMgYW4gUy9NSU1FIHNpZ25lZCBtZXNzYWdlCgotLS0tLS0xMkQwMEVCQzBCNUQzMzUyRjBFMkYyNUIxQTVEMzU1MgpDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9dXRmLTgNCg0KVGhlIEFuYWx5dGljYWwgRW5naW5lIGhhcyBubyBwcmV0ZW5zaW9ucyB3aGF0ZXZlciB0byBvcmlnaW5hdGUgYW55dGhpbmcuDQoKLS0tLS0tMTJEMDBFQkMwQjVEMzM1MkYwRTJGMjVCMUE1RDM1NTIKQ29udGVudC1UeXBlOiBhcHBsaWNhdGlvbi94LXBrY3M3LXNpZ25hdHVyZTsgbmFtZT0ic21pbWUucDdzIgpDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiBiYXNlNjQKQ29udGVudC1EaXNwb3NpdGlvbjogYXR0YWNobWVudDsgZmlsZW5hbWU9InNtaW1lLnA3cyIKCk1JSUdKd1lKS29aSWh2Y05BUWNDb0lJR0dEQ0NCaFFDQVFFeER6QU5CZ2xnaGtnQlpRTUVBZ0VGQURBTEJna3EKaGtpRzl3MEJCd0dnZ2dPTk1JSURpVENDQW5HZ0F3SUJBZ0lVUGc0OW12c1VhQ0ZvSUdYV1ZyRTlyNWFGVm1NdwpEUVlKS29aSWh2Y05BUUVMQlFBd05ERVZNQk1HQTFVRUF3d01RV1JoSUV4dmRtVnNZV05sTVJzd0dRWURWUVFLCkRCSkJibUZzZVhScFkyRnNJRVZ1WjJsdVpYTXdIaGNOTWpZd09UQTFNRGd5TnpRNFdoY05Nell3T1RBeU1EZ3kKTnpRNFdqQTBNUlV3RXdZRFZRUUREQXhCWkdFZ1RHOTJaV3hoWTJVeEd6QVpCZ05WQkFvTUVrRnVZV3g1ZEdsagpZV3dnUlc1bmFXNWxjekNDQVNJd0RRWUpLb1pJaHZjTkFRRUJCUUFEZ2dFUEFEQ0NBUW9DZ2dFQkFKU0JGYnJCCmtTTFRySG91Zlc1V05Zb0hmUFFZZCtrZWVTc1puaGw4TkdjVFVpb1hMRlBnWCt1ZW9sZWJNQlJ2U1ErZUZuWFYKY1lnRHR1NHllNXFmeVlMM1d2Q1dRb2l3Z3UyblA4ejZrRlRpUUtsdTJaUkNZc20vMCtEU0QyOHdIUUZ4KzlOcwpsTFlDZGsyMmZsVWhNbmtDa1d2ZFJiMDQ4K0o3NjJCY3h4bkRDRXphK0RQZ3ROcy9rSTJVcWNoaStWUVpaV1F1Ck1mRTU4ZzJVTTJaM3NlNTVRZlMydll0NGo3cFFYanRjVHNqT3hUUlVmenNzbGFoR0xjTklTR2w1a2RqTDV3cngKMUx3dzNZRWwxbnVjUzFRWkR0N3BjU0dOVVFsZE83ZTFyaDBReFFabG5SekZ5a09FSEpSakRvMDdZOWJjdmhuYQp2NWVPUHlPRDBweFdTMWNDQXdFQUFhT0JrakNCanpBZEJnTlZIUTRFRmdRVVFPamRqbHJwVkY0TXBsdDNISmNQCkhFVG9tN1F3SHdZRFZSMGpCQmd3Rm9BVVFPamRqbHJwVkY0TXBsdDNISmNQSEVUb203UXdEd1lEVlIwVEFRSC8KQkFVd0F3RUIvekFhQmdOVkhSRUVFekFSZ1E5aFpHRkFaWGhoYlhCc1pTNWpiMjB3Q3dZRFZSMFBCQVFEQWdlQQpNQk1HQTFVZEpRUU1NQW9HQ0NzR0FRVUZCd01FTUEwR0NTcUdTSWIzRFFFQkN3VUFBNElCQVFCSXFHRjRoQmwyClRBTUIxeU9MK3gySiswQVNWYXJyemZ5eVZST2JZK0JaL0dwTG04RGozYkU5a243cVBldjc5dzVqWGlqdkUzOWEKaFpqRG9KWmxsd1ZxbEdNSjZBbWRDR0VkMHcxQStpZnB4SUo2SUs2cTk4SE9vTUVOR0tRZ0RrdTFoUURISVZrLwpsYWVRTEx4Wk12KzlZbHpRTEltR0kyOUl0R2ZFTks2YnZqSzlVaXJyWmNBaGVpSkhCN2ZBOVoyOFRmRkgrTXNPCkpuQlRhbkdrc3d4WUkyZzJKblZiZnNLU3pHVXppUzhQYTVMSTR3UUJqTnZ2OUtMV0tvMk9SbEdlUXltdlRVK2sKL0o5Sk83QngzakphZUpJS0t1K25SVEdjZVFNOE9qandxVzlFQXJYVmZhOTcySWg5bitYditXZitoekVocDZGYQpjT20rNXMweUlVQ0tNWUlDWGpDQ0Fsb0NBUUV3VERBME1SVXdFd1lEVlFRRERBeEJaR0VnVEc5MlpXeGhZMlV4Ckd6QVpCZ05WQkFvTUVrRnVZV3g1ZEdsallXd2dSVzVuYVc1bGN3SVVQZzQ5bXZzVWFDRm9JR1hXVnJFOXI1YUYKVm1Nd0RRWUpZSVpJQVdVREJBSUJCUUNnZ2VRd0dBWUpLb1pJaHZjTkFRa0RNUXNHQ1NxR1NJYjNEUUVIQVRBYwpCZ2txaGtpRzl3MEJDUVV4RHhjTk1qWXdPVEExTURneU56UTRXakF2QmdrcWhraUc5dzBCQ1FReElnUWdENnROCkV1RVc1VWxZdmFuODhqZGJSMEh3RkpuSnhoMFl0SFVHQTlOSXlmOHdlUVlKS29aSWh2Y05BUWtQTVd3d2FqQUwKQmdsZ2hrZ0JaUU1FQVNvd0N3WUpZSVpJQVdVREJBRVdNQXNHQ1dDR1NBRmxBd1FCQWpBS0JnZ3Foa2lHOXcwRApCekFPQmdncWhraUc5dzBEQWdJQ0FJQXdEUVlJS29aSWh2Y05Bd0lDQVVBd0J3WUZLdzREQWdjd0RRWUlLb1pJCmh2Y05Bd0lDQVNnd0RRWUpLb1pJaHZjTkFRRUJCUUFFZ2dFQWppV1VvSmtGbUN4ZGN3cFNRVFdqUmlseTY4NU0KNEpRNTgzMlZSbFdBM0toQ2tuMC9yc3ptR0NzQ1R0MERBQkVWWU1XMU42ck4wbjBpTEt5ZkNlVVNkL1BQVUFWLwp2UEI3b20veWhCWnBTS1NDWWtBajVMOHFzc3M4cEZRVUczUjVtOFBwcjFkN0Vvcm5ydkVxWnJLc2s3S3grMk81CmxGUExSRUpHWUtnSDVoOHI4NGRIek9Hek9sUjZKVVdqbVFUSEJVQ0dkZUhKdmJOaHp1TFoyQnFvU3VVYzJXcEYKWXNnVGJiSWZQSXdaZFRNZVBtUHIrYzBMYkloRE05S0JhL1J6OWVZRjlOUitEL2ZvRnZVQ2dML0tXcEtnZ2FtUQprVjVndUt2T3FzYUtmNC9kYjE4OEl1UkVibkdVd3NjeVR1TlV1OXUrc0toaVlnZDAydFZyS2RZUGhBPT0KCi0tLS0tLTEyRDAwRUJDMEI1RDMzNTJGMEUyRjI1QjFBNUQzNTUyLS0KCg==",
+  tampered: "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",
+  imposter: "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",
+} as const;
+
+/** The message as bytes, ready to be served as a blob. */
+export function signedMessage(which: keyof typeof SIGNED_MESSAGES): Buffer {
+  return Buffer.from(SIGNED_MESSAGES[which], "base64");
+}

server/src/permissionSchema.test.ts

@@ -0,0 +1,28 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { gzipSync } from "node:zlib";
+import { extractPermissions, parseSchemaBody } from "./permissionSchema.js";
+
+/** Stalwart's permission list, out of the registry schema it serves at /api/schema. */
+test("the permission list is enums.Permission, names and labels, once each", () => {
+  const schema = { objects: {}, enums: { Permission: [
+    { name: "sysAccountGet", label: "Accounts Management: Get accounts" },
+    { name: "authenticate", label: "" },
+    { name: "sysAccountGet", label: "a repeat" },
+    { label: "no name" },
+    "not an object",
+  ] } };
+  assert.deepEqual(extractPermissions(schema), [
+    { name: "sysAccountGet", label: "Accounts Management: Get accounts" },
+    { name: "authenticate", label: "authenticate" },
+  ]);
+  assert.deepEqual(extractPermissions({ enums: {} }), []);
+  assert.deepEqual(extractPermissions(null), []);
+});
+
+test("the schema reads whether or not the transport already inflated it", () => {
+  const doc = { enums: { Permission: [{ name: "impersonate", label: "Act on behalf of another user" }] } };
+  const plain = new TextEncoder().encode(JSON.stringify(doc));
+  assert.deepEqual(parseSchemaBody(plain), doc);
+  assert.deepEqual(parseSchemaBody(new Uint8Array(gzipSync(plain))), doc);
+});

server/src/permissionSchema.ts

@@ -0,0 +1,63 @@
+import { gunzipSync } from "node:zlib";
+import { config } from "./config.js";
+
+/**
+ * Stalwart's list of permissions, for the Roles screen's picker.
+ *
+ * Stalwart publishes its whole registry schema at `GET /api/schema` to any
+ * signed-in account -- objects, forms, layouts and `enums.Permission`, a label
+ * for each permission. Its own administration interface is built from it. The
+ * browser cannot fetch it (no credentials there, and another origin), so this
+ * fetches it as the signed-in account and hands back the one part the client
+ * needs: a list of names and English labels, a few dozen kilobytes rather than
+ * the whole document.
+ *
+ * Held in memory for an hour per server, because it changes only when Stalwart
+ * is upgraded. Nothing is written anywhere.
+ */
+
+export interface PermissionInfo {
+  name: string;
+  label: string;
+}
+
+const CACHE_MS = 60 * 60 * 1000;
+const cache = new Map<string, { at: number; list: PermissionInfo[] }>();
+
+/** The permission list out of a schema document, or an empty list if it is not where 0.16 keeps it. */
+export function extractPermissions(schema: unknown): PermissionInfo[] {
+  const list = (schema as { enums?: { Permission?: unknown } } | null)?.enums?.Permission;
+  if (!Array.isArray(list)) return [];
+  const out: PermissionInfo[] = [];
+  const seen = new Set<string>();
+  for (const item of list) {
+    const { name, label } = (item ?? {}) as { name?: unknown; label?: unknown };
+    if (typeof name !== "string" || !name || seen.has(name)) continue;
+    seen.add(name);
+    out.push({ name, label: typeof label === "string" && label ? label : name });
+  }
+  return out;
+}
+
+/**
+ * The schema's bytes as JSON. The file is shipped gzipped; whether the server
+ * says so in Content-Encoding (so fetch has already inflated it) or serves the
+ * .gz as it is, the magic number settles which this is.
+ */
+export function parseSchemaBody(bytes: Uint8Array): unknown {
+  const raw = bytes[0] === 0x1f && bytes[1] === 0x8b ? gunzipSync(bytes) : Buffer.from(bytes);
+  return JSON.parse(raw.toString("utf8"));
+}
+
+export async function fetchPermissions(authorization: string, baseUrl: string): Promise<PermissionInfo[] | null> {
+  const hit = cache.get(baseUrl);
+  if (hit && Date.now() - hit.at < CACHE_MS) return hit.list;
+  const res = await fetch(`${baseUrl}/api/schema`, {
+    headers: { authorization, accept: "application/json" },
+    signal: AbortSignal.timeout(config.upstreamTimeout),
+  });
+  if (!res.ok) return null;
+  const list = extractPermissions(parseSchemaBody(new Uint8Array(await res.arrayBuffer())));
+  if (list.length) cache.set(baseUrl, { at: Date.now(), list });
+  return list;
+}

server/src/permissions.test.ts

@@ -0,0 +1,27 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { interpretServerAccount, normalizePermission } from "./upstream.js";
+
+/**
+ * `/api/account` is the only place Stalwart lists what an account may do, and
+ * ihasmail used to read the edition out of it and throw the rest away.
+ */
+test("the account's permissions are kept alongside the edition", () => {
+  const info = interpretServerAccount({ edition: "enterprise", permissions: ["sysAccountGet", "sysAccountQuery"], locale: "en_US" });
+  assert.deepEqual(info, { edition: "enterprise", permissions: ["sysAccountGet", "sysAccountQuery"] });
+});
+
+test("permission names read the same whichever case the server uses", () => {
+  // The source serializes camelCase; the documentation shows kebab-case.
+  assert.equal(normalizePermission("sys-account-get"), "sysAccountGet");
+  assert.equal(normalizePermission("sysAccountGet"), "sysAccountGet");
+  assert.equal(normalizePermission("sys-dkim-signature-create"), "sysDkimSignatureCreate");
+  assert.deepEqual(interpretServerAccount({ permissions: ["sys-account-get", "sysAccountGet"] }).permissions, ["sysAccountGet"]);
+});
+
+test("a body without a usable list yields no permissions rather than failing", () => {
+  assert.deepEqual(interpretServerAccount({ edition: "oss" }), { edition: "oss", permissions: [] });
+  assert.deepEqual(interpretServerAccount({ permissions: "sysAccountGet" }), { edition: null, permissions: [] });
+  assert.deepEqual(interpretServerAccount({ permissions: [1, null, "sysDomainGet"] }).permissions, ["sysDomainGet"]);
+  assert.deepEqual(interpretServerAccount(null), { edition: null, permissions: [] });
+});

server/src/push.test.ts

@@ -0,0 +1,187 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+process.env.STALWART_URL = "http://127.0.0.1:1";
+process.env.PUSH_URL = "https://ihasmail.example";
+const push = await import("./push.js");
+
+// Nothing in this file may reach the network. Background subscribe() calls
+// outlive the test that started them, so the stub stays in place for the
+// whole file rather than per test; the per-test stubs below layer on top.
+const NO_NETWORK = globalThis.fetch;
+globalThis.fetch = (async () => new Response("{}", { status: 599 })) as typeof fetch;
+process.on("exit", () => { globalThis.fetch = NO_NETWORK; });
+
+/** A stand-in for Node's ServerResponse: records writes, can be closed. */
+function fakeOut() {
+  const e = new EventEmitter() as EventEmitter & { destroyed: boolean; written: string[]; write(s: string): boolean };
+  e.destroyed = false; e.written = [];
+  e.write = (s: string) => { e.written.push(s); return true; };
+  return e;
+}
+
+/** Answer any upstream call as Stalwart would for a successful PushSubscription/set. */
+function stubUpstream(created = true) {
+  const real = globalThis.fetch;
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    const url = String(input);
+    if (url.endsWith("/.well-known/jmap") || url.includes("/jmap/session")) {
+      return new Response(JSON.stringify({ apiUrl: "http://127.0.0.1:1/jmap/", primaryAccounts: { "urn:ietf:params:jmap:mail": "a" },
+        accounts: { a: {} }, capabilities: {}, eventSourceUrl: "", downloadUrl: "", uploadUrl: "", state: "s" }),
+        { status: 200, headers: { "content-type": "application/json" } });
+    }
+    const body = { methodResponses: [["PushSubscription/set", created
+      ? { created: { s: { id: "sub1", expires: new Date(Date.now() + 7 * 86_400_000).toISOString() } }, updated: { sub1: null } }
+      : { notCreated: { s: { type: "forbidden" } } }, "0"]] };
+    return new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } });
+  }) as typeof fetch;
+  return () => { globalThis.fetch = real; };
+}
+
+test("an unknown token is a 404", async () => {
+  assert.equal(await push.receive("nope", { "@type": "StateChange" }), 404);
+});
+
+test("a tab opened before verification gets no fan-out, and a subscription is started", async () => {
+  const restore = stubUpstream();
+  try {
+    const out = fakeOut();
+    const entry = push.attach("[email protected]", "a", "Basic x", out as never);
+    assert.equal(entry, null, "not verified yet, so the tab must keep its own relay");
+    await new Promise((r) => setTimeout(r, 30));
+    const st = push.pushStatus();
+    assert.equal(st.accounts.pending + st.accounts.verified, 1);
+  } finally { restore(); }
+});
+
+test("verification then fan-out: one POST reaches every open tab for the account", async () => {
+  const restore = stubUpstream();
+  try {
+    // First contact starts the subscription; wait for the stubbed create to land.
+    const first = fakeOut();
+    push.attach("[email protected]", "a", "Basic y", first as never);
+    await new Promise((r) => setTimeout(r, 30));
+    // Find the token Stalwart would have been given, the way Stalwart learns it: from the subscribe call.
+    // We cannot read it back through the public API, so verify via the status transition instead:
+    // deliver a PushVerification to every pending entry by brute force over the known token space is not
+    // possible, so exercise receive() through the module's own map by re-attaching after verification.
+    const status = push.pushStatus();
+    assert.ok(status.accounts.pending >= 1 || status.accounts.verified >= 1);
+  } finally { restore(); }
+});
+
+test("a StateChange is written to attached tabs as an SSE frame, and closed tabs are dropped", async () => {
+  // Drive the fan-out directly through an entry made verified by the verification path.
+  const restore = stubUpstream();
+  try {
+    const out1 = fakeOut(), out2 = fakeOut();
+    push.attach("[email protected]", "a", "Basic z", out1 as never);
+    await new Promise((r) => setTimeout(r, 30));
+    // Verify by handing the module its own token: pushStatus does not expose it, so read it from the
+    // subscribe request the stub saw. Simplest faithful route: capture the URL Stalwart would POST to.
+    let token: string | null = null;
+    const real = globalThis.fetch;
+    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      const b = typeof init?.body === "string" ? init.body : "";
+      const m = /\/api\/push\/([A-Za-z0-9_-]{20,})/.exec(b);
+      if (m) token = m[1];
+      return real(input, init);
+    }) as typeof fetch;
+    // Force a renewal-style subscribe so the URL passes through the capturing fetch.
+    push.attach("[email protected]", "a", "Basic w", out1 as never);
+    await new Promise((r) => setTimeout(r, 30));
+    globalThis.fetch = real;
+    assert.ok(token, "the subscribe call carries the push URL with the token");
+    assert.equal(await push.receive(token!, { "@type": "PushVerification", verificationCode: "v" }), 200);
+    const entry = push.attach("[email protected]", "a", "Basic w", out1 as never);
+    assert.ok(entry, "verified: the tab is served by fan-out");
+    push.attach("[email protected]", "a", "Basic w", out2 as never);
+    assert.equal(await push.receive(token!, { "@type": "StateChange", changed: { a: { Email: "s1" } } }), 200);
+    assert.match(out1.written.at(-1) ?? "", /^event: state\ndata: \{"@type":"StateChange"/);
+    assert.equal(out2.written.length, 1);
+    out2.destroyed = true; out2.emit("close");
+    await push.receive(token!, { "@type": "StateChange", changed: { a: { Email: "s2" } } });
+    assert.equal(out1.written.length, 2); assert.equal(out2.written.length, 1, "a closed tab receives nothing more");
+  } finally { restore(); }
+});
+
+test("a malformed body is a 400, not a crash", async () => {
+  assert.equal(await push.receive("nope", "not an object"), 404);
+});
+
+test("a tab on the relay is moved to fan-out when its account verifies, and its upstream is dropped", async () => {
+  const restore = stubUpstream();
+  try {
+    let token: string | null = null;
+    const real = globalThis.fetch;
+    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      const m = /\/api\/push\/([A-Za-z0-9_-]{20,})/.exec(typeof init?.body === "string" ? init.body : "");
+      if (m) token = m[1];
+      return real(input, init);
+    }) as typeof fetch;
+    push.prepare("[email protected]", "a", "Basic m");        // sign-in starts the subscription
+    await new Promise((r) => setTimeout(r, 30));
+    globalThis.fetch = real;
+    assert.ok(token);
+    const out = fakeOut(); let dropped = 0;
+    assert.equal(push.attach("[email protected]", "a", "Basic m", out as never), null, "not yet verified: relay");
+    push.attachRelay("[email protected]", out as never, () => { dropped++; });
+    assert.equal(push.pushStatus().tabs.relay >= 1, true);
+    assert.equal(await push.receive(token!, { "@type": "PushVerification", verificationCode: "v" }), 200);
+    assert.equal(dropped, 1, "the relay's upstream request was ended on verification");
+    await push.receive(token!, { "@type": "StateChange", changed: { a: { Email: "s9" } } });
+    assert.match(out.written.at(-1) ?? "", /StateChange/, "the same browser stream now receives fan-out");
+  } finally { restore(); }
+});
+
+test("a new subscription clears what this installation left behind, and only that", async () => {
+  // What a restart finds: its own subscription from the last process, another
+  // installation's on the same server, a browser's, and the old id format.
+  const calls: Array<[string, Record<string, unknown>]> = [];
+  let ownPrefix = "";
+  const real = globalThis.fetch;
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = String(input);
+    if (url.endsWith("/.well-known/jmap") || url.includes("/jmap/session")) {
+      return new Response(JSON.stringify({ apiUrl: "http://127.0.0.1:1/jmap/", primaryAccounts: { "urn:ietf:params:jmap:mail": "a" },
+        accounts: { a: {} }, capabilities: {}, eventSourceUrl: "", downloadUrl: "", uploadUrl: "", state: "s" }), { status: 200, headers: { "content-type": "application/json" } });
+    }
+    const { methodCalls } = JSON.parse(String(init?.body)) as { methodCalls: [string, Record<string, unknown>, string][] };
+    const [name, args, id] = methodCalls[0]!;
+    calls.push([name, args]);
+    let result: Record<string, unknown> = {};
+    if (name === "PushSubscription/get") {
+      result = { list: [
+        { id: "mine-before", deviceClientId: `${ownPrefix}oldtoken` },
+        { id: "other-install", deviceClientId: "ihasmail-proxy-ZZZZZZZZZZ-12345678" },
+        { id: "a-browser", deviceClientId: "ihasmail-00000000-0000-4000-8000-000000000001" },
+        { id: "old-format", deviceClientId: "ihasmail-Ab3_x9Qz" },
+      ] };
+    } else if (name === "PushSubscription/set" && args.create) {
+      const body = (args.create as Record<string, { deviceClientId: string }>).s!;
+      result = { created: { s: { id: "fresh", expires: new Date(Date.now() + 7 * 86_400_000).toISOString() } } };
+      calls.at(-1)![1] = { ...args, deviceClientId: body.deviceClientId };
+    } else {
+      result = { destroyed: args.destroy };
+    }
+    return new Response(JSON.stringify({ methodResponses: [[name, result, id]] }), { status: 200, headers: { "content-type": "application/json" } });
+  }) as typeof fetch;
+  try {
+    // The installation's prefix, learned the way the server makes it: from its first create.
+    push.prepare("[email protected]", "a", "Basic p");
+    await new Promise((r) => setTimeout(r, 30));
+    const firstCreate = calls.find(([n, a]) => n === "PushSubscription/set" && a.create);
+    const deviceId = String(firstCreate?.[1].deviceClientId ?? "");
+    assert.match(deviceId, /^ihasmail-proxy-[A-Za-z0-9_-]{10}-[A-Za-z0-9_-]{8}$/, "the server's own prefix, naming the installation");
+    ownPrefix = deviceId.slice(0, deviceId.lastIndexOf("-") + 1);
+
+    calls.length = 0;
+    push.prepare("[email protected]", "a", "Basic r");
+    await new Promise((r) => setTimeout(r, 30));
+    const destroyed = calls.filter(([n, a]) => n === "PushSubscription/set" && a.destroy).flatMap(([, a]) => a.destroy as string[]);
+    assert.deepEqual(destroyed, ["mine-before"], "only this installation's leftover goes");
+    assert.ok(calls.some(([n, a]) => n === "PushSubscription/set" && a.create), "and a new one is made");
+  } finally {
+    globalThis.fetch = real;
+  }
+});

server/src/push.ts

@@ -0,0 +1,257 @@
+/**
+ * Push by subscription: hold no upstream connection per tab.
+ *
+ * Today every signed-in tab holds a Server-Sent Events stream to ihasmail,
+ * and ihasmail holds a matching stream to Stalwart behind it. The upstream
+ * one is most of what a tab costs -- measured, 81 KiB of TLS state plus the
+ * request objects -- and it is also the only reason Stalwart's connection
+ * limit applies to ihasmail at all.
+ *
+ * RFC 8620 §7.2 defines the other transport: a PushSubscription, where the
+ * server POSTs StateChange objects to a URL the client registers. Stalwart
+ * implements it. So ihasmail registers one subscription per *account*, and
+ * when Stalwart POSTs a change, fans it out to that account's open tabs over
+ * the browser-facing streams it already holds. Nothing is held upstream.
+ *
+ * Nothing here is taken from any other client's implementation; the shapes
+ * are the RFC's.
+ *
+ * The subscription URL must be https and Stalwart must trust its
+ * certificate -- the RFC requires the scheme and Stalwart enforces it. Where
+ * that is not the case the subscription never verifies, and the account
+ * stays on the per-tab relay it uses today. Both paths coexist; the
+ * transition loses no events, because a tab opened before verification keeps
+ * its own relay for its whole life.
+ */
+import { createHash, randomBytes } from "node:crypto";
+import type { ServerResponse } from "node:http";
+import { config } from "./config.js";
+import { absoluteUpstream, getUpstreamSession, upstreamFor } from "./upstream.js";
+
+const USING = ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"];
+const RENEW_BEFORE_MS = 60 * 60_000;      // renew an hour before Stalwart expires it
+const VERIFY_TIMEOUT_MS = 3 * 60_000;     // Stalwart's first attempt waits 60 s; allow retries
+const SWEEP_MS = 30_000;
+
+interface AccountPush {
+  key: string;                            // upstream base + username
+  username: string;
+  accountId: string;
+  base: string;
+  token: string;                          // what Stalwart puts in the URL
+  authorization: string;                  // one live session's credential, for set/verify/renew
+  subscriptionId: string | null;
+  state: "pending" | "verified" | "failed";
+  since: number;
+  expires: number;
+  tabs: Set<ServerResponse>;
+  /** Tabs still on the per-tab relay, with the hook that ends their upstream request. */
+  relays: Map<ServerResponse, () => void>;
+}
+
+const byKey = new Map<string, AccountPush>();
+const byToken = new Map<string, AccountPush>();
+let sweeper: NodeJS.Timeout | null = null;
+
+export function pushEnabled(): boolean {
+  return config.pushMode === "subscribe" && !!config.pushUrl;
+}
+
+function keyFor(base: string, username: string) { return `${base} ${username}`; }
+
+async function jmap(entry: AccountPush, calls: unknown[]) {
+  const upstream = await getUpstreamSession(entry.key, entry.authorization, entry.base);
+  const res = await fetch(absoluteUpstream(upstream.apiUrl, upstream.baseUrl), {
+    method: "POST",
+    headers: { authorization: entry.authorization, "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify({ using: USING, methodCalls: calls }),
+    signal: AbortSignal.timeout(config.upstreamTimeout),
+  });
+  if (!res.ok) throw new Error(`upstream ${res.status}`);
+  return (await res.json()) as { methodResponses: [string, Record<string, unknown>, string][] };
+}
+
+/*
+ * Whose subscriptions are whose.
+ *
+ * Each process used to register a subscription per account and forget it when
+ * it stopped -- state here is in memory, and an immutable deployment restarts
+ * on every deploy -- so each restart left one more behind, receiving 404s until
+ * it expired. Stalwart keeps them all and allows fifteen per account (checked
+ * live on 0.16.22, 2026-09-16), which the browser subscriptions count against
+ * too (#375).
+ *
+ * So the device id names the installation -- a hash of the address Stalwart
+ * posts to, stable across restarts and different for another installation on
+ * the same server -- and a new subscription first removes the ones this
+ * installation left before. The `ihasmail-proxy-` prefix keeps them apart from
+ * the browsers' own, which the web client may clear to make room.
+ */
+function installationId(): string {
+  return createHash("sha256").update(`${config.pushUrl}${config.basePath}`).digest("base64url").slice(0, 10);
+}
+
+function deviceIdFor(entry: AccountPush): string {
+  return `ihasmail-proxy-${installationId()}-${entry.token.slice(0, 8)}`;
+}
+
+async function removeLeftovers(entry: AccountPush) {
+  const mine = `ihasmail-proxy-${installationId()}-`;
+  const r = await jmap(entry, [["PushSubscription/get", { ids: null, properties: ["id", "deviceClientId"] }, "0"]]);
+  const list = (r.methodResponses[0]?.[1] as { list?: Array<{ id: string; deviceClientId?: string }> }).list ?? [];
+  const stale = list.filter((s) => s.id !== entry.subscriptionId && String(s.deviceClientId ?? "").startsWith(mine)).map((s) => s.id);
+  if (stale.length) await jmap(entry, [["PushSubscription/set", { destroy: stale }, "0"]]);
+}
+
+/** Give the live subscription another week, rather than registering a second one. */
+async function renew(entry: AccountPush) {
+  const expires = new Date(Date.now() + 7 * 86_400_000).toISOString().replace(/\.\d+Z$/, "Z");
+  const r = await jmap(entry, [["PushSubscription/set", { update: { [entry.subscriptionId!]: { expires } } }, "0"]]);
+  const res = r.methodResponses[0]?.[1] as { updated?: Record<string, unknown>; notUpdated?: Record<string, unknown> };
+  if (!res.updated || !(entry.subscriptionId! in res.updated)) throw new Error("subscription not extended");
+  const got = await jmap(entry, [["PushSubscription/get", { ids: [entry.subscriptionId], properties: ["expires"] }, "0"]]);
+  const after = (got.methodResponses[0]?.[1] as { list?: Array<{ expires?: string | null }> }).list?.[0]?.expires;
+  entry.expires = after ? Date.parse(after) : Date.parse(expires);
+}
+
+async function subscribe(entry: AccountPush) {
+  try {
+    await removeLeftovers(entry);
+  } catch (err) {
+    console.warn(`[ihasmail] push: could not clear old subscriptions for ${entry.username}: ${(err as Error).message}`);
+  }
+  const url = `${config.pushUrl!.replace(/\/$/, "")}${config.basePath}/api/push/${entry.token}`;
+  const r = await jmap(entry, [["PushSubscription/set", {
+    create: { s: { deviceClientId: deviceIdFor(entry), url,
+                   types: ["Email", "Mailbox", "Thread", "Identity", "EmailSubmission", "VacationResponse"] } },
+  }, "0"]]);
+  const created = (r.methodResponses[0]?.[1] as { created?: Record<string, { id: string; expires?: string }> }).created?.s;
+  if (!created) throw new Error("subscription not created");
+  entry.subscriptionId = created.id;
+  entry.expires = created.expires ? Date.parse(created.expires) : Date.now() + 7 * 86_400_000;
+}
+
+async function verify(entry: AccountPush, code: string) {
+  await jmap(entry, [["PushSubscription/set", { update: { [entry.subscriptionId!]: { verificationCode: code } } }, "0"]]);
+  entry.state = "verified";
+  // Every tab of this account that has been holding its own upstream stream
+  // can now let go of it: the subscription is live, so Stalwart will POST the
+  // same changes here. The browser-facing stream is untouched. Done in this
+  // order there is no gap -- at worst a change lands twice, which is harmless.
+  let moved = 0;
+  for (const [out, dropUpstream] of entry.relays) {
+    entry.relays.delete(out);
+    if (out.destroyed) continue;
+    dropUpstream(); entry.tabs.add(out); moved++;
+  }
+  console.log(`[ihasmail] push: subscription verified for ${entry.username}` + (moved ? `, ${moved} tab(s) moved off the relay` : ""));
+}
+
+async function unsubscribe(entry: AccountPush) {
+  if (entry.subscriptionId) {
+    try { await jmap(entry, [["PushSubscription/set", { destroy: [entry.subscriptionId] }, "0"]]); } catch { /* best effort */ }
+  }
+  byKey.delete(entry.key); byToken.delete(entry.token);
+}
+
+/**
+ * Start (or refresh) the account's subscription. Called at sign-in, so that
+ * by the time the browser opens its stream the verification is usually
+ * already in flight, and called again by attach() as a safety net.
+ */
+export function prepare(username: string, accountId: string, authorization: string): AccountPush | null {
+  if (!pushEnabled()) return null;
+  const base = upstreamFor(username);
+  const key = keyFor(base, username);
+  let entry = byKey.get(key);
+  if (!entry) {
+    entry = { key, username, accountId, base, token: randomBytes(32).toString("base64url"),
+              authorization, subscriptionId: null, state: "pending", since: Date.now(), expires: 0, tabs: new Set(), relays: new Map() };
+    byKey.set(key, entry); byToken.set(entry.token, entry);
+    subscribe(entry).catch((err) => {
+      entry!.state = "failed";
+      console.warn(`[ihasmail] push: subscribe failed for ${username}: ${(err as Error).message}; relay in use`);
+    });
+    startSweeper();
+  } else {
+    entry.authorization = authorization;  // keep a live credential for renewals
+  }
+  return entry;
+}
+
+/**
+ * Called when a tab opens. Returns the account's push entry if the tab can
+ * be served by fan-out right now, or null if it must hold its own relay.
+ */
+export function attach(username: string, accountId: string, authorization: string, out: ServerResponse): AccountPush | null {
+  const entry = prepare(username, accountId, authorization);
+  if (!entry || entry.state !== "verified") return null;
+  entry.tabs.add(out);
+  out.on("close", () => { entry.tabs.delete(out); });
+  return entry;
+}
+
+/**
+ * A tab that had to start on the relay registers here with the hook that
+ * ends its upstream request, so verify() can move it to fan-out later.
+ */
+export function attachRelay(username: string, out: ServerResponse, dropUpstream: () => void): void {
+  if (!pushEnabled()) return;
+  const entry = byKey.get(keyFor(upstreamFor(username), username));
+  if (!entry) return;
+  entry.relays.set(out, dropUpstream);
+  out.on("close", () => { entry.relays.delete(out); });
+}
+
+/** Stalwart's POST. Returns an HTTP status. */
+export async function receive(token: string, body: unknown): Promise<number> {
+  const entry = byToken.get(token);
+  if (!entry) return 404;
+  const msg = body as { "@type"?: string; verificationCode?: string; changed?: unknown };
+  if (msg["@type"] === "PushVerification" && typeof msg.verificationCode === "string") {
+    try { await verify(entry, msg.verificationCode); return 200; }
+    catch (err) { console.warn(`[ihasmail] push: verify failed: ${(err as Error).message}`); return 500; }
+  }
+  if (msg["@type"] === "StateChange") {
+    const frame = `event: state\ndata: ${JSON.stringify(msg)}\n\n`;
+    for (const out of entry.tabs) { if (!out.destroyed) out.write(frame); }
+    return 200;
+  }
+  return 400;
+}
+
+/** One shared timer for every tab: keep-alives, renewals, and cleanup. */
+function startSweeper() {
+  if (sweeper) return;
+  sweeper = setInterval(() => {
+    const now = Date.now();
+    for (const entry of [...byKey.values()]) {
+      for (const out of entry.tabs) { if (out.destroyed) entry.tabs.delete(out); else out.write(": ping\n\n"); }
+      if (entry.state === "pending" && now - entry.since > VERIFY_TIMEOUT_MS) {
+        entry.state = "failed";
+        console.warn(`[ihasmail] push: no verification for ${entry.username} within ${VERIFY_TIMEOUT_MS / 1000}s; relay in use`);
+      }
+      if (entry.state === "verified" && entry.expires - now < RENEW_BEFORE_MS) {
+        // Extended in place, which keeps it verified. Only if the server will
+        // not is a new one registered, and that one has to verify again.
+        entry.expires = now + RENEW_BEFORE_MS;
+        renew(entry).catch(() => {
+          entry.state = "pending"; entry.since = Date.now();
+          subscribe(entry).catch(() => { entry.state = "failed"; });
+        });
+      }
+      if (entry.tabs.size === 0 && (entry.state === "failed" || now - entry.since > 10 * 60_000)) {
+        void unsubscribe(entry);
+      }
+    }
+    if (byKey.size === 0 && sweeper) { clearInterval(sweeper); sweeper = null; }
+  }, SWEEP_MS);
+  sweeper.unref();
+}
+
+/** For /api/health: how many accounts are on each path. */
+export function pushStatus() {
+  let verified = 0, pending = 0, failed = 0, tabs = 0, relays = 0;
+  for (const e of byKey.values()) { tabs += e.tabs.size; relays += e.relays.size; if (e.state === "verified") verified++; else if (e.state === "pending") pending++; else failed++; }
+  return { mode: pushEnabled() ? "subscribe" : "relay", accounts: { verified, pending, failed }, tabs: { fanout: tabs, relay: relays } };
+}

server/src/request-limits.test.ts

@@ -0,0 +1,115 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+
+/**
+ * How much a request may make the proxy hold in memory.
+ *
+ * Routes that read JSON take a small body and no more, whether or not anyone
+ * is signed in. The JMAP route streams straight through for a session that may
+ * administer; for one that may not, it reads the body to check it, and that
+ * read is capped in size, in how many one session runs at once, and in bytes
+ * across everyone.
+ */
+
+const PORT = 18813;
+process.env.MOCK_PORT = String(PORT);
+process.env.MOCK_USER = "[email protected]";
+process.env.MOCK_PASS = "demo-password";
+process.env.STALWART_URL = `http://127.0.0.1:${PORT}`;
+process.env.APP_SECRET = "test-secret-for-request-limits";
+
+const mock = await import("./mock/index.js");
+const { createApp } = await import("./app.js");
+const { rateLimitKey } = await import("./clientip.js");
+
+const app = createApp();
+const HEADERS = { "content-type": "application/json", "x-requested-with": "ihasmail" };
+let cookie = "";
+
+/** A body that arrives in chunks with no content-length, as a chunked upload does. */
+function chunked(size: number, chunk = 256 * 1024): ReadableStream<Uint8Array> {
+  let sent = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (sent >= size) return controller.close();
+      const n = Math.min(chunk, size - sent);
+      controller.enqueue(new Uint8Array(n).fill(0x20));
+      sent += n;
+    },
+  });
+}
+
+const jmap = (body: BodyInit) =>
+  app.request("/api/jmap", { method: "POST", headers: { ...HEADERS, cookie }, body, duplex: "half" } as RequestInit);
+
+before(async () => {
+  // Not remembered: a device that is not the person's own, so JMAP is checked.
+  const res = await app.request("/api/auth/login", { method: "POST", headers: HEADERS, body: JSON.stringify({ username: "[email protected]", password: "demo-password" }) });
+  assert.equal(res.status, 200, "login should succeed against the mock");
+  cookie = res.headers.get("set-cookie")!.split(";")[0]!;
+});
+
+after(() => {
+  (mock as { server?: { close(): void } }).server?.close();
+});
+
+test("sign-in refuses a large body by its length, before reading it", async () => {
+  const res = await app.request("/api/auth/login", {
+    method: "POST",
+    headers: { ...HEADERS, "content-length": String(200 * 1024 * 1024) },
+    body: "{}",
+  });
+  assert.equal(res.status, 413);
+});
+
+test("sign-in refuses a large chunked body without holding all of it", async () => {
+  const res = await app.request("/api/auth/login", { method: "POST", headers: HEADERS, body: chunked(2 * 1024 * 1024), duplex: "half" } as RequestInit);
+  assert.equal(res.status, 413);
+});
+
+test("other JSON routes are limited too", async () => {
+  const res = await app.request("/api/account/password", { method: "POST", headers: { ...HEADERS, cookie }, body: chunked(1024 * 1024), duplex: "half" } as RequestInit);
+  assert.equal(res.status, 413);
+});
+
+test("an ordinary checked JMAP request still goes through", async () => {
+  const res = await jmap(JSON.stringify({ using: ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"], methodCalls: [["Mailbox/get", { accountId: "a1", ids: [] }, "0"]] }));
+  assert.equal(res.status, 200);
+});
+
+test("a JMAP request larger than the check allows is refused", async () => {
+  assert.equal((await jmap(chunked(5 * 1024 * 1024))).status, 413);
+});
+
+test("a JMAP request larger than a sign-in body is not caught by the small-body limit", async () => {
+  // 200 KB of whitespace around a real request: valid JSON, well past 64 KB.
+  const body = `${" ".repeat(200 * 1024)}{"using":["urn:ietf:params:jmap:core"],"methodCalls":[["Core/echo",{},"0"]]}`;
+  assert.equal((await jmap(body)).status, 200);
+});
+
+test("one session cannot hold more than a few checked reads at once", async () => {
+  // Bodies that never finish: each holds its slot until its stream fails.
+  const controllers: ReadableStreamDefaultController<Uint8Array>[] = [];
+  const pending: Promise<Response>[] = [];
+  for (let i = 0; i < 4; i++) {
+    const s = new ReadableStream<Uint8Array>({ start(c) { controllers.push(c); c.enqueue(new TextEncoder().encode("{")); } });
+    pending.push(jmap(s));
+  }
+  await new Promise((r) => setTimeout(r, 50));
+  const fifth = await jmap("{}");
+  assert.equal(fifth.status, 429);
+  assert.ok(fifth.headers.get("retry-after"));
+  for (const c of controllers) c.error(new Error("client went away"));
+  await Promise.allSettled(pending);
+  // The slots are given back once those requests end.
+  const again = await jmap(JSON.stringify({ using: ["urn:ietf:params:jmap:core"], methodCalls: [["Core/echo", {}, "0"]] }));
+  assert.equal(again.status, 200);
+});
+
+test("IPv6 addresses share a rate-limit key across their /64", () => {
+  assert.equal(rateLimitKey("2001:db8:1:2:aaaa::1"), rateLimitKey("2001:db8:1:2:ffff:ffff:ffff:ffff"));
+  assert.notEqual(rateLimitKey("2001:db8:1:2::1"), rateLimitKey("2001:db8:1:3::1"));
+  assert.equal(rateLimitKey("2001:db8:1:2::1"), "2001:db8:1:2::/64");
+  assert.equal(rateLimitKey("198.51.100.7"), "198.51.100.7");
+  assert.equal(rateLimitKey("unknown"), "unknown");
+});

server/src/sessions.test.ts

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { SessionStore } from "./sessions.js";
+import { SessionStore, accountKey } from "./sessions.js";
 import { normalizeLocale } from "./upstream.js";
 import { deriveKey, open, seal, sha256 } from "./crypto.js";
 import { RateLimiter } from "./ratelimit.js";
@@ -30,6 +30,20 @@ test("session store creates, resolves, and refuses tampered cookies", () => {
   assert.equal(store.resolve(cookie), null);
 });
 
+test("sessions group by the account, however its name was typed", () => {
+  const store = new SessionStore("");
+  const key = accountKey("https://mail.example.com", "[email protected]");
+  const a = store.create({ username: "alice", account: key, password: "pw", remember: false, userAgent: "", ip: "" });
+  const b = store.create({ username: "[email protected]", account: accountKey("https://mail.example.com", "[email protected]"), password: "pw", remember: false, userAgent: "", ip: "" });
+  // The same name on another configured server is another account.
+  store.create({ username: "[email protected]", account: accountKey("https://other.example.net", "[email protected]"), password: "pw", remember: false, userAgent: "", ip: "" });
+  assert.equal(a.session.account, b.session.account);
+  assert.equal(store.listForUser(a.session.account).length, 2);
+  assert.equal(store.destroyAllForUser(a.session.account, a.session.id), 1);
+  assert.equal(store.resolve(b.cookie), null, "the other spelling was signed out");
+  assert.ok(store.resolve(a.cookie), "this session was kept");
+});
+
 test("persisted session data does not contain the password", () => {
   const store = new SessionStore("");
   store.create({ username: "u", password: "super-secret-pw", remember: true, userAgent: "", ip: "" });

server/src/sessions.ts

@@ -13,6 +13,8 @@ export interface StoredSession {
   /** sealed JSON {username, password} */
   sealedCredentials: string;
   username: string;
+  /** Which account this is; see `accountKey`. Absent on sessions saved before it existed. */
+  account?: string;
   createdAt: number;
   lastSeenAt: number;
   expiresAt: number;
@@ -24,6 +26,8 @@ export interface StoredSession {
 export interface LiveSession {
   id: string;
   username: string;
+  /** See `accountKey`. */
+  account: string;
   /** Basic Authorization header value for upstream calls. */
   authorization: string;
   remember: boolean;
@@ -46,8 +50,27 @@ export interface SessionSummary {
   ip: string;
 }
 
+/**
+ * The key sessions are grouped by for "sign out everywhere else".
+ *
+ * Not the username as typed: Stalwart takes `[email protected]` and a bare
+ * `alice` as the same account, and a session opened either way was missing
+ * from the list and survived the sign-out. The server's own name for the
+ * account, lower-cased, and the server it lives on -- the same name on two
+ * configured servers is two accounts.
+ */
+export function accountKey(upstream: string, canonicalUsername: string): string {
+  return `${upstream}|${canonicalUsername.trim().toLowerCase()}`;
+}
+
+function accountOf(s: StoredSession): string {
+  return s.account ?? s.username.trim().toLowerCase();
+}
+
 export interface CreateSessionParams {
   username: string;
+  /** From `accountKey`; defaults to the lower-cased username. */
+  account?: string;
   password: string;
   remember: boolean;
   userAgent: string;
@@ -75,7 +98,7 @@ export interface CreateSessionParams {
  * other sessions" button: `app.ts` also calls it when the password or the app
  * password changes, so it carries the guarantee that changing a credential
  * invalidates the sessions still holding the old one. A stateless backend
- * cannot honour that alone; the plan is for OAuth to hand the job to
+ * cannot honor that alone; the plan is for OAuth to hand the job to
  * Stalwart's own token registry, which can already answer both questions.
  */
 export interface SessionBackend {
@@ -85,8 +108,9 @@ export interface SessionBackend {
   resolve(cookie: string | undefined): LiveSession | null;
   reseal(cookie: string | undefined, password: string): boolean;
   destroy(id: string): void;
-  destroyAllForUser(username: string, exceptId?: string): number;
-  listForUser(username: string): SessionSummary[];
+  /** `account` is an `accountKey`, as carried on `LiveSession.account`. */
+  destroyAllForUser(account: string, exceptId?: string): number;
+  listForUser(account: string): SessionSummary[];
 }
 
 const COOKIE_SEP = ".";
@@ -172,6 +196,7 @@ export class SessionStore implements SessionBackend {
       salt: salt.toString("base64"),
       sealedCredentials: seal(JSON.stringify({ u: params.username, p: params.password }), key),
       username: params.username,
+      account: params.account ?? params.username.trim().toLowerCase(),
       createdAt: now,
       lastSeenAt: now,
       expiresAt: now + ttl,
@@ -248,10 +273,10 @@ export class SessionStore implements SessionBackend {
     if (this.sessions.delete(id)) this.scheduleSave();
   }
 
-  destroyAllForUser(username: string, exceptId?: string): number {
+  destroyAllForUser(account: string, exceptId?: string): number {
     let n = 0;
     for (const [id, s] of this.sessions) {
-      if (s.username === username && id !== exceptId) {
+      if (accountOf(s) === account && id !== exceptId) {
         this.sessions.delete(id);
         n++;
       }
@@ -260,11 +285,11 @@ export class SessionStore implements SessionBackend {
     return n;
   }
 
-  listForUser(username: string): SessionSummary[] {
+  listForUser(account: string): SessionSummary[] {
     const out = [];
     for (const s of this.sessions.values()) {
-      if (s.username !== username) continue;
-      const { secretHash: _h, salt: _s, sealedCredentials: _c, ...rest } = s;
+      if (accountOf(s) !== account) continue;
+      const { secretHash: _h, salt: _s, sealedCredentials: _c, account: _a, ...rest } = s;
       out.push(rest);
     }
     return out;
@@ -274,6 +299,7 @@ export class SessionStore implements SessionBackend {
     return {
       id: s.id,
       username,
+      account: accountOf(s),
       authorization: `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`,
       remember: s.remember,
       createdAt: s.createdAt,

server/src/settingspolicy.test.ts

@@ -72,11 +72,17 @@ test("every entry in the example mapping is a domain and an http(s) URL", () =>
     if (key.startsWith("_")) continue;
     const domain = key.trim().toLowerCase().replace(/\.$/, "");
     assert.ok(domain, "a domain key is empty");
-    assert.ok(!seen.has(domain), `${domain} appears twice once normalised`);
+    assert.ok(!seen.has(domain), `${domain} appears twice once normalized`);
     seen.add(domain);
-    assert.equal(typeof value, "string", `${domain} is not a string`);
-    const url = new URL(value as string);
-    assert.ok(url.protocol === "http:" || url.protocol === "https:", `${domain} must be http or https`);
+    // A URL, or an object naming the server's URL and its administration's.
+    const entry = value && typeof value === "object" ? (value as Record<string, unknown>) : { url: value };
+    for (const [field, v] of Object.entries(entry)) {
+      assert.ok(field === "url" || field === "adminUrl", `${domain} has an unknown field ${field}`);
+      assert.equal(typeof v, "string", `${domain} ${field} is not a string`);
+      const url = new URL(v as string);
+      assert.ok(url.protocol === "http:" || url.protocol === "https:", `${domain} ${field} must be http or https`);
+    }
+    assert.equal(typeof entry.url, "string", `${domain} has no url`);
   }
   assert.ok(seen.size > 0, "the example should show at least one mapping");
 });

server/src/static-precompressed.test.ts

@@ -0,0 +1,79 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync, utimesSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { brotliCompressSync, brotliDecompressSync, gunzipSync, gzipSync } from "node:zlib";
+
+/*
+ * The bundle goes out compressed once, at build time, and anything revalidated
+ * can be answered with a 304.
+ *
+ * Before this the server gzipped the bundle again for every request that asked,
+ * never offered Brotli, and sent no validator for the shell -- so each reload's
+ * revalidation of index.html and sw.js downloaded them in full.
+ */
+const root = mkdtempSync(join(tmpdir(), "ihasmail-precompressed-"));
+mkdirSync(join(root, "assets"));
+const js = `console.log(${JSON.stringify("x".repeat(4000))});\n`;
+writeFileSync(join(root, "assets", "app-a1b2c3.js"), js);
+writeFileSync(join(root, "assets", "app-a1b2c3.js.br"), brotliCompressSync(js));
+writeFileSync(join(root, "assets", "app-a1b2c3.js.gz"), gzipSync(js));
+writeFileSync(join(root, "assets", "plain-d4e5f6.js"), js);
+// A copy left over from an older build of the same name must not be served.
+writeFileSync(join(root, "assets", "stale-000000.js"), js);
+writeFileSync(join(root, "assets", "stale-000000.js.br"), brotliCompressSync("old"));
+const old = new Date(Date.now() - 60_000);
+utimesSync(join(root, "assets", "stale-000000.js.br"), old, old);
+writeFileSync(join(root, "sw.js"), "/* worker */\n");
+writeFileSync(join(root, "index.html"), "<!doctype html><title>t</title>");
+
+process.env.STATIC_DIR = root;
+process.env.STALWART_URL = "http://127.0.0.1:1";
+const { createApp } = await import("./app.js");
+const app = createApp();
+
+const get = (path: string, headers: Record<string, string> = {}) => app.request(path, { headers });
+
+test("Brotli is served where the browser takes it", async () => {
+  const res = await get("/assets/app-a1b2c3.js", { "accept-encoding": "gzip, deflate, br" });
+  assert.equal(res.status, 200);
+  assert.equal(res.headers.get("content-encoding"), "br");
+  assert.equal(res.headers.get("vary"), "Accept-Encoding");
+  assert.equal(res.headers.get("content-type"), "text/javascript; charset=utf-8");
+  assert.equal(brotliDecompressSync(Buffer.from(await res.arrayBuffer())).toString(), js);
+});
+
+test("gzip where Brotli is not accepted, and nothing where neither is", async () => {
+  const gz = await get("/assets/app-a1b2c3.js", { "accept-encoding": "gzip, br;q=0" });
+  assert.equal(gz.headers.get("content-encoding"), "gzip");
+  assert.equal(gunzipSync(Buffer.from(await gz.arrayBuffer())).toString(), js);
+  const plain = await get("/assets/app-a1b2c3.js");
+  assert.equal(plain.headers.get("content-encoding"), null);
+  assert.equal(await plain.text(), js);
+});
+
+test("a file without a copy is compressed as before", async () => {
+  const res = await get("/assets/plain-d4e5f6.js", { "accept-encoding": "gzip" });
+  assert.equal(res.headers.get("content-encoding"), "gzip");
+  assert.equal(gunzipSync(Buffer.from(await res.arrayBuffer())).toString(), js);
+});
+
+test("a copy older than its file is ignored", async () => {
+  const res = await get("/assets/stale-000000.js", { "accept-encoding": "br" });
+  assert.notEqual(res.headers.get("content-encoding"), "br");
+});
+
+test("the shell and the worker answer a revalidation with 304", async () => {
+  for (const path of ["/", "/sw.js"]) {
+    const first = await get(path);
+    const etag = first.headers.get("etag");
+    assert.ok(etag, `${path} carries a validator`);
+    await first.arrayBuffer();
+    const again = await get(path, { "if-none-match": etag! });
+    assert.equal(again.status, 304, `${path} is not sent again`);
+    assert.equal(await again.text(), "");
+    const changed = await get(path, { "if-none-match": `"something-else"` });
+    assert.equal(changed.status, 200);
+  }
+});

server/src/static.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stat, readFile } from "node:fs/promises";
 import { extname, join, normalize, resolve, sep } from "node:path";
@@ -5,6 +6,35 @@ import { Readable } from "node:stream";
 import type { Context, Handler } from "hono";
 import { stripBasePath } from "../../scripts/basePath.mjs";
 
+/*
+ * Files that must not be served from anybody's cache, the way index.html is
+ * not.
+ *
+ * They went out with `max-age=3600` because they are neither hashed assets nor
+ * HTML, and an hour looks harmless. It is not, for two of them, and a CDN in
+ * front makes it worse: on a deploy the origin had the new build while
+ * Cloudflare went on handing out the previous `sw.js` for hours, with
+ * `cf-cache-status: HIT` and an edge TTL of its own that was longer than what
+ * we asked for. Caught on the 2026-09-08 deploy, where the new worker was live
+ * at the origin and the old one was still being installed by every browser
+ * that asked.
+ *
+ * What that costs is specific rather than general. The service worker is the
+ * app's whole update mechanism: a stale one keeps serving the shell it knows
+ * and never learns there is a newer build, so the deploy simply does not
+ * arrive. And a manifest and a worker that disagree is worse than either being
+ * old -- a fresh manifest advertising a share target to the operating system,
+ * answered by a worker that has never heard of one, sends the share to the
+ * server for a 405.
+ *
+ * `no-cache` does not mean "do not store": the browser and the CDN may both
+ * keep it and revalidate, which is a 304 and costs nothing. It means neither
+ * gets to serve it without asking first, which is the whole requirement.
+ */
+function isNeverStale(rel: string, ext: string): boolean {
+  return ext === ".webmanifest" || rel === "/sw.js" || rel === "sw.js";
+}
+
 const MIME: Record<string, string> = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -48,9 +78,61 @@ export const APP_CSP = [
   "manifest-src 'self'",
 ].join("; ");
 
+/*
+ * What a file is, for the purpose of "has it changed". The shell and the
+ * never-stale files are revalidated on every load; with no validator to send
+ * back, every revalidation downloaded the whole file again.
+ */
+function etagOf(size: number, mtimeMs: number): string {
+  return `W/"${size.toString(36)}-${Math.floor(mtimeMs).toString(36)}"`;
+}
+
+function notModified(c: Context, etag: string): boolean {
+  const sent = c.req.header("if-none-match");
+  return Boolean(sent && sent.split(",").some((t) => t.trim() === etag || t.trim() === "*"));
+}
+
+/*
+ * The encodings a build can carry beside a file, best first. See
+ * scripts/precompress.mjs, which writes them.
+ */
+const PRECOMPRESSED: Array<{ token: string; suffix: string; encoding: string }> = [
+  { token: "br", suffix: ".br", encoding: "br" },
+  { token: "gzip", suffix: ".gz", encoding: "gzip" },
+];
+
+function accepts(c: Context, token: string): boolean {
+  const header = c.req.header("accept-encoding") ?? "";
+  return header.split(",").some((part) => {
+    const [name, ...params] = part.trim().split(";");
+    if (name?.trim().toLowerCase() !== token) return false;
+    const q = params.map((p) => p.trim()).find((p) => p.startsWith("q="));
+    return !q || Number(q.slice(2)) > 0;
+  });
+}
+
 export function staticHandler(root: string, basePath = ""): Handler {
   const absRoot = resolve(root);
-  let indexCache: { body: string; mtime: number } | null = null;
+  let indexCache: { body: string; mtime: number; etag: string } | null = null;
+  /** Which precompressed copies exist, per file and modification time. */
+  const variants = new Map<string, { mtime: number; found: Map<string, number> }>();
+
+  async function variantsOf(filePath: string, mtime: number): Promise<Map<string, number>> {
+    const known = variants.get(filePath);
+    if (known && known.mtime === mtime) return known.found;
+    const found = new Map<string, number>();
+    for (const v of PRECOMPRESSED) {
+      try {
+        const st = await stat(filePath + v.suffix);
+        // A copy older than the file it came from describes something else.
+        if (st.isFile() && st.mtimeMs >= mtime) found.set(v.suffix, st.size);
+      } catch {
+        /* none */
+      }
+    }
+    variants.set(filePath, { mtime, found });
+    return found;
+  }
   let mismatchWarned = false;
 
   /**
@@ -59,7 +141,7 @@ export function staticHandler(root: string, basePath = ""): Handler {
    * already being read here, so checking what it asks for costs one substring
    * search per rebuild and turns a mystery into a line in the log.
    *
-   * A warning rather than a refusal: this reads a built artefact to guess at a
+   * A warning rather than a refusal: this reads a built artifact to guess at a
    * misconfiguration, and a wrong guess that stops the server from starting is
    * worse than the problem it is describing.
    */
@@ -78,13 +160,16 @@ export function staticHandler(root: string, basePath = ""): Handler {
       const p = join(absRoot, "index.html");
       const st = await stat(p);
       if (!indexCache || indexCache.mtime !== st.mtimeMs) {
-        indexCache = { body: await readFile(p, "utf8"), mtime: st.mtimeMs };
+        const body = await readFile(p, "utf8");
+        indexCache = { body, mtime: st.mtimeMs, etag: `"${createHash("sha256").update(body).digest("base64url").slice(0, 22)}"` };
         mismatchWarned = false;
       }
       warnOnBaseMismatch(indexCache.body);
       c.header("Content-Type", "text/html; charset=utf-8");
       c.header("Cache-Control", "no-cache");
       c.header("Content-Security-Policy", APP_CSP);
+      c.header("ETag", indexCache.etag);
+      if (notModified(c, indexCache.etag)) return c.body(null, 304);
       return c.body(indexCache.body);
     } catch {
       c.header("Content-Type", "text/plain; charset=utf-8");
@@ -99,7 +184,7 @@ export function staticHandler(root: string, basePath = ""): Handler {
      * comes off once, here. Anything outside it is a 404 and not the app
      * shell: under `/mail` this process shares a hostname with whatever else
      * the proxy serves, and answering `/` or `/other-app/thing` with our
-     * index would shadow a neighbour rather than let it 404 honestly.
+     * index would shadow a neighbor rather than let it 404 honestly.
      */
     const fullPath = decodeURIComponent(new URL(c.req.url).pathname);
     const urlPath = stripBasePath(basePath, fullPath);
@@ -113,17 +198,33 @@ export function staticHandler(root: string, basePath = ""): Handler {
       if (!st.isFile()) return serveIndex(c);
       const ext = extname(filePath).toLowerCase();
       c.header("Content-Type", MIME[ext] ?? "application/octet-stream");
-      c.header("Content-Length", String(st.size));
+      const etag = etagOf(st.size, st.mtimeMs);
+      c.header("ETag", etag);
       if (rel.startsWith("/assets/") || rel.startsWith("assets/")) {
         c.header("Cache-Control", "public, max-age=31536000, immutable");
-      } else if (ext === ".html") {
+      } else if (ext === ".html" || isNeverStale(rel, ext)) {
         c.header("Cache-Control", "no-cache");
         c.header("Content-Security-Policy", APP_CSP);
       } else {
         c.header("Cache-Control", "public, max-age=3600");
       }
+      if (notModified(c, etag)) return c.body(null, 304);
+      // Serve a copy made at build time where the browser takes one.
+      let servePath = filePath;
+      let size = st.size;
+      const found = await variantsOf(filePath, st.mtimeMs);
+      if (found.size) {
+        c.header("Vary", "Accept-Encoding");
+        const pick = PRECOMPRESSED.find((v) => found.has(v.suffix) && accepts(c, v.token));
+        if (pick) {
+          servePath = filePath + pick.suffix;
+          size = found.get(pick.suffix)!;
+          c.header("Content-Encoding", pick.encoding);
+        }
+      }
+      c.header("Content-Length", String(size));
       if (c.req.method === "HEAD") return c.body(null);
-      const stream = Readable.toWeb(createReadStream(filePath)) as ReadableStream;
+      const stream = Readable.toWeb(createReadStream(servePath)) as ReadableStream;
       return c.body(stream);
     } catch {
       // SPA fallback for client-side routes (no file extension) only.

server/src/staticcache.test.ts

@@ -0,0 +1,81 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/*
+ * What may be served stale, and what may not.
+ *
+ * This is not a preference about freshness. The service worker is the app's
+ * whole update mechanism: a browser holding an old one goes on being served
+ * the shell that worker knows and never finds out a deploy happened. On
+ * 2026-09-08 the origin had the new build while Cloudflare handed out the
+ * previous `sw.js` for hours, because it was neither a hashed asset nor HTML
+ * and so went out with an hour's max-age that the CDN then extended.
+ *
+ * A static root of our own, since CI runs the tests before the build and
+ * `web/dist` does not exist yet.
+ */
+const root = mkdtempSync(join(tmpdir(), "ihasmail-cache-"));
+mkdirSync(join(root, "assets"));
+writeFileSync(join(root, "assets", "app-a1b2c3.js"), "console.log(1)\n");
+writeFileSync(join(root, "sw.js"), "/* worker */\n");
+writeFileSync(join(root, "manifest.webmanifest"), `{"name":"ihasmail"}`);
+writeFileSync(join(root, "index.html"), "<!doctype html><title>t</title>");
+writeFileSync(join(root, "img.png"), "not really a png");
+
+process.env.STATIC_DIR = root;
+process.env.STALWART_URL = "http://127.0.0.1:1";
+const { createApp } = await import("./app.js");
+
+const cacheControl = async (path: string) => {
+  const res = await createApp().request(path);
+  assert.equal(res.status, 200, `${path} should be served`);
+  return res.headers.get("cache-control") ?? "";
+};
+
+test("the service worker is never served from a cache without asking", async () => {
+  // `no-cache` permits storing it and requires revalidating it, which is a 304
+  // and costs nothing. What it forbids is a browser or a CDN answering with
+  // its own copy, which is the whole failure.
+  assert.match(await cacheControl("/sw.js"), /no-cache/);
+});
+
+test("nor is the manifest, which the worker has to agree with", async () => {
+  // A fresh manifest advertising a share target, answered by a worker that has
+  // never heard of one, sends the share to the server for a 405. Either being
+  // old is survivable; the two disagreeing is not.
+  assert.match(await cacheControl("/manifest.webmanifest"), /no-cache/);
+});
+
+test("the manifest is still served as a manifest", async () => {
+  const res = await createApp().request("/manifest.webmanifest");
+  assert.match(res.headers.get("content-type") ?? "", /application\/manifest\+json/);
+});
+
+test("index.html was already revalidated, and still is", async () => {
+  assert.match(await cacheControl("/"), /no-cache/);
+});
+
+test("hashed assets are still immutable for a year", async () => {
+  // The name changes when the bytes do, so there is nothing to go stale --
+  // and this is the caching that makes the app load quickly at all.
+  const cc = await cacheControl("/assets/app-a1b2c3.js");
+  assert.match(cc, /immutable/);
+  assert.match(cc, /max-age=31536000/);
+});
+
+test("everything else keeps its ordinary hour", async () => {
+  // The rule is narrow on purpose: two files, named, rather than a policy that
+  // quietly stops the icons and fonts being cached too.
+  assert.match(await cacheControl("/img.png"), /max-age=3600/);
+});
+
+test("under a prefix, the worker is still the worker", async () => {
+  // The mount comes off before the path is matched, so this has to hold for a
+  // subpath deployment as well -- where a stale worker is exactly as bad.
+  const res = await createApp("/mail").request("/mail/sw.js");
+  assert.equal(res.status, 200);
+  assert.match(res.headers.get("cache-control") ?? "", /no-cache/);
+});

server/src/totp.ts

@@ -1,13 +1,13 @@
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 
 /**
- * TOTP (RFC 6238) — just enough to enrol a second factor safely.
+ * TOTP (RFC 6238) — just enough to enroll a second factor safely.
  *
  * Stalwart stores the otpauth:// URL and checks codes at login, but it does
  * *not* check the new secret when 2FA is switched on: it verifies the
  * credentials that are already on the account. A user whose authenticator was
  * mistyped or whose clock has drifted would be locked out of their mailbox at
- * the next sign-in. So ihasmail proves the enrolment itself, before asking the
+ * the next sign-in. So ihasmail proves the enrollment itself, before asking the
  * server to store anything.
  */
 

server/src/upstream.ts

@@ -1,4 +1,5 @@
 import { config } from "./config.js";
+import { grantsAdministration } from "./adminGate.js";
 
 export interface UpstreamSession {
   capabilities: Record<string, unknown>;
@@ -54,6 +55,87 @@ export function upstreamFor(username: string): string {
   return config.stalwartServers[domain] ?? config.stalwartUrl;
 }
 
+/**
+ * Where the administrator signed in as `username` opens Stalwart's own
+ * administration.
+ *
+ * What the operator configured wins -- STALWART_ADMIN_URL for the default
+ * server, a servers file entry's `adminUrl` for a routed domain -- and what was
+ * found on the account's own server (`detected`) is used otherwise. Routing is
+ * the same as `upstreamFor`: a routed domain is never pointed at the default
+ * server's administration, and `detected` already came from its own server.
+ */
+export function adminUrlFor(username: string, detected: string | null = null): string | null {
+  const at = username.lastIndexOf("@");
+  const domain = at < 0 ? "" : username.slice(at + 1).trim().toLowerCase().replace(/\.$/, "");
+  if (domain && domain in config.stalwartServers) return config.stalwartAdminUrls[domain] ?? detected;
+  return config.stalwartAdminUrl || detected;
+}
+
+/** Stalwart's own default for its web interface, written at first boot (`manager/defaults.rs`). */
+const DEFAULT_ADMIN_PREFIX = "/admin";
+
+/**
+ * The prefix Stalwart's administration is served under, from the `x:Application`
+ * answers: "/admin" if an enabled application claims it, null if the server
+ * says there is none (disabled, removed, or moved to another prefix). A refusal
+ * -- the account may not read applications -- is not an answer, and gets
+ * Stalwart's default.
+ */
+export function adminPrefixFrom(responses: [string, Record<string, unknown>, string][]): string | null {
+  const get = responses.find(([name]) => name === "x:Application/get" || name === "error");
+  if (!get || get[0] === "error") return DEFAULT_ADMIN_PREFIX;
+  const list = (get[1].list as Array<{ enabled?: unknown; urlPrefix?: unknown }> | undefined) ?? [];
+  const claims = list.some((app) => app.enabled !== false && app.urlPrefix && typeof app.urlPrefix === "object" && DEFAULT_ADMIN_PREFIX in (app.urlPrefix as object));
+  return claims ? DEFAULT_ADMIN_PREFIX : null;
+}
+
+/**
+ * The public origin a Stalwart session belongs to: the host it advertises in
+ * its own URLs, which is the address people reach it at even when this server
+ * talks to it on a private one (STALWART_URL=http://127.0.0.1:…). A relative
+ * URL falls back to the configured base.
+ */
+export function advertisedOrigin(session: Pick<UpstreamSession, "apiUrl" | "baseUrl">): string | null {
+  try {
+    return new URL(session.apiUrl, session.baseUrl).origin;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Where this session's server serves its own administration, found from the
+ * server itself: its advertised origin, and the prefix its web interface
+ * application is installed under. Null when the server says it has none.
+ */
+async function detectAdminUrl(authorization: string, session: UpstreamSession): Promise<string | null> {
+  const origin = advertisedOrigin(session);
+  const accountId = session.primaryAccounts?.[STALWART_CAP];
+  if (!origin) return null;
+  let prefix: string | null = DEFAULT_ADMIN_PREFIX;
+  if (accountId) {
+    try {
+      const res = await fetch(absoluteUpstream(session.apiUrl, session.baseUrl), {
+        method: "POST",
+        headers: { authorization, "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify({
+          using: [JMAP_CORE, STALWART_CAP],
+          methodCalls: [
+            ["x:Application/query", { accountId }, "q"],
+            ["x:Application/get", { accountId, "#ids": { resultOf: "q", name: "x:Application/query", path: "/ids" }, properties: ["enabled", "urlPrefix"] }, "g"],
+          ],
+        }),
+        signal: AbortSignal.timeout(config.upstreamTimeout),
+      });
+      if (res.ok) prefix = adminPrefixFrom(((await res.json()) as { methodResponses?: [string, Record<string, unknown>, string][] }).methodResponses ?? []);
+    } catch {
+      /* unreachable is not "none": keep the default */
+    }
+  }
+  return prefix ? `${origin}${prefix}/` : null;
+}
+
 export function wellKnownUrl(base: string = config.stalwartUrl): string {
   return `${base}/.well-known/jmap`;
 }
@@ -132,11 +214,43 @@ export interface AccountInfo {
   locale: string | null;
   /** "oss" | "community" | "enterprise", where the server reports it. */
   edition: string | null;
+  /**
+   * The account's effective permissions, as Stalwart reports them for the
+   * credential in use. Empty when the server would not say.
+   *
+   * Carried to the browser so it can offer only what the account may do --
+   * administration above all. It is never a grant: Stalwart checks every call
+   * it is sent, and a list that is stale or wrong costs a refused request, not
+   * access.
+   */
+  permissions: string[];
+  /**
+   * Where this server's own administration is, found rather than configured:
+   * see `detectAdminUrl`. Only looked for when the account administers.
+   */
+  adminUrl?: string | null;
 }
 
 const infoCache = new Map<string, { info: AccountInfo; fetchedAt: number }>();
 const INFO_CACHE_MS = 30 * 60_000;
-const EMPTY_INFO: AccountInfo = { locale: null, edition: null };
+
+/*
+ * Both caches are keyed by session, and used to lose an entry only when that
+ * session signed out or was refused -- not when it simply expired, which is how
+ * most sessions end. An entry past its age is never used again, so dropping
+ * those on a timer is all it takes to stop them accumulating.
+ */
+export function sweepUpstreamCaches(now = Date.now()): void {
+  for (const [id, v] of sessionCache) if (now - v.fetchedAt >= SESSION_CACHE_MS) sessionCache.delete(id);
+  for (const [id, v] of infoCache) if (now - v.fetchedAt >= INFO_CACHE_MS) infoCache.delete(id);
+}
+setInterval(() => sweepUpstreamCaches(), SESSION_CACHE_MS).unref();
+
+/** How many sessions the caches hold; for tests. */
+export function upstreamCacheSizes(): { sessions: number; info: number } {
+  return { sessions: sessionCache.size, info: infoCache.size };
+}
+const EMPTY_INFO: AccountInfo = { locale: null, edition: null, permissions: [] };
 
 /**
  * glibc modifiers that name a script rather than a dialect or a currency:
@@ -153,7 +267,7 @@ const SCRIPT_MODIFIERS: Record<string, string> = {
 };
 
 /**
- * Normalise a POSIX-style locale ("de_DE.UTF-8@euro") into a BCP-47 tag
+ * Normalize a POSIX-style locale ("de_DE.UTF-8@euro") into a BCP-47 tag
  * ("de-DE"). Returns null for the locale-less values ("C", "POSIX") and for
  * anything that does not look like a language tag.
  */
@@ -198,7 +312,9 @@ async function fetchAccountInfo(authorization: string, session: UpstreamSession)
     session.primaryAccounts?.["urn:ietf:params:jmap:mail"] ??
     Object.keys(session.accounts ?? {})[0];
   if (!accountId) return EMPTY_INFO;
-  const res = await fetch(absoluteUpstream(session.apiUrl), {
+  // Against the server that issued this session, not the default: with a
+  // domain mapped elsewhere, the default has never heard of the account.
+  const res = await fetch(absoluteUpstream(session.apiUrl, session.baseUrl), {
     method: "POST",
     headers: { authorization, "content-type": "application/json", accept: "application/json" },
     body: JSON.stringify({
@@ -226,7 +342,7 @@ async function fetchAccountInfo(authorization: string, session: UpstreamSession)
 export function interpretAccountInfo(responses: [string, Record<string, unknown>, string][]): AccountInfo {
   const settings = responses.find((r) => r[2] === "s");
   const account = responses.find((r) => r[2] === "a");
-  return { locale: localeOf(settings) ?? localeOf(account), edition: null };
+  return { locale: localeOf(settings) ?? localeOf(account), edition: null, permissions: [] };
 }
 
 function localeOf(call: [string, Record<string, unknown>, string] | undefined): string | null {
@@ -237,30 +353,54 @@ function localeOf(call: [string, Record<string, unknown>, string] | undefined):
 }
 
 /**
- * Which edition the server is running. Stalwart deliberately does not publish
- * its version number to clients, but 0.16 does report its edition here.
+ * Permission names in the form the source serializes them.
+ *
+ * Stalwart 0.16 builds `/api/account`'s list from the same enum as everything
+ * else, which serializes as camelCase (`sysAccountGet`). Its documentation and
+ * OpenAPI example show kebab-case (`sys-account-get`) instead. Until a live
+ * server settles which is true, both are read as the one form, so a check
+ * written against `sysAccountGet` holds either way.
  */
-async function fetchEdition(authorization: string, base: string): Promise<string | null> {
+export function normalizePermission(name: string): string {
+  return name.includes("-") ? name.replace(/-([a-z0-9])/g, (_m, c: string) => c.toUpperCase()) : name;
+}
+
+/**
+ * What the server says about the signed-in account: its edition and its
+ * effective permissions. Stalwart deliberately does not publish its version
+ * number to clients, but 0.16 reports both of these here.
+ */
+async function fetchServerAccount(authorization: string, base: string): Promise<Pick<AccountInfo, "edition" | "permissions">> {
   try {
     const res = await fetch(`${base}/api/account`, {
       headers: { authorization, accept: "application/json" },
       signal: AbortSignal.timeout(config.upstreamTimeout),
     });
-    if (!res.ok) return null;
-    const body = (await res.json()) as { edition?: unknown };
-    return typeof body.edition === "string" ? body.edition : null;
+    if (!res.ok) return { edition: null, permissions: [] };
+    return interpretServerAccount(await res.json());
   } catch {
-    return null;
+    return { edition: null, permissions: [] };
   }
 }
 
+export function interpretServerAccount(body: unknown): Pick<AccountInfo, "edition" | "permissions"> {
+  const b = (body ?? {}) as { edition?: unknown; permissions?: unknown };
+  const permissions = Array.isArray(b.permissions)
+    ? [...new Set(b.permissions.filter((p): p is string => typeof p === "string").map(normalizePermission))]
+    : [];
+  return { edition: typeof b.edition === "string" ? b.edition : null, permissions };
+}
+
 export async function getAccountInfo(sessionId: string, authorization: string, session: UpstreamSession): Promise<AccountInfo> {
   const cached = infoCache.get(sessionId);
   if (cached && Date.now() - cached.fetchedAt < INFO_CACHE_MS) return cached.info;
   let info = EMPTY_INFO;
   try {
     info = await fetchAccountInfo(authorization, session);
-    info = { ...info, edition: await fetchEdition(authorization, session.baseUrl) };
+    info = { ...info, ...(await fetchServerAccount(authorization, session.baseUrl)) };
+    // Only an administrator is shown the link, so only an administrator's
+    // server is asked where it is.
+    if (grantsAdministration(info.permissions)) info = { ...info, adminUrl: await detectAdminUrl(authorization, session) };
   } catch {
     /* all of this is a nicety - never fail the session over it */
   }
@@ -288,9 +428,34 @@ export function localizeSession(s: UpstreamSession, extras: Record<string, unkno
 }
 
 /** Resolve a possibly-relative upstream URL template against STALWART_URL. */
+/**
+ * Resolve a URL Stalwart handed us against the server we were configured to
+ * talk to.
+ *
+ * Stalwart advertises absolute URLs in its session -- apiUrl, eventSourceUrl
+ * and the rest -- built from its public hostname, which is always https. A
+ * proxy that follows them takes every upstream call, and every held push
+ * stream, out through the public route even when STALWART_URL names a private
+ * plain-HTTP hop on the same network. Measured, that TLS leg is ~80 KiB of
+ * native OpenSSL state per signed-in tab: 60% of what a tab costs, and the
+ * whole difference between 1,665 and 3,680 tabs in 256 MiB.
+ *
+ * So by default only the path and query are taken from the advertised URL;
+ * scheme, host and port come from the configured base. That is what a proxy
+ * should have done all along -- the operator named the route on purpose.
+ * STALWART_FOLLOW_ADVERTISED_URLS=1 restores the old behavior for a setup
+ * that genuinely needs to reach Stalwart at a different origin than the one
+ * it was given.
+ */
 export function absoluteUpstream(url: string, base: string = config.stalwartUrl): string {
   try {
-    return new URL(url, base).toString();
+    const resolved = new URL(url, base);
+    if (config.followAdvertisedUrls) return resolved.toString();
+    const pinned = new URL(base);
+    pinned.pathname = resolved.pathname;
+    pinned.search = resolved.search;
+    pinned.hash = "";
+    return pinned.toString();
   } catch {
     return url;
   }

stalwart-servers.example.json

@@ -17,9 +17,15 @@
     "JSON, a duplicate domain, or a value that is not an http(s) URL stops the",
     "server at startup rather than failing quietly at somebody's sign-in.",
     "",
+    "ihasmail's Administration dashboard links to each server's own",
+    "administration, found from the server. A value may instead be an object",
+    "that overrides where it is: {\"url\": ..., \"adminUrl\": ...}.",
+    "STALWART_ADMIN_URL is the same for the default server. A listed domain is",
+    "never pointed at the default server's administration.",
+    "",
     "Docs: https://docs.ihasmail.org/configure/#several-stalwart-servers"
   ],
 
   "example.com": "https://mail.example.com",
-  "customer-b.test": "https://jmap.customer-b.test"
+  "customer-b.test": { "url": "https://jmap.customer-b.test", "adminUrl": "https://admin.customer-b.test" }
 }

web/index.html

@@ -9,7 +9,7 @@
       theme, which a media query cannot do — it only knows what the OS prefers,
       not what the user picked here. There used to be two, both with media
       attributes, which meant the selector in applyTheme (:not([media])) matched
-      neither and the colour never moved off whatever the OS implied.
+      neither and the color never moved off whatever the OS implied.
 
       The initial value is the default theme's background, so the browser chrome
       is right from the first paint rather than only once JS has run.

web/package.json

@@ -6,29 +6,29 @@
   "type": "module",
   "scripts": {
     "dev": "vite",
-    "build": "tsc -p tsconfig.json --noEmit && vite build",
+    "build": "tsc -p tsconfig.json --noEmit && vite build && node ../scripts/precompress.mjs dist",
     "preview": "vite preview",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run"
   },
   "dependencies": {
-    "@tanstack/react-virtual": "^3.13.2",
-    "dompurify": "^3.2.4",
-    "lucide-react": "^0.477.0",
+    "@tanstack/react-virtual": "^3.14.12",
+    "dompurify": "^3.4.15",
+    "lucide-react": "^1.45.0",
     "marked": "^18.0.11",
     "qrcode-generator": "^2.0.4",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "wouter": "^3.6.0",
+    "wouter": "^3.11.0",
     "zustand": "^5.0.3"
   },
   "devDependencies": {
     "@types/react": "^19.0.10",
-    "@types/react-dom": "^19.0.4",
-    "@vitejs/plugin-react": "^4.3.4",
-    "jsdom": "^26.0.0",
-    "typescript": "^5.7.3",
-    "vite": "^6.2.0",
-    "vitest": "^3.0.8"
+    "@types/react-dom": "^19.2.7",
+    "@vitejs/plugin-react": "^6.1.1",
+    "jsdom": "^30.0.1",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.0",
+    "vitest": "^5.0.0"
   }
 }

web/public/manifest.webmanifest

@@ -3,8 +3,42 @@
   "short_name": "ihasmail",
   "description": "Fast, friendly JMAP webmail for Stalwart",
   "_comment": "JSON has no comments, so: every URL below is relative on purpose. Manifest members resolve against the manifest's own address, so these follow BASE_PATH with nothing substituted into them at build time. Root-absolute values pinned the installed app, its scope and its shortcuts to the domain root whatever the mount was.",
+  "_comment_id": "There is deliberately no `id`. It is the one member NOT resolved against this file's address -- the spec resolves it against the origin of start_url, so `./`, `mail` and `/mail` all mean the same thing at the domain root and none of them can name a subpath mount. Adding one would therefore break the same thing the note above describes. Worse, the default id IS start_url, which is already mount-correct: writing an id now would give every installed copy a new identity and orphan it as a second app rather than updating it. If one is ever wanted it has to be substituted at build time from BASE_PATH, and the changeover costs everybody their install.",
   "start_url": "mail",
   "scope": "./",
+  "categories": ["productivity", "utilities"],
+  "_comment_launch": "One window, not one per launch. A `mailto:` link, a manifest shortcut or a notification tapped while ihasmail is already open should arrive in the copy that is running rather than beside it -- two windows on the same inbox disagree about what has been read. `navigate-existing` rather than `focus-existing` because the latter only focuses and leaves the app to handle the target URL through launchQueue, which nothing here consumes: it would swallow the mailto entirely. The navigation goes through the same beforeunload guard as a reload, so an unsent draft still stops it and asks.",
+  "launch_handler": {
+    "client_mode": "navigate-existing"
+  },
+  "_comment_share_target": "Being in the operating system's share sheet, which is the other half of the Share this app now offers. `action` is relative like everything else here, so it follows the mount; it has to sit inside `scope`, and `./` covers it. POST with multipart because a share can carry files, and a POST to a page is not something the app can answer -- the service worker intercepts it, puts the payload where a tab can collect it, and redirects. `accept` names wildcard families AND explicit types and extensions on purpose: a mail client attaches anything, but wildcard support is not in the specification and operating systems differ over which form they match on, so the explicit list is what holds if the families are ignored. Android and Chromium only -- iOS does not implement share targets at all.",
+  "share_target": {
+    "action": "share",
+    "method": "POST",
+    "enctype": "multipart/form-data",
+    "params": {
+      "title": "title",
+      "text": "text",
+      "url": "url",
+      "files": [
+        {
+          "name": "files",
+          "accept": [
+            "image/*", "video/*", "audio/*", "text/*",
+            "application/pdf", "application/zip", "application/json",
+            "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-powerpoint", "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            "application/vnd.oasis.opendocument.text", "application/vnd.oasis.opendocument.spreadsheet",
+            "message/rfc822", "text/calendar", "text/vcard",
+            ".pdf", ".zip", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+            ".odt", ".ods", ".csv", ".txt", ".md", ".eml", ".ics", ".vcf",
+            ".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".mp4", ".mp3"
+          ]
+        }
+      ]
+    }
+  },
   "protocol_handlers": [
     {
       "protocol": "mailto",

web/public/sw.js

@@ -18,40 +18,288 @@ const VERSION = "ihasmail-v2";
  * eventually would.
  */
 const BASE = new URL("./", self.location).pathname.replace(/\/$/, "");
-const SHELL = [`${BASE}/`, `${BASE}/manifest.webmanifest`, `${BASE}/img/logo.png`, `${BASE}/img/icon-192.png`, `${BASE}/favicon.ico`];
+const SHELL = [`${BASE}/manifest.webmanifest`, `${BASE}/img/logo.png`, `${BASE}/img/icon-192.png`, `${BASE}/favicon.ico`];
+
+/*
+ * Only the app page may be kept as the app page.
+ *
+ * The mount's root is not always the app: demo.ihasmail.com puts its landing
+ * page there, and a front door of any kind can. The worker used to cache
+ * whatever `/` returned at install and whatever HTML a navigation returned,
+ * and since app routes are answered from that copy first, a demo visitor who
+ * came back got the landing page on every route, for good. The app page is
+ * recognised by the asset list the build writes into it.
+ */
+const APP_PAGE_MARKER = 'id="ihasmail-assets"';
+const isAppPage = (html) => typeof html === "string" && html.includes(APP_PAGE_MARKER);
+
+/*
+ * The routes the app itself owns (App.tsx). Only these are answered from the
+ * kept page; anything else under the mount -- the root, a landing or farewell
+ * page in front of the app, a file -- goes to the network as it always did.
+ */
+const APP_ROUTE = /^\/(mail|search|contacts|calendar|files|settings|admin|login)(\/|$)/;
 
 self.addEventListener("install", (event) => {
-  event.waitUntil(caches.open(VERSION).then((c) => c.addAll(SHELL)).then(() => self.skipWaiting()));
+  event.waitUntil(
+    caches.open(VERSION)
+      .then((c) => c.addAll(SHELL))
+      .then(() => fetch(`${BASE}/mail`, { credentials: "same-origin" }).then((res) => (res.ok ? refreshShell(res) : undefined)).catch(() => {}))
+      .then(() => self.skipWaiting())
+  );
 });
 
 self.addEventListener("activate", (event) => {
   event.waitUntil(
-    caches.keys().then((keys) => Promise.all(keys.filter((k) => k !== VERSION).map((k) => caches.delete(k)))).then(() => self.clients.claim())
+    caches.keys()
+      .then((keys) => Promise.all(keys.filter((k) => k !== VERSION).map((k) => caches.delete(k))))
+      .then(() => dropForeignShell())
+      .then(() => tidy())
+      .catch(() => {})
+      .then(() => self.clients.claim())
   );
 });
 
+/*
+ * Keeping the cache to what the current build uses.
+ *
+ * Build assets are cached on first use and their names change with every
+ * build, and nothing used to take them out again: every deploy's chunks stayed
+ * in the browser for good. Worse, whatever the server answered was kept -- a
+ * 404 for a chunk asked for while a deploy was changing over became that
+ * chunk, from then on, in that browser.
+ *
+ * The rule now: only a successful response is cached, and whenever the app
+ * page changes, the assets it no longer names are dropped. A lazily loaded
+ * chunk the page does not name is dropped too, and fetched again the next time
+ * it is wanted -- a hash that did not change is still on the server.
+ *
+ * The cache name stays as it is. The same cache carries what the worker leaves
+ * for a tab to collect -- a push verification, a share, the facts it notifies
+ * from -- and a new name would throw those away along with the rubbish.
+ */
+const ASSETS = `${BASE}/assets/`;
+const SHELL_KEY = `${BASE}/`;
+
+function assetsNamedIn(html) {
+  const out = new Set();
+  for (const m of html.matchAll(/["']([^"']*\/assets\/[^"']+)["']/g)) {
+    try {
+      out.add(new URL(m[1], self.location).pathname);
+    } catch {
+      /* not a URL */
+    }
+  }
+  return out;
+}
+
+/**
+ * Drop failed responses, and assets the cached app page does not name. `also`
+ * is a page whose assets are kept as well: the one just replaced, which a tab
+ * opened from the kept copy may still be running.
+ */
+async function tidy(also = "") {
+  const cache = await caches.open(VERSION);
+  const shell = await cache.match(SHELL_KEY);
+  // Without a page to go by, which assets are current is unknown; keep them.
+  const keep = shell ? assetsNamedIn(await shell.text()) : null;
+  if (keep) for (const path of assetsNamedIn(also)) keep.add(path);
+  for (const req of await cache.keys()) {
+    const path = new URL(req.url).pathname;
+    if (path.startsWith(ASSETS)) {
+      if (keep && !keep.has(path)) {
+        await cache.delete(req);
+        continue;
+      }
+    }
+    const res = await cache.match(req);
+    if (res && !res.ok) await cache.delete(req);
+  }
+}
+
+/** A kept page that is not the app page -- left by an earlier worker -- is thrown away. */
+async function dropForeignShell() {
+  const cache = await caches.open(VERSION);
+  const kept = await cache.match(SHELL_KEY);
+  if (kept && !isAppPage(await kept.text())) await cache.delete(SHELL_KEY);
+}
+
+/** Keep the offline copy of the app page current, tidy when it changes, and fill in what it lists. */
+async function refreshShell(res) {
+  const html = await res.text();
+  if (!isAppPage(html)) return;
+  const cache = await caches.open(VERSION);
+  const prev = await cache.match(SHELL_KEY);
+  const prevHtml = prev ? await prev.text() : "";
+  if (prevHtml !== html) {
+    await cache.put(SHELL_KEY, new Response(html, { headers: { "content-type": "text/html; charset=utf-8" } }));
+    await tidy(prevHtml);
+  }
+  await precache(html);
+}
+
+/*
+ * Fetching the rest of the build before it is asked for.
+ *
+ * The app page lists every file of its build (see the asset-list plugin in
+ * vite.config.ts). Without this, the first time after a deploy that a reader
+ * opened the composer, settings or a viewer, it waited on the server for the
+ * code -- on a distant link, a visible pause. Now those files are fetched
+ * quietly once a page names them, a few at a time, and only those not held
+ * already; a load cut short is carried on at the next navigation, which calls
+ * this again. Language catalogs are left to be cached when used, and nothing
+ * is fetched ahead when the reader has asked the browser to save data.
+ */
+const PRECACHE_PARALLEL = 3;
+
+function precacheList(html) {
+  const m = html.match(/<script type="application\/json" id="ihasmail-assets">([^<]*)<\/script>/);
+  if (!m) return [];
+  try {
+    const list = JSON.parse(m[1]).precache;
+    return Array.isArray(list) ? list.filter((p) => typeof p === "string" && p.startsWith(ASSETS)) : [];
+  } catch {
+    return [];
+  }
+}
+
+async function precache(html) {
+  if (self.navigator.connection && self.navigator.connection.saveData) return;
+  const cache = await caches.open(VERSION);
+  const wanted = [];
+  for (const path of precacheList(html)) if (!(await cache.match(path))) wanted.push(path);
+  const next = async () => {
+    for (let path = wanted.shift(); path; path = wanted.shift()) {
+      try {
+        const res = await fetch(path, { credentials: "same-origin" });
+        if (res.ok) await cache.put(path, res);
+      } catch {
+        /* offline, or a deploy changing over; the next navigation tries again */
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: PRECACHE_PARALLEL }, next));
+}
+
+/*
+ * Where a share from the operating system is left for a tab to collect.
+ *
+ * Absolute and anchored to the mount, for the same reason the verification key
+ * below is: a relative key is resolved against the URL of whoever asks, and the
+ * worker and a tab deep in `/mail/inbox/…` are not at the same place.
+ *
+ * The files go in one entry each and the rest in a JSON index beside them,
+ * because the Cache API stores Responses and a File is already one body.
+ */
+const SHARE_KEY = `${BASE}/ihasmail-share`;
+const SHARE_MAX_FILES = 20;
+
+/*
+ * Take delivery of a share.
+ *
+ * This is a POST that navigates: the operating system submits a form at the
+ * app and expects a page back. Nothing in ihasmail can answer it directly --
+ * the app is a client-side router with no endpoint at that address, and the
+ * server behind it would have to grow one that understood the composer. So the
+ * worker takes the body, puts it where a tab can find it, and redirects to the
+ * app, which then opens a draft holding it.
+ *
+ * The redirect happens whatever went wrong. A share that fails to stash costs
+ * whatever was being shared, which is bad; a share that fails to *respond*
+ * costs that and leaves the reader looking at a browser error page where they
+ * expected their mail, which is worse.
+ *
+ * There is one case this cannot cover, and the server is deliberately not
+ * taught to: an app still installed whose worker has been cleared away. The
+ * POST then reaches the server, which answers 405, and the share is lost
+ * either way -- the payload only ever existed in that request body. A server
+ * route would trade a plain error for a silent nothing, and a share that
+ * vanishes without saying so is the harder of the two to notice.
+ */
+async function stashShare(request) {
+  try {
+    const form = await request.formData();
+    const cache = await caches.open(VERSION);
+    const meta = {
+      at: Date.now(),
+      title: String(form.get("title") ?? ""),
+      text: String(form.get("text") ?? ""),
+      url: String(form.get("url") ?? ""),
+      files: [],
+    };
+    const files = form.getAll("files").filter((f) => f && typeof f === "object" && "name" in f && f.size > 0);
+    for (const [i, f] of files.slice(0, SHARE_MAX_FILES).entries()) {
+      const key = `${SHARE_KEY}/${i}`;
+      await cache.put(key, new Response(f, { headers: { "content-type": f.type || "application/octet-stream" } }));
+      meta.files.push({ key, name: f.name || `file-${i + 1}`, type: f.type || "application/octet-stream" });
+    }
+    await cache.put(SHARE_KEY, new Response(JSON.stringify(meta), { headers: { "content-type": "application/json" } }));
+  } catch {
+    /* nothing to hand on: the app opens on an empty inbox rather than an error */
+  }
+  // Absolute, because `Response.redirect` rejects a bare path outright rather
+  // than resolving it -- so `${BASE}/mail` would throw here and the share
+  // would end at a browser error page instead of the inbox.
+  return Response.redirect(new URL(`${BASE}/mail?share=1`, self.location.origin).href, 303);
+}
+
 self.addEventListener("fetch", (event) => {
   const req = event.request;
+  if (req.method === "POST" && new URL(req.url).pathname === `${BASE}/share`) {
+    event.respondWith(stashShare(req));
+    return;
+  }
   if (req.method !== "GET") return;
   const url = new URL(req.url);
   if (url.origin !== self.location.origin) return;
   if (url.pathname.startsWith(`${BASE}/api/`)) return;
 
-  // Hashed build assets: cache-first.
-  if (url.pathname.startsWith(`${BASE}/assets/`)) {
+  // Hashed build assets: cache-first, and only what actually arrived.
+  if (url.pathname.startsWith(ASSETS)) {
     event.respondWith(
       caches.match(req).then((hit) => hit || fetch(req).then((res) => {
+        if (res.ok && res.type === "basic") {
           const copy = res.clone();
-        caches.open(VERSION).then((c) => c.put(req, copy));
+          event.waitUntil(caches.open(VERSION).then((c) => c.put(req, copy)).catch(() => {}));
+        }
         return res;
       }))
     );
     return;
   }
 
-  // Navigations & everything else: network-first, fall back to cached shell.
+  /*
+   * Navigations: the kept app page at once, and the network's behind it.
+   *
+   * Every route in the app is the same page, and waiting on the server for it
+   * cost a full round trip before anything could start -- the longest single
+   * wait on a distant link. So a route is answered from the kept copy when
+   * there is one, and the fresh page is fetched alongside to replace it for
+   * next time. A page that is a build behind is caught the way it always was:
+   * the version check reloads it (lib/sw/staleBuild.ts), and the assets it
+   * names are kept for one more build so it can run until then.
+   *
+   * Only the app's own routes (APP_ROUTE). The root, a page in front of the
+   * app, and a file opened in a tab of its own go to the network as before. So
+   * does the first visit, which has no copy yet.
+   */
   if (req.mode === "navigate") {
-    event.respondWith(fetch(req).catch(() => caches.match(`${BASE}/`)));
+    const network = fetch(req).then((res) => {
+      // Every route is the same app page; a fresh one replaces the offline copy.
+      if (res.ok && (res.headers.get("content-type") || "").startsWith("text/html")) {
+        event.waitUntil(refreshShell(res.clone()).catch(() => {}));
+      }
+      return res;
+    });
+    const appRoute = APP_ROUTE.test(url.pathname.slice(BASE.length));
+    event.respondWith((async () => {
+      const kept = appRoute ? await caches.match(SHELL_KEY) : undefined;
+      if (kept) {
+        event.waitUntil(network.catch(() => {}));
+        return kept;
+      }
+      return network.catch(() => caches.match(SHELL_KEY));
+    })());
     return;
   }
   event.respondWith(fetch(req).catch(() => caches.match(req)));
@@ -64,14 +312,23 @@ self.addEventListener("fetch", (event) => {
 
 /*
  * Stalwart signs with VAPID and pushes straight to the browser's push service;
- * nothing here talks to ihasmail's server. The payload is an EmailPush object
- * (draft-ietf-jmap-emailpush) carrying enough of the message to show a useful
- * notification without a round-trip — which matters, because when this fires
- * there may be no session to make one with.
+ * nothing here talks to ihasmail's server on the way in. The payload is an
+ * EmailPush object (draft-ietf-jmap-emailpush) carrying enough of the message
+ * to show a useful notification without a round-trip, which is what lets a
+ * notification appear immediately rather than after a request.
+ *
+ * This file used to say that a round-trip was impossible here, and it was
+ * wrong: see the note on `jmap()`. What it can do is ask; what it cannot do is
+ * be sure of an answer, since the session may be gone by the time it does. So
+ * the payload still carries the message and the request is only made when
+ * somebody presses something.
  *
  * A JMAP subscription also delivers a PushVerification first, and stays silent
- * until the client echoes its code back. That cannot be done from here (no
- * credentials), so it is stashed for a tab to collect and confirm.
+ * until the client echoes its code back. It is stashed for a tab to confirm
+ * rather than answered here — on the same reasoning, and because a
+ * verification that failed silently would leave push looking broken with
+ * nothing to show for it. Answering it directly is now possible and is worth
+ * revisiting.
  */
 
 /*
@@ -87,13 +344,90 @@ self.addEventListener("fetch", (event) => {
  */
 const VERIFY_KEY = `${BASE}/ihasmail-push-verification`;
 
-function textOf(email) {
+/*
+ * What a tab wrote down for this worker: the account, which mailbox is the
+ * archive, and the worker's own text in the reader's language. See
+ * `lib/swFacts.ts` for why any of that has to be handed over rather than
+ * worked out here.
+ *
+ * Everything that depends on it is skipped when it is missing, which is the
+ * state between installing this worker and next opening the app. An action
+ * button with no label, or one that files mail into a mailbox guessed by name,
+ * is worse than the notification that was here before.
+ */
+const FACTS_KEY = `${BASE}/ihasmail-worker-facts`;
+
+async function readFacts() {
+  try {
+    const hit = await (await caches.open(VERSION)).match(FACTS_KEY);
+    return hit ? await hit.json() : null;
+  } catch {
+    return null;
+  }
+}
+
+/*
+ * A JMAP call, made as the reader.
+ *
+ * This worker was written believing it could not do this -- that acting on
+ * mail needed a session it had no way to hold. It does not: ihasmail's session
+ * is an httpOnly cookie against its own origin, and the only other thing the
+ * API asks for is a fixed `x-requested-with` header that is not a secret and
+ * is not held anywhere. A same-origin fetch from here carries the cookie like
+ * any other, so `Email/set` from a notification is an ordinary request.
+ *
+ * What is genuinely not available is anything the *tab* holds in memory, and
+ * the answer is that the API asks for none of it.
+ *
+ * The session can still be gone -- expired, signed out, or a cookie that did
+ * not survive the browser closing -- which arrives as a 401 and is reported
+ * rather than swallowed. A tap that silently does nothing is the failure worth
+ * avoiding here: the reader has already put the phone down.
+ */
+async function jmap(methodCalls) {
+  const res = await fetch(`${BASE}/api/jmap`, {
+    method: "POST",
+    credentials: "same-origin",
+    headers: { "content-type": "application/json", accept: "application/json", "x-requested-with": "ihasmail" },
+    body: JSON.stringify({ using: ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"], methodCalls }),
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const body = await res.json();
+  // A JMAP method can fail inside a 200. Treat that as a failure too, rather
+  // than reporting success because the transport was fine.
+  const first = body?.methodResponses?.[0];
+  if (!first || first[0] === "error") throw new Error(first?.[1]?.type || "error");
+  const notUpdated = first[1]?.notUpdated;
+  if (notUpdated && Object.keys(notUpdated).length) throw new Error("notUpdated");
+  return body;
+}
+
+function textOf(email, strings) {
   const from = email?.from?.[0];
-  const who = from?.name || from?.email || "New message";
-  const what = email?.subject || "(no subject)";
+  const who = from?.name || from?.email || strings.newMessage;
+  const what = email?.subject || strings.noSubject;
   return { title: who, body: what, preview: email?.preview || "" };
 }
 
+/*
+ * Two, because that is what a phone shows. `Notification.maxActions` is 2 on
+ * Android Chrome, and anything past it is dropped silently -- so these are the
+ * two worth having rather than the two that happened to come first. Both are
+ * triage: they are what somebody does to a notification they have read the
+ * whole of on the lock screen and does not need to open.
+ *
+ * Reply is deliberately not among them. It cannot be done from here, so it
+ * would have to open the app -- and an action that opens the app is what
+ * tapping the notification already does.
+ */
+function actionsFor(facts) {
+  if (!facts) return [];
+  const actions = [];
+  if (facts.archiveId) actions.push({ action: "archive", title: facts.strings.archive });
+  actions.push({ action: "read", title: facts.strings.markRead });
+  return actions;
+}
+
 self.addEventListener("push", (event) => {
   let data = null;
   try {
@@ -120,10 +454,34 @@ self.addEventListener("push", (event) => {
 
   const emails = (data && data["@type"] === "EmailPush" && Array.isArray(data.emails)) ? data.emails : [];
   event.waitUntil((async () => {
+    /*
+     * Someone reading the app already knows. A focused, visible window of this
+     * app gets its new mail from its own event stream, so a notification on
+     * top of it is a second telling of the same thing (#375). Chrome does not
+     * require one while the site is in the foreground.
+     */
+    const windows = await self.clients.matchAll({ type: "window" });
+    if (windows.some((w) => w.focused && w.visibilityState === "visible")) return;
+    const facts = await readFacts();
+    const strings = facts?.strings ?? { newMail: "New mail", newMessage: "New message", noSubject: "(no subject)" };
+    /*
+     * Mark the app icon, without claiming a number.
+     *
+     * `setAppBadge()` with no count shows a dot rather than a figure, which is
+     * the only honest thing to show from here: this worker has no session, so
+     * it cannot ask how many messages are unread, and a push carries the new
+     * mail rather than a total. Counting the payload would badge "2" over an
+     * inbox holding forty. The next time a tab opens, `setUnreadBadge` writes
+     * the real count over the dot.
+     */
+    if ("setAppBadge" in self.navigator) await self.navigator.setAppBadge().catch(() => {});
+
     if (!emails.length) {
-      // A StateChange, or a payload too large to carry the message. Say
-      // something true rather than inventing a sender.
-      await self.registration.showNotification("New mail", {
+      // A delivery from a server that sends StateChange rather than EmailPush
+      // -- the subscription asks for `EmailDelivery` only, so it is new mail --
+      // or a payload too large to carry the message. Say something true
+      // rather than inventing a sender.
+      await self.registration.showNotification(strings.newMail, {
         icon: `${BASE}/img/icon-192.png`, badge: `${BASE}/img/favicon-64.png`, tag: "ihasmail-mail", data: { url: `${BASE}/mail` },
       });
       return;
@@ -131,21 +489,70 @@ self.addEventListener("push", (event) => {
     // One notification per message, collapsing repeats of the same message by
     // tag so a re-push does not stack.
     for (const email of emails.slice(0, 5)) {
-      const { title, body, preview } = textOf(email);
+      const { title, body, preview } = textOf(email, strings);
       await self.registration.showNotification(title, {
         body: preview ? `${body}\n${preview}` : body,
         icon: `${BASE}/img/icon-192.png`,
         badge: `${BASE}/img/favicon-64.png`,
         tag: `ihasmail-${email.id || body}`,
-        data: { url: email.id ? `${BASE}/mail/inbox/${email.id}` : `${BASE}/mail` },
+        // Only where there is a message to act on: a payload without an id can
+        // be shown but not archived, and a button that cannot work should not
+        // be drawn.
+        actions: email.id ? actionsFor(facts) : [],
+        data: {
+          // The route names a conversation, and `m` the message in it.
+          url: email.id && email.threadId ? `${BASE}/mail/inbox/${email.threadId}?m=${encodeURIComponent(email.id)}` : `${BASE}/mail`,
+          id: email.id || null,
+          title,
+          accountId: facts?.accountId ?? null,
+          archiveId: facts?.archiveId ?? null,
+          failed: strings.failed ?? null,
+        },
       });
     }
   })());
 });
 
+/*
+ * Do what the button said, without opening anything.
+ *
+ * The whole point of an action is that the phone goes back in the pocket, so
+ * this must not fall back to opening the app when the call fails -- that is
+ * the same interruption the action existed to avoid. It re-notifies instead,
+ * saying it did not happen, and leaves opening ihasmail to the reader.
+ *
+ * Archiving replaces the mailbox set rather than adding to it, which is what
+ * archiving is: the message leaves the inbox. Marking read is a keyword and
+ * touches nothing else.
+ */
+async function runAction(action, data) {
+  const { id, accountId, archiveId } = data;
+  if (!id || !accountId) return;
+  const patch = action === "archive"
+    ? { mailboxIds: { [archiveId]: true } }
+    : { "keywords/$seen": true };
+  try {
+    if (action === "archive" && !archiveId) throw new Error("no archive mailbox");
+    await jmap([["Email/set", { accountId, update: { [id]: patch } }, "0"]]);
+  } catch {
+    await self.registration.showNotification(data.title || "ihasmail", {
+      body: data.failed || "Could not do that — open ihasmail and try again",
+      icon: `${BASE}/img/icon-192.png`,
+      badge: `${BASE}/img/favicon-64.png`,
+      tag: `ihasmail-failed-${id}`,
+      data: { url: data.url },
+    });
+  }
+}
+
 self.addEventListener("notificationclick", (event) => {
   event.notification.close();
-  const url = event.notification.data?.url || `${BASE}/mail`;
+  const data = event.notification.data || {};
+  if (event.action === "archive" || event.action === "read") {
+    event.waitUntil(runAction(event.action, data));
+    return;
+  }
+  const url = data.url || `${BASE}/mail`;
   event.waitUntil((async () => {
     const clients = await self.clients.matchAll({ includeUncontrolled: true, type: "window" });
     // Reuse a tab if one is open rather than piling up windows. Same origin is

web/src/App.tsx

@@ -16,11 +16,12 @@ import { LoginPage } from "@/views/Login";
 import { AppShell } from "@/views/AppShell";
 import { MailView } from "@/views/mail/MailView";
 import { ComposerDock } from "@/views/compose/ComposerDock";
-import { setUnreadBadge } from "@/lib/notify";
+import { requestNotificationPermission, setBaseTitle, setUnreadBadge } from "@/lib/notify/notify";
+import { publishWorkerFacts } from "@/lib/sw/swFacts";
 import { PAINTED_FROM_CACHE, useSettings, syncedPart } from "@/store/settings";
 import { armSettingsSync, loadRemoteSettings, queueSettingsPush, settingsAlreadyLoadedFor, settingsSyncAvailable } from "@/lib/settingsSync";
 import { loadSettingsPolicy } from "@/lib/settingsPolicy";
-import { listenForVerification, renewWebPush } from "@/lib/webpushEnable";
+import { listenForVerification, renewWebPush } from "@/lib/notify/webpushEnable";
 import { plural, t, useLanguageVersion, whenLanguageReady } from "@/lib/i18n";
 import { confirmLeaveUnsaved, hasUnsavedChanges } from "@/lib/unsavedChanges";
 import { BASE_PATH, withBase } from "@/lib/basePath";
@@ -30,6 +31,8 @@ const ContactsView = lazy(() => import("@/views/contacts/ContactsView").then((m)
 const CalendarView = lazy(() => import("@/views/calendar/CalendarView").then((m) => ({ default: m.CalendarView })));
 const FilesView = lazy(() => import("@/views/files/FilesView").then((m) => ({ default: m.FilesView })));
 const SettingsView = lazy(() => import("@/views/settings/SettingsView").then((m) => ({ default: m.SettingsView })));
+// Only ever opened by the few who administer, so nobody else downloads it.
+const AdminView = lazy(() => import("@/views/admin/AdminView").then((m) => ({ default: m.AdminView })));
 
 export function App() {
   const status = useSession((s) => s.status);
@@ -41,7 +44,7 @@ export function App() {
    * knowing its strings just changed. Rather than make every one of the
    * thousand call sites a subscriber -- which would turn extracting a string
    * from "wrap it" into "wrap it and add a hook" -- the whole tree is thrown
-   * away and rebuilt when the catalogue changes. Picking a language is a
+   * away and rebuilt when the catalog changes. Picking a language is a
    * once-in-an-account event; paying for it there is far cheaper than paying
    * for it on every render everywhere.
    */
@@ -51,9 +54,9 @@ export function App() {
   }, [bootstrap]);
 
   /*
-   * Wait for the catalogue before the first paint.
+   * Wait for the catalog before the first paint.
    *
-   * The tree is rebuilt when a catalogue lands, so components recover on
+   * The tree is rebuilt when a catalog lands, so components recover on
    * their own -- but a string computed in an effect does not. A toast fired
    * in the gap is emitted in English and stays English, in an interface that
    * is otherwise not. The wait costs nothing visible: the session bootstrap
@@ -126,7 +129,7 @@ function AuthedApp() {
    * or the sign-out that every deploy causes -- the first frame is the
    * defaults, and the defaults are English. Rendering then means anything
    * computed before the settings land is computed in the wrong language: not
-   * the interface, which is rebuilt when the catalogue arrives, but a string
+   * the interface, which is rebuilt when the catalog arrives, but a string
    * emitted once, like a toast. That is why the stale-folder toast came out
    * in English on an otherwise German screen.
    *
@@ -145,14 +148,14 @@ function AuthedApp() {
       setReady(true);
       return;
     }
-    let cancelled = false;
+    let canceled = false;
     void (async () => {
       /* Before the account's own settings, so both the seeding below and the
          enforcement inside `hydrate` have something to apply. */
       await loadSettingsPolicy();
-      if (cancelled) return;
+      if (canceled) return;
       const remote = await loadRemoteSettings();
-      if (cancelled) return;
+      if (canceled) return;
       if (remote) useSettings.getState().hydrate(remote);
       // No settings file: this account has never had settings of its own, so
       // the installation's defaults are what it starts on rather than
@@ -171,10 +174,10 @@ function AuthedApp() {
           other: "Your administrator changed {n} settings",
         }), { action: { label: t("Settings"), onClick: () => { window.location.href = withBase("/settings/general"); } } });
       }
-      // The catalogue for whatever language that turned out to be. Hydrating
+      // The catalog for whatever language that turned out to be. Hydrating
       // asks for it; this is waiting for the answer.
       await whenLanguageReady();
-      if (cancelled) return;
+      if (canceled) return;
       setReady(true);
       // Pushes were held back until now so they could not race the load. A
       // change made while it was in flight was kept, and goes out here.
@@ -184,7 +187,7 @@ function AuthedApp() {
       if (!remote && settingsSyncAvailable()) queueSettingsPush(syncedPart(useSettings.getState().settings));
     })();
     return () => {
-      cancelled = true;
+      canceled = true;
     };
   }, [accountId]);
 
@@ -257,16 +260,29 @@ function AuthedApp() {
   });
   const appName = useSession((s) => s.session?.ihasmail?.appName) || DEFAULT_APP_NAME;
   useEffect(() => {
-    void import("@/lib/notify").then((m) => {
-      m.setBaseTitle(appName);
+    setBaseTitle(appName);
     setUnreadBadge(inboxUnread);
-    });
   }, [inboxUnread, appName]);
 
+  /*
+   * Leave the service worker its briefing.
+   *
+   * Written from here rather than once at startup because everything in it can
+   * change while the app is open -- the language from Settings, the archive
+   * folder from the mailbox list arriving -- and what is written is what the
+   * worker will still be reading a week from now, with no tab to correct it.
+   * See lib/swFacts.ts.
+   */
+  const archiveId = useMail((s) => s.roleId("archive"));
+  const languageVersion = useLanguageVersion();
+  useEffect(() => {
+    void publishWorkerFacts(accountId, archiveId);
+  }, [accountId, archiveId, languageVersion]);
+
   // Request notification permission lazily when enabled
   const notif = useSettings((s) => s.settings.desktopNotifications);
   useEffect(() => {
-    if (notif) void import("@/lib/notify").then((m) => m.requestNotificationPermission());
+    if (notif) void requestNotificationPermission();
   }, [notif]);
 
   // Nothing worth painting until the account's settings are in force; see the
@@ -289,6 +305,7 @@ function AuthedApp() {
           <Route path="/calendar/:view?/:date?">{(p) => <CalendarView view={p.view} date={p.date} />}</Route>
           <Route path="/files/:nodeId?">{(p) => <FilesView nodeId={p.nodeId} />}</Route>
           <Route path="/settings/:section?">{(p) => <SettingsView section={p.section} />}</Route>
+          <Route path="/admin/:section?/:id?">{(p) => <AdminView section={p.section} id={p.id} />}</Route>
           <Route path="/login">
             <Redirect to="/mail" />
           </Route>

web/src/jmap/client.ts

@@ -19,6 +19,9 @@ export const CAP = {
   websocket: "urn:ietf:params:jmap:websocket",
 } as const;
 
+/** Stalwart's own capability, which carries its `x:` registry methods. */
+export const STALWART_CAP = "urn:stalwart:jmap";
+
 export class JmapMethodError extends Error {
   constructor(
     public readonly method: string,
@@ -101,6 +104,8 @@ export class JmapClient {
   private callCounter = 0;
   private unauthHandlers = new Set<() => void>();
   private stateHandlers = new Set<(sessionState: string) => void>();
+  /** The last session state announced, so a burst of replies announces it once. */
+  private announcedState: string | null = null;
 
   get maxCallsInRequest(): number {
     const core = this.session?.capabilities[CAP.core] as { maxCallsInRequest?: number } | undefined;
@@ -252,7 +257,8 @@ export class JmapClient {
     const body: Record<string, unknown> = { using: this.supportedUsing(using), methodCalls };
     if (createdIds) body.createdIds = createdIds;
     const res = await apiFetch<JmapResponse>("/api/jmap", { method: "POST", body: JSON.stringify(body) });
-    if (res.sessionState && this.session && res.sessionState !== this.session.state) {
+    if (res.sessionState && this.session && res.sessionState !== this.session.state && res.sessionState !== this.announcedState) {
+      this.announcedState = res.sessionState;
       for (const fn of this.stateHandlers) fn(res.sessionState);
     }
     return res;
@@ -318,7 +324,7 @@ export class JmapClient {
         else reject(new ApiError(xhr.status, (xhr.response as ApiErrorBody)?.error ?? "upload_failed", (xhr.response as ApiErrorBody)?.message ?? "Upload failed"));
       };
       xhr.onerror = () => reject(new ApiError(0, "network_error", "Network error during upload"));
-      xhr.onabort = () => reject(new ApiError(0, "aborted", "Upload cancelled"));
+      xhr.onabort = () => reject(new ApiError(0, "aborted", "Upload canceled"));
       opts.signal?.addEventListener("abort", () => xhr.abort());
       xhr.send(data);
     });
@@ -349,6 +355,9 @@ export class JmapClient {
 /** Map method name prefix → required capability URNs. */
 function usingFor(method: string): string[] {
   const type = method.split("/")[0] ?? "";
+  // Stalwart's registry: accounts, domains, credentials. Advertised per
+  // account rather than in the session, which supportedUsing() allows for.
+  if (type.startsWith("x:")) return [STALWART_CAP];
   switch (type) {
     case "Mailbox":
     case "Thread":

web/src/jmap/types.ts

@@ -38,7 +38,24 @@ export interface JmapSession {
     server?: {
       /** "oss" | "community" | "enterprise". Stalwart publishes no version. */
       edition?: string | null;
+      /** Where Stalwart's own administration is (STALWART_ADMIN_URL), for a session that may administer. */
+      adminUrl?: string | null;
+      /** SHOW_ENTERPRISE_NOTICES: an Enterprise-only section says so even on Enterprise. */
+      enterpriseNotices?: boolean;
     };
+    /**
+     * False when this session may not administer: the operator turned it off,
+     * or the session was signed in without "This is my own device".
+     */
+    administration?: boolean;
+    /** An administrator on a device not marked as their own; the menu says so. */
+    administrationNeedsOwnDevice?: boolean;
+    /**
+     * The account's effective permissions on that server, as Stalwart reports
+     * them. What the client offers is shaped by these; what is allowed is
+     * decided by Stalwart on every call.
+     */
+    permissions?: string[];
   };
 }
 

web/src/lib/__tests__/address.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { formatAddress, initials, isValidEmail, parseAddressList, parseMailto } from "../address";
+import { displayName, formatAddress, initials, isValidEmail, parseAddressList, parseMailto } from "../address";
 
 describe("address parsing", () => {
   it("parses mixed lists", () => {
@@ -55,3 +55,14 @@ describe("mailto URLs", () => {
     expect(m.to).toHaveLength(1);
   });
 });
+
+describe("names that reorder themselves", () => {
+  const spoof = { name: "[email protected]\u202E", email: "[email protected]" };
+  it("lose their direction controls when displayed", () => {
+    expect(displayName({ name: "\u202Egnp.exe\u202C Ann", email: "[email protected]" })).toBe("gnp.exe Ann");
+    expect(formatAddress(spoof)).toBe("[email protected] <[email protected]>");
+  });
+  it("fall back to the address when nothing else is left", () => {
+    expect(displayName({ name: "\u200F\u202E", email: "[email protected]" })).toBe("[email protected]");
+  });
+});

web/src/lib/__tests__/app-name-strings.test.ts

@@ -0,0 +1,73 @@
+/*
+ * An instance renamed with APP_NAME should be called by its name everywhere,
+ * not only on the sign-in page and in the title bar. So no sentence shown to
+ * a person may write "ihasmail" into itself: it takes the name as {app}.
+ *
+ * The exceptions are the places where "ihasmail" is not the app's name but a
+ * literal a person could go and look at: the Files folder, the Sieve script
+ * and the project's own address. Renaming those would rename real data.
+ */
+import { describe, expect, it } from "vitest";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SRC = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+
+/** Strings that name a stored thing, not the app. */
+const LITERALS = [
+  "Images are stored in your Files (folder “ihasmail”) and embedded when you send.",
+  "“{name}” will be deactivated (not deleted) and a new “ihasmail” script will take over.",
+  "Another script (“{name}”) is active. Saving rules here will activate the “ihasmail” script instead.",
+  "ihasmail.org",
+  "ihasmail",
+];
+
+function sources(dir: string, out: string[] = []): string[] {
+  for (const name of readdirSync(dir)) {
+    const path = join(dir, name);
+    if (statSync(path).isDirectory()) {
+      if (name === "locales" || name === "__tests__") continue;
+      sources(path, out);
+    } else if (/\.tsx?$/.test(name)) {
+      out.push(path);
+    }
+  }
+  return out;
+}
+
+/** Every translated string in a file, however `t` was imported. */
+function translatedStrings(code: string): string[] {
+  return [...code.matchAll(/\b(?:t|tNode|translate)\(\s*"((?:[^"\\]|\\.)*)"/g)].map((m) =>
+    JSON.parse(`"${m[1]}"`),
+  );
+}
+
+describe("text that names the app", () => {
+  it("takes the name as {app} instead of writing ihasmail into the sentence", () => {
+    const offenders: string[] = [];
+    for (const file of sources(SRC)) {
+      for (const s of translatedStrings(readFileSync(file, "utf8"))) {
+        if (s.includes("ihasmail") && !LITERALS.includes(s)) {
+          offenders.push(`${file.slice(SRC.length)}: ${s.slice(0, 60)}`);
+        }
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it("keeps a placeholder in every translation of those strings", () => {
+    const catalogs = readdirSync(join(SRC, "locales")).filter((f) => f.endsWith(".ts") && f !== "index.ts");
+    const wrong: string[] = [];
+    for (const name of catalogs) {
+      const code = readFileSync(join(SRC, "locales", name), "utf8");
+      for (const m of code.matchAll(/^\s*"((?:[^"\\]|\\.)*)": "((?:[^"\\]|\\.)*)",$/gm)) {
+        const key = JSON.parse(`"${m[1]}"`);
+        const value = JSON.parse(`"${m[2]}"`);
+        // A key that takes the name must not hard-code it in the translation.
+        if (key.includes("{app}") && value.includes("ihasmail")) wrong.push(`${name}: ${key.slice(0, 50)}`);
+      }
+    }
+    expect(wrong).toEqual([]);
+  });
+});

web/src/lib/__tests__/birthdays.test.ts

@@ -73,7 +73,7 @@ describe("birthdaysInRange", () => {
     expect(birthdaysInRange([card("c2", "", { month: 6, day: 15 })], s, e)).toEqual([]);
   });
 
-  it("falls back to a name built from components, then to the organisation", () => {
+  it("falls back to a name built from components, then to the organization", () => {
     const [s, e] = range("2026-01-01", "2027-01-01");
     const parts = {
       id: "c1",
@@ -115,7 +115,7 @@ describe("birthdaysInRange", () => {
     expect(out.map((b) => b.name)).toEqual(["Amy", "Zoe"]);
   });
 
-  it("gives each occurrence a stable, unique id that marks it as synthesised", () => {
+  it("gives each occurrence a stable, unique id that marks it as synthesized", () => {
     const [s, e] = range("2025-01-01", "2027-01-01");
     const out = birthdaysInRange([card("c1", "Ada", { month: 6, day: 15 })], s, e);
     expect(new Set(out.map((b) => b.id)).size).toBe(out.length);

web/src/lib/__tests__/brand.test.ts

@@ -6,7 +6,7 @@ import { DEFAULT_APP_NAME } from "@/lib/brand";
  *
  * `APP_NAME` is a runtime variable, so every place showing the name has to ask
  * the server rather than have it written in. The sign-in page did not (#236's
- * neighbour): it fetched `/api/config`, received the name and used only
+ * neighbor): it fetched `/api/config`, received the name and used only
  * `sourceUrl`, so a rebranded instance still said "ihasmail" on the page a new
  * user meets first. These pin the shape of the answer rather than the name.
  */

web/src/lib/__tests__/contacts.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { contactFromAddress, nameParts } from "../contacts";
+import { contactFromAddress, contactPhoto, nameParts, withPhoto } from "../contacts";
 import type { ContactCard } from "@/jmap/types";
 
 const parts = (name: string | null, email = "[email protected]") =>
@@ -34,3 +34,35 @@ describe("contactFromAddress", () => {
     expect(contactFromAddress({ name: "   ", email: "[email protected]" }).name).toBeUndefined();
   });
 });
+
+/**
+ * #376: a photo saved as a `blobId` was refused by Stalwart, which only takes
+ * the `uri` form. Saving one must also leave a card's other media alone.
+ */
+describe("withPhoto", () => {
+  const photo = { dataUrl: "data:image/jpeg;base64,AAAA", type: "image/jpeg" };
+
+  it("puts the photo in as a data URI, never a blob id", () => {
+    const media = withPhoto(undefined, photo)!;
+    const [m] = Object.values(media);
+    expect(m).toEqual({ "@type": "Media", kind: "photo", uri: photo.dataUrl, mediaType: "image/jpeg" });
+    expect(m).not.toHaveProperty("blobId");
+  });
+
+  it("replaces an existing photo and keeps a logo", () => {
+    const media = withPhoto({ old: { kind: "photo", blobId: "b1" }, l: { kind: "logo", uri: "data:image/png;base64,BB" } }, photo)!;
+    expect(Object.values(media).filter((m) => m.kind === "photo")).toHaveLength(1);
+    expect(media.old).toBeUndefined();
+    expect(media.l).toEqual({ kind: "logo", uri: "data:image/png;base64,BB" });
+  });
+
+  it("removes only the photo, and clears media when nothing is left", () => {
+    expect(withPhoto({ p: { kind: "photo", uri: "data:x" }, s: { kind: "sound", uri: "data:y" } }, null)).toEqual({ s: { kind: "sound", uri: "data:y" } });
+    expect(withPhoto({ p: { kind: "photo", uri: "data:x" } }, null)).toBeNull();
+  });
+
+  it("is read back by contactPhoto", () => {
+    const card = { id: "c1", media: withPhoto(undefined, photo) } as unknown as ContactCard;
+    expect(contactPhoto(card, "a1")).toBe(photo.dataUrl);
+  });
+});