chore(main): release 3.97.4-beta.0 (#918 )

fix(admin): stop marking events expired up to 24h early (#909 ) (#916 )
differenceInDays truncates to whole days, so an event expiring in a few hours returned 0 and three admin surfaces treated it as gone: - EventsListPage: status chip said 'Expired' (days <= 0) while the public gallery — which compares real timestamps — correctly showed 'expires in X hours'. This is the reporter's exact symptom. - EventDetailsPage: same isExpired math on the detail view. - AdminDashboard: the expiring-soon card showed '0 days left' on the final day. Expired is now gated on the actual timestamp (expires_at <= now), and the countdown chips use ceiling days so the last day reads '1 day left' instead of flipping to Expired/0. Co-authored-by: Paul Nothaft <paul@MacStudio-von-Paul.local>
2026-07-29 20:26:14 +00:00 · 2026-07-29 22:23:55 +02:00 · 2026-07-29 22:23:38 +02:00 · 2026-07-29 19:48:17 +00:00 · 2026-07-29 21:32:33 +02:00 · 2026-07-29 16:02:10 +00:00
328 changed files with 13837 additions and 14140 deletions
@@ -10,6 +10,14 @@ NODE_ENV=production
 # Generate one with: openssl rand -base64 64
 #JWT_SECRET=your_very_long_random_jwt_secret_here

+# OIDC SSO for admins (#798) — configured in the admin UI; only these two
+# values live in the environment:
+# Key encrypting the OIDC client secret at rest (defaults to JWT_SECRET).
+#OIDC_ENCRYPTION_KEY=
+# Break-glass: 'true' re-enables local password login even while the SSO
+# settings disable it (recovery when the IdP is down or misconfigured).
+#OIDC_BREAK_GLASS=false
+
 # Auth cookie Secure flag
 #   unset  - default: follows NODE_ENV (production=true, dev=false)
 #   true   - always set Secure (HTTPS-only cookies; breaks plain-HTTP access)
@@ -56,9 +64,8 @@ DB_NAME=picpeak_prod
 # Admin Account (initial setup) — OPTIONAL
 # Leave these unset (default) to create your admin IN THE BROWSER on first run:
 # open /admin and PicPeak shows a setup screen. The one-time setup token is
-# written to data/SETUP_TOKEN with mode 0600 — read it with
-# `docker compose exec backend cat /app/data/SETUP_TOKEN`. It is NOT logged
-# unless that write fails, so it never sits in `docker logs`.
+# printed to the backend logs (`docker compose logs backend | grep -i "setup token"`)
+# and saved to data/SETUP_TOKEN.
 # Set ADMIN_PASSWORD to auto-create the admin on first boot instead (legacy;
 # credentials written to data/ADMIN_CREDENTIALS.txt).
 #ADMIN_USERNAME=admin
@@ -107,6 +114,11 @@ VITE_API_URL=/api
 # DB_PORT=5432
 # REDIS_PORT=6379

+# File watcher (watch-folder auto-import, local storage only)
+# Max photos processed in parallel — raise on hosts with memory headroom,
+# lower to 1 on very small hosts. Default: 2
+# FILE_WATCHER_CONCURRENCY=2
+
 # Release Channel
 # Options: 'stable' (default), 'beta', or specific version like 'v2.3.0'
 # 'stable' uses the :stable tag (same as :latest on main)
@@ -95,6 +95,15 @@ jobs:
        repo_lc="${GITHUB_REPOSITORY,,}"
        echo "BACKEND_IMAGE_NAME=${repo_lc}/backend" >> "$GITHUB_ENV"
        echo "FRONTEND_IMAGE_NAME=${repo_lc}/frontend" >> "$GITHUB_ENV"
+        # Mirror manifests to Docker Hub (picpeak/{backend,frontend}) only on the
+        # canonical org repo, where the DOCKERHUB_* secrets live. Forks (and any
+        # other owner) fall back to GHCR-only — the Docker Hub image line and login
+        # are gated on this flag so their builds keep working unchanged.
+        if [[ "$GITHUB_REPOSITORY" == "PicPeak/picpeak" ]]; then
+          echo "DOCKERHUB_ENABLED=true" >> "$GITHUB_ENV"
+        else
+          echo "DOCKERHUB_ENABLED=false" >> "$GITHUB_ENV"
+        fi

    - name: Prepare platform pair
      run: |
@@ -203,14 +212,6 @@ jobs:
        format: 'sarif'
        output: 'trivy-backend-${{ env.PLATFORM_PAIR }}.sarif'
        severity: 'CRITICAL,HIGH'
-        # Base-image CVEs with no released fix are not actionable: the
-        # Dockerfiles already run `apt-get upgrade -y` behind a CACHEBUST,
-        # so a fix lands in the next build automatically. Reporting them
-        # buries the findings someone can actually do something about.
-        # Dropping them is also the precondition for ever setting
-        # exit-code: 1, which build-backend's comment flags as a
-        # deliberate follow-up.
-        ignore-unfixed: true
        timeout: '10m'

    - name: Upload Trivy scan results to GitHub Security tab
@@ -241,6 +242,15 @@ jobs:
        repo_lc="${GITHUB_REPOSITORY,,}"
        echo "BACKEND_IMAGE_NAME=${repo_lc}/backend" >> "$GITHUB_ENV"
        echo "FRONTEND_IMAGE_NAME=${repo_lc}/frontend" >> "$GITHUB_ENV"
+        # Mirror manifests to Docker Hub (picpeak/{backend,frontend}) only on the
+        # canonical org repo, where the DOCKERHUB_* secrets live. Forks (and any
+        # other owner) fall back to GHCR-only — the Docker Hub image line and login
+        # are gated on this flag so their builds keep working unchanged.
+        if [[ "$GITHUB_REPOSITORY" == "PicPeak/picpeak" ]]; then
+          echo "DOCKERHUB_ENABLED=true" >> "$GITHUB_ENV"
+        else
+          echo "DOCKERHUB_ENABLED=false" >> "$GITHUB_ENV"
+        fi

    - name: Download digest artifacts
      uses: actions/download-artifact@v4
@@ -274,11 +284,24 @@ jobs:
          echo "is_prerelease=false" >> $GITHUB_OUTPUT
        fi

+    - name: Log in to Docker Hub
+      if: env.DOCKERHUB_ENABLED == 'true'
+      uses: docker/login-action@v3
+      with:
+        registry: docker.io
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
+
    - name: Extract metadata for Backend
      id: meta-backend
      uses: docker/metadata-action@v5
      with:
-        images: ${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}
+        # GHCR always; Docker Hub (picpeak/backend) added on the canonical repo so
+        # the same tag scheme is mirrored to both registries. metadata-action drops
+        # the blank second line on forks → GHCR-only there.
+        images: |
+          ${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}
+          ${{ env.DOCKERHUB_ENABLED == 'true' && 'docker.io/picpeak/backend' || '' }}
        labels: |
          org.opencontainers.image.title=PicPeak Backend
          org.opencontainers.image.description=PicPeak photo sharing platform backend service
@@ -290,6 +313,10 @@ jobs:
          type=semver,pattern={{version}}
          type=semver,pattern={{major}}.{{minor}},enable=${{ steps.context.outputs.is_prerelease == 'false' }}
          type=semver,pattern={{major}},enable=${{ steps.context.outputs.is_prerelease == 'false' }}
+          # #668/#783: publish the git-tag name verbatim (v3.45.0 / v3.84.0-beta.0)
+          # so users can pin the same string as the GitHub release. metadata-action's
+          # `pattern=v{{version}}` silently dropped it on prereleases, so use type=ref.
+          type=ref,event=tag
          type=sha,format=short
          # `:latest` + `:stable` follow the stable channel (the `stable` branch +
          # stable release tags). The default branch is now `main` (active dev),
@@ -306,10 +333,15 @@ jobs:
        docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
          $(printf "${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}@sha256:%s " *)

-    - name: Inspect manifest
+    - name: Inspect manifest (GHCR)
      run: |
        docker buildx imagetools inspect ${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}:${{ steps.meta-backend.outputs.version }}

+    - name: Inspect manifest (Docker Hub)
+      if: env.DOCKERHUB_ENABLED == 'true'
+      run: |
+        docker buildx imagetools inspect docker.io/picpeak/backend:${{ steps.meta-backend.outputs.version }}
+
  # -----------------------------------------------------------------------------
  # Frontend: per-arch build, then merge into a multi-arch manifest
  # -----------------------------------------------------------------------------
@@ -339,6 +371,15 @@ jobs:
        repo_lc="${GITHUB_REPOSITORY,,}"
        echo "BACKEND_IMAGE_NAME=${repo_lc}/backend" >> "$GITHUB_ENV"
        echo "FRONTEND_IMAGE_NAME=${repo_lc}/frontend" >> "$GITHUB_ENV"
+        # Mirror manifests to Docker Hub (picpeak/{backend,frontend}) only on the
+        # canonical org repo, where the DOCKERHUB_* secrets live. Forks (and any
+        # other owner) fall back to GHCR-only — the Docker Hub image line and login
+        # are gated on this flag so their builds keep working unchanged.
+        if [[ "$GITHUB_REPOSITORY" == "PicPeak/picpeak" ]]; then
+          echo "DOCKERHUB_ENABLED=true" >> "$GITHUB_ENV"
+        else
+          echo "DOCKERHUB_ENABLED=false" >> "$GITHUB_ENV"
+        fi

    - name: Prepare platform pair
      run: |
@@ -433,14 +474,6 @@ jobs:
        format: 'sarif'
        output: 'trivy-frontend-${{ env.PLATFORM_PAIR }}.sarif'
        severity: 'CRITICAL,HIGH'
-        # Base-image CVEs with no released fix are not actionable: the
-        # Dockerfiles already run `apt-get upgrade -y` behind a CACHEBUST,
-        # so a fix lands in the next build automatically. Reporting them
-        # buries the findings someone can actually do something about.
-        # Dropping them is also the precondition for ever setting
-        # exit-code: 1, which build-backend's comment flags as a
-        # deliberate follow-up.
-        ignore-unfixed: true
        timeout: '10m'

    - name: Upload Trivy scan results to GitHub Security tab
@@ -466,6 +499,15 @@ jobs:
        repo_lc="${GITHUB_REPOSITORY,,}"
        echo "BACKEND_IMAGE_NAME=${repo_lc}/backend" >> "$GITHUB_ENV"
        echo "FRONTEND_IMAGE_NAME=${repo_lc}/frontend" >> "$GITHUB_ENV"
+        # Mirror manifests to Docker Hub (picpeak/{backend,frontend}) only on the
+        # canonical org repo, where the DOCKERHUB_* secrets live. Forks (and any
+        # other owner) fall back to GHCR-only — the Docker Hub image line and login
+        # are gated on this flag so their builds keep working unchanged.
+        if [[ "$GITHUB_REPOSITORY" == "PicPeak/picpeak" ]]; then
+          echo "DOCKERHUB_ENABLED=true" >> "$GITHUB_ENV"
+        else
+          echo "DOCKERHUB_ENABLED=false" >> "$GITHUB_ENV"
+        fi

    - name: Download digest artifacts
      uses: actions/download-artifact@v4
@@ -499,11 +541,24 @@ jobs:
          echo "is_prerelease=false" >> $GITHUB_OUTPUT
        fi

+    - name: Log in to Docker Hub
+      if: env.DOCKERHUB_ENABLED == 'true'
+      uses: docker/login-action@v3
+      with:
+        registry: docker.io
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
+
    - name: Extract metadata for Frontend
      id: meta-frontend
      uses: docker/metadata-action@v5
      with:
-        images: ${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}
+        # GHCR always; Docker Hub (picpeak/frontend) added on the canonical repo so
+        # the same tag scheme is mirrored to both registries. metadata-action drops
+        # the blank second line on forks → GHCR-only there.
+        images: |
+          ${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}
+          ${{ env.DOCKERHUB_ENABLED == 'true' && 'docker.io/picpeak/frontend' || '' }}
        labels: |
          org.opencontainers.image.title=PicPeak Frontend
          org.opencontainers.image.description=PicPeak photo sharing platform frontend application
@@ -515,6 +570,10 @@ jobs:
          type=semver,pattern={{version}}
          type=semver,pattern={{major}}.{{minor}},enable=${{ steps.context.outputs.is_prerelease == 'false' }}
          type=semver,pattern={{major}},enable=${{ steps.context.outputs.is_prerelease == 'false' }}
+          # #668/#783: publish the git-tag name verbatim (v3.45.0 / v3.84.0-beta.0)
+          # so users can pin the same string as the GitHub release. metadata-action's
+          # `pattern=v{{version}}` silently dropped it on prereleases, so use type=ref.
+          type=ref,event=tag
          type=sha,format=short
          # `:latest` + `:stable` follow the stable channel (the `stable` branch +
          # stable release tags). The default branch is now `main` (active dev),
@@ -531,10 +590,15 @@ jobs:
        docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
          $(printf "${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}@sha256:%s " *)

-    - name: Inspect manifest
+    - name: Inspect manifest (GHCR)
      run: |
        docker buildx imagetools inspect ${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}:${{ steps.meta-frontend.outputs.version }}

+    - name: Inspect manifest (Docker Hub)
+      if: env.DOCKERHUB_ENABLED == 'true'
+      run: |
+        docker buildx imagetools inspect docker.io/picpeak/frontend:${{ steps.meta-frontend.outputs.version }}
+
  summary:
    needs: [build-backend, merge-backend, build-frontend, merge-frontend]
    if: always()
@@ -548,6 +612,15 @@ jobs:
        repo_lc="${GITHUB_REPOSITORY,,}"
        echo "BACKEND_IMAGE_NAME=${repo_lc}/backend" >> "$GITHUB_ENV"
        echo "FRONTEND_IMAGE_NAME=${repo_lc}/frontend" >> "$GITHUB_ENV"
+        # Mirror manifests to Docker Hub (picpeak/{backend,frontend}) only on the
+        # canonical org repo, where the DOCKERHUB_* secrets live. Forks (and any
+        # other owner) fall back to GHCR-only — the Docker Hub image line and login
+        # are gated on this flag so their builds keep working unchanged.
+        if [[ "$GITHUB_REPOSITORY" == "PicPeak/picpeak" ]]; then
+          echo "DOCKERHUB_ENABLED=true" >> "$GITHUB_ENV"
+        else
+          echo "DOCKERHUB_ENABLED=false" >> "$GITHUB_ENV"
+        fi

    - name: Build Summary
      run: |
@@ -586,6 +659,10 @@ jobs:
        echo "### 📦 Images" >> $GITHUB_STEP_SUMMARY
        echo "- Backend: \`${{ env.REGISTRY }}/${{ env.BACKEND_IMAGE_NAME }}\`" >> $GITHUB_STEP_SUMMARY
        echo "- Frontend: \`${{ env.REGISTRY }}/${{ env.FRONTEND_IMAGE_NAME }}\`" >> $GITHUB_STEP_SUMMARY
+        if [[ "$DOCKERHUB_ENABLED" == "true" ]]; then
+          echo "- Backend (Docker Hub): \`docker.io/picpeak/backend\`" >> $GITHUB_STEP_SUMMARY
+          echo "- Frontend (Docker Hub): \`docker.io/picpeak/frontend\`" >> $GITHUB_STEP_SUMMARY
+        fi

        echo "" >> $GITHUB_STEP_SUMMARY
        echo "### 🏗️ Architectures" >> $GITHUB_STEP_SUMMARY
@@ -27,12 +27,32 @@ jobs:
          manifest-file: .release-please-manifest.json
          target-branch: stable

-      # NOTE: stable release PRs are intentionally NOT auto-merged here
-      # anymore. Fixes accumulate in the rolling release PR and are cut as
-      # ONE patch version per day by release-stable-daily.yml (18:00 UTC,
-      # or on demand via workflow_dispatch / a manual merge of the release
-      # PR). Beta keeps instant releases — see release-please-beta.yml —
-      # because same-day reporter verification depends on it.
+      # Auto-approve + auto-merge the open stable release PR. See the beta
+      # workflow for the full rationale. Skipped on the release-cutting run and
+      # whenever no PAT is configured.
+      - name: Auto-approve and enable auto-merge on the release PR
+        if: ${{ steps.release.outputs.release_created != 'true' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RELEASE_PAT: ${{ secrets.RELEASE_PLEASE_TOKEN }}
+          # No checkout in this job — set the repo explicitly so gh works
+          # without a git remote (same pattern as whatsnew, 2a5f0a8).
+          GH_REPO: ${{ github.repository }}
+        run: |
+          if [ -z "$RELEASE_PAT" ]; then
+            echo "RELEASE_PLEASE_TOKEN not set — skipping auto-merge (manual review still required)."
+            exit 0
+          fi
+          pr=$(gh pr list --head release-please--branches--stable --state open --json number --jq '.[0].number // empty')
+          if [ -n "$pr" ]; then
+            # Approve as github-actions[bot] (GITHUB_TOKEN, ≠ the PAT author) so it
+            # is a valid review; enable auto-merge as the PAT so the merge commit is
+            # attributed to a real identity and triggers the tag-cutting run (#719).
+            gh pr review "$pr" --approve --body "Automated approval — release-please version bump + changelog (#719)." || true
+            GH_TOKEN="$RELEASE_PAT" gh pr merge "$pr" --squash --auto || true
+          else
+            echo "No open release PR to auto-merge."
+          fi

      - name: Output Release Info
        if: ${{ steps.release.outputs.release_created }}
@@ -1,86 +0,0 @@
-name: Cut Stable Release (daily batch)
-
-# Stable fixes accumulate in release-please's rolling release PR instead of
-# each cutting its own patch version (the old per-merge auto-merge produced
-# e.g. 3.45.8 AND 3.45.9 on the same day). This workflow merges the open
-# stable release PR once a day, so a day of N bugfixes ships as ONE version
-# with all N changelog entries — and one Docker build instead of N.
-#
-# - schedule only fires from the default branch (main); the stable copy of
-#   this file is inert and exists to keep the branches in sync.
-# - Need a release NOW? Run this via workflow_dispatch, or merge the
-#   release PR by hand — the schedule is a default, not a gate.
-# - Approval/merge mechanics mirror the old inline step (#719): approve as
-#   github-actions[bot] (GITHUB_TOKEN, a valid distinct reviewer), enable
-#   auto-merge as the PAT so the merge attributes to a real identity and
-#   triggers the tag-cutting run. --auto waits for green checks.
-
-on:
-  schedule:
-    - cron: '0 18 * * *'
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  merge-stable-release-pr:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Approve and enable auto-merge on the open stable release PR
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          RELEASE_PAT: ${{ secrets.RELEASE_PLEASE_TOKEN }}
-          # No checkout — set the repo explicitly so gh works without a
-          # git remote (same pattern as whatsnew, 2a5f0a8).
-          GH_REPO: ${{ github.repository }}
-        run: |
-          if [ -z "$RELEASE_PAT" ]; then
-            echo "RELEASE_PLEASE_TOKEN not set — skipping (manual review required)."
-            exit 0
-          fi
-          # Strict selection (review P1): this job runs daily even without a
-          # stable push, and `gh pr list --head` matches the branch NAME only
-          # — a fork PR can spoof `release-please--branches--stable`. Pin the
-          # base to stable AND require a same-repo head (isCrossRepository
-          # == false); a fork PR is cross-repository, so it can never be
-          # picked and auto-merged with the privileged PAT.
-          pr=$(gh pr list \
-            --base stable \
-            --head release-please--branches--stable \
-            --state open \
-            --json number,isCrossRepository \
-            --jq '[.[] | select(.isCrossRepository == false)] | .[0].number // empty')
-          if [ -z "$pr" ]; then
-            echo "No open same-repo stable release PR — nothing to cut today."
-            exit 0
-          fi
-          # Approve is tolerant — a pre-existing approval already satisfies
-          # branch protection and re-approving can return non-zero.
-          gh pr review "$pr" --approve --body "Automated approval — daily stable release batch (release-please version bump + changelog)." || echo "::warning::approve returned non-zero (PR may already be approved)"
-          # But the auto-merge enable is the load-bearing step: this scheduled
-          # job is the ONLY automatic stable cut, so DON'T swallow its failure
-          # (review P2) — an expired/under-scoped PAT would otherwise stop
-          # releases while the workflow stays green.
-          GH_TOKEN="$RELEASE_PAT" gh pr merge "$pr" --squash --auto
-          # `gh pr merge --auto` merges IMMEDIATELY when the required checks
-          # are already green — the normal case at 18:00, since the fixes
-          # merged hours earlier and CI passed. So success is EITHER the PR is
-          # already merged OR an auto-merge request is now pending; only a PR
-          # that is still open with no auto-merge request is a real failure
-          # (expired/under-scoped PAT) worth failing the job on (review round 2).
-          # One snapshot of both fields (review round 3): querying state and
-          # autoMergeRequest separately races — auto-merge can complete
-          # between the two calls, so the first sees OPEN and the second sees
-          # the request already cleared on the now-merged PR → false failure.
-          read -r state automerge < <(gh pr view "$pr" --json state,autoMergeRequest \
-            --jq '[.state, (.autoMergeRequest != null)] | @tsv')
-          if [ "$state" = "MERGED" ]; then
-            echo "Stable release PR #$pr merged immediately (checks were already green)."
-          elif [ "$automerge" = "true" ]; then
-            echo "Auto-merge enabled on stable release PR #$pr — merges when checks are green."
-          else
-            echo "::error::stable release PR #$pr is still open with no auto-merge — check RELEASE_PLEASE_TOKEN scope/expiry."
-            exit 1
-          fi
@@ -30,29 +30,6 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 10

-    # The .picpeak restore suites gate their real-Postgres cases behind
-    # PICPEAK_PG_TEST_URL and `describe.skip` themselves out when it is
-    # unset — so until now they never ran here. That hid the half that
-    # matters: sequence resync, operator/role preservation across a
-    # cross-instance restore, and (with #1041) whether a SQLite-shaped
-    # row actually lands in Postgres with the right STORED VALUES rather
-    # than merely not throwing. Everything else in the suite still runs
-    # on SQLite; this service only un-gates those cases.
-    services:
-      postgres:
-        image: postgres:15-alpine
-        env:
-          POSTGRES_USER: picpeak
-          POSTGRES_PASSWORD: testpass
-          POSTGRES_DB: picpeak_test
-        options: >-
-          --health-cmd "pg_isready -U picpeak -d picpeak_test"
-          --health-interval 2s
-          --health-timeout 2s
-          --health-retries 30
-        ports:
-          - 5432:5432
-
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
@@ -75,9 +52,6 @@ jobs:
          # The S3 path itself is covered separately by the integration
          # suite when MinIO is provisioned.
          SKIP_S3_TESTS: 'true'
-          # Un-gates the real-Postgres cases in the .picpeak restore suites
-          # (see the `services:` note above). Absent it they silently skip.
-          PICPEAK_PG_TEST_URL: 'postgres://picpeak:testpass@127.0.0.1:5432/picpeak_test'
        run: |
          # Excluded suites — fail on upstream/beta too, tracked
          # separately as test-infra debt:
@@ -131,7 +131,5 @@ docker-compose.dev.yml
 new-layouts/

 # Backend runtime storage (generated media, previews, thumbnails,
-# CRM/accounting documents) — never commit. Matches main: a dev instance
-# writes event photos into backend/storage/, and the narrower
-# business-docs-only rule let `git add -A` sweep them into a commit.
+# CRM/accounting documents) — never commit
 backend/storage/
@@ -1,3 +1,3 @@
 {
-  ".": "3.83.0-beta.0"
+  ".": "3.97.4-beta.0"
 }
@@ -1 +1 @@
-{".":"3.46.4"}
+{".":"3.44.0"}
@@ -111,15 +111,10 @@ docker compose up -d
 On first start with no `ADMIN_PASSWORD` set, PicPeak has **no admin account yet** and greets you with an in-browser setup screen — no credentials in `.env`:

 1. Open **http://localhost:3000/admin** — you'll be redirected to `/setup`.
-2. Read the **one-time setup token** from the 0600 file the backend writes it to
-   (it is deliberately *not* printed to the logs — that would leave a live
-   bootstrap credential in `docker logs`):
+2. Grab the **one-time setup token** from the backend logs (it's also saved to `data/SETUP_TOKEN`):
   ```bash
-   docker compose exec backend cat /app/data/SETUP_TOKEN
+   docker compose logs backend | grep -i "setup token"
   ```
-   It is bind-mounted, so `sudo cat data/SETUP_TOKEN` on the host works too. Only
-   if that file could not be written does the backend fall back to logging the
-   token (`docker compose logs backend | grep -i "setup token"`).
 3. Paste the token, set your admin **email + password**, and you're in. The token is single-use, and the setup screen closes permanently once an admin exists.

 > Prefer the old behaviour? Set `ADMIN_PASSWORD` in `.env` and PicPeak auto-creates the admin on first boot instead (credentials written to `data/ADMIN_CREDENTIALS.txt`).
@@ -52,13 +52,19 @@ The actual mechanics, in order:
   - **`.release-please-manifest.json`** — keep `stable`'s; release-please owns this file.
   - Any other auto-merged file — spot-check that the auto-merge produced something sensible, especially for security-sensitive files (`backend/src/middleware/`, `backend/src/utils/tokenUtils.js`).

-5. **Wait for CI on the PR.** All ten checks (the original eight plus `merge-backend` and `merge-frontend`) must be green. If anything fails, fix on the release branch (NOT on `main` — `main` has already moved on).
+5. **Pin the stable version to match `main` (number alignment — see Versioning).** Determine `X.Y.Z` = the `main` tip's **base** version (its `vX.Y.Z-beta.N`, dropping the `-beta.N` suffix), and add an empty commit on the release branch:
+   ```bash
+   git commit --allow-empty -m "chore: release X.Y.Z" -m "Release-As: X.Y.Z"
+   ```
+   The `Release-As:` footer forces release-please to cut exactly `X.Y.Z`. Without it, release-please computes the next MINOR from the *previous stable* tag (e.g. `3.45.0` → `3.46.0`) while `main` is already at `3.84.x`, so the stable number drifts ever further behind for the same code.

-6. **Merge.** Standard merge commit, not squash — the PR's history (the individual feature commits) carries forward into `stable`'s log.
+6. **Wait for CI on the PR.** All ten checks (the original eight plus `merge-backend` and `merge-frontend`) must be green. If anything fails, fix on the release branch (NOT on `main` — `main` has already moved on).

-7. **release-please picks it up.** Within minutes, release-please will open a new `chore(stable): release X.Y.Z` PR proposing the stable release. Review the auto-generated CHANGELOG.md entries for accuracy, edit if needed, and merge. That merge creates the `vX.Y.Z` git tag, publishes Docker images on the `:stable` and `:latest` tags, and creates the GitHub Release page.
+7. **Merge.** Standard merge commit, not squash — the PR's history (the individual feature commits) carries forward into `stable`'s log.

-8. **Close the loop.** Bulk-close any `bug` issues that were fixed-but-not-closed and now appear in the released changelog. Reference the merge commit so reporters know which version contains the fix.
+8. **release-please picks it up.** Within minutes, release-please will open a new `chore(stable): release X.Y.Z` PR proposing the stable release. Review the auto-generated CHANGELOG.md entries for accuracy, edit if needed, and merge. That merge creates the `vX.Y.Z` git tag, publishes Docker images on the `:stable` and `:latest` tags, and creates the GitHub Release page.
+
+9. **Close the loop.** Bulk-close any `bug` issues that were fixed-but-not-closed and now appear in the released changelog. Reference the merge commit so reporters know which version contains the fix.

 ## Hotfix path (backport to current stable)

@@ -83,6 +89,14 @@ PicPeak follows [Semantic Versioning](https://semver.org/) with one project-spec

 release-please derives all of this from conventional commit prefixes (`feat:`, `fix:`, `BREAKING CHANGE:`, etc.) automatically.

+### Stable ↔ pre-release number alignment
+
+The two channels run **independent** release-please counters: `main` bumps on every merge (racing ahead), while `stable` only bumps on a promotion. Left to itself, `stable` computes each promotion as the next MINOR from the *previous stable tag*, so the two drift far apart — e.g. `main` at `v3.83.x-beta.0` while `stable` sat at `v3.45.0` for the **same code**, which reads as "stable is 38 versions behind" when it isn't.
+
+To keep the numbers legible, **a promotion sets the stable version to the current `main` base version** (the `X.Y.Z` of the `main` tip's `vX.Y.Z-beta.N`, minus the suffix). Promoting a `main` at `v3.84.2-beta.0` therefore cuts stable `v3.84.2`, and the stable number tracks `main` instead of lagging. This is forced with the `Release-As:` commit in step 5 of the cut procedure — the one-time catch-up jump (e.g. `3.45.0 → 3.84.x`) is expected and happens only on the first aligned promotion.
+
+> **Release-engineering note (2026-07):** `release-please.yml` (the stable workflow) *must* keep `target-branch: stable`. Without it, release-please defaults to the repo's default branch (`main`), reads `main`'s stale `.release-please-manifest.json`, and cuts a wrong/regressed version — this is what produced a bogus `v2.7.0` once. If a promotion ever yields an unexpected version, check that first.
+
 ## Things that don't go through this process

 - **Documentation-only changes** can land on either `stable` or `main` directly (no release cut needed); release-please will pick them up on the next regular release.
@@ -170,12 +170,10 @@ If you installed with `picpeak-setup.sh` and gave an `--admin-password`, your ad
 If you started PicPeak **without** setting `ADMIN_PASSWORD` (e.g. a plain `docker compose up`), there's **no admin yet** and you create it in the browser:

 1. Open `http://your-server:3000/admin` — you'll land on a setup screen.
-2. Read the **one-time setup token** from the 0600 file the backend writes it to
-   (it is not logged — that would leave a live credential in `docker logs`):
+2. Get the **one-time setup token** from the backend logs (also saved to `data/SETUP_TOKEN`):
   ```bash
-   docker compose exec backend cat /app/data/SETUP_TOKEN
+   docker compose logs backend | grep -i "setup token"
   ```
-   Only if that write fails does the backend log the token instead.
 3. Paste it, set your admin email + password. The token is single-use and the screen closes once an admin exists.

 ## 🌐 Access Methods
@@ -1,9 +1,7 @@
 node_modules
 npm-debug.log
 .env
-storage/events/active/*
-storage/events/archived/*
-storage/thumbnails/*
+storage
 data/*.db
 logs/*
 coverage
@@ -106,6 +106,12 @@ ARCHIVE_PATH=/app/storage/events/archived
 # EVENTS_PATH=./storage/events
 # ARCHIVE_PATH=./storage/events/archived

+# File watcher (auto-import from the events/active folder, local storage only)
+# Max photos processed in parallel by the watcher. The boot scan and bulk
+# folder drops fire one handler per file — this bound keeps thumbnail
+# generation from exhausting memory on small hosts. Default: 2
+# FILE_WATCHER_CONCURRENCY=2
+
 # Analytics Backend Configuration (OPTIONAL)
 # Used for server-side tracking only
 # Primary configuration should be done through Admin UI > Settings > Analytics
@@ -27,15 +27,6 @@ FROM node:22-alpine

 WORKDIR /app

-# knexfile.js picks its config block by NODE_ENV, and the `development` block
-# defaults to sqlite3. Leaving NODE_ENV unset here meant every deployment that
-# doesn't go through our compose files — Kubernetes, Helm, plain `docker run` —
-# silently ran on SQLite and ignored DB_HOST/DB_USER/DB_PASSWORD, while
-# wait-for-db.sh (shell, reads DB_HOST directly) reported "PostgreSQL is up" in
-# the same log. The compose files still override this, so nothing changes for
-# compose users. See #1038.
-ENV NODE_ENV=production
-
 # Redeclare CACHEBUST — ARGs don't cross stage boundaries, so the builder
 # stage's declaration never reached this stage. Consuming it in the RUN below
 # busts that layer's cache every CI run (CACHEBUST=github.run_number), so the
@@ -78,8 +69,11 @@ RUN rm -rf /usr/local/lib/node_modules/npm /usr/local/bin/npm /usr/local/bin/npx
 # malicious) PDF. pdftoppm does not execute embedded JS or fetch remote
 # resources, so it doubles as the SSRF/phone-home guard for untrusted inbound
 # documents (see docs/accounting-inbound-invoices.md).
+# exiftool extracts the embedded full-res JPEG preview from RAW/DNG uploads
+# (Apple ProRAW etc.) — sharp's libvips has no raw loader, so the pipeline
+# thumbnails/displays that preview while keeping the original for download.
 RUN apk add --no-cache dumb-init postgresql-client ffmpeg su-exec \
-    fontconfig ttf-dejavu ttf-liberation poppler-utils && \
+    fontconfig ttf-dejavu ttf-liberation poppler-utils exiftool && \
    fc-cache -f

 # Create non-root user
@@ -8,7 +8,10 @@ RUN apk upgrade --no-cache
 # Install dumb-init for proper signal handling and ffmpeg for video uploads.
 # Alpine's ffmpeg ships both ffmpeg + ffprobe built natively against musl;
 # the npm-bundled binary doesn't run reliably on Alpine. Match production.
-RUN apk add --no-cache dumb-init ffmpeg
+# exiftool: extract embedded JPEG previews from RAW/DNG uploads (#821) — kept in
+# sync with the production Dockerfile so dev/native runtimes don't accept a DNG
+# and then fail it with ENOENT.
+RUN apk add --no-cache dumb-init ffmpeg exiftool

 # Copy package files
 COPY package*.json ./
@@ -1,246 +0,0 @@
-/**
- * POST /admin/thumbnails/regenerate for external/reference photos (#1129).
- *
- * STABLE TWIN. Diverges from the main version in one place: stable has no
- * responsive ?w= tiers (#1095/#1109), so there is no deleteThumbnailTiers call
- * to assert and the "drops the tiers first" test is absent here. Everything
- * else — the external rebuild, the thumbnail_path:null contract, video
- * skipping, per-event scoping and the superseded-key deletion — is identical.
- *
- * The route used to resolve every source as `storage/events/active/<path>` and
- * `fs.access` it. External and reference rows do not live there — their
- * originals sit under `events.external_path` — so every one of them failed the
- * check and was counted as an error.
- *
- * That alone would be inert. What made it destructive is that the tier
- * deletion runs FIRST (deliberately, so S3 and external rows are not skipped):
- * on a reference install the button dropped every ?w= tier and rebuilt
- * nothing, while the UI reported success — the response is sent before the
- * background loop starts.
- *
- * The background work is fired with setImmediate, so every assertion here has
- * to wait for it to drain rather than trusting the response.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const express = require('express');
-const request = require('supertest');
-
-describe('admin thumbnail regeneration (#1129)', () => {
-  let tmpDir; let db; let cleanup; let app; let imageProcessor; let storage;
-
-  beforeAll(async () => {
-    tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'picpeak-regen-'));
-    process.env.NODE_ENV = 'test';
-    process.env.TEST_DATABASE_PATH = path.join(tmpDir, 'data', 'test.db');
-    process.env.STORAGE_PATH = path.join(tmpDir, 'storage');
-    await fs.promises.mkdir(path.dirname(process.env.TEST_DATABASE_PATH), { recursive: true });
-    await fs.promises.mkdir(process.env.STORAGE_PATH, { recursive: true });
-
-    jest.resetModules();
-
-    jest.doMock('../../src/middleware/auth', () => ({
-      adminAuth: (req, _res, next) => { req.admin = { id: 1, username: 'tester' }; next(); },
-    }));
-    jest.doMock('../../src/middleware/permissions', () => ({
-      requirePermission: () => (_req, _res, next) => next(),
-    }));
-    // One instance, not a fresh object per call — the route and the
-    // assertions have to be looking at the same mock.
-    jest.doMock('../../src/services/storage', () => {
-      const instance = { delete: jest.fn().mockResolvedValue(undefined) };
-      return { getStorage: () => instance };
-    });
-    jest.doMock('../../src/services/imageProcessor', () => ({
-      ensureThumbnail: jest.fn().mockResolvedValue('thumbnails/thumb_ext1_shot.jpg'),
-      ensurePreviewImage: jest.fn().mockResolvedValue('previews/p.jpg'),
-      deletePreviewTiers: jest.fn().mockResolvedValue(undefined),
-    }));
-
-    // bootCrmDb, not run-migrations: the latter calls process.exit(0) on
-    // success, which ends the jest worker mid-suite.
-    ({ db, cleanup } = await require('./helpers/crmDb').bootCrmDb());
-
-    imageProcessor = require('../../src/services/imageProcessor');
-    storage = require('../../src/services/storage').getStorage();
-    app = express();
-    app.use(express.json());
-    app.use('/admin/thumbnails', require('../../src/routes/adminThumbnails'));
-  }, 180000);
-
-  afterAll(async () => {
-    if (cleanup) await cleanup();
-    await fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-  });
-
-  beforeEach(async () => {
-    jest.clearAllMocks();
-    await db('photos').del();
-    await db('events').del();
-  });
-
-  async function seedEvent() {
-    const [row] = await db('events').insert({
-      slug: 'nas-wedding', event_type: 'wedding', event_name: 'nas',
-      event_date: '2026-01-01', host_email: 'h@example.com', admin_email: 'a@example.com',
-      password_hash: 'x', share_link: 'nas-share', expires_at: new Date().toISOString(),
-      source_mode: 'reference', external_path: 'weddings/2026-08',
-    }).returning('id');
-    return typeof row === 'object' ? row.id : row;
-  }
-
-  async function seedPhoto(eventId, overrides = {}) {
-    const [row] = await db('photos').insert({
-      event_id: eventId, filename: 'shot.jpg', path: 'nas-wedding/shot.jpg',
-      type: 'individual', ...overrides,
-    }).returning('id');
-    return typeof row === 'object' ? row.id : row;
-  }
-
-  /** The work runs in setImmediate; give it room to finish. */
-  const drain = () => new Promise((resolve) => setTimeout(resolve, 150));
-
-  it('rebuilds the canonical thumbnail for an external photo instead of erroring', async () => {
-    const eventId = await seedEvent();
-    await seedPhoto(eventId, {
-      source_origin: 'external',
-      external_relpath: 'shot.jpg',
-      thumbnail_path: 'thumbnails/stale.jpg',
-    });
-
-    const res = await request(app).post('/admin/thumbnails/regenerate').send({});
-    expect(res.status).toBe(200);
-    await drain();
-
-    // The whole bug: this used to be zero calls and one logged
-    // "Original file not found" per photo.
-    expect(imageProcessor.ensureThumbnail).toHaveBeenCalledTimes(1);
-  });
-
-  it('nulls thumbnail_path so the valid-thumbnail short-circuit cannot skip the rebuild', async () => {
-    const eventId = await seedEvent();
-    await seedPhoto(eventId, {
-      source_origin: 'external',
-      external_relpath: 'shot.jpg',
-      thumbnail_path: 'thumbnails/still-on-disk.jpg',
-    });
-
-    await request(app).post('/admin/thumbnails/regenerate').send({});
-    await drain();
-
-    // Without this the endpoint is a no-op whenever the OLD thumbnail is still
-    // readable — which is the normal case after a settings change, and exactly
-    // when the admin pressed the button.
-    const [photoArg] = imageProcessor.ensureThumbnail.mock.calls[0];
-    expect(photoArg.thumbnail_path).toBeNull();
-    expect(photoArg.source_origin).toBe('external');
-    // Carried through so ensureThumbnail can resolve off the mount rather than
-    // under events/active.
-    expect(photoArg.external_relpath).toBe('shot.jpg');
-  });
-
-  it('leaves videos alone rather than handing a container file to Sharp', async () => {
-    const eventId = await seedEvent();
-    await seedPhoto(eventId, { source_origin: 'managed', media_type: 'video', filename: 'clip.mp4' });
-    await seedPhoto(eventId, { source_origin: 'managed', filename: 'still.jpg' });
-
-    const res = await request(app).post('/admin/thumbnails/regenerate').send({});
-    await drain();
-
-    expect(res.body.count).toBe(1);
-    expect(imageProcessor.ensureThumbnail).toHaveBeenCalledTimes(1);
-    expect(imageProcessor.ensureThumbnail.mock.calls[0][0].filename).toBe('still.jpg');
-  });
-
-  /**
-   * On S3, ensureThumbnail downloads the source to a randomly-named temp file,
-   * and for non-RAW input withProcessableImage passes no outputBasename — so
-   * generateThumbnail derives the key from that random name and it differs on
-   * every run. Nulling thumbnail_path hides the old key from everything that
-   * would otherwise clean it up, so each regeneration would strand a full
-   * thumbnail in the bucket, once per photo per run.
-   */
-  describe('superseded canonical renditions', () => {
-    it('removes the old thumbnail when the key moved', async () => {
-      const eventId = await seedEvent();
-      await seedPhoto(eventId, {
-        source_origin: 'managed',
-        thumbnail_path: 'thumbnails/thumb_OLDRANDOM_shot.jpg',
-      });
-      imageProcessor.ensureThumbnail.mockResolvedValueOnce('thumbnails/thumb_NEWRANDOM_shot.jpg');
-
-      await request(app).post('/admin/thumbnails/regenerate').send({});
-      await drain();
-
-      expect(storage.delete).toHaveBeenCalledWith('thumbnails/thumb_OLDRANDOM_shot.jpg');
-    });
-
-    it('does NOT delete when the key is unchanged — that is the new file', async () => {
-      const eventId = await seedEvent();
-      await seedPhoto(eventId, {
-        source_origin: 'managed',
-        thumbnail_path: 'thumbnails/thumb_stable.jpg',
-      });
-      // Local storage resolves to a stable path, so the key is identical.
-      imageProcessor.ensureThumbnail.mockResolvedValueOnce('thumbnails/thumb_stable.jpg');
-
-      await request(app).post('/admin/thumbnails/regenerate').send({});
-      await drain();
-
-      expect(storage.delete).not.toHaveBeenCalled();
-    });
-
-    it.each([
-      ['a Windows-style legacy path', 'thumbnails\\thumb_ext1_shot.jpg'],
-      ['a leading ./', './thumbnails/thumb_ext1_shot.jpg'],
-      ['a doubled separator', 'thumbnails//thumb_ext1_shot.jpg'],
-    ])('does not delete the file it just wrote when the old path is %s', async (_name, stored) => {
-      const eventId = await seedEvent();
-      await seedPhoto(eventId, { source_origin: 'managed', thumbnail_path: stored });
-      // Both storage backends fold these to the same key, so this is the SAME
-      // object — deleting it would remove the freshly generated thumbnail and
-      // leave the row pointing at nothing.
-      imageProcessor.ensureThumbnail.mockResolvedValueOnce('thumbnails/thumb_ext1_shot.jpg');
-
-      await request(app).post('/admin/thumbnails/regenerate').send({});
-      await drain();
-
-      expect(storage.delete).not.toHaveBeenCalled();
-    });
-
-    it('counts the photo as regenerated even if the old object cannot be removed', async () => {
-      const eventId = await seedEvent();
-      await seedPhoto(eventId, {
-        source_origin: 'managed',
-        thumbnail_path: 'thumbnails/thumb_OLD.jpg',
-      });
-      imageProcessor.ensureThumbnail.mockResolvedValueOnce('thumbnails/thumb_NEW.jpg');
-      storage.delete.mockRejectedValueOnce(new Error('bucket said no'));
-
-      await request(app).post('/admin/thumbnails/regenerate').send({});
-      await drain();
-
-      // Losing the old object is untidy; the regeneration itself succeeded.
-      expect(imageProcessor.ensureThumbnail).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it('scopes to one event when asked', async () => {
-    const a = await seedEvent();
-    await seedPhoto(a, { source_origin: 'external', external_relpath: 'a.jpg' });
-    const [b] = await db('events').insert({
-      slug: 'other', event_type: 'wedding', event_name: 'other', event_date: '2026-01-01',
-      host_email: 'h@example.com', admin_email: 'a@example.com', password_hash: 'x',
-      share_link: 'other-share', expires_at: new Date().toISOString(),
-    }).returning('id');
-    await seedPhoto(typeof b === 'object' ? b.id : b, { source_origin: 'managed' });
-
-    const res = await request(app).post('/admin/thumbnails/regenerate').send({ eventId: a });
-    await drain();
-
-    expect(res.body.count).toBe(1);
-    expect(imageProcessor.ensureThumbnail).toHaveBeenCalledTimes(1);
-  });
-});
@@ -0,0 +1,108 @@
+/**
+ * Backup credential exposure regression tests.
+ *
+ * The generic settings reads (GET /admin/settings, GET /admin/settings/:type)
+ * masked the recaptcha/umami/rybbit keys but returned backup_s3_secret_key
+ * and backup_rsync_ssh_key (an SSH PRIVATE KEY) in plaintext to any
+ * settings.view holder; GET /admin/backup/config returned them too. Both now
+ * mask, and PUT /admin/backup/config skips the mask sentinel so the edit
+ * form round-trips without clobbering stored credentials.
+ */
+
+const request = require('supertest');
+const express = require('express');
+
+const { bootCrmDb } = require('./helpers/crmDb');
+
+jest.mock('../../src/middleware/auth', () => ({
+  adminAuth: (req, _res, next) => {
+    req.admin = { id: 1, username: 'test-admin' };
+    next();
+  },
+}));
+jest.mock('../../src/middleware/permissions', () => ({
+  requirePermission: () => (_req, _res, next) => next(),
+}));
+
+describe('backup credential masking', () => {
+  let db;
+  let cleanup;
+  let app;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+
+    // Upsert: several backup_* keys are pre-seeded by the backup migrations.
+    const seed = [
+      { setting_key: 'backup_destination_type', setting_value: JSON.stringify('s3'), setting_type: 'backup' },
+      { setting_key: 'backup_s3_endpoint', setting_value: JSON.stringify('https://s3.example.com'), setting_type: 'backup' },
+      { setting_key: 'backup_s3_bucket', setting_value: JSON.stringify('backups'), setting_type: 'backup' },
+      { setting_key: 'backup_s3_access_key', setting_value: JSON.stringify('AKIAEXAMPLE'), setting_type: 'backup' },
+      { setting_key: 'backup_s3_secret_key', setting_value: JSON.stringify('super-secret-s3-key'), setting_type: 'backup' },
+      { setting_key: 'backup_rsync_ssh_key', setting_value: JSON.stringify('-----BEGIN OPENSSH PRIVATE KEY-----abc'), setting_type: 'backup' },
+    ];
+    for (const row of seed) {
+      await db('app_settings').insert(row).onConflict('setting_key').merge();
+    }
+
+    app = express();
+    app.use(express.json());
+    app.use('/api/admin/backup', require('../../src/routes/adminBackup'));
+    app.use('/api/admin/settings', require('../../src/routes/adminSettings'));
+  }, 120000);
+
+  afterAll(async () => {
+    if (cleanup) await cleanup();
+  });
+
+  it('masks the credentials in GET /admin/backup/config', async () => {
+    const res = await request(app).get('/api/admin/backup/config').expect(200);
+    expect(res.body.backup_s3_secret_key).toBe('••••••••');
+    expect(res.body.backup_rsync_ssh_key).toBe('••••••••');
+    // Non-secret fields stay readable for the form.
+    expect(res.body.backup_s3_bucket).toBe('backups');
+  });
+
+  it('masks the credentials in the generic GET /admin/settings/:type read', async () => {
+    const res = await request(app).get('/api/admin/settings/backup').expect(200);
+    expect(res.body.backup_s3_secret_key).toBe('••••••••');
+    expect(res.body.backup_rsync_ssh_key).toBe('••••••••');
+  });
+
+  it('masks the credentials in the generic GET /admin/settings read', async () => {
+    const res = await request(app).get('/api/admin/settings').expect(200);
+    expect(res.body.backup_s3_secret_key).toBe('••••••••');
+    expect(res.body.backup_rsync_ssh_key).toBe('••••••••');
+  });
+
+  it('PUT /admin/backup/config keeps the stored secret when the sentinel round-trips', async () => {
+    await request(app)
+      .put('/api/admin/backup/config')
+      .send({
+        backup_destination_type: 's3',
+        backup_s3_endpoint: 'https://s3.example.com',
+        backup_s3_bucket: 'renamed-bucket',
+        backup_s3_access_key: 'AKIAEXAMPLE',
+        backup_s3_secret_key: '••••••••',
+        backup_rsync_ssh_key: '••••••••',
+      })
+      .expect(200);
+
+    const secret = await db('app_settings').where({ setting_key: 'backup_s3_secret_key' }).first();
+    expect(JSON.parse(secret.setting_value)).toBe('super-secret-s3-key');
+    const sshKey = await db('app_settings').where({ setting_key: 'backup_rsync_ssh_key' }).first();
+    expect(JSON.parse(sshKey.setting_value)).toBe('-----BEGIN OPENSSH PRIVATE KEY-----abc');
+    const bucket = await db('app_settings').where({ setting_key: 'backup_s3_bucket' }).first();
+    expect(JSON.parse(bucket.setting_value)).toBe('renamed-bucket');
+  });
+
+  it('PUT /admin/backup/config stores a genuinely new secret', async () => {
+    await request(app)
+      .put('/api/admin/backup/config')
+      .send({ backup_s3_secret_key: 'rotated-s3-key' })
+      .expect(200);
+
+    const secret = await db('app_settings').where({ setting_key: 'backup_s3_secret_key' }).first();
+    expect(JSON.parse(secret.setting_value)).toBe('rotated-s3-key');
+  });
+});
@@ -0,0 +1,211 @@
+/**
+ * Layered per-event category ordering (#782).
+ *
+ * Two ordering layers, resolved per event:
+ *   - GLOBAL default   — photo_categories.display_order (migration 159),
+ *                        set via POST /reorder-global; applies everywhere.
+ *   - PER-EVENT override — event_category_order (migration 160), set via
+ *                        POST /reorder; overrides the default for one gallery.
+ *   - DELETE /reorder/:eventId clears an event's override.
+ *
+ * Verified against a real SQLite DB with the full core-migration set applied.
+ */
+const request = require('supertest');
+const {
+  bootCrmDb, seedMinimal, assignAdminRole, mintAdminToken, buildRouteApp,
+} = require('./helpers/crmDb');
+
+jest.setTimeout(120000);
+
+describe('category ordering (#782)', () => {
+  let db;
+  let cleanup;
+  let token;
+  let app;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    const { adminId } = await seedMinimal(db);
+    await assignAdminRole(db, adminId, 'super_admin');
+    token = mintAdminToken(adminId);
+    app = buildRouteApp('/api/admin/categories', require('../../src/routes/adminCategories'));
+  }, 120000);
+
+  afterAll(async () => { if (cleanup) await cleanup(); });
+
+  const auth = (r) => r.set('Authorization', `Bearer ${token}`);
+
+  async function insertEvent(slug) {
+    await db('events').insert({
+      event_type: 'wedding', password_hash: 'x',
+      expires_at: new Date(Date.now() + 9e9).toISOString(),
+      is_active: true, is_archived: false, slug, share_link: slug,
+      event_name: slug, event_date: '2026-01-01',
+    });
+    return (await db('events').where({ slug }).first()).id;
+  }
+
+  async function insertCat(name, { is_global = false, event_id = null, display_order = 0 } = {}) {
+    const res = await db('photo_categories').insert({
+      name,
+      slug: name.toLowerCase().replace(/\s+/g, '-'),
+      is_global: is_global ? 1 : 0,
+      event_id,
+      display_order,
+    }).returning('id');
+    return res[0]?.id ?? res[0];
+  }
+
+  const getEvent = (eventId) => auth(request(app).get(`/api/admin/categories/event/${eventId}`)).expect(200);
+
+  describe('migration 159 backfill', () => {
+    it('seeds display_order from alphabetical order, scoped per event', async () => {
+      const eventId = await insertEvent('backfill-ev');
+      await insertCat('Reception', { event_id: eventId });
+      await insertCat('Ceremony', { event_id: eventId });
+      await insertCat('Pre-Ceremony', { event_id: eventId });
+
+      // Re-run the migration: addColumn is guarded (no-op); the backfill loop
+      // re-runs and assigns per-scope alphabetical order — what an upgrade does.
+      await require('../../migrations/core/159_add_category_display_order').up(db);
+
+      const evCats = await db('photo_categories').where({ event_id: eventId }).orderBy('display_order', 'asc');
+      expect(evCats.map((c) => c.name)).toEqual(['Ceremony', 'Pre-Ceremony', 'Reception']);
+      expect(evCats.map((c) => c.display_order)).toEqual([1, 2, 3]);
+    });
+  });
+
+  describe('global default order (POST /reorder-global)', () => {
+    it('reverses the global order and every non-customised event follows it', async () => {
+      const before = (await auth(request(app).get('/api/admin/categories/global')).expect(200)).body;
+      expect(before.length).toBeGreaterThan(1);
+      const reversedIds = before.map((c) => c.id).reverse();
+
+      const res = await auth(request(app).post('/api/admin/categories/reorder-global'))
+        .send({ orderedIds: reversedIds })
+        .expect(200);
+      expect(res.body.map((c) => c.id)).toEqual(reversedIds);
+
+      // A fresh event (no override) shows globals in the new global order.
+      const eventId = await insertEvent('follows-global');
+      const globalsInEvent = (await getEvent(eventId)).body.filter((c) => c.is_global).map((c) => c.id);
+      expect(globalsInEvent).toEqual(reversedIds);
+    });
+  });
+
+  describe('per-event override (POST /reorder)', () => {
+    it('pins a custom order for one event without affecting another', async () => {
+      const eventA = await insertEvent('override-a');
+      const eventB = await insertEvent('override-b');
+      const a1 = await insertCat('A-Ceremony', { event_id: eventA });
+      const a2 = await insertCat('A-Reception', { event_id: eventA });
+
+      // Current resolved list for A (globals + A's two categories).
+      const listA = (await getEvent(eventA)).body;
+      // Put A-Reception first, then A-Ceremony, then the globals in their order.
+      const globalsA = listA.filter((c) => c.is_global).map((c) => c.id);
+      const desired = [a2, a1, ...globalsA];
+
+      const res = await auth(request(app).post('/api/admin/categories/reorder'))
+        .send({ event_id: eventA, orderedIds: desired })
+        .expect(200);
+      expect(res.body.map((c) => c.id)).toEqual(desired);
+      // override_position is set on every row for a customised event.
+      expect(res.body.every((c) => c.override_position != null)).toBe(true);
+
+      // Event B is untouched — no override, follows the global default.
+      const listB = (await getEvent(eventB)).body;
+      expect(listB.every((c) => c.override_position == null)).toBe(true);
+    });
+
+    it('accepts global ids but rejects another event’s category', async () => {
+      const eventId = await insertEvent('scope-ev');
+      const own = await insertCat('Own', { event_id: eventId });
+      const global = (await db('photo_categories').where('is_global', 1).first()).id;
+      const foreign = await insertCat('Foreign', { event_id: await insertEvent('other-ev') });
+
+      // A global id is allowed (globals can be arranged per event).
+      await auth(request(app).post('/api/admin/categories/reorder'))
+        .send({ event_id: eventId, orderedIds: [own, global] })
+        .expect(200);
+
+      // A foreign event's category is out of scope.
+      await auth(request(app).post('/api/admin/categories/reorder'))
+        .send({ event_id: eventId, orderedIds: [own, foreign] })
+        .expect(400);
+    });
+  });
+
+  describe('reset (DELETE /reorder/:eventId)', () => {
+    it('clears the override and reverts to the global default', async () => {
+      const eventId = await insertEvent('reset-ev');
+      const c1 = await insertCat('R-One', { event_id: eventId });
+      const list = (await getEvent(eventId)).body;
+      const globals = list.filter((c) => c.is_global).map((c) => c.id);
+
+      await auth(request(app).post('/api/admin/categories/reorder'))
+        .send({ event_id: eventId, orderedIds: [c1, ...globals] })
+        .expect(200);
+      expect((await getEvent(eventId)).body.some((c) => c.override_position != null)).toBe(true);
+
+      const res = await auth(request(app).delete(`/api/admin/categories/reorder/${eventId}`)).expect(200);
+      expect(res.body.every((c) => c.override_position == null)).toBe(true);
+      expect(await db('event_category_order').where({ event_id: eventId }).first()).toBeUndefined();
+    });
+  });
+
+  describe('event ownership (PR #790 review)', () => {
+    let limitedToken;
+    let foreignEventId;
+
+    beforeAll(async () => {
+      const bcrypt = require('bcrypt');
+      // A non-super_admin role that DOES hold settings.view + settings.edit —
+      // the exact case the review flagged (settings.edit is grantable).
+      const roleRes = await db('roles').insert({ name: 'gallery-mgr', display_name: 'Gallery Mgr' }).returning('id');
+      const roleId = roleRes[0]?.id ?? roleRes[0];
+      const permIds = await db('permissions').whereIn('name', ['settings.view', 'settings.edit']).pluck('id');
+      await db('role_permissions').insert(permIds.map((permission_id) => ({ role_id: roleId, permission_id })));
+
+      const a2 = await db('admin_users').insert({
+        username: 'limited', email: 'limited@example.com',
+        password_hash: await bcrypt.hash('x', 4), role_id: roleId,
+        must_change_password: false, created_at: new Date(),
+      }).returning('id');
+      limitedToken = mintAdminToken(a2[0]?.id ?? a2[0]);
+
+      // An event owned by a DIFFERENT admin (the seeded super_admin).
+      const owner = (await db('admin_users').where({ username: 'tester' }).first()).id;
+      await db('events').insert({
+        event_type: 'wedding', password_hash: 'x',
+        expires_at: new Date(Date.now() + 9e9).toISOString(),
+        is_active: true, is_archived: false, slug: 'owned-ev', share_link: 'owned-ev',
+        event_name: 'Owned', event_date: '2026-01-01', created_by: owner,
+      });
+      foreignEventId = (await db('events').where({ slug: 'owned-ev' }).first()).id;
+    });
+
+    const limitedAuth = (r) => r.set('Authorization', `Bearer ${limitedToken}`);
+
+    it('blocks a non-owner from reading, reordering or resetting another event', async () => {
+      await limitedAuth(request(app).get(`/api/admin/categories/event/${foreignEventId}`)).expect(403);
+      await limitedAuth(request(app).post('/api/admin/categories/reorder'))
+        .send({ event_id: foreignEventId, orderedIds: [1] }).expect(403);
+      await limitedAuth(request(app).delete(`/api/admin/categories/reorder/${foreignEventId}`)).expect(403);
+    });
+  });
+
+  describe('POST / (create) appends to the end of its scope', () => {
+    it('assigns display_order = max + 1 within the event', async () => {
+      const eventId = await insertEvent('append-ev');
+      await insertCat('First', { event_id: eventId, display_order: 1 });
+      await insertCat('Second', { event_id: eventId, display_order: 2 });
+
+      const res = await auth(request(app).post('/api/admin/categories'))
+        .send({ name: 'Third', is_global: false, event_id: eventId })
+        .expect(200);
+
+      expect(res.body.display_order).toBe(3);
+    });
+  });
+});
@@ -0,0 +1,413 @@
+/**
+ * CRM mint-and-send paths — integration tests (#587).
+ *
+ * Pins the three document "mint" flows end-to-end through the real
+ * HTTP → route → service → DB → email-queue → file pipeline:
+ *
+ *   1. POST /api/admin/quotes/:id/send        (draft → sent + PDF + token + email)
+ *   2. POST /api/admin/invoices/:id/cancel    (issued → cancelled + Storno row)
+ *      — the issue spec named this /:id/storno; the real route is
+ *        /:id/cancel (invoiceService.cancelInvoice → createStorno).
+ *   3. POST /api/admin/contracts/:id/countersign
+ *      (signed_by_customer → fully_signed + stamped PDF + sha256 + email)
+ *
+ * Real SQLite with the full core-migration run (helpers/crmDb), real
+ * pdfkit/pdf-lib rendering — no mock-fs, no network.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const request = require('supertest');
+const {
+  bootCrmDb, seedMinimal, assignAdminRole, mintAdminToken, buildRouteApp,
+} = require('./helpers/crmDb');
+
+// Full migration run + cold-requiring pdfService/emailProcessor is slow
+// under CI load; match the other CRM integration suites.
+jest.setTimeout(120000);
+
+const CUSTOMER_EMAIL = 'customer@example.com';
+
+// 1x1 transparent PNG — smallest valid signature pad output.
+const SIGNATURE_DATA_URL = 'data:image/png;base64,'
+  + 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
+
+// SQLite round-trips dates inconsistently (epoch ms number, numeric
+// string, or ISO string) — parse robustly before comparing.
+const toMillis = (v) => {
+  if (typeof v === 'number') return v;
+  if (typeof v === 'string' && /^\d+$/.test(v)) return Number(v);
+  return Date.parse(v);
+};
+
+const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex');
+
+// Count embedded image XObjects per page via pdf-lib — used to prove BOTH
+// signature stamps (customer + admin) made it into the final PDF instead of
+// only asserting file existence/hash (codex review of #850 round 2).
+async function countImagesPerPage(pdfPath) {
+  const { PDFDocument, PDFName, PDFDict } = require('pdf-lib');
+  const doc = await PDFDocument.load(fs.readFileSync(pdfPath));
+  return doc.getPages().map((page) => {
+    const resources = page.node.Resources();
+    const xobjects = resources && resources.lookupMaybe(PDFName.of('XObject'), PDFDict);
+    if (!xobjects) return 0;
+    let images = 0;
+    for (const [, ref] of xobjects.entries()) {
+      const stream = page.doc.context.lookup(ref);
+      const subtype = stream && stream.dict && stream.dict.get(PDFName.of('Subtype'));
+      if (subtype && subtype.toString() === '/Image') images += 1;
+    }
+    return images;
+  });
+}
+
+let db;
+let cleanup;
+let tmpDir;
+// Real (symlink-resolved) storage root — on macOS os.tmpdir() returns
+// /var/... while the services persist under process.cwd() which
+// resolves to /private/var/....
+let storageRoot;
+let adminId;
+let customerId;
+let token;
+let quoteApp;
+let invoiceApp;
+let contractApp;
+let quoteService;
+let invoiceService;
+let contractService;
+
+const prevCwd = process.cwd();
+
+const auth = { get Authorization() { return `Bearer ${token}`; } };
+
+async function enableFlag(key) {
+  const updated = await db('feature_flags').where({ key }).update({ value: true });
+  if (!updated) await db('feature_flags').insert({ key, value: true });
+}
+
+// ----- per-path seed helpers -----------------------------------------
+
+async function seedQuote() {
+  const id = await quoteService.createQuote({
+    customerAccountId: customerId,
+    currency: 'CHF',
+    vatRate: 0,
+    eventName: 'Testshooting',
+    lineItems: [
+      { position: 1, quantity: 1, description: 'Photo package', unit_price_minor: 150000, discount_percent: 0 },
+    ],
+  }, adminId);
+  return id;
+}
+
+async function seedIssuedInvoice(status = 'sent') {
+  const { invoiceIds } = await invoiceService.createInvoice({
+    customerAccountId: customerId,
+    currency: 'CHF',
+    vatRate: 7.7,
+    lineItems: [
+      { position: 1, quantity: 1, description: 'Wedding coverage', unit_price_minor: 200000, discount_percent: 0 },
+    ],
+  }, adminId);
+  const id = invoiceIds[0];
+  // Fast-forward past the send step — Storno only applies to issued
+  // documents (sent/paid/overdue), and rendering+sending the original
+  // is covered by the quote path already.
+  await db('invoices').where({ id }).update({
+    status, sent_at: new Date(), updated_at: new Date(),
+  });
+  return db('invoices').where({ id }).first();
+}
+
+async function seedCustomerSignedContract() {
+  const id = await contractService.createContract({
+    customerAccountId: customerId,
+    title: 'Fotografie-Vertrag',
+  }, adminId);
+  // Real send + customer-sign flow (codex review of #850): a direct
+  // status UPDATE skipped the customer's signature asset and stamped
+  // PDF, so countersign exercised its unsigned-PDF fallback and a
+  // regression dropping the customer's signature would stay green.
+  const { token } = await contractService.sendContract(id, adminId);
+  await contractService.recordCustomerSignature({
+    token,
+    name: 'Custo Mer',
+    ip: '127.0.0.1',
+    signatureDataUrl: SIGNATURE_DATA_URL,
+    accepted: true,
+  });
+  return db('contracts').where({ id }).first();
+}
+
+// ----- suite ----------------------------------------------------------
+
+beforeAll(async () => {
+  ({ db, cleanup, tmpDir } = await bootCrmDb());
+  // Business-doc PDFs (quotes/invoices/contracts) persist under
+  // `process.cwd()/storage/business-docs/...` — chdir into the temp dir
+  // so every test artifact lands isolated and gets cleaned up.
+  process.chdir(tmpDir);
+  storageRoot = path.join(fs.realpathSync(tmpDir), 'storage', 'business-docs');
+
+  // Fail-fast on the pre-existing logActivity-inside-transaction
+  // deadlock: createContract and createStorno call logActivity() from
+  // inside a knex transaction WITHOUT passing the trx as executor, so
+  // the audit insert tries to grab a second connection from the
+  // single-connection SQLite pool while the trx holds it. In
+  // production that stalls each call for the full 60 s acquire
+  // timeout (the error is then swallowed by logActivity's catch);
+  // here we shrink the timeout so the same swallowed failure costs
+  // 2 s instead of blowing the per-test budget. Behaviour under test
+  // is unchanged — the mint paths themselves never wait on this.
+  db.client.pool.acquireTimeoutMillis = 2000;
+
+  // node-sqlite3 detects Date bind params via `InstanceOf(global.Date)`
+  // against the NATIVE realm's Date — under jest's vm sandbox the
+  // service code's `new Date()` is a different constructor, the check
+  // fails, and the value stringifies to the literal "[object Object]"
+  // (the exact pathology helpers/crmDb.js documents for
+  // createPublicToken). Normalize Date bindings to ISO strings before
+  // they reach the driver so the real service inserts round-trip the
+  // same way they do outside jest.
+  // Patch on the prototype — knex mints transaction clients via
+  // Object.create(prototype), so an instance-level patch would miss
+  // every query issued inside a db.transaction().
+  const clientProto = Object.getPrototypeOf(db.client);
+  const origQuery = clientProto._query;
+  clientProto._query = function patchedQuery(connection, obj) {
+    if (obj && Array.isArray(obj.bindings)) {
+      obj.bindings = obj.bindings.map(
+        (b) => (b && typeof b === 'object' && typeof b.toISOString === 'function' ? b.toISOString() : b),
+      );
+    }
+    return origQuery.call(this, connection, obj);
+  };
+
+  ({ adminId, customerId } = await seedMinimal(db));
+  await assignAdminRole(db, adminId, 'super_admin');
+  token = mintAdminToken(adminId);
+
+  // CRM surfaces are feature-flagged; migration 107 seeds them OFF.
+  await enableFlag('quotes');
+  await enableFlag('bills');
+  await enableFlag('contracts');
+
+  quoteService = require('../../src/services/quoteService');
+  invoiceService = require('../../src/services/invoiceService');
+  contractService = require('../../src/services/contractService');
+
+  quoteApp = buildRouteApp('/api/admin/quotes', require('../../src/routes/adminQuotes'));
+  invoiceApp = buildRouteApp('/api/admin/invoices', require('../../src/routes/adminInvoices'));
+  contractApp = buildRouteApp('/api/admin/contracts', require('../../src/routes/adminContracts'));
+}, 120000);
+
+afterAll(async () => {
+  process.chdir(prevCwd);
+  if (cleanup) await cleanup();
+});
+
+describe('POST /api/admin/quotes/:id/send', () => {
+  test('draft quote: 200 → sent + sent_at + PDF on disk + action token + quote_sent email', async () => {
+    const quoteId = await seedQuote();
+    await db('email_queue').del();
+
+    const res = await request(quoteApp)
+      .post(`/api/admin/quotes/${quoteId}/send`)
+      .set(auth);
+    expect(res.status).toBe(200);
+    expect(res.body.sent).toBe(true);
+    expect(res.body.token).toMatch(/^[0-9a-f]{64}$/);
+
+    // DB state
+    const quote = await db('quotes').where({ id: quoteId }).first();
+    expect(quote.status).toBe('sent');
+    expect(quote.sent_at).toBeTruthy();
+
+    // PDF persisted inside the isolated storage root
+    expect(quote.pdf_path).toBeTruthy();
+    expect(quote.pdf_path.startsWith(path.join(storageRoot, 'quote'))).toBe(true);
+    expect(fs.existsSync(quote.pdf_path)).toBe(true);
+    expect(fs.statSync(quote.pdf_path).size).toBeGreaterThan(0);
+
+    // Action token row: right quote, future expiry
+    const tokenRow = await db('quote_action_tokens').where({ token: res.body.token }).first();
+    expect(tokenRow).toBeTruthy();
+    expect(tokenRow.quote_id).toBe(quoteId);
+    expect(toMillis(tokenRow.expires_at)).toBeGreaterThan(Date.now());
+
+    // Email queued to the customer's primary address
+    const emails = await db('email_queue').where({ email_type: 'quote_sent' });
+    expect(emails).toHaveLength(1);
+    expect(emails[0].recipient_email).toBe(CUSTOMER_EMAIL);
+    const emailData = JSON.parse(emails[0].email_data);
+    expect(emailData.quote_number).toBe(quote.quote_number);
+  });
+
+  test('already-sent quote: 409 (spec said 400; service throws 409)', async () => {
+    const quoteId = await seedQuote();
+    await request(quoteApp).post(`/api/admin/quotes/${quoteId}/send`).set(auth).expect(200);
+
+    const res = await request(quoteApp)
+      .post(`/api/admin/quotes/${quoteId}/send`)
+      .set(auth);
+    expect(res.status).toBe(409);
+    expect(res.body.error).toMatch(/cannot send a quote with status 'sent'/i);
+  });
+});
+
+describe('POST /api/admin/invoices/:id/cancel (Storno mint)', () => {
+  test('sent invoice: original cancelled, Storno row minted with negated totals + lineage', async () => {
+    const original = await seedIssuedInvoice('sent');
+    await db('email_queue').del();
+
+    const res = await request(invoiceApp)
+      .post(`/api/admin/invoices/${original.id}/cancel`)
+      .set(auth);
+    // Route responds via successResponse default — 200, not the 201
+    // the issue spec assumed.
+    expect(res.status).toBe(200);
+    expect(res.body.cancelled).toBe(true);
+    expect(res.body.stornoId).toBeGreaterThan(0);
+
+    const storno = await db('invoices').where({ id: res.body.stornoId }).first();
+    expect(storno.kind).toBe('storno');
+    expect(storno.cancels_invoice_id).toBe(original.id);
+    expect(storno.deal_uuid).toBe(original.deal_uuid);
+
+    // Negated amounts
+    expect(storno.net_amount_minor).toBe(-original.net_amount_minor);
+    expect(storno.vat_amount_minor).toBe(-original.vat_amount_minor);
+    expect(storno.total_amount_minor).toBe(-original.total_amount_minor);
+
+    // Freshly sequenced number from the same series
+    expect(typeof storno.invoice_number).toBe('string');
+    expect(storno.invoice_number.length).toBeGreaterThan(0);
+    expect(storno.invoice_number).not.toBe(original.invoice_number);
+
+    // Line items snapshotted onto the Storno
+    const originalItems = await db('invoice_line_items').where({ invoice_id: original.id });
+    const stornoItems = await db('invoice_line_items').where({ invoice_id: storno.id });
+    expect(stornoItems).toHaveLength(originalItems.length);
+
+    // Original flipped + back-linked
+    const refreshed = await db('invoices').where({ id: original.id }).first();
+    expect(refreshed.status).toBe('cancelled');
+    expect(refreshed.cancellation_storno_id).toBe(storno.id);
+
+    // sendStorno side effects (codex review of #850): cancelInvoice
+    // swallows a sendStorno failure by design, so without these
+    // assertions a broken render/persist/queue leg would stay green.
+    const sentStorno = await db('invoices').where({ id: storno.id }).first();
+    expect(sentStorno.status).toBe('sent');
+    expect(sentStorno.pdf_path).toBeTruthy();
+    expect(fs.existsSync(sentStorno.pdf_path)).toBe(true);
+    const stornoEmails = await db('email_queue').where({ email_type: 'storno_issued' });
+    expect(stornoEmails.length).toBeGreaterThanOrEqual(1);
+    expect(stornoEmails[0].recipient_email).toBe(CUSTOMER_EMAIL);
+  });
+
+  test('paid invoice can be cancelled via Storno too (refund document leg)', async () => {
+    const original = await seedIssuedInvoice('paid');
+
+    const res = await request(invoiceApp)
+      .post(`/api/admin/invoices/${original.id}/cancel`)
+      .set(auth);
+    expect(res.status).toBe(200);
+    expect(res.body.stornoId).toBeGreaterThan(0);
+
+    const refreshed = await db('invoices').where({ id: original.id }).first();
+    expect(refreshed.status).toBe('cancelled');
+  });
+
+  test('already-cancelled invoice: 409 ALREADY_CANCELLED', async () => {
+    const original = await seedIssuedInvoice('sent');
+    await request(invoiceApp).post(`/api/admin/invoices/${original.id}/cancel`).set(auth).expect(200);
+
+    const res = await request(invoiceApp)
+      .post(`/api/admin/invoices/${original.id}/cancel`)
+      .set(auth);
+    expect(res.status).toBe(409);
+    expect(res.body.code).toBe('ALREADY_CANCELLED');
+  });
+});
+
+describe('POST /api/admin/contracts/:id/countersign', () => {
+  test('customer-signed contract: 200 → fully_signed + stamped PDF + sha256 + signature asset + email with attachment', async () => {
+    const contract = await seedCustomerSignedContract();
+    await db('email_queue').del();
+
+    const res = await request(contractApp)
+      .post(`/api/admin/contracts/${contract.id}/countersign`)
+      .set(auth)
+      .send({ name: 'Admin Tester', signatureDataUrl: SIGNATURE_DATA_URL });
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe('fully_signed');
+
+    const row = await db('contracts').where({ id: contract.id }).first();
+    expect(row.status).toBe('fully_signed');
+    expect(row.signed_admin_name).toBe('Admin Tester');
+    expect(row.signed_by_admin_at).toBeTruthy();
+
+    // The customer's own signature (from the real sign flow in the seed)
+    // must survive countersigning — layered, not replaced.
+    expect(row.signed_customer_signature_path).toBeTruthy();
+    expect(fs.existsSync(row.signed_customer_signature_path)).toBe(true);
+    expect(row.signed_customer_name).toBe('Custo Mer');
+
+    // Admin signature image persisted under the storage root
+    expect(row.signed_admin_signature_path).toBeTruthy();
+    expect(row.signed_admin_signature_path.startsWith(
+      path.join(storageRoot, 'contract', 'signatures'),
+    )).toBe(true);
+    expect(fs.existsSync(row.signed_admin_signature_path)).toBe(true);
+
+    // Stamped, fully-signed PDF written and hashed. The issue spec
+    // called this `integrity_hash`; the real column is
+    // `signed_pdf_sha256` (plus `pdf_sha256` for the unsigned base).
+    expect(row.signed_pdf_render_failed_at).toBeFalsy();
+    expect(row.signed_pdf_path).toBeTruthy();
+    expect(fs.existsSync(row.signed_pdf_path)).toBe(true);
+    expect(row.signed_pdf_sha256).toMatch(/^[0-9a-f]{64}$/);
+    expect(sha256(fs.readFileSync(row.signed_pdf_path))).toBe(row.signed_pdf_sha256);
+
+    // BOTH stamps must be embedded in the final document — a regression
+    // stamping the admin onto the unsigned base PDF would keep every
+    // path/hash assertion above green (codex review of #850 round 2).
+    const imagesPerPage = await countImagesPerPage(row.signed_pdf_path);
+    const maxImagesOnAPage = Math.max(...imagesPerPage);
+    expect(maxImagesOnAPage).toBeGreaterThanOrEqual(2);
+
+    // contract_fully_signed email to the customer's primary address,
+    // carrying the signed PDF as attachment (plus the audit cert).
+    const emails = await db('email_queue').where({ email_type: 'contract_fully_signed' });
+    const customerCopy = emails.find((e) => e.recipient_email === CUSTOMER_EMAIL);
+    expect(customerCopy).toBeTruthy();
+    const emailData = JSON.parse(customerCopy.email_data);
+    expect(emailData.contract_number).toBe(contract.contract_number);
+    expect(Array.isArray(emailData.attachments)).toBe(true);
+    const pdfAttachment = emailData.attachments.find(
+      (a) => a.filename === `${contract.contract_number}-signed.pdf`,
+    );
+    expect(pdfAttachment).toBeTruthy();
+    expect(pdfAttachment.contentType).toBe('application/pdf');
+    expect(fs.existsSync(pdfAttachment.contentPath)).toBe(true);
+  });
+
+  test('draft contract: 409 — countersign requires sent/signed_by_customer', async () => {
+    const draftId = await contractService.createContract({
+      customerAccountId: customerId,
+      title: 'Noch nicht versendet',
+    }, adminId);
+
+    const res = await request(contractApp)
+      .post(`/api/admin/contracts/${draftId}/countersign`)
+      .set(auth)
+      .send({ name: 'Admin Tester' });
+    expect(res.status).toBe(409);
+    expect(res.body.error).toMatch(/cannot counter-sign a contract with status 'draft'/i);
+  });
+});
@@ -0,0 +1,50 @@
+/**
+ * Catalog-driven event-type defaults (#800 follow-up).
+ *
+ * The contract→event conversion used to hardcode `event_type: 'wedding'` and
+ * the v1 API validated against a fixed whitelist. Both now follow the live
+ * event_types catalog; these tests pin the shared resolver.
+ */
+
+const { bootCrmDb } = require('./helpers/crmDb');
+
+describe('resolveDefaultEventType follows the catalog', () => {
+  let db;
+  let cleanup;
+  let eventTypeService;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    // Require AFTER bootCrmDb so the service shares this db instance
+    // (see crmDb.js — a second knex pool on one SQLite file deadlocks).
+    eventTypeService = require('../../src/services/eventTypeService');
+  }, 120000);
+
+  afterAll(async () => {
+    if (cleanup) await cleanup();
+  });
+
+  it("prefers the 'other' catch-all while it is active", async () => {
+    expect(await eventTypeService.resolveDefaultEventType()).toBe('other');
+  });
+
+  it('falls over to the first active type when other is deactivated', async () => {
+    const other = await db('event_types').where({ slug_prefix: 'other' }).first();
+    await db('event_types').where({ id: other.id }).update({ is_active: 0 });
+
+    const resolved = await eventTypeService.resolveDefaultEventType();
+    expect(resolved).not.toBe('other');
+    expect(await db('event_types').where({ slug_prefix: resolved }).first()).toBeTruthy();
+
+    await db('event_types').where({ id: other.id }).update({ is_active: 1 });
+  });
+
+  it("returns the literal 'other' only for an empty catalog", async () => {
+    const rows = await db('event_types').select('*');
+    await db('event_types').del();
+
+    expect(await eventTypeService.resolveDefaultEventType()).toBe('other');
+
+    await db('event_types').insert(rows);
+  });
+});
@@ -0,0 +1,133 @@
+/**
+ * Setup-window event type deletion (#800).
+ *
+ * The first-run setup wizard may delete the seeded SYSTEM event types —
+ * but ONLY while the `setup_wizard_completed` flag is unset (migration 161
+ * seeds it false on a fresh install, true when an admin already exists).
+ * These tests pin the whole contract:
+ *
+ *   - fresh install → flag false → system types deletable (in-use checks
+ *     still apply), and the per-type reminder template goes with the type
+ *   - reminder-template self-heal does NOT resurrect templates for slugs
+ *     that no longer exist in the catalog
+ *   - after markSetupWizardCompleted() → system deletion is refused again
+ */
+
+const { bootCrmDb } = require('./helpers/crmDb');
+
+describe('event type deletion during the setup window (#800)', () => {
+  let db;
+  let cleanup;
+  let eventTypeService;
+  let setupService;
+  let ensureEventReminderTemplatesSeeded;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    // Require AFTER bootCrmDb so every service shares this db instance
+    // (see crmDb.js — a second knex pool on one SQLite file deadlocks).
+    eventTypeService = require('../../src/services/eventTypeService');
+    setupService = require('../../src/services/setupService');
+    ({ ensureEventReminderTemplatesSeeded } = require('../../src/services/eventReminderTemplates'));
+  }, 120000);
+
+  afterAll(async () => {
+    if (cleanup) await cleanup();
+  });
+
+  it('migration 161 seeds the flag false on a fresh (admin-less) install', async () => {
+    const row = await db('app_settings').where({ setting_key: 'setup_wizard_completed' }).first();
+    expect(row).toBeTruthy();
+    expect(JSON.parse(row.setting_value)).toBe(false);
+    expect(await setupService.isSetupWizardCompleted()).toBe(false);
+  });
+
+  it('refuses to delete a system type that events already use, even in the window', async () => {
+    const corporate = await db('event_types').where({ slug_prefix: 'corporate' }).first();
+    await db('events').insert({
+      slug: 'corporate-test-2026-01-01',
+      event_name: 'Test',
+      event_type: 'corporate',
+      event_date: '2026-01-01',
+      host_email: 'host@example.com',
+      admin_email: 'admin@example.com',
+      password_hash: 'x',
+      share_link: 'share-corporate-test',
+      expires_at: new Date(Date.now() + 86400000),
+    });
+
+    await expect(eventTypeService.deleteEventType(corporate.id))
+      .rejects.toMatchObject({ code: 'IN_USE' });
+  });
+
+  it('deletes an unused system type in the window, taking its reminder template along', async () => {
+    // Seed the per-type reminder templates first so there is something to clean up.
+    await ensureEventReminderTemplatesSeeded(db);
+    expect(await db('email_templates').where({ template_key: 'event_reminder_wedding' }).first()).toBeTruthy();
+
+    const wedding = await db('event_types').where({ slug_prefix: 'wedding' }).first();
+    expect(wedding.is_system).toBeTruthy();
+
+    const result = await eventTypeService.deleteEventType(wedding.id);
+    expect(result.success).toBe(true);
+
+    expect(await db('event_types').where({ slug_prefix: 'wedding' }).first()).toBeFalsy();
+    expect(await db('email_templates').where({ template_key: 'event_reminder_wedding' }).first()).toBeFalsy();
+
+    // The deleted slug must NOT stay creatable through the legacy fallback —
+    // the live catalog is authoritative while it has rows.
+    expect(await eventTypeService.isValidEventType('wedding')).toBe(false);
+    expect(await eventTypeService.isValidEventType('birthday')).toBe(true);
+  });
+
+  it('does not resurrect reminder templates for deleted types on the next self-heal pass', async () => {
+    // The seeder caches success per process — reset the module to force a
+    // genuine second pass, exactly what a backend restart would run.
+    jest.resetModules();
+    const fresh = require('../../src/services/eventReminderTemplates');
+    await fresh.ensureEventReminderTemplatesSeeded(db);
+
+    expect(await db('email_templates').where({ template_key: 'event_reminder_wedding' }).first()).toBeFalsy();
+    // Types still in the catalog keep their templates.
+    expect(await db('email_templates').where({ template_key: 'event_reminder_birthday' }).first()).toBeTruthy();
+    expect(await db('email_templates').where({ template_key: 'event_reminder_default' }).first()).toBeTruthy();
+  });
+
+  it('re-locks system types once the wizard is marked complete', async () => {
+    await setupService.markSetupWizardCompleted();
+    expect(await setupService.isSetupWizardCompleted()).toBe(true);
+
+    const birthday = await db('event_types').where({ slug_prefix: 'birthday' }).first();
+    await expect(eventTypeService.deleteEventType(birthday.id))
+      .rejects.toMatchObject({ code: 'SYSTEM_TYPE' });
+
+    // Custom (non-system) types remain deletable as before.
+    const custom = await eventTypeService.createEventType({ name: 'Family', slug_prefix: 'family' });
+    const result = await eventTypeService.deleteEventType(custom.id);
+    expect(result.success).toBe(true);
+  });
+
+  it('fails closed when the completion marker row is missing', async () => {
+    // A portable-backup restore can replace app_settings with a set that
+    // predates migration 161 (which will not rerun) — absence must mean
+    // "configured instance", never an open deletion window.
+    await db('app_settings').where({ setting_key: 'setup_wizard_completed' }).del();
+    expect(await setupService.isSetupWizardCompleted()).toBe(true);
+    await setupService.markSetupWizardCompleted();
+  });
+
+  it('refuses to delete the last remaining event type', async () => {
+    // Reduce the catalog to a single custom type via direct db writes (the
+    // service paths are already covered above), then hit the guard.
+    const solo = await eventTypeService.createEventType({ name: 'Solo', slug_prefix: 'solo' });
+    await db('events').del();
+    await db('event_types').whereNot('id', solo.id).del();
+
+    await expect(eventTypeService.deleteEventType(solo.id))
+      .rejects.toMatchObject({ code: 'LAST_TYPE' });
+
+    // Deactivating it would empty the ACTIVE catalog just the same.
+    await expect(eventTypeService.updateEventType(solo.id, { is_active: false }))
+      .rejects.toMatchObject({ code: 'LAST_ACTIVE' });
+  });
+});
@@ -1,216 +0,0 @@
-/**
- * Guest filters must respect show_feedback_to_guests (#1044 follow-up).
- *
- * Every filter token on /photos is an OR of two halves: what THIS viewer
- * marked, and what ANYONE marked. The response fields built from the second
- * half — like_count, comment_count — are all gated on
- * show_feedback_to_guests. The FILTER was not.
- *
- * So with the setting off, the numbers were hidden but `?filter=liked` still
- * returned exactly the photos other people had liked: the same information as
- * a set instead of a count, one token at a time. These tests pin the gate on
- * every token, and pin that the viewer's own half is never gated — filtering
- * by what you yourself marked is yours to do regardless.
- */
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('./helpers/crmDb');
-
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'filter-visibility-secret';
-
-const SLUG = 'filter-visibility-event';
-const ME = 'guest-me-identifier';
-const SOMEONE_ELSE = 'guest-other-identifier';
-
-describe('guest filters and show_feedback_to_guests (#1044)', () => {
-  let db;
-  let cleanup;
-  let app;
-  let eventId;
-  let mine;
-  let theirs;
-  let myGuestRowId;
-
-  const galleryToken = () => jwt.sign(
-    { eventId, eventSlug: SLUG, type: 'gallery' },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-
-  const setVisibility = (visible) => db('event_feedback_settings')
-    .where({ event_id: eventId })
-    .update({ show_feedback_to_guests: visible });
-
-  // A real verified guest, which is how the viewer's own feedback is actually
-  // identified — NOT the `guest_id` query parameter the frontend invents.
-  const guestToken = () => jwt.sign(
-    { type: 'guest', guestId: myGuestRowId, eventId },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-
-  const filter = async (token, { as = 'me', claimGuestId } = {}) => {
-    const req = request(app)
-      .get(`/api/gallery/${SLUG}/photos`)
-      .query({ filter: token, ...(claimGuestId ? { guest_id: claimGuestId } : {}) })
-      .set('Authorization', `Bearer ${galleryToken()}`);
-    if (as === 'me') req.set('x-guest-token', guestToken());
-    const res = await req;
-    expect(res.status).toBe(200);
-    const photos = Array.isArray(res.body) ? res.body : res.body.photos;
-    return (photos || []).map((p) => p.id).sort((a, b) => a - b);
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const inserted = await db('events').insert({
-      slug: SLUG,
-      event_type: 'wedding',
-      event_name: 'Filter Visibility',
-      event_date: '2026-08-01',
-      host_email: 'host@example.com',
-      admin_email: 'admin@example.com',
-      password_hash: 'x',
-      share_link: `/gallery/${SLUG}/share`,
-      share_token: 'filter-visibility-share',
-      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-      is_active: 1,
-      is_archived: 0,
-      is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    eventId = inserted[0]?.id ?? inserted[0];
-
-    const addPhoto = async (name) => {
-      const p = await db('photos').insert({
-        event_id: eventId,
-        filename: name,
-        path: `events/filter/${name}`,
-        type: 'individual',
-        uploaded_at: new Date().toISOString(),
-      }).returning('id');
-      return p[0]?.id ?? p[0];
-    };
-    mine = await addPhoto('mine.jpg');
-    theirs = await addPhoto('theirs.jpg');
-
-    await db('event_feedback_settings').insert({
-      event_id: eventId,
-      feedback_enabled: true,
-      allow_likes: true,
-      allow_comments: true,
-      allow_ratings: true,
-      allow_favorites: true,
-      moderate_comments: false,
-      show_feedback_to_guests: true,
-    });
-
-    const guestRow = await db('gallery_guests').insert({
-      event_id: eventId,
-      name: 'Me',
-      identifier: ME,
-      created_at: new Date().toISOString(),
-      last_seen_at: new Date().toISOString(),
-      is_deleted: false,
-    }).returning('id');
-    myGuestRowId = guestRow[0]?.id ?? guestRow[0];
-
-    const feedback = (photoId, who, type, extra = {}) => db('photo_feedback').insert({
-      photo_id: photoId,
-      event_id: eventId,
-      guest_identifier: who,
-      // Submission links to the per-person guest row when one is present, and
-      // that is the column the viewer's own half resolves through.
-      guest_id: who === ME ? myGuestRowId : null,
-      feedback_type: type,
-      is_approved: true,
-      is_hidden: false,
-      created_at: new Date().toISOString(),
-      ...extra,
-    });
-
-    // Everything on `theirs` belongs to somebody else; `mine` is this viewer's.
-    await feedback(mine, ME, 'like');
-    await feedback(theirs, SOMEONE_ELSE, 'like');
-    await feedback(theirs, SOMEONE_ELSE, 'favorite');
-    await feedback(theirs, SOMEONE_ELSE, 'comment', { comment_text: 'lovely' });
-    await feedback(theirs, SOMEONE_ELSE, 'rating', { rating: 5 });
-
-    // The denormalized counters the aggregate half of the filter reads.
-    await db('photos').where('id', theirs).update({
-      like_count: 1, favorite_count: 1, comment_count: 1, average_rating: 5,
-    });
-    await db('photos').where('id', mine).update({ like_count: 1 });
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/gallery', require('../../src/routes/gallery'));
-  }, 120000);
-
-  afterAll(async () => {
-    if (cleanup) await cleanup();
-  });
-
-  describe('with feedback visible to guests', () => {
-    beforeAll(() => setVisibility(true));
-
-    it('shows other people\'s marks through every token, as before', async () => {
-      expect(await filter('liked')).toEqual([mine, theirs].sort((a, b) => a - b));
-      expect(await filter('favorited')).toEqual([theirs]);
-      expect(await filter('rated')).toEqual([theirs]);
-      expect(await filter('commented')).toEqual([theirs]);
-    });
-  });
-
-  describe('with feedback hidden from guests', () => {
-    beforeAll(() => setVisibility(false));
-
-    it('stops every token from selecting on other people\'s marks', async () => {
-      // `theirs` is the photo only other guests marked. It must not come back
-      // through any token — a filter that selects on hidden feedback reports
-      // that feedback just as surely as a count would.
-      expect(await filter('favorited')).toEqual([]);
-      expect(await filter('rated')).toEqual([]);
-      expect(await filter('commented')).toEqual([]);
-    });
-
-    it('still filters by what the viewer marked themselves', async () => {
-      // The viewer's own half is never gated: this is their own action, and
-      // hiding it would break "show me the ones I liked" for no privacy gain.
-      expect(await filter('liked')).toEqual([mine]);
-    });
-
-    it('drops the viewer\'s own feedback once an admin hides it', async () => {
-      // Moderation has to reach the filter too. getPhotoFeedback excludes
-      // hidden rows for the guest's OWN feedback, so a photo matching here
-      // would come back with nothing visible on it to explain why.
-      await db('photo_feedback')
-        .where({ photo_id: mine, guest_id: myGuestRowId, feedback_type: 'like' })
-        .update({ is_hidden: true });
-
-      expect(await filter('liked')).toEqual([]);
-
-      await db('photo_feedback')
-        .where({ photo_id: mine, guest_id: myGuestRowId, feedback_type: 'like' })
-        .update({ is_hidden: false });
-      expect(await filter('liked')).toEqual([mine]);
-    });
-
-    it('ignores a guest_id supplied by the caller', async () => {
-      // The own-half is resolved from the request identity. If it honoured the
-      // query string instead, anyone holding another guest's identifier could
-      // read that guest's hidden memberships one token at a time — straight
-      // back through the gate this file exists to pin.
-      expect(await filter('favorited', { claimGuestId: SOMEONE_ELSE })).toEqual([]);
-      // And an anonymous caller claiming to be me gets nothing of mine.
-      expect(await filter('liked', { as: 'anon', claimGuestId: ME })).toEqual([]);
-    });
-  });
-});
@@ -0,0 +1,121 @@
+/**
+ * Gallery password invisible-Unicode fallback (#654).
+ *
+ * Passwords relayed through chat apps (Instagram DMs especially) pick up
+ * invisible characters on copy-paste — zero-width space/joiners, word
+ * joiner, BOM, soft hyphen — which fail the byte-exact bcrypt compare and
+ * surface as "incorrect password" for a correct password. The verify route
+ * retries the compare with those characters stripped, in the SAME request,
+ * so the fallback costs no reCAPTCHA token and no failed-attempt quota.
+ *
+ * Pins the contract:
+ *  - exact submitted bytes always win first, so stored passwords that
+ *    legitimately contain these characters (e.g. ZWJ emoji sequences)
+ *    keep working
+ *  - paste artifacts (mid-string ZWSP, leading BOM, trailing space) are
+ *    rescued by the sanitized fallback compare
+ *  - the fallback never invents a match (missing ZWJ still 401s), and a
+ *    rescued login records no failed attempt
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bcrypt = require('bcrypt');
+
+const { bootCrmDb, seedMinimal } = require('./helpers/crmDb');
+
+process.env.JWT_SECRET = process.env.JWT_SECRET || 'sanitize-test-secret';
+
+const PLAIN_SLUG = 'sanitize-plain-event';
+const ZWJ_SLUG = 'sanitize-zwj-event';
+const PLAIN_PASSWORD = 'wedding2026';
+// Stored password legitimately containing a ZWJ emoji sequence.
+const ZWJ_PASSWORD = 'Family\u{1F468}\u200D\u{1F469}Aa1';
+
+describe('gallery/verify invisible-Unicode fallback (#654)', () => {
+  let db;
+  let cleanup;
+  let app;
+
+  const makeEvent = async (slug, password) => {
+    const inserted = await db('events').insert({
+      slug,
+      event_type: 'wedding',
+      event_name: `Sanitize ${slug}`,
+      event_date: '2026-08-01',
+      host_email: 'host@example.com',
+      admin_email: 'admin@example.com',
+      password_hash: await bcrypt.hash(password, 4),
+      share_link: `/gallery/${slug}/share`,
+      share_token: `${slug}-share`,
+      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
+      is_active: 1,
+      is_archived: 0,
+      is_draft: 0,
+      created_at: new Date().toISOString(),
+    }).returning('id');
+    return inserted[0]?.id ?? inserted[0];
+  };
+  let plainEventId;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    await seedMinimal(db);
+    plainEventId = await makeEvent(PLAIN_SLUG, PLAIN_PASSWORD);
+    await makeEvent(ZWJ_SLUG, ZWJ_PASSWORD);
+
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/auth', require('../../src/routes/auth'));
+  }, 120000);
+
+  afterAll(async () => {
+    if (cleanup) await cleanup();
+  });
+
+  const verify = (slug, password) =>
+    request(app).post('/api/auth/gallery/verify').send({ slug, password });
+
+  it('accepts the exact password', async () => {
+    const res = await verify(PLAIN_SLUG, PLAIN_PASSWORD);
+    expect(res.status).toBe(200);
+    expect(res.body.token).toBeTruthy();
+  });
+
+  it('rescues a mid-string zero-width space from chat-app copy-paste', async () => {
+    const res = await verify(PLAIN_SLUG, 'wedding\u200B2026');
+    expect(res.status).toBe(200);
+    expect(res.body.token).toBeTruthy();
+  });
+
+  it('rescues leading BOM + trailing space paste artifacts', async () => {
+    const res = await verify(PLAIN_SLUG, `\uFEFF${PLAIN_PASSWORD} `);
+    expect(res.status).toBe(200);
+    expect(res.body.token).toBeTruthy();
+  });
+
+  it('records no login_fail for a rescued login (single-request fallback)', async () => {
+    await verify(PLAIN_SLUG, 'wedding\u200B2026').expect(200);
+    const failed = await db('access_logs')
+      .where({ event_id: plainEventId, action: 'login_fail' });
+    expect(failed).toHaveLength(0);
+  });
+
+  it('still accepts a stored password that legitimately contains a ZWJ', async () => {
+    const res = await verify(ZWJ_SLUG, ZWJ_PASSWORD);
+    expect(res.status).toBe(200);
+    expect(res.body.token).toBeTruthy();
+  });
+
+  it('does not invent a match when the ZWJ is missing from the input', async () => {
+    const res = await verify(ZWJ_SLUG, 'Family\u{1F468}\u{1F469}Aa1');
+    expect(res.status).toBe(401);
+  });
+
+  it('rejects a plain wrong password', async () => {
+    const res = await verify(PLAIN_SLUG, 'not-the-password');
+    expect(res.status).toBe(401);
+  });
+});
@@ -0,0 +1,167 @@
+/**
+ * Minimal in-process OIDC provider for integration tests (#798).
+ *
+ * Serves just enough of the spec for openid-client's full validation to
+ * pass: discovery, JWKS (RS256), authorization endpoint (immediate redirect,
+ * no login UI), and token endpoint (authorization_code + PKCE). Claims for
+ * the next login are scripted per test via `setNextUser()`.
+ *
+ * Runs on an ephemeral localhost port over plain http — the service allows
+ * that in NODE_ENV=test only.
+ */
+
+const http = require('http');
+const crypto = require('crypto');
+const { URL } = require('url');
+
+function b64url(input) {
+  return Buffer.from(input).toString('base64url');
+}
+
+class MockOidcProvider {
+  constructor() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 2048 });
+    this.privateKey = privateKey;
+    this.publicJwk = publicKey.export({ format: 'jwk' });
+    this.publicJwk.kid = 'test-key-1';
+    this.publicJwk.alg = 'RS256';
+    this.publicJwk.use = 'sig';
+
+    this.clientId = 'picpeak-test';
+    this.clientSecret = 'test-client-secret';
+    this.codes = new Map(); // code -> { nonce, redirectUri, codeChallenge, user }
+    this.nextUser = { sub: 'user-1', email: 'sso@example.com', email_verified: true };
+    // Test hooks:
+    this.tamperNonce = false; // sign the ID token with a WRONG nonce
+    this.emailViaUserinfoOnly = false; // omit email from the ID token; serve it on /userinfo
+    this.advertiseEndSession = true; // include end_session_endpoint in discovery (#798 phase 3)
+    this.accessTokens = new Map(); // access_token -> user (for /userinfo)
+    this.server = null;
+    this.issuer = null;
+  }
+
+  setNextUser(user) {
+    this.nextUser = user;
+  }
+
+  signIdToken({ sub, nonce, extraClaims = {} }) {
+    const now = Math.floor(Date.now() / 1000);
+    const header = { alg: 'RS256', kid: this.publicJwk.kid, typ: 'JWT' };
+    const payload = {
+      iss: this.issuer,
+      aud: this.clientId,
+      sub,
+      iat: now,
+      exp: now + 300,
+      nonce,
+      ...extraClaims,
+    };
+    const signingInput = `${b64url(JSON.stringify(header))}.${b64url(JSON.stringify(payload))}`;
+    const signature = crypto.sign('RSA-SHA256', Buffer.from(signingInput), this.privateKey);
+    return `${signingInput}.${signature.toString('base64url')}`;
+  }
+
+  async start() {
+    this.server = http.createServer((req, res) => this.handle(req, res));
+    await new Promise((resolve) => this.server.listen(0, '127.0.0.1', resolve));
+    this.issuer = `http://127.0.0.1:${this.server.address().port}`;
+    return this.issuer;
+  }
+
+  async stop() {
+    if (this.server) await new Promise((resolve) => this.server.close(resolve));
+  }
+
+  handle(req, res) {
+    const url = new URL(req.url, this.issuer);
+    const json = (status, body) => {
+      res.writeHead(status, { 'content-type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+
+    if (url.pathname === '/.well-known/openid-configuration') {
+      return json(200, {
+        issuer: this.issuer,
+        authorization_endpoint: `${this.issuer}/authorize`,
+        token_endpoint: `${this.issuer}/token`,
+        userinfo_endpoint: `${this.issuer}/userinfo`,
+        jwks_uri: `${this.issuer}/jwks`,
+        ...(this.advertiseEndSession ? { end_session_endpoint: `${this.issuer}/logout` } : {}),
+        response_types_supported: ['code'],
+        subject_types_supported: ['public'],
+        id_token_signing_alg_values_supported: ['RS256'],
+        code_challenge_methods_supported: ['S256'],
+        token_endpoint_auth_methods_supported: ['client_secret_basic', 'client_secret_post'],
+      });
+    }
+
+    if (url.pathname === '/jwks') {
+      return json(200, { keys: [this.publicJwk] });
+    }
+
+    if (url.pathname === '/authorize') {
+      // "Log in" instantly: mint a code bound to this request's params and
+      // bounce back to the redirect_uri like a real IdP would.
+      const code = crypto.randomBytes(16).toString('base64url');
+      this.codes.set(code, {
+        nonce: url.searchParams.get('nonce'),
+        redirectUri: url.searchParams.get('redirect_uri'),
+        codeChallenge: url.searchParams.get('code_challenge'),
+        user: this.nextUser,
+      });
+      const back = new URL(url.searchParams.get('redirect_uri'));
+      back.searchParams.set('code', code);
+      back.searchParams.set('state', url.searchParams.get('state'));
+      res.writeHead(302, { location: back.href });
+      return res.end();
+    }
+
+    if (url.pathname === '/token' && req.method === 'POST') {
+      let body = '';
+      req.on('data', (c) => { body += c; });
+      req.on('end', () => {
+        const params = new URLSearchParams(body);
+        const stored = this.codes.get(params.get('code'));
+        if (!stored) return json(400, { error: 'invalid_grant' });
+        this.codes.delete(params.get('code'));
+
+        // PKCE check — S256(code_verifier) must match the challenge.
+        const verifier = params.get('code_verifier') || '';
+        const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
+        if (challenge !== stored.codeChallenge) {
+          return json(400, { error: 'invalid_grant', error_description: 'PKCE verification failed' });
+        }
+
+        const { sub, ...extraClaims } = stored.user;
+        // Spec-compliant providers may keep profile/email claims OFF the ID
+        // token and serve them from /userinfo only — this hook simulates that.
+        const idTokenClaims = this.emailViaUserinfoOnly ? {} : extraClaims;
+        const idToken = this.signIdToken({
+          sub,
+          nonce: this.tamperNonce ? 'tampered-nonce' : stored.nonce,
+          extraClaims: idTokenClaims,
+        });
+        const accessToken = crypto.randomBytes(16).toString('base64url');
+        this.accessTokens.set(accessToken, stored.user);
+        return json(200, {
+          access_token: accessToken,
+          token_type: 'Bearer',
+          expires_in: 300,
+          id_token: idToken,
+        });
+      });
+      return undefined;
+    }
+
+    if (url.pathname === '/userinfo') {
+      const auth = req.headers.authorization || '';
+      const user = this.accessTokens.get(auth.replace(/^Bearer\s+/i, ''));
+      if (!user) return json(401, { error: 'invalid_token' });
+      return json(200, { ...user });
+    }
+
+    return json(404, { error: 'not_found' });
+  }
+}
+
+module.exports = { MockOidcProvider };
@@ -1,245 +0,0 @@
-/**
- * Hidden feedback, seen from the guest who left it (#1150).
- *
- * Everything in the system treats a hidden row as absent: getPhotoFeedback
- * drops it even for the guest's own feedback, the /photos filters drop it, and
- * updatePhotoFeedbackStats does not count it. One place disagreed — the
- * per-viewer `is_liked` heart — so a like the photographer had hidden still
- * showed as liked on a photo whose like_count was zero. (The `my_color_label`
- * badge has the same shape on main; colour labels are not on this branch.)
- *
- * Making those two agree exposes the second half: the duplicate check that
- * powers like/favorite toggling did NOT skip hidden rows, so the now-empty
- * heart, when clicked, found the hidden row and toggled it OFF. The click
- * appeared to do nothing and it took two more to get back to a filled heart.
- *
- * Hiding a non-comment is deliberate, not an accident of the raw route: #839
- * and #1044 both ship it, with tests asserting that a hidden reaction or
- * colour label stops counting. So the fix is to make hidden mean absent
- * consistently — not to stop admins hiding these.
- */
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('./helpers/crmDb');
-
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'hidden-feedback-secret';
-
-const SLUG = 'hidden-own-feedback';
-const ME = 'guest-me-identifier';
-
-describe('a guest\'s own hidden feedback (#1150)', () => {
-  let db; let cleanup; let app; let feedbackService;
-  let eventId; let photoId; let myGuestRowId;
-
-  const galleryToken = () => jwt.sign(
-    { eventId, eventSlug: SLUG, type: 'gallery' },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-  const guestToken = () => jwt.sign(
-    { type: 'guest', guestId: myGuestRowId, eventId },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-
-  const getPhoto = async () => {
-    const res = await request(app)
-      .get(`/api/gallery/${SLUG}/photos`)
-      .set('Authorization', `Bearer ${galleryToken()}`)
-      .set('x-guest-token', guestToken());
-    expect(res.status).toBe(200);
-    const photos = Array.isArray(res.body) ? res.body : res.body.photos;
-    return (photos || []).find((p) => p.id === photoId);
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-    feedbackService = require('../../src/services/feedbackService');
-
-    const [ev] = await db('events').insert({
-      slug: SLUG,
-      event_type: 'wedding',
-      event_name: 'Hidden Own Feedback',
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_link: `/gallery/${SLUG}/share`,
-      share_token: 'hidden-own-share',
-      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    eventId = typeof ev === 'object' ? ev.id : ev;
-
-    const [p] = await db('photos').insert({
-      event_id: eventId, filename: 'shot.jpg', path: 'events/hidden/shot.jpg',
-      type: 'individual', uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    photoId = typeof p === 'object' ? p.id : p;
-
-    const [g] = await db('gallery_guests').insert({
-      event_id: eventId, name: 'Me', identifier: ME,
-      created_at: new Date().toISOString(), last_seen_at: new Date().toISOString(),
-      is_deleted: false,
-    }).returning('id');
-    myGuestRowId = typeof g === 'object' ? g.id : g;
-
-    await db('event_feedback_settings').insert({
-      event_id: eventId, feedback_enabled: true, allow_likes: true,
-      moderate_comments: false,
-      show_feedback_to_guests: true,
-    });
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/gallery', require('../../src/routes/gallery'));
-    app.use('/api/gallery', require('../../src/routes/galleryFeedback'));
-  }, 180000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  const like = () => db('photo_feedback').insert({
-    photo_id: photoId, event_id: eventId, guest_identifier: ME,
-    guest_id: myGuestRowId, feedback_type: 'like',
-    is_approved: true, is_hidden: false, created_at: new Date().toISOString(),
-  });
-
-  beforeEach(async () => {
-    await db('photo_feedback').where({ photo_id: photoId }).del();
-    await db('photos').where('id', photoId).update({ like_count: 0 });
-  });
-
-  describe('the read surfaces agree with each other', () => {
-    it('un-fills the heart once the like is hidden', async () => {
-      await like();
-      await feedbackService.updatePhotoFeedbackStats(photoId);
-      expect((await getPhoto()).is_liked).toBe(true);
-
-      await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like' })
-        .update({ is_hidden: true });
-      await feedbackService.updatePhotoFeedbackStats(photoId);
-
-      const photo = await getPhoto();
-      // like_count already ignored hidden rows, so the heart was the only
-      // thing still claiming this photo was liked.
-      expect(photo.like_count).toBe(0);
-      expect(photo.is_liked).toBe(false);
-    });
-
-  });
-
-  describe('and every other surface agrees', () => {
-    it('keeps a hidden like out of /my-feedback', async () => {
-      await like();
-      await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like' })
-        .update({ is_hidden: true });
-
-      const res = await request(app)
-        .get(`/api/gallery/${SLUG}/my-feedback`)
-        .set('Authorization', `Bearer ${galleryToken()}`)
-        .set('x-guest-token', guestToken());
-      expect(res.status).toBe(200);
-
-      // In guest identity mode the Liked/Favorited/Rated chips and their
-      // filters are built from THIS array, not from is_liked — so a hidden
-      // like left an empty heart while the chip still counted it.
-      expect(res.body.filter((f) => f.feedback_type === 'like')).toHaveLength(0);
-    });
-
-    it('does not count a hidden row against the guest cap', async () => {
-      await db('event_feedback_settings')
-        .where({ event_id: eventId }).update({ max_likes_per_guest: 1 });
-      await like();
-      await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like' })
-        .update({ is_hidden: true });
-
-      // The hidden row is room, not an occupant: the guest sees an empty
-      // heart, and meeting that click with limit_reached leaves the control
-      // dead until they un-like something they can still see.
-      const result = await feedbackService.submitFeedback(photoId, eventId, {
-        feedback_type: 'like', guest_identifier: ME, guest_id: myGuestRowId,
-      });
-      expect(result.limit_reached).toBeUndefined();
-
-      await db('event_feedback_settings')
-        .where({ event_id: eventId }).update({ max_likes_per_guest: null });
-    });
-
-    it('leaves other anonymous rows alone when there is no identity to scope by', async () => {
-      // With neither guest_id nor guest_identifier the collapse scope degrades
-      // to `guest_identifier IS NULL` — every identifier-less row on the
-      // photo, i.e. other people's.
-      const anon = (extra) => ({
-        photo_id: photoId, event_id: eventId, feedback_type: 'like',
-        is_approved: true, created_at: new Date().toISOString(), ...extra,
-      });
-      const [h] = await db('photo_feedback').insert(anon({ is_hidden: true })).returning('id');
-      const hiddenId = typeof h === 'object' ? h.id : h;
-      await db('photo_feedback').insert(anon({ is_hidden: false }));
-      await db('photo_feedback').insert(anon({ is_hidden: false }));
-
-      await feedbackService.moderateFeedback(hiddenId, 'approve', 1);
-
-      expect(await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like', is_hidden: false }))
-        .toHaveLength(3);
-    });
-
-    it('collapses the replacement when an admin unhides the original', async () => {
-      await like();
-      const original = await db('photo_feedback').where({ photo_id: photoId }).first();
-      await db('photo_feedback').where('id', original.id).update({ is_hidden: true });
-
-      await feedbackService.submitFeedback(photoId, eventId, {
-        feedback_type: 'like', guest_identifier: ME, guest_id: myGuestRowId,
-      });
-      expect(await db('photo_feedback').where({ photo_id: photoId })).toHaveLength(2);
-
-      await feedbackService.moderateFeedback(original.id, 'approve', 1);
-
-      // Two visible rows for one guest would double-count in the tallies and
-      // need two toggles to clear, since each deletes a single row.
-      const visible = await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like', is_hidden: false });
-      expect(visible).toHaveLength(1);
-      expect(visible[0].id).toBe(original.id);
-    });
-  });
-
-  describe('and clicking still works afterwards', () => {
-    it('re-liking creates a fresh row instead of toggling the hidden one off', async () => {
-      await like();
-      await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like' })
-        .update({ is_hidden: true });
-
-      // What the guest sees is an empty heart, so this is an ADD.
-      const result = await feedbackService.submitFeedback(photoId, eventId, {
-        feedback_type: 'like',
-        guest_identifier: ME,
-        guest_id: myGuestRowId,
-      });
-
-      // Before this, the duplicate check found the hidden row and deleted it —
-      // `removed: true` — so the click did nothing visible and the moderation
-      // was silently undone.
-      expect(result.removed).toBeUndefined();
-
-      const visible = await db('photo_feedback')
-        .where({ photo_id: photoId, feedback_type: 'like', is_hidden: false });
-      expect(visible).toHaveLength(1);
-      expect((await getPhoto()).is_liked).toBe(true);
-    });
-  });
-
-});
@@ -0,0 +1,272 @@
+/**
+ * OIDC logout-to-IdP integration tests (#798 phase 3).
+ *
+ * Same full-stack shape as oidcSso.test.js: real routes over a mock
+ * in-process IdP, genuine discovery/JWKS/PKCE via openid-client. Pins:
+ *
+ *   - the SSO callback stores the raw ID token in the oidc_id_token cookie
+ *   - /logout with that cookie + oidc_logout_from_idp=true returns the
+ *     IdP end-session URL (id_token_hint, post_logout_redirect_uri,
+ *     client_id) and clears the cookie
+ *   - feature off → no ssoLogoutUrl even for an SSO session
+ *   - no oidc_id_token cookie (local-password session) → no ssoLogoutUrl
+ *     even with the feature on — local sessions never bounce to the IdP
+ *   - IdP without an end_session_endpoint → no ssoLogoutUrl, logout still 200
+ *   - settings surface: GET exposes the flag + post_logout_redirect_uri,
+ *     PUT persists the flag
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bcrypt = require('bcrypt');
+
+const { bootCrmDb } = require('./helpers/crmDb');
+const { MockOidcProvider } = require('./helpers/mockOidcProvider');
+
+describe('OIDC logout-to-IdP (#798 phase 3)', () => {
+  let db;
+  let cleanup;
+  let app;
+  let idp;
+  let oidcService;
+
+  beforeAll(async () => {
+    process.env.JWT_SECRET = process.env.JWT_SECRET || 'oidc-logout-test-secret';
+    process.env.FRONTEND_URL = 'http://localhost:5199';
+    ({ db, cleanup } = await bootCrmDb());
+
+    idp = new MockOidcProvider();
+    const issuer = await idp.start();
+
+    oidcService = require('../../src/services/oidcService');
+    await oidcService.saveOidcSettings({
+      oidc_enabled: true,
+      oidc_issuer_url: issuer,
+      oidc_client_id: idp.clientId,
+      oidc_client_secret: idp.clientSecret,
+      oidc_autoprovision: true,
+      oidc_default_role: 'viewer',
+      oidc_logout_from_idp: true,
+    });
+
+    const authRouter = require('../../src/routes/auth');
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/auth', authRouter);
+  }, 120000);
+
+  afterAll(async () => {
+    if (idp) await idp.stop();
+    if (cleanup) await cleanup();
+  });
+
+  /** Drive login → IdP → callback like a browser; returns the callback response. */
+  async function ssoRoundTrip() {
+    const loginRes = await request(app).get('/api/auth/admin/sso/login').expect(302);
+    const stateCookie = (loginRes.headers['set-cookie'] || [])
+      .find((c) => c.startsWith('oidc_state='))
+      .split(';')[0];
+
+    const idpRes = await fetch(loginRes.headers.location, { redirect: 'manual' });
+    expect(idpRes.status).toBe(302);
+    const back = new URL(idpRes.headers.get('location'));
+
+    return request(app)
+      .get(`${back.pathname}?${back.searchParams.toString()}`)
+      .set('Cookie', stateCookie)
+      .expect(302);
+  }
+
+  /**
+   * The oidc_id_token cookie pair ("oidc_id_token=<jwt>") from a callback
+   * response. The callback carries TWO Set-Cookie headers for this name —
+   * establishAdminSession clears any stale marker, then the callback sets
+   * the fresh one — and browsers apply them in order, so the LAST wins.
+   */
+  function idTokenCookie(res) {
+    const cookies = (res.headers['set-cookie'] || []).filter((c) => c.startsWith('oidc_id_token='));
+    const last = cookies[cookies.length - 1];
+    return last ? last.split(';')[0] : null;
+  }
+
+  it('stores the raw ID token in the oidc_id_token cookie on SSO login', async () => {
+    idp.setNextUser({ sub: 'logout-sub-1', email: 'logout@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+
+    const cookie = idTokenCookie(res);
+    expect(cookie).toBeTruthy();
+    // Raw JWT, HttpOnly, scoped to /api/auth.
+    const raw = decodeURIComponent(cookie.replace('oidc_id_token=', ''));
+    expect(raw.split('.')).toHaveLength(3);
+    const setCookies = (res.headers['set-cookie'] || []).filter((c) => c.startsWith('oidc_id_token='));
+    const full = setCookies[setCookies.length - 1];
+    expect(full).toMatch(/HttpOnly/i);
+    expect(full).toMatch(/Path=\/api\/auth/i);
+  });
+
+  it('returns the IdP end-session URL on logout and clears the cookie', async () => {
+    idp.setNextUser({ sub: 'logout-sub-2', email: 'logout2@example.com', email_verified: true });
+    const cbRes = await ssoRoundTrip();
+    const cookie = idTokenCookie(cbRes);
+    const rawIdToken = decodeURIComponent(cookie.replace('oidc_id_token=', ''));
+
+    const res = await request(app)
+      .post('/api/auth/logout')
+      .set('Cookie', cookie)
+      .expect(200);
+
+    expect(res.body.ssoLogoutUrl).toBeTruthy();
+    const url = new URL(res.body.ssoLogoutUrl);
+    expect(url.href.startsWith(`${idp.issuer}/logout`)).toBe(true);
+    expect(url.searchParams.get('id_token_hint')).toBe(rawIdToken);
+    expect(url.searchParams.get('post_logout_redirect_uri')).toBe('http://localhost:5199/admin/login');
+    expect(url.searchParams.get('client_id')).toBe(idp.clientId);
+
+    // Cookie must be cleared so a later local-password logout in the same
+    // browser doesn't bounce to the IdP again.
+    const cleared = (res.headers['set-cookie'] || []).find((c) => c.startsWith('oidc_id_token='));
+    expect(cleared).toBeTruthy();
+    expect(cleared).toMatch(/Expires=Thu, 01 Jan 1970|Max-Age=0/i);
+  });
+
+  it('omits ssoLogoutUrl when the feature is disabled', async () => {
+    idp.setNextUser({ sub: 'logout-sub-3', email: 'logout3@example.com', email_verified: true });
+    const cbRes = await ssoRoundTrip();
+    const cookie = idTokenCookie(cbRes);
+
+    await oidcService.saveOidcSettings({ oidc_logout_from_idp: false });
+    try {
+      const res = await request(app)
+        .post('/api/auth/logout')
+        .set('Cookie', cookie)
+        .expect(200);
+      expect(res.body.ssoLogoutUrl).toBeUndefined();
+    } finally {
+      await oidcService.saveOidcSettings({ oidc_logout_from_idp: true });
+    }
+  });
+
+  it('omits ssoLogoutUrl without an oidc_id_token cookie (local-password session)', async () => {
+    const res = await request(app).post('/api/auth/logout').expect(200);
+    expect(res.body.ssoLogoutUrl).toBeUndefined();
+  });
+
+  it('omits ssoLogoutUrl when the IdP advertises no end_session_endpoint', async () => {
+    // Separate provider whose discovery document lacks end_session_endpoint;
+    // repointing the settings invalidates the discovery cache.
+    const bareIdp = new MockOidcProvider();
+    bareIdp.advertiseEndSession = false;
+    const bareIssuer = await bareIdp.start();
+    try {
+      await oidcService.saveOidcSettings({
+        oidc_issuer_url: bareIssuer,
+        oidc_client_id: bareIdp.clientId,
+        oidc_client_secret: bareIdp.clientSecret,
+      });
+
+      bareIdp.setNextUser({ sub: 'logout-sub-4', email: 'logout4@example.com', email_verified: true });
+      const cbRes = await ssoRoundTrip();
+      const cookie = idTokenCookie(cbRes);
+      expect(cookie).toBeTruthy();
+
+      const res = await request(app)
+        .post('/api/auth/logout')
+        .set('Cookie', cookie)
+        .expect(200);
+      expect(res.body.ssoLogoutUrl).toBeUndefined();
+    } finally {
+      await bareIdp.stop();
+      await oidcService.saveOidcSettings({
+        oidc_issuer_url: idp.issuer,
+        oidc_client_id: idp.clientId,
+        oidc_client_secret: idp.clientSecret,
+      });
+    }
+  });
+
+  it('stores a bare marker for oversized ID tokens; logout still round-trips, without a hint', async () => {
+    idp.setNextUser({
+      sub: 'logout-sub-5',
+      email: 'logout5@example.com',
+      email_verified: true,
+      // ~9KB of group claims — far past the 4KB cookie limit.
+      groups: Array.from({ length: 300 }, (_, i) => `group-${String(i).padStart(4, '0')}-xxxxxxxxxxxxxxxx`),
+    });
+    const cbRes = await ssoRoundTrip();
+    const cookie = idTokenCookie(cbRes);
+    expect(cookie).toBeTruthy();
+    expect(decodeURIComponent(cookie.replace('oidc_id_token=', ''))).toBe('sso');
+
+    const res = await request(app)
+      .post('/api/auth/logout')
+      .set('Cookie', cookie)
+      .expect(200);
+    expect(res.body.ssoLogoutUrl).toBeTruthy();
+    const url = new URL(res.body.ssoLogoutUrl);
+    expect(url.searchParams.get('id_token_hint')).toBeNull();
+    expect(url.searchParams.get('client_id')).toBe(idp.clientId);
+  });
+
+  it('a fresh local-password login clears a stale SSO marker', async () => {
+    const role = await db('roles').where({ name: 'admin' }).first();
+    await db('admin_users').insert({
+      username: 'stale-marker-admin',
+      email: 'stale-marker@example.com',
+      password_hash: await bcrypt.hash('StaleMarker123!', 4),
+      role_id: role.id,
+      is_active: 1,
+      must_change_password: 0,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    });
+
+    // Stale marker from a dead SSO session rides along on the login request.
+    const res = await request(app)
+      .post('/api/auth/admin/login')
+      .set('Cookie', 'oidc_id_token=stale.jwt.value')
+      .send({ username: 'stale-marker-admin', password: 'StaleMarker123!' })
+      .expect(200);
+
+    const cleared = (res.headers['set-cookie'] || []).find((c) => c.startsWith('oidc_id_token='));
+    expect(cleared).toBeTruthy();
+    expect(cleared).toMatch(/Expires=Thu, 01 Jan 1970|Max-Age=0/i);
+  });
+
+  it('skips the round-trip when the stored hint was issued by a DIFFERENT issuer (config changed)', async () => {
+    // Fake-but-well-formed JWT from another IdP — payload is all that matters,
+    // buildEndSessionUrl decodes without verification for routing only.
+    const b64 = (obj) => Buffer.from(JSON.stringify(obj)).toString('base64url');
+    const foreignToken = `${b64({ alg: 'none' })}.${b64({ iss: 'http://other-idp.example', aud: idp.clientId })}.sig`;
+
+    const res = await request(app)
+      .post('/api/auth/logout')
+      .set('Cookie', `oidc_id_token=${foreignToken}`)
+      .expect(200);
+    expect(res.body.ssoLogoutUrl).toBeUndefined();
+  });
+
+  it('drops only the hint when the issuer matches but the client changed', async () => {
+    const b64 = (obj) => Buffer.from(JSON.stringify(obj)).toString('base64url');
+    const oldClientToken = `${b64({ alg: 'none' })}.${b64({ iss: idp.issuer, aud: 'previous-client-id' })}.sig`;
+
+    const res = await request(app)
+      .post('/api/auth/logout')
+      .set('Cookie', `oidc_id_token=${oldClientToken}`)
+      .expect(200);
+    expect(res.body.ssoLogoutUrl).toBeTruthy();
+    const url = new URL(res.body.ssoLogoutUrl);
+    expect(url.searchParams.get('id_token_hint')).toBeNull();
+    expect(url.searchParams.get('client_id')).toBe(idp.clientId);
+  });
+
+  it('exposes the flag and post_logout_redirect_uri via getOidcConfig/getPostLogoutRedirectUri', async () => {
+    // Settings-route auth chains are covered in oidcSso.test.js; here the
+    // service surface the routes read from is pinned directly.
+    const cfg = await oidcService.getOidcConfig();
+    expect(cfg.logoutFromIdp).toBe(true);
+    expect(await oidcService.getPostLogoutRedirectUri()).toBe('http://localhost:5199/admin/login');
+  });
+});
@@ -0,0 +1,416 @@
+/**
+ * OIDC role mapping + login policy integration tests (#798, phase 2).
+ *
+ * Same harness as oidcSso.test.js: supertest over the real routes, mock
+ * in-process IdP with genuine RS256/PKCE validation, fresh-SQLite DB. Pins:
+ *
+ *   - JIT provisioning takes the MAPPED role from a nested dot-path claim
+ *     (Keycloak's realm_access.roles), not the static default
+ *   - roles are re-evaluated on every SSO login (upgrade AND downgrade)
+ *   - several mapped roles → the highest-priority one wins
+ *   - non-strict: unmapped login keeps the current role / default at JIT
+ *   - strict (require_mapped_role): unmapped login → sso_error=no_role
+ *   - the last active super_admin is never demoted by mapping
+ *   - space-separated string claim values work (flat `roles` claim)
+ *   - disable_local_login: password login → 403; OIDC_BREAK_GLASS=true
+ *     re-opens it; flag is inert while SSO is disabled
+ *   - PUT /sso validation: unknown mapping target and
+ *     disable-local-login-without-SSO are rejected
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+
+const { bootCrmDb } = require('./helpers/crmDb');
+const { MockOidcProvider } = require('./helpers/mockOidcProvider');
+
+describe('OIDC role mapping + login policy (#798 phase 2)', () => {
+  let db;
+  let cleanup;
+  let app;
+  let idp;
+  let oidcService;
+  let superAdminToken;
+
+  beforeAll(async () => {
+    process.env.JWT_SECRET = process.env.JWT_SECRET || 'oidc-test-secret';
+    process.env.FRONTEND_URL = 'http://localhost:5199';
+    delete process.env.OIDC_BREAK_GLASS;
+    ({ db, cleanup } = await bootCrmDb());
+
+    idp = new MockOidcProvider();
+    const issuer = await idp.start();
+
+    oidcService = require('../../src/services/oidcService');
+    await oidcService.saveOidcSettings({
+      oidc_enabled: true,
+      oidc_issuer_url: issuer,
+      oidc_client_id: idp.clientId,
+      oidc_client_secret: idp.clientSecret,
+      oidc_autoprovision: true,
+      oidc_default_role: 'viewer',
+      oidc_role_mapping_enabled: true,
+      oidc_roles_claim: 'realm_access.roles',
+      oidc_role_mappings: {
+        'pp-super': 'super_admin',
+        'pp-admins': 'admin',
+        'pp-view': 'viewer',
+      },
+    });
+
+    const authRouter = require('../../src/routes/auth');
+    const adminSettingsRouter = require('../../src/routes/adminSettings');
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/auth', authRouter);
+    app.use('/api/admin/settings', adminSettingsRouter);
+
+    // A real super_admin row + token for the settings-validation tests.
+    const superRole = await db('roles').where({ name: 'super_admin' }).first();
+    const [rootId] = await db('admin_users').insert({
+      username: 'root-admin',
+      email: 'root@example.com',
+      password_hash: await bcrypt.hash('RootPass123', 4),
+      role_id: superRole.id,
+      is_active: 1,
+      auth_provider: 'local',
+      created_at: new Date(),
+      updated_at: new Date(),
+    }).returning('id').then((r) => [r[0]?.id || r[0]]);
+    superAdminToken = jwt.sign(
+      { id: rootId, username: 'root-admin', type: 'admin', role: 'super_admin', loginTime: Date.now() },
+      process.env.JWT_SECRET,
+      { expiresIn: '1h', issuer: 'picpeak-auth' }
+    );
+  }, 120000);
+
+  afterAll(async () => {
+    delete process.env.OIDC_BREAK_GLASS;
+    if (idp) await idp.stop();
+    if (cleanup) await cleanup();
+  });
+
+  /** Drive login → IdP → callback like a browser; returns the callback response. */
+  async function ssoRoundTrip() {
+    const loginRes = await request(app).get('/api/auth/admin/sso/login').expect(302);
+    const stateCookie = (loginRes.headers['set-cookie'] || [])
+      .find((c) => c.startsWith('oidc_state=')).split(';')[0];
+    const idpRes = await fetch(loginRes.headers.location, { redirect: 'manual' });
+    expect(idpRes.status).toBe(302);
+    const back = new URL(idpRes.headers.get('location'));
+    return request(app)
+      .get(`${back.pathname}?${back.searchParams.toString()}`)
+      .set('Cookie', stateCookie)
+      .expect(302);
+  }
+
+  async function roleOf(email) {
+    const row = await db('admin_users').where({ email }).first();
+    const role = await db('roles').where({ id: row.role_id }).first();
+    return role.name;
+  }
+
+  it('JIT-provisions with the role mapped from the nested dot-path claim', async () => {
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['irrelevant', 'pp-admins'] },
+    });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(await roleOf('mapped@example.com')).toBe('admin');
+  });
+
+  it('re-evaluates the role on every login — downgrade lands', async () => {
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['pp-view'] },
+    });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(await roleOf('mapped@example.com')).toBe('viewer');
+  });
+
+  it('re-evaluates the role on every login — upgrade lands and the session JWT carries it', async () => {
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['pp-admins'] },
+    });
+    const res = await ssoRoundTrip();
+    expect(await roleOf('mapped@example.com')).toBe('admin');
+
+    // The freshly-minted session token must already carry the NEW role —
+    // the sync happens before session establishment.
+    const adminCookie = (res.headers['set-cookie'] || []).find((c) => c.startsWith('admin_token='));
+    const token = decodeURIComponent(adminCookie.split(';')[0].replace('admin_token=', ''));
+    const decoded = jwt.verify(token, process.env.JWT_SECRET, { issuer: 'picpeak-auth' });
+    expect(decoded.role).toBe('admin');
+  });
+
+  it('picks the highest-priority role when several IdP values map', async () => {
+    idp.setNextUser({
+      sub: 'sub-multi',
+      email: 'multi@example.com',
+      email_verified: true,
+      realm_access: { roles: ['pp-view', 'pp-admins'] },
+    });
+    await ssoRoundTrip();
+    expect(await roleOf('multi@example.com')).toBe('admin');
+  });
+
+  it('non-strict: an unmapped login keeps the current role / gets the default at JIT', async () => {
+    // Existing admin keeps its role.
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['nothing-mapped'] },
+    });
+    let res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(await roleOf('mapped@example.com')).toBe('admin');
+
+    // JIT falls back to the configured default role.
+    idp.setNextUser({
+      sub: 'sub-unmapped-jit',
+      email: 'unmapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['nothing-mapped'] },
+    });
+    res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(await roleOf('unmapped@example.com')).toBe('viewer');
+  });
+
+  it('strict mode refuses unmapped logins with sso_error=no_role and no session', async () => {
+    await oidcService.saveOidcSettings({ oidc_require_mapped_role: true });
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['nothing-mapped'] },
+    });
+    const res = await ssoRoundTrip();
+    await oidcService.saveOidcSettings({ oidc_require_mapped_role: false });
+
+    expect(res.headers.location).toBe('http://localhost:5199/admin/login?sso_error=no_role');
+    expect((res.headers['set-cookie'] || []).find((c) => c.startsWith('admin_token='))).toBeFalsy();
+    // Role untouched by the refused attempt.
+    expect(await roleOf('mapped@example.com')).toBe('admin');
+  });
+
+  it('never demotes the last active super_admin', async () => {
+    // Make the SSO admin the ONLY active super_admin.
+    const superRole = await db('roles').where({ name: 'super_admin' }).first();
+    const ssoAdmin = await db('admin_users').where({ email: 'mapped@example.com' }).first();
+    await db('admin_users').where({ role_id: superRole.id }).update({ is_active: 0 });
+    await db('admin_users').where({ id: ssoAdmin.id }).update({ role_id: superRole.id, is_active: 1 });
+
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['pp-view'] },
+    });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    // Still super_admin — the demotion was refused, the login was not.
+    expect(await roleOf('mapped@example.com')).toBe('super_admin');
+
+    // Restore: root admin back to active super_admin, SSO admin back to admin.
+    const adminRole = await db('roles').where({ name: 'admin' }).first();
+    await db('admin_users').where({ email: 'root@example.com' }).update({ is_active: 1 });
+    await db('admin_users').where({ id: ssoAdmin.id }).update({ role_id: adminRole.id });
+
+    // With ANOTHER active super_admin present the same downgrade goes through.
+    idp.setNextUser({
+      sub: 'sub-map-1',
+      email: 'mapped@example.com',
+      email_verified: true,
+      realm_access: { roles: ['pp-view'] },
+    });
+    await db('admin_users').where({ id: ssoAdmin.id }).update({ role_id: superRole.id });
+    await ssoRoundTrip();
+    expect(await roleOf('mapped@example.com')).toBe('viewer');
+  });
+
+  it('never demotes the last LOCAL-password super_admin even when an OIDC-owned super exists', async () => {
+    const superRole = await db('roles').where({ name: 'super_admin' }).first();
+    const viewerRole = await db('roles').where({ name: 'viewer' }).first();
+
+    // A local-password super admin, SSO-linked via verified email so role
+    // sync applies to it.
+    const [localId] = await db('admin_users').insert({
+      username: 'local-super',
+      email: 'local-super@example.com',
+      password_hash: await bcrypt.hash('LocalSuper123', 4),
+      role_id: superRole.id,
+      is_active: 1,
+      auth_provider: 'local',
+      created_at: new Date(),
+      updated_at: new Date(),
+    }).returning('id').then((r) => [r[0]?.id || r[0]]);
+
+    // The only OTHER active super is OIDC-owned (root goes inactive) — the
+    // plain last-super guard would allow the demotion, the break-glass
+    // guard must not.
+    const ssoAdmin = await db('admin_users').where({ email: 'mapped@example.com' }).first();
+    await db('admin_users').where({ id: ssoAdmin.id }).update({ role_id: superRole.id });
+    await db('admin_users').where({ email: 'root@example.com' }).update({ is_active: 0 });
+
+    idp.setNextUser({
+      sub: 'sub-local-super',
+      email: 'local-super@example.com',
+      email_verified: true,
+      realm_access: { roles: ['pp-view'] },
+    });
+    const res = await ssoRoundTrip();
+
+    const row = await db('admin_users').where({ id: localId }).first();
+    // Restore the fixture state before asserting.
+    await db('admin_users').where({ email: 'root@example.com' }).update({ is_active: 1 });
+    await db('admin_users').where({ id: ssoAdmin.id }).update({ role_id: viewerRole.id });
+    await db('admin_users').where({ id: localId }).update({ is_active: 0 });
+
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(row.role_id).toBe(superRole.id); // kept — it is the break-glass account
+  });
+
+  it('treats prototype-property IdP values (constructor/toString) as unmapped, not as an error', async () => {
+    idp.setNextUser({
+      sub: 'sub-proto',
+      email: 'proto@example.com',
+      email_verified: true,
+      realm_access: { roles: ['constructor', 'toString', '__proto__'] },
+    });
+    const res = await ssoRoundTrip();
+    // Non-strict: unmapped → JIT with the default role, login succeeds.
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(await roleOf('proto@example.com')).toBe('viewer');
+  });
+
+  it('accepts a space-separated string value on a flat claim', async () => {
+    await oidcService.saveOidcSettings({ oidc_roles_claim: 'roles' });
+    idp.setNextUser({
+      sub: 'sub-flat',
+      email: 'flat@example.com',
+      email_verified: true,
+      roles: 'other pp-admins',
+    });
+    const res = await ssoRoundTrip();
+    await oidcService.saveOidcSettings({ oidc_roles_claim: 'realm_access.roles' });
+
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    expect(await roleOf('flat@example.com')).toBe('admin');
+  });
+
+  it('refuses local password login while disable_local_login is effective', async () => {
+    await oidcService.saveOidcSettings({ oidc_disable_local_login: true });
+    const res = await request(app)
+      .post('/api/auth/admin/login')
+      .send({ username: 'root@example.com', password: 'RootPass123' });
+    expect(res.status).toBe(403);
+    expect(res.body.code).toBe('LOCAL_LOGIN_DISABLED');
+  });
+
+  it('OIDC_BREAK_GLASS=true re-opens local login despite the policy', async () => {
+    process.env.OIDC_BREAK_GLASS = 'true';
+    const res = await request(app)
+      .post('/api/auth/admin/login')
+      .send({ username: 'root@example.com', password: 'RootPass123' });
+    delete process.env.OIDC_BREAK_GLASS;
+    expect(res.status).toBe(200);
+    expect(res.body.user).toBeTruthy();
+  });
+
+  it('the stored flag is inert while SSO is disabled', async () => {
+    // Simulate a torn-down SSO config with the stale flag still set — the
+    // runtime check must ignore it (no lockout).
+    await db('app_settings').where({ setting_key: 'oidc_enabled' })
+      .update({ setting_value: JSON.stringify(false) });
+    expect(await oidcService.isLocalLoginDisabled()).toBe(false);
+    await db('app_settings').where({ setting_key: 'oidc_enabled' })
+      .update({ setting_value: JSON.stringify(true) });
+    expect(await oidcService.isLocalLoginDisabled()).toBe(true);
+    await oidcService.saveOidcSettings({ oidc_disable_local_login: false });
+  });
+
+  it('the policy disarms itself when no active local-password super admin remains', async () => {
+    await oidcService.saveOidcSettings({ oidc_disable_local_login: true });
+    expect(await oidcService.isLocalLoginDisabled()).toBe(true);
+    // The break-glass account disappears (e.g. manual demotion/deactivation
+    // while the policy is on) → local login must re-open by itself.
+    await db('admin_users').where({ email: 'root@example.com' }).update({ auth_provider: 'oidc' });
+    expect(await oidcService.isLocalLoginDisabled()).toBe(false);
+    await db('admin_users').where({ email: 'root@example.com' }).update({ auth_provider: 'local' });
+    await oidcService.saveOidcSettings({ oidc_disable_local_login: false });
+  });
+
+  it('PUT /sso rejects a mapping onto an unknown role', async () => {
+    const res = await request(app)
+      .put('/api/admin/settings/sso')
+      .set('Authorization', `Bearer ${superAdminToken}`)
+      .send({ oidc_role_mappings: { 'pp-admins': 'does_not_exist' } });
+    expect(res.status).toBe(400);
+    expect(res.body.error).toMatch(/does_not_exist/);
+    // Stored mapping unchanged.
+    const cfg = await oidcService.getOidcConfig();
+    expect(cfg.roleMappings['pp-admins']).toBe('admin');
+  });
+
+  it('PUT /sso rejects disabling local login while SSO is (being turned) off', async () => {
+    const res = await request(app)
+      .put('/api/admin/settings/sso')
+      .set('Authorization', `Bearer ${superAdminToken}`)
+      .send({ oidc_enabled: false, oidc_disable_local_login: true });
+    expect(res.status).toBe(400);
+    expect(res.body.error).toMatch(/while SSO is enabled/);
+  });
+
+  it('PUT /sso refuses SSO-only mode without an active local-password super admin', async () => {
+    // Make every active super_admin OIDC-owned — break-glass would then
+    // re-open a password route that no account can use.
+    const superRole = await db('roles').where({ name: 'super_admin' }).first();
+    await db('admin_users').where({ role_id: superRole.id }).update({ auth_provider: 'oidc' });
+    const denied = await request(app)
+      .put('/api/admin/settings/sso')
+      .set('Authorization', `Bearer ${superAdminToken}`)
+      .send({ oidc_disable_local_login: true });
+    // Restore the local break-glass account, then the same request passes.
+    await db('admin_users').where({ email: 'root@example.com' }).update({ auth_provider: 'local' });
+    expect(denied.status).toBe(400);
+    expect(denied.body.error).toMatch(/break-glass/);
+
+    const allowed = await request(app)
+      .put('/api/admin/settings/sso')
+      .set('Authorization', `Bearer ${superAdminToken}`)
+      .send({ oidc_disable_local_login: true });
+    expect(allowed.status).toBe(200);
+    await oidcService.saveOidcSettings({ oidc_disable_local_login: false });
+  });
+
+  it('GET /sso returns the phase-2 fields', async () => {
+    const res = await request(app)
+      .get('/api/admin/settings/sso')
+      .set('Authorization', `Bearer ${superAdminToken}`);
+    expect(res.status).toBe(200);
+    expect(res.body.oidc_role_mapping_enabled).toBe(true);
+    expect(res.body.oidc_roles_claim).toBe('realm_access.roles');
+    expect(res.body.oidc_role_mappings).toEqual({
+      'pp-super': 'super_admin',
+      'pp-admins': 'admin',
+      'pp-view': 'viewer',
+    });
+    expect(res.body.oidc_require_mapped_role).toBe(false);
+    expect(res.body.oidc_disable_local_login).toBe(false);
+  });
+});
@@ -0,0 +1,302 @@
+/**
+ * OIDC SSO integration tests (#798, phase 1).
+ *
+ * Full-stack over a mock in-process IdP (mockOidcProvider): supertest drives
+ * the real /admin/sso/login and /admin/sso/callback routes on a fresh-SQLite
+ * database, openid-client does genuine discovery/JWKS/PKCE/ID-token
+ * validation against the mock issuer. Pins:
+ *
+ *   - happy path: JIT provisioning creates an admin and sets the session cookie
+ *   - JIT off → not_provisioned redirect, no row created
+ *   - repeat login matches by sub, not email (email change ≠ new account)
+ *   - verified-email one-time link onto an existing local admin
+ *   - unverified email must NOT link (falls through to JIT/or error)
+ *   - deactivated admin → inactive redirect
+ *   - missing/forged state cookie → state redirect
+ *   - nonce tamper from the IdP → idp redirect
+ *   - settings endpoints: secret write-only, generic /general upsert cannot
+ *     clobber oidc_client_secret
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+
+const { bootCrmDb } = require('./helpers/crmDb');
+const { MockOidcProvider } = require('./helpers/mockOidcProvider');
+
+describe('OIDC SSO (#798)', () => {
+  let db;
+  let cleanup;
+  let app;
+  let idp;
+  let oidcService;
+
+  const agentCookies = {};
+
+  beforeAll(async () => {
+    process.env.JWT_SECRET = process.env.JWT_SECRET || 'oidc-test-secret';
+    // The redirect_uri derives from the public base URL — pin it explicitly:
+    // CI has no backend/.env, and getFrontendBaseUrl() returning '' makes
+    // buildAuthorizationRequest fail (by design) with OIDC_BAD_CONFIG.
+    process.env.FRONTEND_URL = 'http://localhost:5199';
+    ({ db, cleanup } = await bootCrmDb());
+
+    idp = new MockOidcProvider();
+    const issuer = await idp.start();
+
+    // Require AFTER bootCrmDb so services share this db instance.
+    oidcService = require('../../src/services/oidcService');
+    await oidcService.saveOidcSettings({
+      oidc_enabled: true,
+      oidc_issuer_url: issuer,
+      oidc_client_id: idp.clientId,
+      oidc_client_secret: idp.clientSecret,
+      oidc_autoprovision: true,
+      oidc_default_role: 'viewer',
+    });
+
+    const authRouter = require('../../src/routes/auth');
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/auth', authRouter);
+  }, 120000);
+
+  afterAll(async () => {
+    if (idp) await idp.stop();
+    if (cleanup) await cleanup();
+  });
+
+  /** Drive login → IdP → callback like a browser; returns the callback response. */
+  async function ssoRoundTrip({ mutateState } = {}) {
+    const loginRes = await request(app).get('/api/auth/admin/sso/login').expect(302);
+    const idpUrl = loginRes.headers.location;
+    expect(idpUrl.startsWith(idp.issuer)).toBe(true);
+
+    let stateCookie = (loginRes.headers['set-cookie'] || [])
+      .find((c) => c.startsWith('oidc_state='));
+    expect(stateCookie).toBeTruthy();
+    stateCookie = stateCookie.split(';')[0];
+    if (mutateState === 'drop') stateCookie = null;
+    if (mutateState === 'forge') {
+      stateCookie = `oidc_state=${jwt.sign({ type: 'oidc_state', s: 'x', n: 'y', cv: 'z' }, 'wrong-secret', { issuer: 'picpeak-auth' })}`;
+    }
+
+    // "Browser" follows the redirect to the IdP, which instantly bounces back.
+    const idpRes = await fetch(idpUrl, { redirect: 'manual' });
+    expect(idpRes.status).toBe(302);
+    const back = new URL(idpRes.headers.get('location'));
+
+    let cb = request(app).get(`${back.pathname}?${back.searchParams.toString()}`);
+    if (stateCookie) cb = cb.set('Cookie', stateCookie);
+    return cb.expect(302);
+  }
+
+  it('JIT-provisions an unknown user and establishes an admin session', async () => {
+    idp.setNextUser({ sub: 'sub-jit-1', email: 'jit@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    const adminCookie = (res.headers['set-cookie'] || []).find((c) => c.startsWith('admin_token='));
+    expect(adminCookie).toBeTruthy();
+
+    const row = await db('admin_users').where({ email: 'jit@example.com' }).first();
+    expect(row).toBeTruthy();
+    expect(row.auth_provider).toBe('oidc');
+    expect(row.external_subject).toBe('sub-jit-1');
+
+    const role = await db('roles').where('id', row.role_id).first();
+    expect(role.name).toBe('viewer');
+
+    // The session JWT must be a normal admin token.
+    const token = adminCookie.split(';')[0].replace('admin_token=', '');
+    const decoded = jwt.verify(decodeURIComponent(token), process.env.JWT_SECRET, { issuer: 'picpeak-auth' });
+    expect(decoded.type).toBe('admin');
+    expect(decoded.id).toBe(row.id);
+    agentCookies.jitAdminId = row.id;
+  });
+
+  it('matches repeat logins by sub even when the email changed at the IdP', async () => {
+    idp.setNextUser({ sub: 'sub-jit-1', email: 'renamed@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+
+    // No second row — resolved via external_subject.
+    expect(await db('admin_users').where({ email: 'renamed@example.com' }).first()).toBeFalsy();
+    const byId = await db('admin_users').where({ id: agentCookies.jitAdminId }).first();
+    expect(byId.external_subject).toBe('sub-jit-1');
+  });
+
+  it('links an existing local admin one-time via VERIFIED email and stamps the sub', async () => {
+    const role = await db('roles').where({ name: 'admin' }).first();
+    const [localId] = await db('admin_users').insert({
+      username: 'local-admin',
+      email: 'local@example.com',
+      password_hash: await bcrypt.hash('LocalPass123', 4),
+      role_id: role.id,
+      is_active: 1,
+      auth_provider: 'local',
+      created_at: new Date(),
+      updated_at: new Date(),
+    }).returning('id').then((r) => [r[0]?.id || r[0]]);
+
+    idp.setNextUser({ sub: 'sub-local-1', email: 'local@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+
+    const row = await db('admin_users').where({ id: localId }).first();
+    expect(row.external_subject).toBe('sub-local-1');
+    expect(row.auth_provider).toBe('local'); // password keeps working
+  });
+
+  it('does NOT link by unverified email — provisions a separate account instead', async () => {
+    const role = await db('roles').where({ name: 'admin' }).first();
+    await db('admin_users').insert({
+      username: 'victim-admin',
+      email: 'victim@example.com',
+      password_hash: await bcrypt.hash('VictimPass123', 4),
+      role_id: role.id,
+      is_active: 1,
+      auth_provider: 'local',
+      created_at: new Date(),
+      updated_at: new Date(),
+    });
+
+    idp.setNextUser({ sub: 'sub-attacker', email: 'victim@example.com', email_verified: false });
+    // JIT would need this email but the victim row owns it (unique) — the
+    // insert fails and the flow must land on an error, never on the
+    // victim's session.
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toMatch(/sso_error=/);
+
+    const victim = await db('admin_users').where({ email: 'victim@example.com' }).first();
+    expect(victim.external_subject).toBeNull();
+  });
+
+  it('refuses a deactivated admin with sso_error=inactive', async () => {
+    await db('admin_users').where({ id: agentCookies.jitAdminId }).update({ is_active: 0 });
+    idp.setNextUser({ sub: 'sub-jit-1', email: 'renamed@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/login?sso_error=inactive');
+    await db('admin_users').where({ id: agentCookies.jitAdminId }).update({ is_active: 1 });
+  });
+
+  it('rejects a callback without the state cookie', async () => {
+    const res = await ssoRoundTrip({ mutateState: 'drop' });
+    expect(res.headers.location).toBe('http://localhost:5199/admin/login?sso_error=state');
+  });
+
+  it('rejects a forged state cookie (wrong signing key)', async () => {
+    const res = await ssoRoundTrip({ mutateState: 'forge' });
+    expect(res.headers.location).toBe('http://localhost:5199/admin/login?sso_error=state');
+  });
+
+  it('rejects an ID token whose nonce does not match', async () => {
+    idp.tamperNonce = true;
+    idp.setNextUser({ sub: 'sub-nonce', email: 'nonce@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    idp.tamperNonce = false;
+    expect(res.headers.location).toBe('http://localhost:5199/admin/login?sso_error=idp');
+    expect(await db('admin_users').where({ email: 'nonce@example.com' }).first()).toBeFalsy();
+  });
+
+  it('blocks JIT with sso_error=not_provisioned when autoprovision is off', async () => {
+    await oidcService.saveOidcSettings({ oidc_autoprovision: false });
+    idp.setNextUser({ sub: 'sub-new-user', email: 'new@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    expect(res.headers.location).toBe('http://localhost:5199/admin/login?sso_error=not_provisioned');
+    expect(await db('admin_users').where({ email: 'new@example.com' }).first()).toBeFalsy();
+    await oidcService.saveOidcSettings({ oidc_autoprovision: true });
+  });
+
+  it('stores the client secret encrypted and survives a config round-trip', async () => {
+    const row = await db('app_settings').where({ setting_key: 'oidc_client_secret' }).first();
+    const stored = JSON.parse(row.setting_value);
+    expect(stored).not.toContain(idp.clientSecret);
+    expect(oidcService.decryptSecret(stored)).toBe(idp.clientSecret);
+
+    const cfg = await oidcService.getOidcConfig();
+    expect(cfg.clientSecret).toBe(idp.clientSecret);
+  });
+
+  it('refuses local password login for OIDC-owned accounts', async () => {
+    // Give the JIT admin a KNOWN password hash directly in the DB — the
+    // auth_provider check must reject the login even with valid credentials
+    // (otherwise a password reset would mint an IdP-bypassing local login).
+    await db('admin_users').where({ id: agentCookies.jitAdminId }).update({
+      password_hash: await bcrypt.hash('KnownPass123', 4),
+    });
+    const row = await db('admin_users').where({ id: agentCookies.jitAdminId }).first();
+
+    const res = await request(app)
+      .post('/api/auth/admin/login')
+      .send({ username: row.email, password: 'KnownPass123' });
+    expect(res.status).toBe(401);
+  });
+
+  it('returns 404 from /sso/login when SSO is disabled', async () => {
+    await oidcService.saveOidcSettings({ oidc_enabled: false });
+    await request(app).get('/api/auth/admin/sso/login').expect(404);
+    await oidcService.saveOidcSettings({ oidc_enabled: true });
+  });
+
+  it('merges email from the UserInfo endpoint when the ID token omits it', async () => {
+    idp.emailViaUserinfoOnly = true;
+    idp.setNextUser({ sub: 'sub-userinfo', email: 'userinfo@example.com', email_verified: true });
+    const res = await ssoRoundTrip();
+    idp.emailViaUserinfoOnly = false;
+
+    expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+    const row = await db('admin_users').where({ email: 'userinfo@example.com' }).first();
+    expect(row).toBeTruthy();
+    expect(row.external_subject).toBe('sub-userinfo');
+  });
+
+  it('binds identities per ISSUER — a sub collision on a new IdP must not inherit the old account', async () => {
+    // The JIT admin from the first test is bound to (issuer A, 'sub-jit-1').
+    const boundAdmin = await db('admin_users').where({ id: agentCookies.jitAdminId }).first();
+    expect(boundAdmin.external_issuer).toBe(idp.issuer);
+
+    // Same sub, DIFFERENT issuer: a second IdP the instance switches to.
+    const idp2 = new MockOidcProvider();
+    await idp2.start();
+    try {
+      await oidcService.saveOidcSettings({
+        oidc_issuer_url: idp2.issuer,
+        oidc_client_id: idp2.clientId,
+        oidc_client_secret: idp2.clientSecret,
+      });
+      idp2.setNextUser({ sub: 'sub-jit-1', email: 'colliding@example.com', email_verified: true });
+
+      const loginRes = await request(app).get('/api/auth/admin/sso/login').expect(302);
+      const stateCookie = (loginRes.headers['set-cookie'] || [])
+        .find((c) => c.startsWith('oidc_state=')).split(';')[0];
+      const idpRes = await fetch(loginRes.headers.location, { redirect: 'manual' });
+      const back = new URL(idpRes.headers.get('location'));
+      const res = await request(app)
+        .get(`${back.pathname}?${back.searchParams.toString()}`)
+        .set('Cookie', stateCookie)
+        .expect(302);
+      expect(res.headers.location).toBe('http://localhost:5199/admin/dashboard');
+
+      // A NEW row bound to issuer B — the issuer-A admin is untouched and
+      // its role was not inherited.
+      const collider = await db('admin_users').where({ email: 'colliding@example.com' }).first();
+      expect(collider).toBeTruthy();
+      expect(collider.id).not.toBe(agentCookies.jitAdminId);
+      expect(collider.external_issuer).toBe(idp2.issuer);
+      const original = await db('admin_users').where({ id: agentCookies.jitAdminId }).first();
+      expect(original.external_issuer).toBe(idp.issuer);
+    } finally {
+      await idp2.stop();
+      await oidcService.saveOidcSettings({
+        oidc_issuer_url: idp.issuer,
+        oidc_client_id: idp.clientId,
+        oidc_client_secret: idp.clientSecret,
+      });
+    }
+  });
+});
@@ -1,197 +0,0 @@
-'use strict';
-
-/**
- * Cross-engine .picpeak restore policy (#1041): a SQLite archive restored onto
- * a PostgreSQL instance — the official small-install → full-stack upgrade
- * path — now allowed by validateManifest's direction rule instead of the
- * former CLI-only allowEngineSwitch flag. The coercion engine itself
- * (typedColumnsFor / epochToIso / coerceForTargetEngine) landed with #1039;
- * these tests pin the direction policy and the coercion's cross-engine
- * value-correctness.
- *
- * Ungated: validateManifest direction rules and the pure coercion units.
- * The reverse direction (pg backup onto a sqlite instance) staying blocked is
- * pinned by picpeakRoundtrip.test.js, which runs on the real sqlite harness.
- *
- * Gated on PICPEAK_PG_TEST_URL (same contract as picpeakRestorePg.test.js):
- * sqlite-shaped NDJSON rows land in real Postgres with correct stored VALUES,
- * not just row counts, e.g.
- *   PICPEAK_PG_TEST_URL="postgres://picpeak:pw@127.0.0.1:7102/picpeak_xengine_test" \
- *     npx jest __tests__/integration/picpeakCrossEngine.test.js
- */
-const knexLib = require('knex');
-
-describe('validateManifest cross-engine direction (pg target)', () => {
-  let validateManifest;
-
-  beforeAll(() => {
-    jest.resetModules();
-    jest.doMock('../../knexfile', () => ({ client: 'pg' }));
-    // validateManifest wraps its knex_migrations lookup in try/catch — a
-    // throwing stub simply skips the forward-only check, which is not under
-    // test here.
-    jest.doMock('../../src/database/db', () => ({ db: () => { throw new Error('stub'); } }));
-    ({ validateManifest } = require('../../src/services/picpeakImportService'));
-  });
-
-  afterAll(() => {
-    jest.dontMock('../../src/database/db');
-    jest.dontMock('../../knexfile');
-    jest.resetModules();
-  });
-
-  it('allows a sqlite backup onto a pg instance (upgrade direction)', async () => {
-    const blockers = await validateManifest({
-      kind: 'picpeak-backup', format: 1, database: { engine: 'sqlite' }, tables: {},
-    });
-    expect(blockers.filter((b) => /engine/i.test(b))).toHaveLength(0);
-  });
-
-  it('still allows same-engine pg → pg', async () => {
-    const blockers = await validateManifest({
-      kind: 'picpeak-backup', format: 1, database: { engine: 'pg' }, tables: {},
-    });
-    expect(blockers.filter((b) => /engine/i.test(b))).toHaveLength(0);
-  });
-});
-
-describe('epochToIso (landed with #1039)', () => {
-  let epochToIso;
-
-  beforeAll(() => {
-    jest.resetModules();
-    ({ epochToIso } = require('../../src/services/picpeakImportService'));
-  });
-
-  it('converts epoch milliseconds', () => {
-    expect(epochToIso(1723400000000)).toBe('2024-08-11T18:13:20.000Z');
-  });
-
-  it('converts epoch SECONDS to the same instant, not January 1970', () => {
-    expect(epochToIso(1723400000)).toBe('2024-08-11T18:13:20.000Z');
-  });
-
-  it('converts numeric strings', () => {
-    expect(epochToIso('1723400000000')).toBe('2024-08-11T18:13:20.000Z');
-  });
-
-  it('passes non-numeric values through untouched', () => {
-    expect(epochToIso('2026-08-12 10:00:00')).toBe('2026-08-12 10:00:00');
-  });
-});
-
-describe('coerceForTargetEngine on sqlite-shaped rows', () => {
-  let coerceForTargetEngine;
-
-  beforeAll(() => {
-    jest.resetModules();
-    ({ coerceForTargetEngine } = require('../../src/services/picpeakImportService'));
-  });
-
-  const types = { timestamps: ['created_at', 'expires_at'], booleans: ['is_active'] };
-
-  it('coerces 0/1 booleans and epoch timestamps, leaves date strings alone', () => {
-    const [row] = coerceForTargetEngine(
-      [{ id: 1, is_active: 1, created_at: 1723400000000, expires_at: '2026-09-01 12:00:00' }],
-      types
-    );
-    expect(row.is_active).toBe(true);
-    expect(row.created_at).toBe('2024-08-11T18:13:20.000Z');
-    expect(row.expires_at).toBe('2026-09-01 12:00:00'); // pg parses this natively
-  });
-
-  it('coerces falsy variants and passes null/empty through', () => {
-    const [row] = coerceForTargetEngine(
-      [{ is_active: 0, created_at: null, expires_at: '' }],
-      types
-    );
-    expect(row.is_active).toBe(false);
-    expect(row.created_at).toBeNull();
-    expect(row.expires_at).toBe('');
-  });
-});
-
-// ── Real-Postgres integration (gated) ────────────────────────────────────────
-const PG_URL = process.env.PICPEAK_PG_TEST_URL;
-const maybe = PG_URL ? describe : describe.skip;
-
-maybe('sqlite-shaped rows land correctly in real Postgres', () => {
-  let pgDb;
-  let svc;
-
-  beforeAll(async () => {
-    pgDb = knexLib({ client: 'pg', connection: PG_URL });
-    await pgDb.raw('DROP TABLE IF EXISTS xengine_events, xengine_settings CASCADE');
-    await pgDb.schema.createTable('xengine_events', (t) => {
-      t.increments('id');
-      t.string('slug');
-      t.boolean('is_active').defaultTo(true);
-      t.boolean('allow_downloads').defaultTo(true);
-      t.timestamp('created_at');
-      t.timestamp('expires_at');
-    });
-    await pgDb.schema.createTable('xengine_settings', (t) => {
-      t.increments('id');
-      t.string('setting_key').notNullable().unique();
-      t.jsonb('setting_value');
-    });
-
-    jest.resetModules();
-    jest.doMock('../../knexfile', () => ({ client: 'pg' }));
-    jest.doMock('../../src/database/db', () => ({ db: pgDb }));
-    svc = require('../../src/services/picpeakImportService');
-  });
-
-  afterAll(async () => {
-    jest.dontMock('../../src/database/db');
-    jest.dontMock('../../knexfile');
-    if (pgDb) {
-      await pgDb.raw('DROP TABLE IF EXISTS xengine_events, xengine_settings CASCADE');
-      await pgDb.destroy();
-    }
-  });
-
-  it('typedColumnsFor classifies boolean and timestamp columns via columnInfo()', async () => {
-    const types = await svc.typedColumnsFor(pgDb, 'xengine_events');
-    expect(types.booleans.sort()).toEqual(['allow_downloads', 'is_active']);
-    expect(types.timestamps.sort()).toEqual(['created_at', 'expires_at']);
-  });
-
-  it('inserts a sqlite archive row (0/1 booleans, epoch dates, json text) with correct stored values', async () => {
-    // Exactly what a sqlite-created .picpeak carries: integers for booleans,
-    // epoch numbers for #485-shape timestamps (ms here, seconds covered by the
-    // epochToIso unit), a "YYYY-MM-DD HH:MM:SS" string for clean ones, and
-    // json columns as TEXT (the crossEngine path skips serialiseJsonColumns —
-    // the text is already what pg wants).
-    const epoch = 1723400000000;
-    const eventRows = [
-      { id: 1, slug: 'wedding', is_active: 1, allow_downloads: 0, created_at: epoch, expires_at: '2026-09-01 12:00:00' },
-    ];
-    const settingRows = [{ id: 1, setting_key: 'brand', setting_value: '{"name":"PicPeak","dark":true}' }];
-
-    await pgDb.transaction(async (trx) => {
-      const evTypes = await svc.typedColumnsFor(trx, 'xengine_events');
-      await trx.batchInsert('xengine_events', svc.coerceForTargetEngine(eventRows, evTypes), 100);
-      const stTypes = await svc.typedColumnsFor(trx, 'xengine_settings');
-      await trx.batchInsert('xengine_settings', svc.coerceForTargetEngine(settingRows, stTypes), 100);
-    });
-
-    const ev = await pgDb('xengine_events').where({ id: 1 }).first();
-    expect(ev.is_active).toBe(true);          // 1 → true, not backwards (#1028 class)
-    expect(ev.allow_downloads).toBe(false);   // 0 → false
-    expect(new Date(ev.created_at).getTime()).toBe(epoch);
-    expect(new Date(ev.expires_at).toISOString().slice(0, 10)).toBe('2026-09-01');
-
-    const st = await pgDb('xengine_settings').where({ id: 1 }).first();
-    // jsonb parsed back by the driver — value intact, no double encoding.
-    expect(st.setting_value).toEqual({ name: 'PicPeak', dark: true });
-  });
-
-  it('id sequence works after explicit-id insert + resync (next natural insert)', async () => {
-    await svc.resyncSequences(['xengine_events']);
-    const [next] = await pgDb('xengine_events')
-      .insert({ slug: 'fresh', is_active: true })
-      .returning('id');
-    expect(Number(next.id || next)).toBe(2);
-  });
-});
@@ -0,0 +1,190 @@
+/**
+ * PostgreSQL integration tests for the .picpeak restore robustness fixes.
+ * Gated: runs only when PICPEAK_PG_TEST_URL points at a throwaway Postgres DB,
+ * e.g.
+ *   PICPEAK_PG_TEST_URL="postgres://picpeak:picpeak_secure_pass_2024@127.0.0.1:7102/picpeak_restore_test" \
+ *     npx jest __tests__/integration/picpeakRestorePg.test.js
+ *
+ * Validates the Postgres-specific paths that SQLite can't exercise: identity
+ * sequences left stale by explicit-id inserts, pg_get_serial_sequence raising on
+ * id-less tables, reinject/role-recreate explicit-id inserts, and FK integrity.
+ */
+const knex = require('knex');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PG_URL = process.env.PICPEAK_PG_TEST_URL;
+const maybe = PG_URL ? describe : describe.skip;
+
+maybe('picpeak restore on Postgres', () => {
+  let pgDb;
+  let svc;
+
+  beforeAll(async () => {
+    pgDb = knex({ client: 'pg', connection: PG_URL });
+
+    await pgDb.raw('DROP TABLE IF EXISTS role_permissions, events, admin_users, roles, permissions, app_settings CASCADE');
+    await pgDb.schema.createTable('roles', (t) => {
+      t.increments('id');
+      t.string('name', 50).notNullable().unique();
+      t.string('display_name', 100);
+      t.integer('priority').defaultTo(0);
+      t.boolean('is_system').defaultTo(false);
+    });
+    await pgDb.schema.createTable('permissions', (t) => {
+      t.increments('id');
+      t.string('name', 100).notNullable().unique();
+      t.string('display_name', 150);
+      t.string('category', 50);
+    });
+    await pgDb.schema.createTable('role_permissions', (t) => {
+      t.integer('role_id').notNullable().references('id').inTable('roles').onDelete('CASCADE');
+      t.integer('permission_id').notNullable().references('id').inTable('permissions').onDelete('CASCADE');
+      t.primary(['role_id', 'permission_id']);
+    });
+    await pgDb.schema.createTable('admin_users', (t) => {
+      t.increments('id');
+      t.string('username').notNullable().unique();
+      t.string('email').notNullable().unique();
+      t.string('password_hash');
+      t.boolean('is_active').defaultTo(true);
+      t.boolean('must_change_password').defaultTo(false);
+      t.integer('role_id').references('id').inTable('roles').onDelete('SET NULL');
+      t.integer('created_by').references('id').inTable('admin_users').onDelete('SET NULL');
+      t.boolean('two_factor_enabled').defaultTo(false);
+      t.string('two_factor_secret');
+      t.text('two_factor_recovery_codes');
+    });
+    await pgDb.schema.createTable('events', (t) => {
+      t.increments('id');
+      t.string('slug');
+      t.integer('created_by').references('id').inTable('admin_users').onDelete('SET NULL');
+    });
+    await pgDb.schema.createTable('app_settings', (t) => {
+      t.increments('id');
+      t.string('setting_key').notNullable().unique();
+      t.json('setting_value');
+      t.string('setting_type');
+      t.timestamp('updated_at').defaultTo(pgDb.fn.now());
+    });
+
+    jest.resetModules();
+    jest.doMock('../../knexfile', () => ({ client: 'pg' }));
+    jest.doMock('../../src/database/db', () => ({ db: pgDb }));
+    svc = require('../../src/services/picpeakImportService');
+  });
+
+  afterAll(async () => {
+    jest.dontMock('../../src/database/db');
+    jest.dontMock('../../knexfile');
+    if (pgDb) await pgDb.destroy();
+  });
+
+  beforeEach(async () => {
+    await pgDb('role_permissions').del();
+    await pgDb('events').del();
+    await pgDb('admin_users').del();
+    await pgDb('roles').del();
+    await pgDb('permissions').del();
+  });
+
+  test('resyncSequences fast-forwards stale sequences and skips id-less tables', async () => {
+    // Simulate a restore: explicit-id inserts leave the sequence at 1.
+    await pgDb('roles').insert([{ id: 5, name: 'super_admin', display_name: 'SA' }]);
+    await pgDb('admin_users').insert([{ id: 9, username: 'a', email: 'a@x.io', password_hash: 'h' }]);
+    await pgDb('permissions').insert([{ id: 3, name: 'events.create', display_name: 'C', category: 'events' }]);
+    await pgDb('role_permissions').insert([{ role_id: 5, permission_id: 3 }]); // id-less table
+
+    // Must not throw on role_permissions (no `id` column → pg_get_serial_sequence raises unguarded).
+    await expect(svc.resyncSequences(['roles', 'admin_users', 'permissions', 'role_permissions'])).resolves.toBeUndefined();
+
+    // Natural inserts (no explicit id) now avoid the restored ids.
+    const [adminId] = await pgDb('admin_users').insert({ username: 'b', email: 'b@x.io', password_hash: 'h' }).returning('id');
+    expect(Number(adminId.id || adminId)).toBe(10); // max(9)+1, no duplicate-key error
+    const [roleId] = await pgDb('roles').insert({ name: 'editor', display_name: 'Ed' }).returning('id');
+    expect(Number(roleId.id || roleId)).toBe(6);
+  });
+
+  test('reinjectCurrentAdmin insert branch works with a stale sequence (explicit max+1)', async () => {
+    await pgDb('admin_users').insert({ id: 9, username: 'backup', email: 'backup@x.io', password_hash: 'h' });
+    const operator = { id: 1, username: 'admin', email: 'op@x.io', password_hash: 'OP', is_active: true, created_by: 42 };
+
+    await pgDb.transaction((trx) => svc.reinjectCurrentAdmin(trx, operator));
+
+    const op = await pgDb('admin_users').where({ email: 'op@x.io' }).first();
+    expect(op.id).toBe(10);            // max(9)+1
+    expect(op.password_hash).toBe('OP');
+    expect(op.created_by).toBeNull();  // self-ref FK nulled so the insert can't dangle
+  });
+
+  test('preserveOperatorRole re-creates a missing role on Postgres and keeps FK integrity', async () => {
+    await pgDb('permissions').insert([{ id: 3, name: 'events.create', display_name: 'C', category: 'events' }]);
+    await pgDb('roles').insert([{ id: 2, name: 'viewer', display_name: 'V' }]);
+    await pgDb('admin_users').insert({ id: 1, username: 'admin', email: 'op@x.io', password_hash: 'h', role_id: null });
+    const snapshot = { role: { name: 'super_admin', display_name: 'SA', priority: 100, is_system: true }, permissions: ['events.create', 'missing.perm'] };
+
+    await pgDb.transaction((trx) => svc.preserveOperatorRole(trx, 1, snapshot));
+    await svc.resyncSequences(['roles']); // post-commit, mirrors importFromPicpeak
+
+    const role = await pgDb('roles').where({ name: 'super_admin' }).first();
+    expect(role).toBeTruthy();
+    const op = await pgDb('admin_users').where({ id: 1 }).first();
+    expect(op.role_id).toBe(role.id);  // FK valid, operator not downgraded
+    const grants = await pgDb('role_permissions').where({ role_id: role.id }).pluck('permission_id');
+    expect(grants).toEqual([3]);        // existing perm granted, missing.perm skipped
+  });
+
+  test('full replaceAllTables: cross-instance backup preserves the operator, role, FKs, and sequences', async () => {
+    // A backup from ANOTHER instance: omits the operator's email AND their
+    // super_admin role; uses explicit ids that leave sequences stale.
+    const staging = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-pgtest-'));
+    const dataDir = path.join(staging, 'data');
+    fs.mkdirSync(dataDir);
+    const write = (t, rows) => fs.writeFileSync(path.join(dataDir, `${t}.ndjson`), rows.map((r) => JSON.stringify(r)).join('\n'));
+    write('roles', [{ id: 5, name: 'admin', display_name: 'Admin', priority: 50, is_system: true }]);
+    write('permissions', [{ id: 3, name: 'events.create', display_name: 'C', category: 'events' }]);
+    write('role_permissions', [{ role_id: 5, permission_id: 3 }]);
+    write('admin_users', [{ id: 9, username: 'backupadmin', email: 'backup@x.io', password_hash: 'h', role_id: 5, is_active: true }]);
+    write('events', [{ id: 2, slug: 'restored-ev', created_by: 9 }]);
+
+    const operator = { id: 1, username: 'admin', email: 'op@x.io', password_hash: 'OP', is_active: true, role_id: 999, created_by: null };
+    const roleSnapshot = { role: { name: 'super_admin', display_name: 'Super Admin', priority: 100, is_system: true }, permissions: ['events.create'] };
+    const tables = ['roles', 'permissions', 'role_permissions', 'admin_users', 'events'];
+
+    // replaceAllTables isn't exported, so drive its exact transaction sequence
+    // (suspend FKs, wipe, batchInsert, reinject, preserve role) through the
+    // exported units against real Postgres.
+    const importSvc = svc;
+    await pgDb.transaction(async (trx) => {
+      await trx.raw('SET session_replication_role = \'replica\'');
+      for (const t of tables) await trx(t).del();
+      for (const t of tables) {
+        const rows = fs.readFileSync(path.join(dataDir, `${t}.ndjson`), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
+        if (rows.length) await trx.batchInsert(t, rows, 100);
+      }
+      const opId = await importSvc.reinjectCurrentAdmin(trx, operator);
+      await importSvc.preserveOperatorRole(trx, opId, roleSnapshot);
+      await trx.raw('SET session_replication_role = \'origin\'');
+    });
+    await importSvc.resyncSequences(tables);
+
+    // Operator preserved (inserted, since email absent from backup).
+    const op = await pgDb('admin_users').where({ email: 'op@x.io' }).first();
+    expect(op).toBeTruthy();
+    expect(op.password_hash).toBe('OP');
+    // super_admin role re-created and the operator bound to it.
+    const sa = await pgDb('roles').where({ name: 'super_admin' }).first();
+    expect(sa).toBeTruthy();
+    expect(op.role_id).toBe(sa.id);
+    expect(await pgDb('role_permissions').where({ role_id: sa.id }).pluck('permission_id')).toEqual([3]);
+    // Restored event's created_by FK to the backup admin still valid.
+    const ev = await pgDb('events').where({ slug: 'restored-ev' }).first();
+    expect(ev.created_by).toBe(9);
+    // Sequences resynced → natural inserts don't collide.
+    const [newAdmin] = await pgDb('admin_users').insert({ username: 'fresh', email: 'fresh@x.io', password_hash: 'h' }).returning('id');
+    expect(Number(newAdmin.id || newAdmin)).toBeGreaterThan(op.id);
+
+    fs.rmSync(staging, { recursive: true, force: true });
+  });
+});
@@ -1,259 +0,0 @@
-/**
- * scripts/regenerate-thumbnails.js against external photos (#1148).
- *
- * The same defect #1129 fixed in the admin route, still standing in the CLI
- * fallback: the script resolved every source as
- * `storage/events/active/<photo.path>` and fs.access'd it. External and
- * reference rows do not live there — their originals sit under
- * `events.external_path` — so every one failed the check and was counted as an
- * error. On an install where all photos are external the script did nothing at
- * all, while reporting one error per photo.
- *
- * Driven against a REAL file on a REAL external mount with the real
- * imageProcessor, not a mock: the whole point is that the source resolves off
- * the mount, and a mocked ensureThumbnail would assert nothing about that.
- *
- * Responsive tiers (#1095/#1109) do not exist on this branch, so the tier
- * backfill in the main twin has nothing to port. Everything else does.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const sharp = require('sharp');
-const { execFile } = require('child_process');
-
-describe('regenerate-thumbnails script (#1148)', () => {
-  let tmpDir; let db; let cleanup; let regenerateThumbnails;
-  let eventId; let externalPhotoId; let videoPhotoId; let watcherVideoId; let repairPhotoId;
-  let vanishingPhotoId;
-  let externalRoot;
-
-  beforeAll(async () => {
-    tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'picpeak-regen-script-'));
-    process.env.NODE_ENV = 'test';
-    process.env.TEST_DATABASE_PATH = path.join(tmpDir, 'data', 'test.db');
-    process.env.STORAGE_PATH = path.join(tmpDir, 'storage');
-    // External sources are sandboxed under EXTERNAL_MEDIA_ROOT; event
-    // external_path is relative to it, exactly as on a real install.
-    process.env.EXTERNAL_MEDIA_ROOT = path.join(tmpDir, 'media');
-    externalRoot = path.join(process.env.EXTERNAL_MEDIA_ROOT, 'wedding');
-
-    await fs.promises.mkdir(path.dirname(process.env.TEST_DATABASE_PATH), { recursive: true });
-    await fs.promises.mkdir(process.env.STORAGE_PATH, { recursive: true });
-    await fs.promises.mkdir(externalRoot, { recursive: true });
-
-    jest.resetModules();
-    ({ db, cleanup } = await require('./helpers/crmDb').bootCrmDb());
-
-    // A real image on the external mount — never under events/active.
-    await sharp({
-      create: { width: 1200, height: 800, channels: 3, background: { r: 10, g: 90, b: 160 } },
-    }).jpeg().toFile(path.join(externalRoot, 'shot.jpg'));
-
-    const [ev] = await db('events').insert({
-      slug: 'regen-script-event',
-      event_type: 'wedding',
-      event_name: 'Regen Script',
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_link: '/gallery/regen-script-event/share',
-      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-      source_mode: 'reference',
-      external_path: 'wedding',
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    eventId = typeof ev === 'object' ? ev.id : ev;
-
-    const [p] = await db('photos').insert({
-      event_id: eventId,
-      filename: 'shot.jpg',
-      // `path` is what the old script joined onto events/active. Left
-      // populated on purpose: the fix must ignore it for an external row.
-      path: 'regen-script-event/shot.jpg',
-      type: 'individual',
-      source_origin: 'external',
-      external_relpath: 'shot.jpg',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    externalPhotoId = typeof p === 'object' ? p.id : p;
-
-    const [v] = await db('photos').insert({
-      event_id: eventId,
-      filename: 'clip.mp4',
-      path: 'regen-script-event/clip.mp4',
-      type: 'individual',
-      media_type: 'video',
-      mime_type: 'video/mp4',
-      source_origin: 'external',
-      external_relpath: 'clip.mp4',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    videoPhotoId = typeof v === 'object' ? v.id : v;
-
-    // How fileWatcher.processNewPhoto actually writes a video: `type` and
-    // `mime_type` set, media_type left to its 'image' default. A media_type-only
-    // filter lets this through and hands the container to Sharp.
-    //
-    // The file has to EXIST, otherwise the row fails resolution and looks
-    // skipped for the wrong reason — the bug is Sharp being handed a video, not
-    // a missing source. Real MP4 header bytes, no image in sight.
-    await fs.promises.writeFile(
-      path.join(externalRoot, 'watched.mp4'),
-      Buffer.from('00000018667479706d70343200000000', 'hex')
-    );
-    const [wv] = await db('photos').insert({
-      event_id: eventId,
-      filename: 'watched.mp4',
-      path: 'regen-script-event/watched.mp4',
-      type: 'video',
-      mime_type: 'video/mp4',
-      source_origin: 'external',
-      external_relpath: 'watched.mp4',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    watcherVideoId = typeof wv === 'object' ? wv.id : wv;
-    expect((await db('photos').where('id', watcherVideoId).first()).media_type).not.toBe('video');
-
-    // A photo whose thumbnail_path points at something that is no longer there.
-    await sharp({
-      create: { width: 900, height: 600, channels: 3, background: { r: 200, g: 40, b: 40 } },
-    }).jpeg().toFile(path.join(externalRoot, 'repair.jpg'));
-    const [rp] = await db('photos').insert({
-      event_id: eventId,
-      filename: 'repair.jpg',
-      path: 'regen-script-event/repair.jpg',
-      type: 'individual',
-      thumbnail_path: 'thumbnails/thumb_ext_missing_repair.jpg',
-      source_origin: 'external',
-      external_relpath: 'repair.jpg',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    repairPhotoId = typeof rp === 'object' ? rp.id : rp;
-
-    // A photo whose source is not on the mount at all — an unavailable mount,
-    // which is the failure an operator most needs to hear about.
-    const [vp] = await db('photos').insert({
-      event_id: eventId,
-      filename: 'missing.jpg',
-      path: 'regen-script-event/missing.jpg',
-      type: 'individual',
-      source_origin: 'external',
-      external_relpath: 'missing.jpg',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    vanishingPhotoId = typeof vp === 'object' ? vp.id : vp;
-
-    ({ regenerateThumbnails } = require('../../scripts/regenerate-thumbnails'));
-  }, 180000);
-
-  afterAll(async () => {
-    if (cleanup) await cleanup();
-    await fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-  });
-
-  it('builds a thumbnail for an external photo instead of erroring on events/active', async () => {
-    // The location the old script computed and fs.access'd. Nothing is there,
-    // which is the whole defect — it is not where an external original lives.
-    // (The old script cannot be driven from a test directly: it had no export
-    // and ran on require, calling process.exit. Making it importable is part
-    // of this fix.)
-    const legacyPath = path.join(process.env.STORAGE_PATH, 'events/active', 'regen-script-event/shot.jpg');
-    expect(fs.existsSync(legacyPath)).toBe(false);
-
-    const result = await regenerateThumbnails(eventId);
-
-    // The old script reported an error for this photo and wrote nothing.
-    // The unresolvable row fails; the external photo and the repair row build.
-    expect(result.errorCount).toBe(1);
-    expect(result.successCount).toBe(2);
-
-    const row = await db('photos').where('id', externalPhotoId).first();
-    expect(row.thumbnail_path).toBeTruthy();
-    const onDisk = path.join(process.env.STORAGE_PATH, row.thumbnail_path);
-    expect(fs.existsSync(onDisk)).toBe(true);
-
-    // Named per-photo so two events referencing one NAS basename cannot
-    // clobber each other — the property ensureThumbnail owns and the reason
-    // the script must not build this name itself.
-    expect(path.basename(row.thumbnail_path)).toContain(`ext${externalPhotoId}_`);
-  });
-
-  it('leaves videos alone', async () => {
-    // A video thumbnail is a poster frame from videoProcessor; handing the
-    // container to Sharp produced one error per video row.
-    const row = await db('photos').where('id', videoPhotoId).first();
-    expect(row.thumbnail_path).toBeFalsy();
-  });
-
-  it('leaves a watcher-imported video alone, which carries no media_type', async () => {
-    // fileWatcher writes type + mime_type and lets media_type default to
-    // 'image', so filtering on media_type alone still fed these to Sharp. The
-    // signal is errorCount: the images are already done by now, so the only
-    // NEW thing that could fail this run is a video reaching Sharp. One error
-    // is the deliberately unresolvable row; two would be the video.
-    const result = await regenerateThumbnails(eventId);
-
-    expect(result.errorCount).toBe(1);
-    const row = await db('photos').where('id', watcherVideoId).first();
-    expect(row.thumbnail_path).toBeFalsy();
-  });
-
-  it('is idempotent — a second run skips instead of rebuilding', async () => {
-    const before = await db('photos').where('id', externalPhotoId).first();
-    const result = await regenerateThumbnails(eventId);
-
-    expect(result.errorCount).toBe(1);
-    expect(result.successCount).toBe(0);
-    expect(result.skipCount).toBe(2);
-
-    const after = await db('photos').where('id', externalPhotoId).first();
-    expect(after.thumbnail_path).toBe(before.thumbnail_path);
-  });
-
-  it('counts a repaired thumbnail as generated, not skipped', async () => {
-    // Both images are valid at this point. Destroy ONE thumbnail object while
-    // leaving thumbnail_path pointing at it — the corrupt/missing case.
-    const row = await db('photos').where('id', repairPhotoId).first();
-    const onDisk = path.join(process.env.STORAGE_PATH, row.thumbnail_path);
-    await fs.promises.rm(onDisk);
-
-    const result = await regenerateThumbnails(eventId);
-
-    // On local and external storage the rebuilt key is identical, so inferring
-    // "skipped" from an unchanged path reports this repair as already valid —
-    // the one number an operator running this is actually reading.
-    expect(result.successCount).toBe(1);
-    expect(result.skipCount).toBe(1);
-    expect(result.errorCount).toBe(1);
-    expect(fs.existsSync(onDisk)).toBe(true);
-  });
-
-  /** Run the CLI the way cron does, and hand back its exit status. */
-  const runCli = (args = []) => new Promise((resolve) => {
-    execFile(
-      process.execPath,
-      [path.join(__dirname, '..', '..', 'scripts', 'regenerate-thumbnails.js'), ...args],
-      { env: { ...process.env }, cwd: path.join(__dirname, '..', '..') },
-      (error, stdout, stderr) => resolve({ code: error?.code ?? 0, stdout, stderr })
-    );
-  });
-
-  it('exits nonzero when a photo could not be built', async () => {
-    // Exit status is the only thing a cron job reads, and `missing.jpg` has no
-    // source on the mount.
-    const failed = await runCli([String(eventId)]);
-    expect(failed.code).toBe(1);
-    expect(failed.stderr).toContain('completed with failures');
-  }, 120000);
-
-  it('exits zero when every photo resolves', async () => {
-    // Drop the unresolvable row: a clean run must not cry wolf at automation.
-    await db('photos').where('id', vanishingPhotoId).del();
-    const ok = await runCli([String(eventId)]);
-    expect(ok.code).toBe(0);
-    expect(ok.stdout).toContain('Script completed successfully');
-  }, 120000);
-});
@@ -0,0 +1,402 @@
+/**
+ * Reveal mode integration tests (#838).
+ *
+ * Pins the contract:
+ *  - effective visibility is computed at request time (isGalleryHidden):
+ *    reveal_at in the past opens the gate even before the scheduler stamps
+ *  - /photos returns the event shell with photos: [] + hidden_until_reveal
+ *    for plain guests; slideshow / client / admin-preview see everything
+ *  - image + download endpoints 403 with GALLERY_HIDDEN for plain guests
+ *  - the guest upload route is NOT gated (uploading while hidden is the point)
+ *  - the scheduler stamps revealed_at for due events, exactly once
+ *  - POST /events/:id/reveal stamps revealed_at (idempotent, 400 when the
+ *    mode is off); re-enabling reveal_mode clears revealed_at (re-hide)
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+
+const { bootCrmDb, seedMinimal } = require('./helpers/crmDb');
+
+process.env.JWT_SECRET = process.env.JWT_SECRET || 'reveal-test-secret';
+
+const SLUG = 'reveal-test-event';
+
+describe('Reveal mode (#838)', () => {
+  let db;
+  let cleanup;
+  let app;
+  let eventId;
+  let photoIds;
+  let adminToken;
+  const { isGalleryHidden } = require('../../src/utils/revealMode');
+
+  const galleryToken = (extra = {}) => jwt.sign(
+    { eventId, eventSlug: SLUG, type: 'gallery', ...extra },
+    process.env.JWT_SECRET,
+    { expiresIn: '1h', issuer: 'picpeak-auth' }
+  );
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    await seedMinimal(db);
+
+    const inserted = await db('events').insert({
+      slug: SLUG,
+      event_type: 'wedding',
+      event_name: 'Reveal Test',
+      event_date: '2026-08-01',
+      host_email: 'host@example.com',
+      admin_email: 'admin@example.com',
+      password_hash: 'x',
+      share_link: `/gallery/${SLUG}/share`,
+      share_token: 'reveal-test-share',
+      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
+      is_active: 1,
+      is_archived: 0,
+      is_draft: 0,
+      allow_user_uploads: 1,
+      reveal_mode: 1,
+      created_at: new Date().toISOString(),
+    }).returning('id');
+    eventId = inserted[0]?.id ?? inserted[0];
+
+    photoIds = [];
+    for (let i = 0; i < 2; i++) {
+      const p = await db('photos').insert({
+        event_id: eventId,
+        filename: `photo-${i}.jpg`,
+        path: `events/reveal/${i}.jpg`,
+        type: 'individual',
+        uploaded_at: new Date().toISOString(),
+      }).returning('id');
+      photoIds.push(p[0]?.id ?? p[0]);
+    }
+
+    // Super admin for the admin routes.
+    const superRole = await db('roles').where({ name: 'super_admin' }).first();
+    const [rootId] = await db('admin_users').insert({
+      username: 'reveal-admin',
+      email: 'reveal-admin@example.com',
+      password_hash: await bcrypt.hash('RevealAdmin123', 4),
+      role_id: superRole.id,
+      is_active: 1,
+      created_at: new Date(),
+      updated_at: new Date(),
+    }).returning('id').then((r) => [r[0]?.id || r[0]]);
+    adminToken = jwt.sign(
+      { id: rootId, username: 'reveal-admin', type: 'admin', role: 'super_admin', loginTime: Date.now() },
+      process.env.JWT_SECRET,
+      { expiresIn: '1h', issuer: 'picpeak-auth' }
+    );
+
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/gallery', require('../../src/routes/gallery'));
+    app.use('/api/secure-images', require('../../src/routes/secureImages'));
+    app.use('/api/images', require('../../src/routes/protectedImages'));
+    app.use('/api/gallery', require('../../src/routes/galleryFeedback'));
+    app.use('/api/admin/events', require('../../src/routes/adminEvents'));
+  }, 120000);
+
+  afterAll(async () => {
+    if (cleanup) await cleanup();
+  });
+
+  describe('effective visibility math (isGalleryHidden)', () => {
+    const base = { reveal_mode: true, revealed_at: null, reveal_at: null };
+    it('is hidden while armed and unrevealed, visible otherwise', () => {
+      expect(isGalleryHidden({ ...base })).toBe(true);
+      expect(isGalleryHidden({ ...base, reveal_mode: false })).toBe(false);
+      expect(isGalleryHidden({ ...base, revealed_at: new Date() })).toBe(false);
+      // reveal_at in the past opens the gate WITHOUT any stamp — time-exact.
+      expect(isGalleryHidden({ ...base, reveal_at: new Date(Date.now() - 60_000) })).toBe(false);
+      expect(isGalleryHidden({ ...base, reveal_at: new Date(Date.now() + 60_000) })).toBe(true);
+      // SQLite 0/1 booleans
+      expect(isGalleryHidden({ reveal_mode: 1, revealed_at: null, reveal_at: null })).toBe(true);
+      expect(isGalleryHidden({ reveal_mode: 0, revealed_at: null, reveal_at: null })).toBe(false);
+    });
+  });
+
+  describe('gallery routes while hidden', () => {
+    it('/photos gives plain guests the shell with no photos and the flag', async () => {
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(res.status).toBe(200);
+      expect(res.body.hidden_until_reveal).toBe(true);
+      expect(res.body.photos).toEqual([]);
+      expect(res.body.categories).toEqual([]);
+      expect(res.body.event.event_name).toBe('Reveal Test');
+    });
+
+    it('/photos serves the slideshow token everything (surprise beamer)', async () => {
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken({ accessLevel: 'slideshow' })}`);
+      expect(res.status).toBe(200);
+      expect(res.body.hidden_until_reveal).toBe(false);
+      expect(res.body.photos).toHaveLength(2);
+    });
+
+    it('/photos serves client access everything (host review)', async () => {
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken({ accessLevel: 'client' })}`);
+      expect(res.status).toBe(200);
+      expect(res.body.hidden_until_reveal).toBe(false);
+      expect(res.body.photos).toHaveLength(2);
+    });
+
+    it('/photos serves the admin preview everything', async () => {
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/photos?preview=${encodeURIComponent(adminToken)}`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(res.status).toBe(200);
+      expect(res.body.hidden_until_reveal).toBe(false);
+      expect(res.body.photos).toHaveLength(2);
+    });
+
+    it('image and download endpoints 403 with GALLERY_HIDDEN for plain guests', async () => {
+      for (const url of [
+        `/api/gallery/${SLUG}/thumbnail/${photoIds[0]}`,
+        `/api/gallery/${SLUG}/photo/${photoIds[0]}`,
+        `/api/gallery/${SLUG}/download/${photoIds[0]}`,
+        `/api/gallery/${SLUG}/download-all`,
+        `/api/gallery/${SLUG}/stats`,
+        `/api/gallery/${SLUG}/hero/${photoIds[0]}`,
+      ]) {
+        const res = await request(app).get(url).set('Authorization', `Bearer ${galleryToken()}`);
+        expect(`${url}:${res.status}`).toBe(`${url}:403`);
+        expect(res.body.code).toBe('GALLERY_HIDDEN');
+      }
+    });
+
+    it('image endpoints are NOT reveal-blocked for the slideshow token', async () => {
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/thumbnail/${photoIds[0]}`)
+        .set('Authorization', `Bearer ${galleryToken({ accessLevel: 'slideshow' })}`);
+      // The seeded file doesn't exist on disk, so anything but the reveal
+      // gate's 403 is fine here.
+      expect(res.body.code).not.toBe('GALLERY_HIDDEN');
+    });
+
+    it('/info exposes the effective hidden state without auth', async () => {
+      const res = await request(app).get(`/api/gallery/${SLUG}/info`);
+      expect(res.status).toBe(200);
+      expect(res.body.hidden_until_reveal).toBe(true);
+    });
+
+    it('the guest upload route is not gated', async () => {
+      const res = await request(app)
+        .post(`/api/gallery/${eventId}/upload`)
+        .set('Authorization', `Bearer ${galleryToken()}`)
+        .send({});
+      // Fails later for other reasons (no multipart body) — but never on the
+      // reveal gate.
+      expect(res.body.code).not.toBe('GALLERY_HIDDEN');
+    });
+
+    it('legacy protected-image routes are reveal-gated for plain guests', async () => {
+      for (const [method, url] of [
+        ['get', `/api/images/${SLUG}/photo/${photoIds[0]}/view`],
+        ['post', `/api/images/${SLUG}/photo/${photoIds[0]}/generate-secure-token`],
+        ['post', `/api/images/${SLUG}/photo/${photoIds[0]}/generate-url`],
+      ]) {
+        const res = await request(app)[method](url).set('Authorization', `Bearer ${galleryToken()}`);
+        expect(`${url}:${res.status}`).toBe(`${url}:403`);
+        expect(res.body.code).toBe('GALLERY_HIDDEN');
+      }
+    });
+
+    it('feedback endpoints are reveal-gated; my-feedback degrades to empty', async () => {
+      // Feedback must be enabled for the routes to get past their own gate.
+      await db('event_feedback_settings').insert({
+        event_id: eventId, feedback_enabled: 1, allow_likes: 1,
+        created_at: new Date().toISOString(), updated_at: new Date().toISOString(),
+      });
+      const getRes = await request(app)
+        .get(`/api/gallery/${SLUG}/photos/${photoIds[0]}/feedback`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(getRes.status).toBe(403);
+      expect(getRes.body.code).toBe('GALLERY_HIDDEN');
+
+      const postRes = await request(app)
+        .post(`/api/gallery/${SLUG}/photos/${photoIds[0]}/feedback`)
+        .set('Authorization', `Bearer ${galleryToken()}`)
+        .send({ feedback_type: 'like' });
+      expect(postRes.status).toBe(403);
+      expect(postRes.body.code).toBe('GALLERY_HIDDEN');
+
+      const mine = await request(app)
+        .get(`/api/gallery/${SLUG}/my-feedback`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(mine.status).toBe(200);
+      expect(mine.body).toEqual([]);
+    });
+
+    it('secure-image token minting is reveal-gated for plain guests', async () => {
+      const res = await request(app)
+        .post(`/api/secure-images/${SLUG}/generate-token`)
+        .set('Authorization', `Bearer ${galleryToken()}`)
+        .send({ photoId: photoIds[0] });
+      expect(res.status).toBe(403);
+      expect(res.body.code).toBe('GALLERY_HIDDEN');
+    });
+
+    it('customer-portal tokens (via:customer, no accessLevel) bypass reveal mode', async () => {
+      const acct = await db('customer_accounts').insert({
+        email: 'portal-customer@example.com',
+        password_hash: 'x',
+        is_active: 1,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      }).returning('id');
+      const customerId = acct[0]?.id ?? acct[0];
+      await db('event_customer_assignments').insert({
+        event_id: eventId,
+        customer_account_id: customerId,
+      });
+
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken({ via: 'customer', customerId })}`);
+      expect(res.status).toBe(200);
+      expect(res.body.hidden_until_reveal).toBe(false);
+      expect(res.body.photos).toHaveLength(2);
+    });
+
+    it('a reveal_at in the past opens the gate without any stamp', async () => {
+      await db('events').where('id', eventId).update({ reveal_at: new Date(Date.now() - 60_000).toISOString() });
+      const res = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(res.body.hidden_until_reveal).toBe(false);
+      expect(res.body.photos).toHaveLength(2);
+      await db('events').where('id', eventId).update({ reveal_at: null });
+    });
+  });
+
+  describe('scheduler and admin reveal', () => {
+    it('the scheduler stamps revealed_at for due events exactly once', async () => {
+      const revealAt = new Date(Date.now() - 5 * 60_000);
+      await db('events').where('id', eventId).update({ reveal_at: revealAt.toISOString(), revealed_at: null });
+
+      const { checkScheduledReveals } = require('../../src/services/revealScheduler');
+      await checkScheduledReveals();
+
+      const asMs = (v) => new Date(v).getTime();
+      const row = await db('events').where('id', eventId).first();
+      expect(row.revealed_at).not.toBeNull();
+      expect(asMs(row.revealed_at)).toBe(revealAt.getTime());
+      expect(row.reveal_at).toBeNull(); // schedule consumed, like "Reveal now"
+
+      // Second pass no-ops (revealed_at already set).
+      await checkScheduledReveals();
+      const again = await db('events').where('id', eventId).first();
+      expect(asMs(again.revealed_at)).toBe(revealAt.getTime());
+
+      await db('events').where('id', eventId).update({ reveal_at: null, revealed_at: null });
+    });
+
+    it('POST /:id/reveal stamps revealed_at, clears the schedule, and is idempotent', async () => {
+      await db('events').where('id', eventId).update({ reveal_at: new Date(Date.now() + 3600_000).toISOString() });
+      const res = await request(app)
+        .post(`/api/admin/events/${eventId}/reveal`)
+        .set('Authorization', `Bearer ${adminToken}`);
+      expect(res.status).toBe(200);
+      expect(res.body.revealed_at).toBeTruthy();
+      // "Reveal now" consumes the pending schedule.
+      const cleared = await db('events').where('id', eventId).first();
+      expect(cleared.reveal_at).toBeNull();
+
+      const first = res.body.revealed_at;
+      const res2 = await request(app)
+        .post(`/api/admin/events/${eventId}/reveal`)
+        .set('Authorization', `Bearer ${adminToken}`);
+      expect(res2.status).toBe(200);
+      expect(res2.body.revealed_at).toBe(first);
+
+      // Guests see photos now.
+      const gallery = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(gallery.body.hidden_until_reveal).toBe(false);
+      expect(gallery.body.photos).toHaveLength(2);
+    });
+
+    it('re-enabling reveal_mode clears revealed_at (re-hide)', async () => {
+      await db('events').where('id', eventId).update({ reveal_mode: 0 });
+      const res = await request(app)
+        .put(`/api/admin/events/${eventId}`)
+        .set('Authorization', `Bearer ${adminToken}`)
+        .send({ reveal_mode: true });
+      expect(res.status).toBe(200);
+
+      const row = await db('events').where('id', eventId).first();
+      expect(row.revealed_at).toBeNull();
+
+      const gallery = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(gallery.body.hidden_until_reveal).toBe(true);
+    });
+
+    it('scheduling a FUTURE reveal on a revealed gallery re-arms hiding', async () => {
+      // State: revealed (previous tests). Saving a future schedule re-hides.
+      await db('events').where('id', eventId).update({ revealed_at: new Date().toISOString() });
+      const res = await request(app)
+        .put(`/api/admin/events/${eventId}`)
+        .set('Authorization', `Bearer ${adminToken}`)
+        .send({ reveal_mode: true, reveal_at: new Date(Date.now() + 3600_000).toISOString() });
+      expect(res.status).toBe(200);
+      const row = await db('events').where('id', eventId).first();
+      expect(row.revealed_at).toBeNull();
+
+      const gallery = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(gallery.body.hidden_until_reveal).toBe(true);
+      await db('events').where('id', eventId).update({ reveal_at: null });
+    });
+
+    it('re-arming without a schedule clears a stale PAST reveal_at', async () => {
+      // Legacy/partial-API state: revealed with the old past schedule still
+      // stored. {reveal_mode:false} then {reveal_mode:true} without
+      // reveal_at must re-hide, not instantly re-open via the stale date.
+      await db('events').where('id', eventId).update({
+        reveal_mode: 0,
+        revealed_at: new Date().toISOString(),
+        reveal_at: new Date(Date.now() - 3600_000).toISOString(),
+      });
+      const res = await request(app)
+        .put(`/api/admin/events/${eventId}`)
+        .set('Authorization', `Bearer ${adminToken}`)
+        .send({ reveal_mode: true });
+      expect(res.status).toBe(200);
+
+      const row = await db('events').where('id', eventId).first();
+      expect(row.revealed_at).toBeNull();
+      expect(row.reveal_at).toBeNull();
+
+      const gallery = await request(app)
+        .get(`/api/gallery/${SLUG}/photos`)
+        .set('Authorization', `Bearer ${galleryToken()}`);
+      expect(gallery.body.hidden_until_reveal).toBe(true);
+      expect(gallery.body.photos).toEqual([]);
+    });
+
+    it('POST /:id/reveal 400s while reveal mode is off', async () => {
+      await db('events').where('id', eventId).update({ reveal_mode: 0, revealed_at: null });
+      const res = await request(app)
+        .post(`/api/admin/events/${eventId}/reveal`)
+        .set('Authorization', `Bearer ${adminToken}`);
+      expect(res.status).toBe(400);
+      await db('events').where('id', eventId).update({ reveal_mode: 1 });
+    });
+  });
+});
@@ -1,150 +0,0 @@
-/**
- * Slideshow photo source (#1015).
- *
- * The bug: with `lightbox_preview_enabled` off (the default), /photos emitted
- * `preview_url: null`, so the slideshow's `preview_url || hero_url || url`
- * chain fell through to `hero_url` — a 1920x1080 `fit: 'cover'` centre crop
- * meant for gallery header banners. With the "Black Bars (No crop)" fit the
- * show then letterboxed an already-cropped frame: portrait photos lost their
- * top and bottom and the setting looked broken.
- *
- * The contract pinned here: `slideshow_url` points at the aspect-preserved
- * preview tier and is emitted for image photos REGARDLESS of the lightbox
- * toggle, so the slideshow never has a reason to reach for `hero_url`.
- * `preview_url` itself must stay gated — the lightbox opt-in is unchanged.
- */
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('./helpers/crmDb');
-
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'slideshow-src-test-secret';
-
-const SLUG = 'slideshow-source-event';
-
-describe('Slideshow photo source (#1015)', () => {
-  let db;
-  let cleanup;
-  let app;
-  let eventId;
-  let imagePhotoId;
-  let videoPhotoId;
-
-  const galleryToken = () => jwt.sign(
-    { eventId, eventSlug: SLUG, type: 'gallery' },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-
-  const setLightboxPreview = async (on) => {
-    await db('app_settings').where({ setting_key: 'lightbox_preview_enabled' }).del();
-    await db('app_settings').insert({
-      setting_key: 'lightbox_preview_enabled',
-      setting_value: JSON.stringify(on),
-      setting_type: 'general',
-      updated_at: new Date().toISOString(),
-    });
-  };
-
-  const fetchPhotos = async () => {
-    const res = await request(app)
-      .get(`/api/gallery/${SLUG}/photos`)
-      .set('Authorization', `Bearer ${galleryToken()}`)
-      .expect(200);
-    return res.body.photos;
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const inserted = await db('events').insert({
-      slug: SLUG,
-      event_type: 'wedding',
-      event_name: 'Slideshow Source Test',
-      event_date: '2026-08-01',
-      host_email: 'host@example.com',
-      admin_email: 'admin@example.com',
-      password_hash: 'x',
-      share_link: `/gallery/${SLUG}/share`,
-      share_token: 'slideshow-source-share',
-      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-      is_active: 1,
-      is_archived: 0,
-      is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    eventId = inserted[0]?.id ?? inserted[0];
-
-    const img = await db('photos').insert({
-      event_id: eventId,
-      filename: 'portrait.jpg',
-      path: 'events/slideshow-source/portrait.jpg',
-      type: 'individual',
-      mime_type: 'image/jpeg',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    imagePhotoId = img[0]?.id ?? img[0];
-
-    const vid = await db('photos').insert({
-      event_id: eventId,
-      filename: 'clip.mp4',
-      path: 'events/slideshow-source/clip.mp4',
-      type: 'individual',
-      media_type: 'video',
-      mime_type: 'video/mp4',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    videoPhotoId = vid[0]?.id ?? vid[0];
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/gallery', require('../../src/routes/gallery'));
-  }, 120000);
-
-  afterAll(async () => {
-    if (cleanup) await cleanup();
-  });
-
-  it('emits slideshow_url for image photos even when lightbox previews are OFF', async () => {
-    await setLightboxPreview(false);
-    const photos = await fetchPhotos();
-    const image = photos.find((p) => p.id === imagePhotoId);
-
-    expect(image.slideshow_url).toBe(`/api/gallery/${SLUG}/preview/${imagePhotoId}`);
-    // The regression: this is what used to be null, pushing the show to hero.
-    expect(image.preview_url).toBeNull();
-  });
-
-  it('leaves preview_url gated so the lightbox opt-in is unchanged', async () => {
-    await setLightboxPreview(true);
-    const photos = await fetchPhotos();
-    const image = photos.find((p) => p.id === imagePhotoId);
-
-    expect(image.preview_url).toBe(`/api/gallery/${SLUG}/preview/${imagePhotoId}`);
-    expect(image.slideshow_url).toBe(image.preview_url);
-  });
-
-  it('never points the slideshow at the cover-cropped hero tier', async () => {
-    await setLightboxPreview(false);
-    const photos = await fetchPhotos();
-    const image = photos.find((p) => p.id === imagePhotoId);
-
-    // hero_url still ships (the gallery header uses it) — it just must not be
-    // what the slideshow resolves to.
-    expect(image.hero_url).toBe(`/api/gallery/${SLUG}/hero/${imagePhotoId}`);
-    expect(image.slideshow_url).not.toBe(image.hero_url);
-  });
-
-  it('emits slideshow_url: null for videos, which have no preview tier', async () => {
-    await setLightboxPreview(false);
-    const photos = await fetchPhotos();
-    const video = photos.find((p) => p.id === videoPhotoId);
-
-    expect(video.slideshow_url).toBeNull();
-  });
-});
@@ -0,0 +1,136 @@
+/**
+ * SQLite epoch-timestamp normalization (#485 follow-up).
+ *
+ * On SQLite, timestamp columns written with a raw `new Date()` through knex
+ * hold epoch-millisecond numbers. Postgres returns ISO strings, so frontend
+ * code written against Postgres calls parseISO() and crashes on native
+ * (SQLite) installs — the exact class fixed for admin Users in #485, which
+ * listed api tokens / photos / activity as an out-of-scope follow-up.
+ *
+ * Pins:
+ *  - gallery /photos serializes uploaded_at / captured_at as ISO strings
+ *    even when the row holds an epoch number (pre-fix archive restores)
+ *  - the api-tokens list serializes created_at / expires_at / last_used_at /
+ *    revoked_at as ISO strings for epoch-stored rows
+ */
+
+const request = require('supertest');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+
+const { bootCrmDb, seedMinimal } = require('./helpers/crmDb');
+
+process.env.JWT_SECRET = process.env.JWT_SECRET || 'epoch-test-secret';
+
+const SLUG = 'epoch-test-event';
+const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+
+describe('SQLite epoch timestamp normalization', () => {
+  let db;
+  let cleanup;
+  let app;
+  let eventId;
+  let adminToken;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    await seedMinimal(db);
+
+    const inserted = await db('events').insert({
+      slug: SLUG,
+      event_type: 'wedding',
+      event_name: 'Epoch Test',
+      event_date: '2026-08-01',
+      host_email: 'host@example.com',
+      admin_email: 'admin@example.com',
+      password_hash: 'x',
+      share_link: `/gallery/${SLUG}/share`,
+      share_token: 'epoch-test-share',
+      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
+      is_active: 1,
+      is_archived: 0,
+      is_draft: 0,
+      created_at: new Date().toISOString(),
+    }).returning('id');
+    eventId = inserted[0]?.id ?? inserted[0];
+
+    // The pre-fix corruption shape: epoch numbers in timestamp columns.
+    await db('photos').insert({
+      event_id: eventId,
+      filename: 'restored.jpg',
+      path: 'events/epoch/restored.jpg',
+      type: 'individual',
+      uploaded_at: Date.now() - 3600_000,
+      captured_at: Date.now() - 7200_000,
+    });
+
+    const superRole = await db('roles').where({ name: 'super_admin' }).first();
+    const [rootId] = await db('admin_users').insert({
+      username: 'epoch-admin',
+      email: 'epoch-admin@example.com',
+      password_hash: await bcrypt.hash('EpochAdmin123', 4),
+      role_id: superRole.id,
+      is_active: 1,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    }).returning('id').then((r) => [r[0]?.id || r[0]]);
+    adminToken = jwt.sign(
+      { id: rootId, username: 'epoch-admin', type: 'admin', role: 'super_admin', loginTime: Date.now() },
+      process.env.JWT_SECRET,
+      { expiresIn: '1h', issuer: 'picpeak-auth' }
+    );
+
+    await db('api_tokens').insert({
+      name: 'epoch-token',
+      hashed_token: 'x'.repeat(64),
+      preview: 'pk_test…abcd',
+      scopes: JSON.stringify(['events:read']),
+      created_by: rootId,
+      created_at: Date.now() - 86400_000,
+      last_used_at: Date.now() - 3600_000,
+      revoked_at: Date.now() - 60_000,
+    });
+
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/gallery', require('../../src/routes/gallery'));
+    app.use('/api/admin/api-tokens', require('../../src/routes/adminApiTokens'));
+  }, 120000);
+
+  afterAll(async () => {
+    if (cleanup) await cleanup();
+  });
+
+  it('gallery /photos serializes epoch-stored uploaded_at/captured_at as ISO strings', async () => {
+    const galleryToken = jwt.sign(
+      { eventId, eventSlug: SLUG, type: 'gallery' },
+      process.env.JWT_SECRET,
+      { expiresIn: '1h', issuer: 'picpeak-auth' }
+    );
+    const res = await request(app)
+      .get(`/api/gallery/${SLUG}/photos`)
+      .set('Authorization', `Bearer ${galleryToken}`);
+    expect(res.status).toBe(200);
+    expect(res.body.photos).toHaveLength(1);
+    const photo = res.body.photos[0];
+    expect(typeof photo.uploaded_at).toBe('string');
+    expect(photo.uploaded_at).toMatch(ISO_RE);
+    expect(photo.captured_at).toMatch(ISO_RE);
+  });
+
+  it('api-tokens list serializes epoch-stored timestamps as ISO strings', async () => {
+    const res = await request(app)
+      .get('/api/admin/api-tokens')
+      .set('Authorization', `Bearer ${adminToken}`);
+    expect(res.status).toBe(200);
+    const token = res.body.find((t) => t.name === 'epoch-token');
+    expect(token).toBeTruthy();
+    for (const field of ['created_at', 'last_used_at', 'revoked_at']) {
+      expect(`${field}:${typeof token[field]}`).toBe(`${field}:string`);
+      expect(token[field]).toMatch(ISO_RE);
+    }
+  });
+});
@@ -1,111 +0,0 @@
-/**
- * The roles-join fallback in adminAuth fabricates `role_name = 'super_admin'`
- * to keep existing sessions working across the RBAC upgrade window. The catch
- * around it used to be unconditional, so ANY transient database failure —
- * connection reset, deadlock, statement timeout, pool exhaustion — took the
- * same branch and handed the caller super_admin for the duration of the fault.
- *
- * `roleName` is the sole discriminator for every ownership check (ownership.js,
- * adminProjects, adminUsers, adminApiTokens, projectService, ...), so that
- * inverted the whole authorization model rather than failing the request.
- * Issue #968. Same treatment apiTokenAuth already got for the v1 surface.
- */
-
-const jwt = require('jsonwebtoken');
-
-jest.mock('../../src/utils/tokenRevocation', () => ({ isTokenRevoked: jest.fn().mockResolvedValue(false) }));
-jest.mock('../../src/utils/logger', () => ({ warn: jest.fn(), error: jest.fn(), debug: jest.fn(), info: jest.fn() }));
-
-// The joined query throws whatever the test stages; the role-less fallback
-// query (no .leftJoin) always succeeds, which is what made the original bug
-// reachable — it is the cheaper single-table read.
-// `mock`-prefixed so jest's module-factory hoisting allows the reference.
-let mockJoinError = null;
-const mockAdminRow = { id: 7, username: 'scoped', email: 's@example.com', password_changed_at: null };
-
-jest.mock('../../src/database/db', () => ({
-  db: () => ({
-    _joined: false,
-    leftJoin() { this._joined = true; return this; },
-    where() { return this; },
-    select() { return this; },
-    first() {
-      if (this._joined && mockJoinError) return Promise.reject(mockJoinError);
-      return Promise.resolve({ ...mockAdminRow });
-    },
-  }),
-}));
-
-const { adminAuth } = require('../../src/middleware/auth');
-
-const SECRET = 'test-secret-for-admin-auth-fallback';
-
-function makeReq() {
-  const token = jwt.sign(
-    { id: mockAdminRow.id, type: 'admin' },
-    SECRET,
-    { algorithm: 'HS256', issuer: 'picpeak-auth' },
-  );
-  return { headers: { authorization: `Bearer ${token}` }, ip: '127.0.0.1', connection: {} };
-}
-
-function makeRes() {
-  return {
-    statusCode: null,
-    body: null,
-    status(code) { this.statusCode = code; return this; },
-    json(payload) { this.body = payload; return this; },
-  };
-}
-
-describe('adminAuth roles-join fallback (#968)', () => {
-  const OLD_SECRET = process.env.JWT_SECRET;
-  beforeAll(() => { process.env.JWT_SECRET = SECRET; });
-  afterAll(() => { process.env.JWT_SECRET = OLD_SECRET; });
-  beforeEach(() => { mockJoinError = null; });
-
-  it('grants the upgrade-window fallback only for a genuinely missing roles table', async () => {
-    mockJoinError = new Error('SQLITE_ERROR: no such table: roles');
-    const req = makeReq();
-    const res = makeRes();
-    const next = jest.fn();
-
-    await adminAuth(req, res, next);
-
-    expect(next).toHaveBeenCalled();
-    expect(req.admin.roleName).toBe('super_admin');
-  });
-
-  it.each([
-    ['connection reset', new Error('Connection terminated unexpectedly')],
-    ['deadlock', new Error('deadlock detected')],
-    ['pool exhaustion', new Error('Knex: Timeout acquiring a connection')],
-    ['statement timeout', new Error('canceling statement due to statement timeout')],
-  ])('does NOT fabricate super_admin on a transient failure (%s)', async (_label, err) => {
-    mockJoinError = err;
-    const req = makeReq();
-    const res = makeRes();
-    const next = jest.fn();
-
-    await adminAuth(req, res, next);
-
-    // Fails closed: request rejected, req.admin never populated. The specific
-    // status is 401 (adminAuth's blanket outer catch) — what matters is that
-    // the caller is not elevated and does not reach the route.
-    expect(next).not.toHaveBeenCalled();
-    expect(req.admin).toBeUndefined();
-    expect(res.statusCode).toBe(401);
-  });
-
-  it('does NOT fabricate super_admin when an unrelated table is missing', async () => {
-    mockJoinError = new Error('SQLITE_ERROR: no such table: admin_sessions');
-    const req = makeReq();
-    const res = makeRes();
-    const next = jest.fn();
-
-    await adminAuth(req, res, next);
-
-    expect(next).not.toHaveBeenCalled();
-    expect(req.admin).toBeUndefined();
-  });
-});
@@ -1,72 +0,0 @@
-/**
- * The roles-join fallback in apiTokenAuth grants `super_admin` (upgrade-path
- * parity with adminAuth). It must therefore fire ONLY when the roles schema is
- * genuinely absent — a catch-all turns any transient database failure into a
- * privilege escalation that reopens GHSA-9697 for a demoted token owner.
- */
-
-const { isMissingRolesSchema } = require('../../src/middleware/apiTokenAuth');
-
-describe('apiTokenAuth roles-schema fallback predicate (GHSA-9697)', () => {
-  it('accepts a genuinely missing roles table on both engines', () => {
-    expect(isMissingRolesSchema(new Error('SQLITE_ERROR: no such table: roles'))).toBe(true);
-    expect(isMissingRolesSchema(
-      Object.assign(new Error('relation "roles" does not exist'), { code: '42P01' }),
-    )).toBe(true);
-    expect(isMissingRolesSchema(
-      Object.assign(new Error('column roles.name does not exist'), { code: '42703' }),
-    )).toBe(true);
-  });
-
-  it('rejects transient failures that must not elevate the caller', () => {
-    expect(isMissingRolesSchema(new Error('Connection terminated unexpectedly'))).toBe(false);
-    expect(isMissingRolesSchema(new Error('deadlock detected'))).toBe(false);
-    expect(isMissingRolesSchema(new Error('Knex: Timeout acquiring a connection'))).toBe(false);
-    expect(isMissingRolesSchema(new Error('canceling statement due to statement timeout'))).toBe(false);
-    expect(isMissingRolesSchema(undefined)).toBe(false);
-  });
-
-  it('rejects a missing-table error for an unrelated table', () => {
-    expect(isMissingRolesSchema(new Error('SQLITE_ERROR: no such table: api_tokens'))).toBe(false);
-  });
-
-  // knex prefixes the failing SQL to err.message, and that SQL always names
-  // `roles` on this join — so the message substring proves nothing about the
-  // error, and only an exact driver phrase (or a SQLSTATE) may be trusted.
-  // These are real knex message shapes, captured from the actual query.
-  describe('with knex\'s SQL prefix on the message (#968)', () => {
-    const withSql = (driverMessage) => new Error(
-      'select `roles`.`name` as `role_name` from `admin_users` '
-      + 'left join `roles` on `roles`.`id` = `admin_users`.`role_id` '
-      + `where \`admin_users\`.\`id\` = 1 limit 1 - ${driverMessage}`,
-    );
-
-    it('accepts both legitimate upgrade-window states', () => {
-      // pre-054: the roles table does not exist yet
-      expect(isMissingRolesSchema(
-        Object.assign(withSql('SQLITE_ERROR: no such table: roles'), { code: 'SQLITE_ERROR' }),
-      )).toBe(true);
-      // post-054, pre-057: roles exists, admin_users.role_id not added yet
-      expect(isMissingRolesSchema(
-        Object.assign(withSql('SQLITE_ERROR: no such column: admin_users.role_id'), { code: 'SQLITE_ERROR' }),
-      )).toBe(true);
-    });
-
-    it('rejects an unrelated "does not exist" fault despite the SQL naming roles', () => {
-      // pgbouncer transaction pooling loses a named prepared statement
-      // (SQLSTATE 26000). Transient — the fallback query would succeed on a
-      // fresh connection, so accepting this would fabricate super_admin.
-      expect(isMissingRolesSchema(
-        Object.assign(withSql('prepared statement "S_1" does not exist'), { code: '26000' }),
-      )).toBe(false);
-      // The DB role/user, not the roles table.
-      expect(isMissingRolesSchema(
-        Object.assign(withSql('role "picpeak" does not exist'), { code: '28000' }),
-      )).toBe(false);
-      expect(isMissingRolesSchema(
-        Object.assign(withSql('database "picpeak" does not exist'), { code: '3D000' }),
-      )).toBe(false);
-      expect(isMissingRolesSchema(withSql('Connection terminated unexpectedly'))).toBe(false);
-    });
-  });
-});
@@ -1,35 +0,0 @@
-/**
- * Migration 167 (projects.created_by) — idempotent on re-run, reversible,
- * and backfills the owner from a project's single linked event (GHSA-wrg5).
- */
-const path=require('path'), fs=require('fs'), os=require('os');
-process.env.NODE_ENV='test';
-process.env.TEST_DATABASE_PATH=path.join(fs.mkdtempSync(path.join(os.tmpdir(),'picpeak-mig167-')),'db.sqlite');
-process.env.JWT_SECRET='mig';
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-const mig = require('../../migrations/core/167_add_projects_created_by');
-describe('migration 167', () => {
-  let db, cleanup;
-  beforeAll(async()=>{ ({db,cleanup}=await bootCrmDb()); await seedMinimal(db); },120000);
-  afterAll(async()=>{ if(cleanup) await cleanup(); });
-  it('is idempotent on re-run and reversible', async () => {
-    await mig.up(db);            // already applied by boot; must no-op
-    await mig.up(db);            // and again
-    expect(await db.schema.hasColumn('projects','created_by')).toBe(true);
-    await mig.down(db);
-    expect(await db.schema.hasColumn('projects','created_by')).toBe(false);
-    await mig.up(db);            // re-apply cleanly
-    expect(await db.schema.hasColumn('projects','created_by')).toBe(true);
-  });
-  it('backfills created_by from a single linked event owner', async () => {
-    const p = await db('projects').insert({name:'bf',status:'active',created_at:new Date(),updated_at:new Date()}).returning('id');
-    const pid = p[0]?.id ?? p[0];
-    await db('events').insert({slug:'bf-ev',event_type:'wedding',event_name:'bf',event_date:'2026-08-01',
-      host_email:'h@e.com',admin_email:'a@e.com',password_hash:'x',share_token:'t1',share_link:'/g/bf-ev/t1',
-      created_by: 4242, project_id: pid, expires_at:new Date(Date.now()+864e5).toISOString(),
-      is_active:1,is_archived:0,is_draft:0,created_at:new Date().toISOString()});
-    await mig.up(db);
-    const row = await db('projects').where({id:pid}).first();
-    expect(row.created_by).toBe(4242);
-  });
-});
@@ -1,83 +0,0 @@
-/**
- * GHSA-jhcf round 3: scoping the activity feed does nothing about the rows
- * already on disk. expenseService used to pass adminId into logActivity's
- * `eventId` slot, so upgraded instances carry accounting rows whose event_id
- * is an ADMIN id — and the scope predicate happily matches those against a
- * same-numbered event the caller owns.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-mig168-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'mig168-test-secret';
-
-const { bootCrmDb } = require('../integration/helpers/crmDb');
-const migration = require('../../migrations/core/168_fix_expense_activity_event_id');
-
-describe('migration 168 — legacy accounting activity rows (GHSA-jhcf)', () => {
-  let db; let cleanup;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('re-attributes the admin id and clears event_id, leaving real rows alone', async () => {
-    await db('activity_logs').insert([
-      // Legacy shape: event_id is really admin #7, no actor recorded.
-      {
-        activity_type: 'expense_created',
-        actor_type: 'system',
-        actor_id: null,
-        event_id: 7,
-        metadata: JSON.stringify({ expenseId: 1 }),
-        created_at: new Date().toISOString(),
-      },
-      {
-        activity_type: 'incoming_invoice_captured',
-        actor_type: 'system',
-        actor_id: null,
-        event_id: 9,
-        metadata: JSON.stringify({ inboundDocumentId: 2 }),
-        created_at: new Date().toISOString(),
-      },
-      // A genuine event-scoped row from another subsystem must survive intact.
-      {
-        activity_type: 'photo_uploaded',
-        actor_type: 'admin',
-        actor_id: 3,
-        event_id: 7,
-        metadata: JSON.stringify({}),
-        created_at: new Date().toISOString(),
-      },
-    ]);
-
-    await migration.up(db);
-
-    const expense = await db('activity_logs').where({ activity_type: 'expense_created' }).first();
-    expect(expense.event_id == null).toBe(true);
-    expect(Number(expense.actor_id)).toBe(7);
-    expect(expense.actor_type).toBe('admin');
-
-    const captured = await db('activity_logs').where({ activity_type: 'incoming_invoice_captured' }).first();
-    expect(captured.event_id == null).toBe(true);
-    expect(Number(captured.actor_id)).toBe(9);
-
-    const photo = await db('activity_logs').where({ activity_type: 'photo_uploaded' }).first();
-    expect(Number(photo.event_id)).toBe(7);
-    expect(Number(photo.actor_id)).toBe(3);
-  });
-
-  it('is idempotent on re-run', async () => {
-    await expect(migration.up(db)).resolves.toBeUndefined();
-    const expense = await db('activity_logs').where({ activity_type: 'expense_created' }).first();
-    expect(Number(expense.actor_id)).toBe(7);
-    expect(expense.event_id == null).toBe(true);
-  });
-});
@@ -1,242 +0,0 @@
-/**
- * Repairing the bundled templates' fixed image height (#1131).
- *
- * The risk in a migration that rewrites user-visible CSS is doing too much,
- * so most of what is pinned here is what it must NOT touch: the other pixel
- * heights inside the very same templates (a 1px divider, an 8px scrollbar),
- * and any rule a user wrote themselves.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-const migration = require('../../migrations/core/175_fix_css_template_photo_height');
-
-const ELEGANT_DARK = `
-.photo-card {
-  border-radius: 12px;
-}
-
-.photo-card img {
-  width: 100%;
-  height: 200px;
-  object-fit: cover;
-  transition: transform 0.3s ease;
-}
-`;
-
-const LIQUID_GLASS_DARK = `
-.gallery-page::after {
-  content: '';
-  height: 1px;
-  background: linear-gradient(90deg, transparent, #fff, transparent);
-}
-
-.photo-card img {
-  width: 100%;
-  height: 240px;
-  object-fit: cover;
-  filter: brightness(0.9);
-}
-
-.gallery-page ::-webkit-scrollbar {
-  width: 8px;
-  height: 8px;
-}
-
-@media (max-width: 640px) {
-  .photo-card img {
-    height: 180px;
-  }
-}
-`;
-
-describe('migration 175 — CSS template image height (#1131)', () => {
-  let knex; let tmpDir;
-
-  beforeAll(async () => {
-    tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'picpeak-mig175-'));
-    knex = require('knex')({
-      client: 'sqlite3',
-      connection: { filename: path.join(tmpDir, 'db.sqlite') },
-      useNullAsDefault: true,
-    });
-    await knex.schema.createTable('css_templates', (t) => {
-      t.increments('id').primary();
-      t.string('name');
-      t.text('css_content');
-    });
-  });
-
-  afterAll(async () => {
-    if (knex) await knex.destroy();
-    await fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-  });
-
-  beforeEach(async () => { await knex('css_templates').del(); });
-
-  const contentOf = async (name) =>
-    (await knex('css_templates').where({ name }).first()).css_content;
-
-  it('relaxes the default template so the layouts h-full can win', async () => {
-    await knex('css_templates').insert({ name: 'Elegant Dark', css_content: ELEGANT_DARK });
-
-    await migration.up(knex);
-
-    const css = await contentOf('Elegant Dark');
-    expect(css).toContain('height: 100%');
-    expect(css).not.toContain('height: 200px');
-    // Everything else about the rule survives.
-    expect(css).toContain('object-fit: cover');
-    expect(css).toContain('transition: transform 0.3s ease');
-  });
-
-  it('fixes both the base rule and the mobile override of the dark glass template', async () => {
-    await knex('css_templates').insert({ name: 'Liquid Glass Dark', css_content: LIQUID_GLASS_DARK });
-
-    await migration.up(knex);
-
-    const css = await contentOf('Liquid Glass Dark');
-    expect(css).not.toContain('height: 240px');
-    expect(css).not.toContain('height: 180px');
-    expect(css.match(/height: 100%/g)).toHaveLength(2);
-  });
-
-  it('leaves the divider and the scrollbar alone', async () => {
-    await knex('css_templates').insert({ name: 'Liquid Glass Dark', css_content: LIQUID_GLASS_DARK });
-
-    await migration.up(knex);
-
-    // The whole reason this matches full rule bodies rather than every
-    // `height: <n>px`: these are in the same stylesheet and are correct.
-    const css = await contentOf('Liquid Glass Dark');
-    expect(css).toContain('height: 1px');
-    expect(css).toContain('width: 8px');
-    expect(css).toContain('height: 8px');
-  });
-
-  /**
-   * The case that forced the scope wider. `sanitizeCSS` strips control
-   * characters, so any template ever saved through the editor — including a
-   * save that only changed its name — has had every newline REMOVED. An
-   * exact-text migration finds nothing on those installs, is recorded as
-   * applied, and leaves them broken permanently.
-   */
-  it('fixes a template that has been through the editor, newlines and all', async () => {
-    const { sanitizeCSS } = require('../../src/utils/cssSanitizer');
-    const { sanitized } = sanitizeCSS(ELEGANT_DARK);
-    // Precondition: the sanitizer really did flatten it.
-    expect(sanitized).not.toContain('\n');
-    expect(sanitized).toContain('height: 200px');
-    await knex('css_templates').insert({ name: 'Saved Once', css_content: sanitized });
-
-    await migration.up(knex);
-
-    const css = await contentOf('Saved Once');
-    expect(css).not.toContain('200px');
-    expect(css).toContain('height: 100%');
-  });
-
-  it('relaxes a user-authored fixed height too, but only on .photo-card img', async () => {
-    // Deliberately broader than the seeded text — see the migration header. A
-    // pixel height on the image cannot be right under any of the seven
-    // layouts, whoever wrote it; a height anywhere else is none of our
-    // business.
-    const mine = '.photo-card img {\n  height: 220px;\n}\n.hero { height: 400px; }';
-    await knex('css_templates').insert({ name: 'My Own', css_content: mine });
-
-    await migration.up(knex);
-
-    const css = await contentOf('My Own');
-    expect(css).toContain('height: 100%');
-    expect(css).not.toContain('220px');
-    expect(css).toContain('.hero { height: 400px; }');
-  });
-
-  it('does not rewrite other properties that merely end in -height', async () => {
-    // `line-height: 200px` contains `height: 200px` as a substring, so an
-    // unanchored pattern silently rewrites it — in a migration that cannot be
-    // undone.
-    const mine = [
-      '.photo-card img {',
-      '  line-height: 200px;',
-      '  max-height: 300px;',
-      '  min-height: 14px;',
-      '  --tile-height: 220px;',
-      '  height: 200px;',
-      '}',
-    ].join('\n');
-    await knex('css_templates').insert({ name: 'Adjacent Props', css_content: mine });
-
-    await migration.up(knex);
-
-    const css = await contentOf('Adjacent Props');
-    expect(css).toContain('line-height: 200px');
-    expect(css).toContain('max-height: 300px');
-    expect(css).toContain('min-height: 14px');
-    expect(css).toContain('--tile-height: 220px');
-    // Only the real one moved.
-    expect(css).toContain('height: 100%');
-    expect(css).not.toMatch(/(?<![\w-])height:\s*200px/);
-  });
-
-  it('handles a grouped selector list', async () => {
-    // Requiring `{` straight after `img` skipped these entirely — and the
-    // migration is still recorded as applied, so the template kept the bug.
-    const mine = '.photo-card img, .thumbnail img {\n  height: 200px;\n}';
-    await knex('css_templates').insert({ name: 'Grouped', css_content: mine });
-
-    await migration.up(knex);
-
-    const css = await contentOf('Grouped');
-    expect(css).toContain('.photo-card img, .thumbnail img {');
-    expect(css).toContain('height: 100%');
-    expect(css).not.toContain('200px');
-  });
-
-  it('skips a nested rule rather than rewriting the wrong declaration', async () => {
-    // Valid nested CSS that passes the validator. A brace-greedy body would
-    // capture the inner block and rewrite the CAPTION's height, which cannot
-    // be undone. Leaving it untouched is the lesser evil.
-    const mine = '.photo-card img {\n  & + .caption { height: 200px; }\n}';
-    await knex('css_templates').insert({ name: 'Nested', css_content: mine });
-
-    await migration.up(knex);
-
-    expect(await contentOf('Nested')).toBe(mine);
-  });
-
-  it('leaves non-pixel heights on the image alone', async () => {
-    const mine = '.photo-card img { height: 50vh; }\n.photo-card img { height: auto; }';
-    await knex('css_templates').insert({ name: 'Relative', css_content: mine });
-
-    await migration.up(knex);
-
-    expect(await contentOf('Relative')).toBe(mine);
-  });
-
-  it('is idempotent and safe on a row with no CSS', async () => {
-    await knex('css_templates').insert([
-      { name: 'Elegant Dark', css_content: ELEGANT_DARK },
-      { name: 'Empty', css_content: null },
-    ]);
-
-    await migration.up(knex);
-    const once = await contentOf('Elegant Dark');
-    await migration.up(knex);
-
-    expect(await contentOf('Elegant Dark')).toBe(once);
-    expect(await contentOf('Empty')).toBeNull();
-  });
-
-  it('no-ops when the table does not exist yet', async () => {
-    await knex.schema.dropTable('css_templates');
-    await expect(migration.up(knex)).resolves.toBeUndefined();
-    await knex.schema.createTable('css_templates', (t) => {
-      t.increments('id').primary();
-      t.string('name');
-      t.text('css_content');
-    });
-  });
-});
@@ -0,0 +1,122 @@
+/**
+ * HTTP tests for the gallery QR endpoints (#836):
+ *   GET /api/admin/events/:id/qr        (PNG / SVG)
+ *   GET /api/admin/events/:id/qr-print  (table-card / poster PDF)
+ * Same real-SQLite harness as adminEvents.smoke.test.js.
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+process.env.NODE_ENV = 'test';
+process.env.TEST_DATABASE_PATH = path.join(
+  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-events-qr-')), 'db.sqlite'
+);
+process.env.JWT_SECRET = process.env.JWT_SECRET || 'admin-events-qr-test-secret';
+
+const express = require('express');
+const cookieParser = require('cookie-parser');
+const request = require('supertest');
+const { bootCrmDb, seedMinimal, assignAdminRole, mintAdminToken } = require('../integration/helpers/crmDb');
+
+async function insertEvent(db, adminId, over = {}) {
+  const base = {
+    slug: `ev-${Math.random().toString(16).slice(2)}`,
+    event_type: 'wedding',
+    event_name: 'QR Test Wedding',
+    event_date: '2026-05-29',
+    host_email: 'host@example.com',
+    admin_email: 'admin@example.com',
+    password_hash: 'x',
+    share_link: `/gallery/share-${Math.random().toString(16).slice(2)}`,
+    share_token: `st-${Math.random().toString(16).slice(2)}`,
+    expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
+    is_active: 1, is_archived: 0, is_draft: 0,
+    created_by: adminId,
+    created_at: new Date().toISOString(),
+    ...over,
+  };
+  const r = await db('events').insert(base).returning('id');
+  return r[0]?.id ?? r[0];
+}
+
+describe('admin event QR endpoints', () => {
+  let db; let cleanup; let app; let adminId; let token;
+
+  beforeAll(async () => {
+    ({ db, cleanup } = await bootCrmDb());
+    ({ adminId } = await seedMinimal(db));
+    await assignAdminRole(db, adminId, 'super_admin');
+    token = mintAdminToken(adminId);
+
+    app = express();
+    app.use(express.json());
+    app.use(cookieParser());
+    app.use('/api/admin/events', require('../../src/routes/adminEvents'));
+    // eslint-disable-next-line no-unused-vars
+    app.use((err, req, res, next) => {
+      res.status(err.statusCode || err.status || 500).json({ error: err.message, code: err.code });
+    });
+  }, 120000);
+
+  afterAll(async () => { await cleanup(); });
+
+  beforeEach(async () => { await db('events').del(); });
+
+  const auth = (req) => req.set('Authorization', `Bearer ${token}`);
+
+  it('401s without an admin token', async () => {
+    const eventId = await insertEvent(db, adminId);
+    const res = await request(app).get(`/api/admin/events/${eventId}/qr`);
+    expect(res.status).toBe(401);
+  });
+
+  it('returns a PNG QR by default', async () => {
+    const eventId = await insertEvent(db, adminId);
+    const res = await auth(request(app).get(`/api/admin/events/${eventId}/qr`)).buffer();
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('image/png');
+    // PNG magic bytes
+    expect(res.body.slice(0, 4)).toEqual(Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+  });
+
+  it('returns an SVG QR when requested', async () => {
+    const eventId = await insertEvent(db, adminId);
+    // supertest doesn't text-parse image/svg+xml — buffer and decode manually.
+    const res = await auth(request(app).get(`/api/admin/events/${eventId}/qr?format=svg`)).buffer();
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toMatch(/image\/svg\+xml/);
+    expect(Buffer.from(res.body).toString('utf8')).toContain('<svg');
+  });
+
+  it('sets attachment disposition with download=1', async () => {
+    const eventId = await insertEvent(db, adminId);
+    const res = await auth(request(app).get(`/api/admin/events/${eventId}/qr?download=1`)).buffer();
+    expect(res.headers['content-disposition']).toMatch(/^attachment/);
+  });
+
+  // 30s: the print PDFs embed the full IBM Plex Sans TTFs (~200 KB each) —
+  // font parsing + subsetting exceeds jest's 5s default on slower CI runners.
+  it.each(['table-card', 'poster'])('renders the %s print PDF', async (template) => {
+    const eventId = await insertEvent(db, adminId);
+    const res = await auth(
+      request(app).get(`/api/admin/events/${eventId}/qr-print?template=${template}&lang=de`)
+    ).buffer();
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('application/pdf');
+    expect(res.body.slice(0, 4).toString()).toBe('%PDF');
+  }, 120000);
+
+  it('409s when the event has no share link', async () => {
+    // events.share_link is NOT NULL — an empty string is the closest real-world
+    // "no share link" shape (no token extractable from it either).
+    const eventId = await insertEvent(db, adminId, { share_link: '', share_token: null });
+    const res = await auth(request(app).get(`/api/admin/events/${eventId}/qr`));
+    expect(res.status).toBe(409);
+  });
+
+  it('404s for a non-existent event', async () => {
+    const res = await auth(request(app).get('/api/admin/events/999999/qr'));
+    expect(res.status).toBe(404);
+  });
+});
@@ -147,30 +147,6 @@ describe('admin photo view Content-Type (#908)', () => {
    expect(res2.headers['content-type']).toBe('video/webm');
  });

-  it('preserves an auto-imported avif via the safe stored-MIME allowlist', async () => {
-    // .avif isn't in EXTENSION_TO_MIME; s3AutoImporter stores image/avif.
-    // Map-only would mislabel it image/jpeg — the allowlist keeps it.
-    const id = await addPhoto('imported.avif', { mime_type: 'image/avif' });
-    const res = await getPhotoRes(id);
-    expect(res.status).toBe(200);
-    expect(res.headers['content-type']).toBe('image/avif');
-  });
-
-  it('preserves other importer raster types too (apng, x-icon)', async () => {
-    const apng = await addPhoto('anim.apng', { mime_type: 'image/apng' });
-    expect((await getPhotoRes(apng)).headers['content-type']).toBe('image/apng');
-    const ico = await addPhoto('fav.ico', { mime_type: 'image/x-icon' });
-    expect((await getPhotoRes(ico)).headers['content-type']).toBe('image/x-icon');
-  });
-
-  it('does NOT honor a stored scriptable image type (image/svg+xml)', async () => {
-    // svg is inline-scriptable and must never be echoed — allowlist excludes it.
-    const id = await addPhoto('vector.svg', { mime_type: 'image/svg+xml' });
-    const res = await getPhotoRes(id);
-    expect(res.status).toBe(200);
-    expect(res.headers['content-type']).toBe('image/jpeg');
-  });
-
  it('never echoes a stored non-media MIME type (inline XSS guard)', async () => {
    const id = await addPhoto('evil.png', { mime_type: 'text/html' });
    const res = await getPhotoRes(id);
@@ -199,21 +175,6 @@ describe('admin photo view Content-Type (#908)', () => {
    expect(res.headers['content-type']).toBe('image/png');
  });

-  it('handles Object.prototype key extensions without a 500 (.constructor)', async () => {
-    // The extension-to-MIME lookup must be own-property only — a raw
-    // index access returns an inherited function for these keys and the
-    // downstream startsWith throws. Serve image/jpeg instead of 500.
-    const id = await addPhoto('payload.constructor');
-    const res = await getPhotoRes(id);
-    expect(res.status).toBe(200);
-    expect(res.headers['content-type']).toBe('image/jpeg');
-
-    const id2 = await addPhoto('payload.__proto__', { media_type: 'video' });
-    const res2 = await getPhotoRes(id2);
-    expect(res2.status).toBe(200);
-    expect(res2.headers['content-type']).toBe('video/mp4');
-  });
-
  it('does not synthesize types from unmapped image extensions', async () => {
    // Raw interpolation would produce image/svg+xml (scriptable inline)
    // or arbitrary strings from client-controlled filenames — the shared
@@ -1,42 +0,0 @@
-/**
- * Source-inspection contract test for #1078.
- *
- * POST /api/admin/thumbnails/regenerate-previews hands its selected rows to
- * ensurePreviewImage, which branches on `source_origin` (and then reads
- * `external_relpath` / `filename`) to reach an external/reference photo on its
- * media mount. When the select list omitted those columns, every external row
- * looked managed, resolvePhotoStorageKey returned null, and the endpoint
- * reported success while silently generating nothing for reference galleries.
- */
-const fs = require('fs');
-const path = require('path');
-
-describe('regenerate-previews selects the columns ensurePreviewImage branches on (#1078)', () => {
-  const src = fs.readFileSync(
-    path.join(__dirname, '..', '..', 'src', 'routes', 'adminThumbnails.js'),
-    'utf8',
-  );
-
-  // The select feeding the regenerate-previews handler, from the route
-  // declaration to the end of that statement.
-  const selectStatement = (() => {
-    const routeIdx = src.indexOf('/regenerate-previews');
-    expect(routeIdx).toBeGreaterThan(-1);
-    const selectIdx = src.indexOf('.select(', routeIdx);
-    expect(selectIdx).toBeGreaterThan(-1);
-    return src.slice(selectIdx, src.indexOf(';', selectIdx));
-  })();
-
-  it.each(['source_origin', 'external_relpath', 'filename'])(
-    'selects %s',
-    (column) => {
-      expect(selectStatement).toContain(`'${column}'`);
-    }
-  );
-
-  it('still selects the columns the managed path needs', () => {
-    for (const column of ['id', 'event_id', 'path', 'media_type', 'mime_type', 'preview_path']) {
-      expect(selectStatement).toContain(`'${column}'`);
-    }
-  });
-});
@@ -32,9 +32,17 @@ jest.mock('../../src/database/db', () => {
    if (table === 'admin_users') {
      let rowFilter = () => true;
      return {
+        // The session route joins roles for the adminUser payload (#798);
+        // fake rows carry no role fields, so the join is a pass-through.
+        leftJoin() {
+          return this;
+        },
        where(criteria) {
          rowFilter = (row) => {
-            return Object.entries(criteria).every(([k, v]) => {
+            return Object.entries(criteria).every(([rawKey, v]) => {
+              // Joined queries prefix columns ('admin_users.id') — the fake
+              // rows use bare names.
+              const k = rawKey.replace(/^admin_users\./, '');
              if (k === 'is_active') return Boolean(row.is_active) === Boolean(v);
              return row[k] === v;
            });
@@ -50,7 +58,12 @@ jest.mock('../../src/database/db', () => {
          if (!row) return undefined;
          if (!this._cols) return row;
          const out = {};
-          for (const c of this._cols) out[c] = row[c];
+          for (const c of this._cols) {
+            // Support 'table.col' and 'table.col as alias' shapes.
+            const [source, alias] = c.split(/\s+as\s+/i);
+            const bare = source.includes('.') ? source.split('.').pop() : source;
+            out[alias || bare] = row[bare];
+          }
          return out;
        },
      };
@@ -135,9 +148,9 @@ function signAdminToken({ id = 1, username = 'admin', iat, exp }) {
  );
 }

-function signGalleryToken({ eventId = 100, eventSlug = 'wedding', ...extra } = {}) {
+function signGalleryToken({ eventId = 100, eventSlug = 'wedding' } = {}) {
  return jwt.sign(
-    { eventId, eventSlug, type: 'gallery', ...extra },
+    { eventId, eventSlug, type: 'gallery' },
    process.env.JWT_SECRET,
    { expiresIn: '1h', issuer: 'picpeak-auth' }
  );
@@ -288,56 +301,6 @@ describe('GET /auth/session — symmetry with protected middleware', () => {
    expect(res.body.valid).toBe(true);
  });

-  /**
-   * What KIND of gallery session this is (#1149).
-   *
-   * The frontend used to keep this in sessionStorage, which is per-TAB while
-   * the cookie is per-browser: a gallery reopened in a second tab lost
-   * 'client' even though the backend still served it as one, and the UI hid
-   * the only control that clears the privileged cookie. Reported from the
-   * token so a restored session knows what it actually is.
-   */
-  describe('gallery session kind', () => {
-    beforeEach(() => {
-      fakeDb.events.push({
-        id: 100,
-        slug: 'wedding',
-        is_active: true,
-        is_archived: false,
-        expires_at: new Date(Date.now() + 86400_000),
-      });
-    });
-
-    it('reports a PIN-client session as client', async () => {
-      const res = await request(makeApp())
-        .get('/auth/session?slug=wedding')
-        .set('Authorization', `Bearer ${signGalleryToken({ accessLevel: 'client' })}`);
-      expect(res.body.valid).toBe(true);
-      expect(res.body.accessLevel).toBe('client');
-      expect(res.body.viaCustomer).toBe(false);
-    });
-
-    it('reports a customer-portal session, which looks like a guest', async () => {
-      const res = await request(makeApp())
-        .get('/auth/session?slug=wedding')
-        .set('Authorization', `Bearer ${signGalleryToken({ via: 'customer', customerId: 7 })}`);
-      expect(res.body.valid).toBe(true);
-      expect(res.body.accessLevel).toBe('guest');
-      expect(res.body.viaCustomer).toBe(true);
-    });
-
-    it('reports a plain guest as neither', async () => {
-      // The flags have to discriminate, or they would just hand every visitor
-      // a Logout button back.
-      const res = await request(makeApp())
-        .get('/auth/session?slug=wedding')
-        .set('Authorization', `Bearer ${signGalleryToken()}`);
-      expect(res.body.valid).toBe(true);
-      expect(res.body.accessLevel).toBe('guest');
-      expect(res.body.viaCustomer).toBe(false);
-    });
-  });
-
  it('returns valid:false when the token is revoked', async () => {
    fakeDb.adminUsers.push({
      id: 1,
@@ -1,211 +0,0 @@
-/**
- * Authorization / ownership gaps (GHSA permission cluster):
- *  - jm7j: API-token list must scope to the caller (non-super sees only own)
- *  - gprq: API-token revoke must be owner-or-super_admin
- *  - 3rqx: event update must not mass-assign identity/secret columns
- *  - j2f4: category hero must belong to that category
- */
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-authz-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'authz-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-authz-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const bcrypt = require('bcrypt');
-const {
-  bootCrmDb, seedMinimal, assignAdminRole, mintAdminToken,
-} = require('../integration/helpers/crmDb');
-
-describe('authorization / ownership gaps', () => {
-  let db; let cleanup; let app;
-  let superId; let superTok; let adminId; let adminTok;
-
-  const grantPermissionToRole = async (roleName, permName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const perm = await db('permissions').where({ name: permName }).first();
-    const exists = await db('role_permissions')
-      .where({ role_id: role.id, permission_id: perm.id }).first();
-    if (!exists) {
-      await db('role_permissions').insert({ role_id: role.id, permission_id: perm.id });
-    }
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    ({ adminId: superId } = await seedMinimal(db));
-    await assignAdminRole(db, superId, 'super_admin');
-    superTok = mintAdminToken(superId);
-
-    const pass = await bcrypt.hash('x', 4);
-    const ins = await db('admin_users').insert({
-      username: 'plain-admin', email: 'plain@example.com',
-      password_hash: pass, must_change_password: false, created_at: new Date(),
-    }).returning('id');
-    adminId = ins[0]?.id ?? ins[0];
-    await assignAdminRole(db, adminId, 'admin');
-    // Grant settings.edit to the admin role BEFORE any request populates the
-    // 60s permission cache, so the revoke test exercises the ownership check
-    // (404) rather than the missing-permission gate (403). This models a
-    // custom role that carries settings.edit — the scenario GHSA-gprq needs.
-    await grantPermissionToRole('admin', 'settings.edit');
-    adminTok = mintAdminToken(adminId);
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/admin/api-tokens', require('../../src/routes/adminApiTokens'));
-    app.use('/api/admin/events', require('../../src/routes/adminEvents'));
-    app.use('/api/admin/categories', require('../../src/routes/adminCategories'));
-    // eslint-disable-next-line no-unused-vars
-    app.use((err, req, res, next) => {
-      res.status(err.statusCode || err.status || 500).json({ error: err.message, code: err.code });
-    });
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  const auth = (req, tok) => req.set('Authorization', `Bearer ${tok}`);
-
-  describe('API tokens (jm7j / gprq)', () => {
-    let superTokenId;
-
-    beforeAll(async () => {
-      const res = await auth(request(app).post('/api/admin/api-tokens'), superTok)
-        .send({ name: 'super-token', scopes: ['read'] });
-      expect(res.status).toBe(201);
-      superTokenId = res.body.id;
-    });
-
-    it('non-super admin does not see another admin\'s tokens in the list', async () => {
-      const res = await auth(request(app).get('/api/admin/api-tokens'), adminTok);
-      expect(res.status).toBe(200);
-      expect(res.body.find((t) => t.id === superTokenId)).toBeUndefined();
-    });
-
-    it('super_admin sees all tokens', async () => {
-      const res = await auth(request(app).get('/api/admin/api-tokens'), superTok);
-      expect(res.status).toBe(200);
-      expect(res.body.find((t) => t.id === superTokenId)).toBeDefined();
-    });
-
-    it('a non-owner (with settings.edit) cannot revoke another admin\'s token', async () => {
-      const res = await auth(request(app).delete(`/api/admin/api-tokens/${superTokenId}`), adminTok);
-      expect(res.status).toBe(404);
-      const row = await db('api_tokens').where({ id: superTokenId }).first();
-      expect(row.revoked_at).toBeFalsy();
-    });
-
-    it('the owner can revoke their own token', async () => {
-      const res = await auth(request(app).delete(`/api/admin/api-tokens/${superTokenId}`), superTok);
-      expect(res.status).toBe(200);
-    });
-  });
-
-  describe('event update mass-assignment (3rqx)', () => {
-    it('ignores identity/secret columns in the request body', async () => {
-      const seedShareToken = 'orig-share-token';
-      const ins = await db('events').insert({
-        slug: 'authz-mass-assign', event_type: 'wedding', event_name: 'Before',
-        event_date: '2026-08-01', host_email: 'h@example.com', admin_email: 'a@example.com',
-        password_hash: 'orig-hash', share_link: '/gallery/authz/share', share_token: seedShareToken, expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-        is_active: 1, is_archived: 0, is_draft: 0, created_by: superId,
-        created_at: new Date().toISOString(),
-      }).returning('id');
-      const eventId = ins[0]?.id ?? ins[0];
-
-      const res = await auth(request(app).put(`/api/admin/events/${eventId}`), superTok).send({
-        event_name: 'After',
-        created_by: 99999,
-        slug: 'hijacked-slug',
-        share_token: 'hijacked-token',
-        password_hash: 'hijacked-hash',
-        is_archived: 1,
-        archive_path: '/hijacked/archive/path',
-        hero_logo_path: '/etc/passwd',
-        is_draft: 1,
-        project_id: 99999,
-        // Case-variant keys — SQLite matches columns case-insensitively.
-        Password_Hash: 'case-hijack-hash',
-        Created_By: 88888,
-      });
-      expect(res.status).toBe(200);
-
-      const row = await db('events').where({ id: eventId }).first();
-      expect(row.event_name).toBe('After');        // legit field applied
-      expect(row.created_by).toBe(superId);         // ownership untouched (+ case-variant)
-      expect(row.slug).toBe('authz-mass-assign');   // routing identity untouched
-      expect(row.share_token).toBe(seedShareToken); // secret untouched
-      expect(row.password_hash).toBe('orig-hash');  // secret untouched (+ case-variant)
-      expect(row.is_archived).toBeFalsy();          // archive lifecycle untouched
-      expect(row.archive_path).toBeFalsy();         // forged archive path rejected
-      expect(row.hero_logo_path).toBeFalsy();       // fs.unlink primitive blocked
-      expect(row.is_draft).toBeFalsy();             // publish workflow not bypassed
-      expect(row.project_id).toBeFalsy();           // server-managed relationship untouched
-    });
-
-    it('returns 200 (no-op) when the body contains only protected fields', async () => {
-      const ins = await db('events').insert({
-        slug: 'authz-empty-update', event_type: 'wedding', event_name: 'Keep',
-        event_date: '2026-08-01', host_email: 'h@example.com', admin_email: 'a@example.com',
-        password_hash: 'x', share_link: '/gallery/authz-empty/share', share_token: 'authz-empty-share',
-        expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-        is_active: 1, is_archived: 0, is_draft: 0, created_by: superId,
-        created_at: new Date().toISOString(),
-      }).returning('id');
-      const id = ins[0]?.id ?? ins[0];
-      // Body reduces to {} after the denylist — must not 500 (Knex rejects
-      // .update({})).
-      const res = await auth(request(app).put(`/api/admin/events/${id}`), superTok)
-        .send({ created_by: 1, slug: 'x', is_archived: 1 });
-      expect(res.status).toBe(200);
-      const row = await db('events').where({ id }).first();
-      expect(row.event_name).toBe('Keep');
-    });
-  });
-
-  describe('category hero cross-category (j2f4)', () => {
-    it('rejects a hero photo that is not in the category', async () => {
-      const evIns = await db('events').insert({
-        slug: 'authz-cat', event_type: 'wedding', event_name: 'Cat Event',
-        event_date: '2026-08-01', host_email: 'h@example.com', admin_email: 'a@example.com',
-        password_hash: 'x', share_link: '/gallery/authz-cat/share', share_token: 'authz-cat-share', expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-        is_active: 1, is_archived: 0, is_draft: 0, created_by: superId,
-        created_at: new Date().toISOString(),
-      }).returning('id');
-      const evId = evIns[0]?.id ?? evIns[0];
-
-      const mkCat = async (name) => {
-        const c = await db('photo_categories').insert({
-          event_id: evId, name, slug: name.toLowerCase(), created_at: new Date().toISOString(),
-        }).returning('id');
-        return c[0]?.id ?? c[0];
-      };
-      const cat1 = await mkCat('Cat1');
-      const cat2 = await mkCat('Cat2');
-
-      const pIns = await db('photos').insert({
-        event_id: evId, filename: 'p.jpg', path: 'authz-cat/p.jpg', type: 'individual',
-        category_id: cat1, uploaded_at: new Date().toISOString(),
-      }).returning('id');
-      const photoInCat1 = pIns[0]?.id ?? pIns[0];
-
-      // Pointing cat2's hero at a photo that lives in cat1 must be refused.
-      const bad = await auth(request(app).put(`/api/admin/categories/${cat2}/hero`), superTok)
-        .send({ hero_photo_id: photoInCat1 });
-      expect(bad.status).toBe(404);
-
-      // The photo's own category accepts it.
-      const ok = await auth(request(app).put(`/api/admin/categories/${cat1}/hero`), superTok)
-        .send({ hero_photo_id: photoInCat1 });
-      expect(ok.status).toBe(200);
-    });
-  });
-});
@@ -1,95 +0,0 @@
-/**
- * Full-instance export is super_admin only (GHSA-pv6w-rj34-wj9v).
- *
- * GET /api/admin/backup/picpeak/export dumps every table unredacted (bcrypt
- * hashes, 2FA, SMTP/SSO/WhatsApp/webhook/S3 secrets). It was gated only by
- * requirePermission('backup.create'), which the built-in `admin` role holds —
- * so any non-super_admin admin could download the whole database. Pins that
- * `admin` now gets 403 and `super_admin` passes the gate.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-bkexport-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'bkexport-test-secret';
-
-// The export otherwise walks the whole DB and writes a zip — stub it so the
-// super_admin happy path is fast and deterministic; the gate is what's tested.
-// The route deletes path.dirname(filePath) recursively after download, so the
-// stub MUST live in its own dir — a bare os.tmpdir() file would make the route
-// wipe the whole temp root (and other jest workers' DB files).
-const mockExportDir = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-export-stub-'));
-const mockExportPath = path.join(mockExportDir, 'export.picpeak');
-fs.writeFileSync(mockExportPath, 'stub');
-jest.mock('../../src/services/picpeakExportService', () => ({
-  createPicpeak: jest.fn(async () => ({ filePath: mockExportPath })),
-}));
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('backup export super_admin gate (GHSA-pv6w)', () => {
-  let db;
-  let cleanup;
-  let app;
-  let adminToken; let superToken;
-
-  const mkUser = async (username, roleName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const r = await db('admin_users').insert({
-      username,
-      email: `${username}@example.com`,
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id,
-      is_active: 1,
-      created_at: new Date(),
-      updated_at: new Date(),
-    }).returning('id');
-    const id = r[0]?.id ?? r[0];
-    return jwt.sign(
-      { id, username, type: 'admin', role: roleName, loginTime: Date.now() },
-      process.env.JWT_SECRET,
-      { expiresIn: '1h', issuer: 'picpeak-auth' },
-    );
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-    adminToken = await mkUser('limited-admin', 'admin');
-    superToken = await mkUser('root-admin', 'super_admin');
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/admin/backup', require('../../src/routes/adminBackup'));
-  }, 120000);
-
-  afterAll(async () => {
-    if (cleanup) await cleanup();
-    fs.rmSync(mockExportDir, { recursive: true, force: true });
-  });
-
-  it('denies the built-in admin role (was: full DB dump)', async () => {
-    const res = await request(app)
-      .get('/api/admin/backup/picpeak/export')
-      .set('Authorization', `Bearer ${adminToken}`);
-    expect(res.status).toBe(403);
-  });
-
-  it('allows super_admin', async () => {
-    const res = await request(app)
-      .get('/api/admin/backup/picpeak/export')
-      .set('Authorization', `Bearer ${superToken}`);
-    expect(res.status).not.toBe(403);
-    expect(res.status).toBeLessThan(500);
-  });
-});
@@ -1,196 +0,0 @@
-/**
- * Dashboard endpoints must not leak other admins' data to event-scoped
- * editors — GHSA-c2jj (/stats), GHSA-gqx7 (/analytics), GHSA-jhcf (/activity).
- *
- * All three are gated only by `analytics.view`, which the `editor` role holds.
- * But the events LIST restricts editors to their own rows
- * (adminEvents/crud.js: roleName === 'editor' → created_by = admin.id), so an
- * editor saw instance-wide totals — and, via /analytics topGalleries, other
- * admins' gallery names and SLUGS (the public gallery URL component) — for
- * events invisible to them everywhere else.
- *
- * Scoping deliberately keys on `editor` to mirror the events list exactly, so
- * the `admin` role's dashboard is unchanged.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-dashscope-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'dashscope-test-secret';
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('dashboard scoping (GHSA-c2jj / gqx7 / jhcf)', () => {
-  let db; let cleanup; let app;
-  let editorToken; let superToken;
-  let ownEventId; let foreignEventId;
-
-  const mkAdmin = async (username, roleName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const r = await db('admin_users').insert({
-      username,
-      email: `${username}@example.com`,
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id,
-      is_active: 1,
-      created_at: new Date(),
-      updated_at: new Date(),
-    }).returning('id');
-    const id = r[0]?.id ?? r[0];
-    const token = jwt.sign(
-      { id, username, type: 'admin', role: roleName, loginTime: Date.now() },
-      process.env.JWT_SECRET,
-      { expiresIn: '1h', issuer: 'picpeak-auth' },
-    );
-    return { id, token };
-  };
-
-  const mkEvent = async (slug, createdBy) => {
-    const r = await db('events').insert({
-      slug,
-      event_type: 'wedding',
-      event_name: `${slug}-name`,
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_token: `tok-${slug}`,
-      share_link: `/gallery/${slug}/tok-${slug}`,
-      created_by: createdBy,
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const editor = await mkAdmin('scoped-editor', 'editor');
-    const sup = await mkAdmin('root-admin', 'super_admin');
-    editorToken = editor.token;
-    superToken = sup.token;
-
-    ownEventId = await mkEvent('own-gallery', editor.id);
-    foreignEventId = await mkEvent('foreign-gallery', sup.id);
-
-    // One photo + one view per event so the aggregates are non-zero.
-    for (const [eventId, name] of [[ownEventId, 'own'], [foreignEventId, 'foreign']]) {
-      await db('photos').insert({
-        event_id: eventId,
-        filename: `${name}.jpg`,
-        path: `events/active/${name}.jpg`,
-        type: 'individual',
-        size_bytes: 1000,
-        uploaded_at: new Date().toISOString(),
-      });
-      await db('access_logs').insert({
-        event_id: eventId,
-        action: 'view',
-        ip_address: `10.0.0.${eventId}`,
-        user_agent: 'Mozilla/5.0',
-        timestamp: new Date().toISOString(),
-      });
-      await db('activity_logs').insert({
-        activity_type: 'photo_viewed',
-        actor_type: 'admin',
-        actor_name: `${name}-actor`,
-        event_id: eventId,
-        created_at: new Date().toISOString(),
-      });
-    }
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/admin/dashboard', require('../../src/routes/adminDashboard'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('/stats counts only the editor\'s own events and photos', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/stats')
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect(res.status).toBe(200);
-    expect(Number(res.body.totalEvents)).toBe(1);
-    expect(Number(res.body.totalPhotos)).toBe(1);
-    expect(Number(res.body.storageUsed)).toBe(1000);
-  });
-
-  it('/analytics does not expose a foreign gallery name or slug', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/analytics?days=7')
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect(res.status).toBe(200);
-    const body = JSON.stringify(res.body);
-    expect(body).not.toContain('foreign-gallery');
-    expect(body).not.toContain('foreign-gallery-name');
-    expect(res.body.topGalleries.map((g) => g.slug)).toEqual(['own-gallery']);
-  });
-
-  it('/activity does not surface a foreign event\'s entries', async () => {
-    const res = await request(app)
-      .get('/api/admin/dashboard/activity')
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect(res.status).toBe(200);
-    const actors = res.body.map((a) => a.actorName);
-    expect(actors).toContain('own-actor');
-    expect(actors).not.toContain('foreign-actor');
-  });
-
-  it('leaves super_admin unscoped across all three', async () => {
-    const stats = await request(app)
-      .get('/api/admin/dashboard/stats')
-      .set('Authorization', `Bearer ${superToken}`);
-    expect(Number(stats.body.totalEvents)).toBe(2);
-
-    const analytics = await request(app)
-      .get('/api/admin/dashboard/analytics?days=7')
-      .set('Authorization', `Bearer ${superToken}`);
-    expect(analytics.body.topGalleries.map((g) => g.slug).sort())
-      .toEqual(['foreign-gallery', 'own-gallery']);
-
-    const activity = await request(app)
-      .get('/api/admin/dashboard/activity')
-      .set('Authorization', `Bearer ${superToken}`);
-    expect(activity.body.map((a) => a.actorName)).toContain('foreign-actor');
-  });
-});
-
-/**
- * Codex round 2: the /activity filter trusts `activity_logs.event_id`, but
- * expenseService was passing `adminId` into logActivity's third positional
- * parameter — which is `eventId`. Admin and event id sequences overlap, so a
- * foreign admin's expense metadata could surface under an editor's event.
- * Those writers now pass the actor instead, leaving event_id NULL.
- */
-describe('activity writers do not put admin ids in event_id (GHSA-jhcf)', () => {
-  it('expenseService passes the actor, not adminId, as the event id', () => {
-    const fs2 = require('fs');
-    const src = fs2.readFileSync(
-      require('path').join(__dirname, '../../src/services/expenseService.js'), 'utf8',
-    );
-    // No logActivity call may end with a bare `, adminId)` — that slot is eventId.
-    const offenders = src.split('\n').filter(
-      (l) => l.includes('logActivity(') && /,\s*adminId\s*\)/.test(l),
-    );
-    expect(offenders).toEqual([]);
-    // And the actor form must actually be in use.
-    expect(src).toContain("{ type: 'admin', id: adminId }");
-  });
-});
@@ -1,120 +0,0 @@
-/**
- * Manual database backup must not honour a caller-supplied destination
- * (GHSA-jw8m-43r2-jqrm).
- *
- * POST /api/admin/database-backup/backup forwarded req.body straight into
- * databaseBackupService.backup(), which merges options over its config:
- *   const { destinationPath = '/backup/database', ... } = { ...config, ...options }
- * `destinationPath` is not a persistable setting (the /config allowlist only
- * accepts `database_backup_*` keys), so the request body was its ONLY source.
- *
- * The `admin` role holds backup.create but neither settings.edit nor
- * backup.restore — so it could aim a full DB dump (bcrypt hashes, gallery
- * password hashes, encrypted SMTP creds) at the PUBLIC /uploads static mount
- * (server.js mounts it with no auth middleware) and fetch it unauthenticated.
- *
- * Pins that destinationPath from the body is ignored, while the legitimate
- * knobs still pass through.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-dbbackup-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'dbbackup-test-secret';
-
-// Capture what the route hands the service; never run a real backup.
-const mockBackup = jest.fn(async () => ({ success: true }));
-jest.mock('../../src/services/databaseBackup', () => ({
-  databaseBackupService: {
-    get isRunning() { return false; },
-    backup: (...args) => mockBackup(...args),
-  },
-}));
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('manual database backup destination (GHSA-jw8m)', () => {
-  let db; let cleanup; let app; let adminToken;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const role = await db('roles').where({ name: 'admin' }).first();
-    const r = await db('admin_users').insert({
-      username: 'limited-admin',
-      email: 'limited-admin@example.com',
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id,
-      is_active: 1,
-      created_at: new Date(),
-      updated_at: new Date(),
-    }).returning('id');
-    const id = r[0]?.id ?? r[0];
-    adminToken = jwt.sign(
-      { id, username: 'limited-admin', type: 'admin', role: 'admin', loginTime: Date.now() },
-      process.env.JWT_SECRET,
-      { expiresIn: '1h', issuer: 'picpeak-auth' },
-    );
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/admin/database-backup', require('../../src/routes/adminDatabaseBackup'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  beforeEach(() => mockBackup.mockClear());
-
-  it('ignores a caller-supplied destinationPath', async () => {
-    const res = await request(app)
-      .post('/api/admin/database-backup/backup')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .send({ destinationPath: '/app/storage/uploads' });
-
-    expect(res.status).toBe(200);
-    // Give the fire-and-forget call a tick to land.
-    await new Promise((resolve) => setImmediate(resolve));
-    expect(mockBackup).toHaveBeenCalled();
-    const opts = mockBackup.mock.calls[0][0];
-    expect(opts).not.toHaveProperty('destinationPath');
-    expect(JSON.stringify(opts)).not.toContain('uploads');
-  });
-
-  it('still forwards the legitimate backup knobs', async () => {
-    const res = await request(app)
-      .post('/api/admin/database-backup/backup')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .send({ compress: false, validateIntegrity: false, destinationPath: '/tmp/evil' });
-
-    expect(res.status).toBe(200);
-    await new Promise((resolve) => setImmediate(resolve));
-    const opts = mockBackup.mock.calls[0][0];
-    expect(opts.compress).toBe(false);
-    expect(opts.validateIntegrity).toBe(false);
-    expect(opts).not.toHaveProperty('destinationPath');
-  });
-
-  it('omits absent knobs entirely so service/config defaults still apply', async () => {
-    const res = await request(app)
-      .post('/api/admin/database-backup/backup')
-      .set('Authorization', `Bearer ${adminToken}`)
-      .send({});
-
-    expect(res.status).toBe(200);
-    await new Promise((resolve) => setImmediate(resolve));
-    // An explicit `{compress: undefined}` would override config on spread —
-    // absent keys must simply not be present.
-    expect(mockBackup.mock.calls[0][0]).toEqual({});
-  });
-});
@@ -1,101 +0,0 @@
-/**
- * GHSA-2qc2 / GHSA-32h4 / GHSA-3335 — feedback moderation, deletion, and the
- * pending-moderation list are by-feedback-id (or global) and lacked ownership
- * scoping, so a restricted editor could act on / enumerate feedback for events
- * it does not own. super_admin keeps global access.
- */
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-fbown-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'fbown-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-fbown-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const bcrypt = require('bcrypt');
-const { bootCrmDb, seedMinimal, assignAdminRole, mintAdminToken } = require('../integration/helpers/crmDb');
-
-describe('feedback ownership scoping', () => {
-  let db; let cleanup; let app;
-  let superTok; let editorTok; let editorId;
-  let foreignFeedbackId;
-
-  const auth = (req, tok) => req.set('Authorization', `Bearer ${tok}`);
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    const { adminId: superId } = await seedMinimal(db);
-    await assignAdminRole(db, superId, 'super_admin');
-    superTok = mintAdminToken(superId);
-
-    const ins = await db('admin_users').insert({
-      username: 'editor', email: 'editor@example.com',
-      password_hash: await bcrypt.hash('x', 4), must_change_password: false, created_at: new Date(),
-    }).returning('id');
-    editorId = ins[0]?.id ?? ins[0];
-    await assignAdminRole(db, editorId, 'editor');
-    editorTok = mintAdminToken(editorId);
-
-    // Event owned by super_admin (NOT the editor).
-    const ev = await db('events').insert({
-      slug: 'fbown-foreign', event_type: 'wedding', event_name: 'Foreign',
-      event_date: '2026-08-01', host_email: 'h@e.com', admin_email: 'a@e.com',
-      password_hash: 'x', share_link: '/g/fbown/s', share_token: 'fbown-share',
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0, created_by: superId,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    const eventId = ev[0]?.id ?? ev[0];
-    const ph = await db('photos').insert({
-      event_id: eventId, filename: 'p.jpg', path: 'fbown-foreign/p.jpg', type: 'individual',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    const photoId = ph[0]?.id ?? ph[0];
-    const fb = await db('photo_feedback').insert({
-      photo_id: photoId, event_id: eventId, feedback_type: 'comment',
-      comment_text: 'hi', is_approved: 0, is_hidden: 0, created_at: new Date().toISOString(),
-    }).returning('id');
-    foreignFeedbackId = fb[0]?.id ?? fb[0];
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/admin/feedback', require('../../src/routes/adminFeedback'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('editor cannot moderate feedback on an event it does not own (404)', async () => {
-    const res = await auth(request(app).put(`/api/admin/feedback/feedback/${foreignFeedbackId}/approve`), editorTok);
-    expect(res.status).toBe(404);
-    const row = await db('photo_feedback').where({ id: foreignFeedbackId }).first();
-    expect([false, 0]).toContain(row.is_approved); // untouched
-  });
-
-  it('editor cannot delete foreign feedback, row survives', async () => {
-    const res = await auth(request(app).delete(`/api/admin/feedback/feedback/${foreignFeedbackId}`), editorTok);
-    // Denied either at the events.delete permission layer (editor lacks it →
-    // 403) or the ownership layer (404) — both must leave the row intact.
-    expect([403, 404]).toContain(res.status);
-    expect(await db('photo_feedback').where({ id: foreignFeedbackId }).first()).toBeDefined();
-  });
-
-  it('editor sees no foreign feedback in pending-moderation', async () => {
-    const res = await auth(request(app).get('/api/admin/feedback/feedback/pending-moderation'), editorTok);
-    expect(res.status).toBe(200);
-    expect(res.body.find((f) => f.id === foreignFeedbackId)).toBeUndefined();
-  });
-
-  it('super_admin CAN moderate and see it', async () => {
-    const pending = await auth(request(app).get('/api/admin/feedback/feedback/pending-moderation'), superTok);
-    expect(pending.body.find((f) => f.id === foreignFeedbackId)).toBeDefined();
-    const res = await auth(request(app).put(`/api/admin/feedback/feedback/${foreignFeedbackId}/approve`), superTok);
-    expect(res.status).toBe(200);
-  });
-});
@@ -1,87 +0,0 @@
-/**
- * GHSA-rh8r-7x3h-36rv — the unauthenticated GET /api/gallery/resolve/:identifier
- * must NOT return a gallery's secret share_token (nor the share links that
- * embed it) for a bare *slug* lookup. Slugs appear in gallery URLs and are
- * guessable; handing back the secret turns a known slug into share-link
- * access to a no-password gallery. The token is only returned when the caller
- * resolved via the token / full share link (i.e. already holds it).
- */
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-resolve-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'resolve-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-resolve-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-const SLUG = 'resolve-test-event';
-const SHARE_TOKEN = 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6';
-
-describe('GET /api/gallery/resolve/:identifier (GHSA-rh8r)', () => {
-  let db; let cleanup; let app;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-    await db('events').insert({
-      slug: SLUG,
-      event_type: 'wedding',
-      event_name: 'Resolve Test',
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_link: `/gallery/${SLUG}/${SHARE_TOKEN}`,
-      share_token: SHARE_TOKEN,
-      require_password: 0, // no-password → the token IS the access credential
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    });
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/gallery', require('../../src/routes/gallery'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('does NOT leak the share_token (or share links) for a bare slug lookup', async () => {
-    const res = await request(app).get(`/api/gallery/resolve/${SLUG}`);
-    expect(res.status).toBe(200);
-    expect(res.body.slug).toBe(SLUG);
-    expect(res.body.matchType).toBe('slug');
-    // The secret must be absent — and must not sneak out via the share links.
-    expect(res.body.token).toBeUndefined();
-    expect(res.body.share_link).toBeUndefined();
-    expect(res.body.share_url).toBeUndefined();
-    expect(JSON.stringify(res.body)).not.toContain(SHARE_TOKEN);
-  });
-
-  it('DOES return the token when the caller already resolved via the token', async () => {
-    const res = await request(app).get(`/api/gallery/resolve/${SHARE_TOKEN}`);
-    expect(res.status).toBe(200);
-    expect(res.body.token).toBe(SHARE_TOKEN);
-    expect(res.body.matchType).toMatch(/token/);
-  });
-
-  it('does NOT leak the token via SQL LIKE wildcards in the link_partial fallback', async () => {
-    // Before the escaping fix, an anonymous request of 32 underscores matched
-    // any share_link ending in a 32-char token (`_` = single-char wildcard),
-    // resolved as matchType 'link_partial', and handed back the bearer token.
-    // The share_token here has no underscores, so an escaped LIKE must miss.
-    const res = await request(app).get(`/api/gallery/resolve/${'_'.repeat(SHARE_TOKEN.length)}`);
-    expect(res.status).toBe(404);
-    expect(res.body.token).toBeUndefined();
-    expect(JSON.stringify(res.body)).not.toContain(SHARE_TOKEN);
-  });
-});
@@ -1,188 +0,0 @@
-/**
- * SQLite boolean coercion in the guest gallery surface (#1028).
- *
- * SQLite stores booleans as 0/1; Postgres stores true/false. The /photos
- * payload and every download guard compared strictly against `true`/`false`,
- * so on SQLite:
- *
- *   allow_downloads:    0 !== false → true   (button shown while disabled)
- *   allow_user_uploads: 1 === true  → false  (button hidden while enabled)
- *   if (allow_downloads === false)  → never fires, so ALL download endpoints
- *                                     kept serving with downloads switched off
- *
- * (The download-jobs route asserted on main is #858, which is beta-only —
- * this branch covers the three download endpoints that exist here.)
- *
- * The harness runs on SQLite, so these assertions exercise the real engine
- * values rather than a mock. Every test here fails on the unfixed code.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-sqlite-flags-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'sqlite-flags-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-sqlite-flags-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-const SLUG = 'sqlite-flags-gallery';
-
-describe('gallery flags survive SQLite 0/1 storage (#1028)', () => {
-  let db; let cleanup; let app; let eventId; let photoId;
-
-  async function setEventFlags(patch) {
-    await db('events').where('id', eventId).update(patch);
-  }
-
-  async function getPayload() {
-    const res = await request(app).get(`/api/gallery/${SLUG}/photos`);
-    expect(res.status).toBe(200);
-    return res.body.event;
-  }
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const ev = await db('events').insert({
-      slug: SLUG,
-      event_type: 'wedding',
-      event_name: 'SQLite Flags',
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_link: `/gallery/${SLUG}/s`,
-      share_token: 'sqlite-flags-share',
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1,
-      is_archived: 0,
-      is_draft: 0,
-      // Password-free so verifyGalleryAccess takes the public path and loads
-      // the row with SELECT * — i.e. the raw 0/1 values, same as production.
-      require_password: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    eventId = ev[0]?.id ?? ev[0];
-
-    const ph = await db('photos').insert({
-      event_id: eventId,
-      filename: 'p.jpg',
-      path: `${SLUG}/p.jpg`,
-      type: 'individual',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    photoId = ph[0]?.id ?? ph[0];
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/gallery', require('../../src/routes/gallery'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  test('the engine under test really is SQLite storing 0/1', async () => {
-    expect(['sqlite3', 'better-sqlite3']).toContain(db.client.config.client);
-    await setEventFlags({ allow_downloads: 0 });
-    const row = await db('events').where('id', eventId).first('allow_downloads');
-    expect(row.allow_downloads).toBe(0);
-  });
-
-  describe('with downloads disabled (allow_downloads = 0)', () => {
-    beforeAll(async () => {
-      await setEventFlags({ allow_downloads: 0, allow_user_uploads: 1 });
-    });
-
-    test('payload reports allow_downloads false (was true — header button shown)', async () => {
-      expect((await getPayload()).allow_downloads).toBe(false);
-    });
-
-    test('payload reports allow_user_uploads true (was false — upload button hidden)', async () => {
-      expect((await getPayload()).allow_user_uploads).toBe(true);
-    });
-
-    test('single-photo download is refused', async () => {
-      const res = await request(app).get(`/api/gallery/${SLUG}/download/${photoId}`);
-      expect(res.status).toBe(403);
-    });
-
-    test('download-all is refused', async () => {
-      const res = await request(app).get(`/api/gallery/${SLUG}/download-all`);
-      expect(res.status).toBe(403);
-    });
-
-    test('download-selected is refused', async () => {
-      const res = await request(app)
-        .post(`/api/gallery/${SLUG}/download-selected`)
-        .send({ photo_ids: [photoId] });
-      expect(res.status).toBe(403);
-    });
-  });
-
-  describe('with downloads enabled (allow_downloads = 1)', () => {
-    beforeAll(async () => {
-      await setEventFlags({ allow_downloads: 1, allow_user_uploads: 0 });
-    });
-
-    test('payload reports allow_downloads true / allow_user_uploads false', async () => {
-      const event = await getPayload();
-      expect(event.allow_downloads).toBe(true);
-      expect(event.allow_user_uploads).toBe(false);
-    });
-
-    test('download-all is no longer refused', async () => {
-      const res = await request(app).get(`/api/gallery/${SLUG}/download-all`);
-      expect(res.status).not.toBe(403);
-    });
-  });
-
-  describe('protection flags', () => {
-    test('0/1 protection toggles are reported the way they are stored', async () => {
-      await setEventFlags({
-        disable_right_click: 1,
-        enable_devtools_protection: 1,
-        use_canvas_rendering: 1,
-        watermark_downloads: 1,
-        overlay_protection: 0,
-      });
-      const event = await getPayload();
-      expect(event.disable_right_click).toBe(true);
-      expect(event.enable_devtools_protection).toBe(true);
-      expect(event.use_canvas_rendering).toBe(true);
-      expect(event.watermark_downloads).toBe(true);
-      expect(event.overlay_protection).toBe(false);
-    });
-  });
-
-  describe('per-category download blocking (#640) on SQLite', () => {
-    test('a category with allow_downloads = 0 is reported as blocked', async () => {
-      const cat = await db('photo_categories').insert({
-        name: 'Blocked', slug: 'blocked', event_id: eventId, is_global: 0, allow_downloads: 0,
-      }).returning('id');
-      const categoryId = cat[0]?.id ?? cat[0];
-      await db('photos').where('id', photoId).update({ category_id: categoryId });
-
-      await setEventFlags({ allow_downloads: 1 });
-      const res = await request(app).get(`/api/gallery/${SLUG}/photos`);
-      expect(res.status).toBe(200);
-
-      const category = res.body.categories.find((c) => c.id === categoryId);
-      expect(category.allow_downloads).toBe(false);
-      const photo = res.body.photos.find((p) => p.id === photoId);
-      expect(photo.category_allow_downloads).toBe(false);
-
-      // …and the per-category guard on the single-photo route fires.
-      const dl = await request(app).get(`/api/gallery/${SLUG}/download/${photoId}`);
-      expect(dl.status).toBe(403);
-    });
-  });
-});
@@ -1,240 +0,0 @@
-/**
- * Hidden/client-only photo access control across the bulk + secure photo
- * routes (GHSA cluster: fpwq / ghf8 / 3jvw / 9cc4 / 2hqg / jc22).
- *
- * A photo with visibility='hidden' is client-only. The main photo-list and
- * single-photo download/view routes enforced this, but the bulk-download,
- * protected-image, and secure-image routes shipped without the check —
- * letting an ordinary guest reach hidden photos. These tests pin that
- * guests are refused and PIN-clients (accessLevel='client') still succeed.
- */
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-hidden-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'hidden-photo-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-hidden-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const cookieParser = require('cookie-parser');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-const SLUG = 'hidden-photo-test-event';
-
-describe('hidden-photo access control (GHSA cluster)', () => {
-  let db;
-  let cleanup;
-  let app;
-  let eventId;
-  let visibleId;
-  let hiddenId;
-
-  const guestToken = () => jwt.sign(
-    { eventId, eventSlug: SLUG, type: 'gallery' },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-  const clientToken = () => jwt.sign(
-    { eventId, eventSlug: SLUG, type: 'gallery', accessLevel: 'client' },
-    process.env.JWT_SECRET,
-    { expiresIn: '1h', issuer: 'picpeak-auth' }
-  );
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const inserted = await db('events').insert({
-      slug: SLUG,
-      event_type: 'wedding',
-      event_name: 'Hidden Photo Test',
-      event_date: '2026-08-01',
-      host_email: 'host@example.com',
-      admin_email: 'admin@example.com',
-      password_hash: 'x',
-      share_link: `/gallery/${SLUG}/share`,
-      share_token: 'hidden-photo-share',
-      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0, allow_downloads: 1,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    eventId = inserted[0]?.id ?? inserted[0];
-
-    const photoDir = path.join(process.env.STORAGE_PATH, 'events/active', SLUG);
-    fs.mkdirSync(photoDir, { recursive: true });
-
-    // A real 1x1 PNG so the protected /view route's Sharp processing path
-    // succeeds (fake bytes 500 on metadata()). Content, not extension,
-    // drives Sharp's format detection.
-    const PNG_1x1 = Buffer.from(
-      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M8AAAMCAQGV2rY9AAAAAElFTkSuQmCC',
-      'base64'
-    );
-    const mkPhoto = async (filename, visibility) => {
-      fs.writeFileSync(path.join(photoDir, filename), PNG_1x1);
-      const p = await db('photos').insert({
-        event_id: eventId,
-        filename,
-        path: `${SLUG}/${filename}`,
-        type: 'individual',
-        visibility,
-        uploaded_at: new Date().toISOString(),
-      }).returning('id');
-      return p[0]?.id ?? p[0];
-    };
-    visibleId = await mkPhoto('visible.jpg', 'visible');
-    hiddenId = await mkPhoto('hidden.jpg', 'hidden');
-
-    app = express();
-    app.use(express.json());
-    app.use(cookieParser());
-    app.use('/api/gallery', require('../../src/routes/gallery'));
-    app.use('/api/images', require('../../src/routes/protectedImages'));
-    app.use('/api/secure-images', require('../../src/routes/secureImages'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  describe('download-selected (GHSA-ghf8, medium)', () => {
-    it('omits a hidden photo for a guest even when its id is requested', async () => {
-      const res = await request(app)
-        .post(`/api/gallery/${SLUG}/download-selected`)
-        .set('Authorization', `Bearer ${guestToken()}`)
-        .send({ photo_ids: [visibleId, hiddenId] });
-      // The visible photo still zips; the hidden one is filtered out. If
-      // only the hidden id were requested, the filter empties the set → 404.
-      expect(res.status).toBe(200);
-      const solo = await request(app)
-        .post(`/api/gallery/${SLUG}/download-selected`)
-        .set('Authorization', `Bearer ${guestToken()}`)
-        .send({ photo_ids: [hiddenId] });
-      expect(solo.status).toBe(404);
-    });
-
-    it('includes the hidden photo for a client', async () => {
-      const res = await request(app)
-        .post(`/api/gallery/${SLUG}/download-selected`)
-        .set('Authorization', `Bearer ${clientToken()}`)
-        .send({ photo_ids: [hiddenId] });
-      expect(res.status).toBe(200);
-    });
-  });
-
-  describe('download-all (GHSA-fpwq, medium)', () => {
-    it('streams for a guest without erroring (hidden photos filtered)', async () => {
-      const res = await request(app)
-        .get(`/api/gallery/${SLUG}/download-all`)
-        .set('Authorization', `Bearer ${guestToken()}`);
-      expect(res.status).toBe(200);
-    });
-  });
-
-  describe('protected-image view (GHSA-9cc4)', () => {
-    it('403s a hidden photo for a guest', async () => {
-      const res = await request(app)
-        .get(`/api/images/${SLUG}/photo/${hiddenId}/view`)
-        .set('Authorization', `Bearer ${guestToken()}`);
-      expect(res.status).toBe(403);
-    });
-    it('serves a visible photo for a guest', async () => {
-      const res = await request(app)
-        .get(`/api/images/${SLUG}/photo/${visibleId}/view`)
-        .set('Authorization', `Bearer ${guestToken()}`);
-      expect(res.status).toBe(200);
-    });
-    it('serves a hidden photo for a client', async () => {
-      const res = await request(app)
-        .get(`/api/images/${SLUG}/photo/${hiddenId}/view`)
-        .set('Authorization', `Bearer ${clientToken()}`);
-      expect(res.status).toBe(200);
-    });
-  });
-
-  describe('signed-URL mint (GHSA-3jvw)', () => {
-    it('403s minting a signed URL for a hidden photo as a guest', async () => {
-      const res = await request(app)
-        .post(`/api/images/${SLUG}/photo/${hiddenId}/generate-url`)
-        .set('Authorization', `Bearer ${guestToken()}`);
-      expect(res.status).toBe(403);
-    });
-    it('mints for a client', async () => {
-      const res = await request(app)
-        .post(`/api/images/${SLUG}/photo/${hiddenId}/generate-url`)
-        .set('Authorization', `Bearer ${clientToken()}`);
-      expect(res.status).toBe(200);
-      expect(res.body.url).toContain('/signed/');
-    });
-  });
-
-  describe('legacy secure-token mint (protectedImages generate-secure-token)', () => {
-    it('403s a hidden photo for a guest', async () => {
-      const res = await request(app)
-        .post(`/api/images/${SLUG}/photo/${hiddenId}/generate-secure-token`)
-        .set('Authorization', `Bearer ${guestToken()}`);
-      expect(res.status).toBe(403);
-    });
-    it('mints for a client', async () => {
-      const res = await request(app)
-        .post(`/api/images/${SLUG}/photo/${hiddenId}/generate-secure-token`)
-        .set('Authorization', `Bearer ${clientToken()}`);
-      expect(res.status).toBe(200);
-      expect(res.body.token).toBeDefined();
-    });
-  });
-
-  describe('secure-token mint (GHSA-2hqg)', () => {
-    it('403s minting a secure token for a hidden photo as a guest', async () => {
-      const res = await request(app)
-        .post(`/api/secure-images/${SLUG}/generate-token`)
-        .set('Authorization', `Bearer ${guestToken()}`)
-        .send({ photoId: hiddenId });
-      expect(res.status).toBe(403);
-    });
-    it('mints for a client', async () => {
-      const res = await request(app)
-        .post(`/api/secure-images/${SLUG}/generate-token`)
-        .set('Authorization', `Bearer ${clientToken()}`)
-        .send({ photoId: hiddenId });
-      expect(res.status).toBe(200);
-      expect(res.body.token).toBeDefined();
-    });
-  });
-
-  // A capability minted while a photo is visible must stop serving once the
-  // photo is hidden — unless minted by a client (clientBypass in the token).
-  describe('signed-URL TOCTOU (hidden AFTER minting)', () => {
-    afterEach(async () => {
-      await db('photos').where({ id: visibleId }).update({ visibility: 'visible' });
-    });
-
-    it("a guest's pre-minted signed URL stops serving once the photo is hidden", async () => {
-      const mint = await request(app)
-        .post(`/api/images/${SLUG}/photo/${visibleId}/generate-url`)
-        .set('Authorization', `Bearer ${guestToken()}`);
-      expect(mint.status).toBe(200);
-      const url = mint.body.url;
-      // Still visible → serves.
-      expect((await request(app).get(url)).status).toBe(200);
-      // Hide it → the guest token (no clientBypass) must now be refused.
-      await db('photos').where({ id: visibleId }).update({ visibility: 'hidden' });
-      expect((await request(app).get(url)).status).toBe(403);
-    });
-
-    it("a client's pre-minted signed URL keeps serving after the photo is hidden", async () => {
-      const mint = await request(app)
-        .post(`/api/images/${SLUG}/photo/${visibleId}/generate-url`)
-        .set('Authorization', `Bearer ${clientToken()}`);
-      expect(mint.status).toBe(200);
-      const url = mint.body.url;
-      await db('photos').where({ id: visibleId }).update({ visibility: 'hidden' });
-      expect((await request(app).get(url)).status).toBe(200);
-    });
-  });
-});
@@ -1,123 +0,0 @@
-/**
- * Logo diagnostic must not leak the filesystem layout, and must mirror what
- * resolveLogoFile actually tries (GHSA-29vm, codex round 2).
- *
- * Round 1 relativised `resolvedTo` and the candidate paths but still echoed
- * `sources[].value` verbatim — and branding_logo_path is stored ABSOLUTE by
- * multer, so the layout went out anyway. It also dropped the raw-absolute
- * candidate, which the resolver retains (subject to containment), making the
- * diagnostic report every candidate as missing for a legitimately contained
- * absolute logo while `resolvedTo` named the file.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-logodiag-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'logodiag-test-secret';
-
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('logo diagnostic disclosure (GHSA-29vm)', () => {
-  let db; let cleanup; let app; let token;
-  // bootCrmDb() sets STORAGE_PATH itself, so resolve these AFTER it runs.
-  let STORAGE; let logoDir; let logoPath;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    // A legitimately contained absolute logo in a NON-standard storage subdir.
-    STORAGE = process.env.STORAGE_PATH;
-    logoDir = path.join(STORAGE, 'custom');
-    logoPath = path.join(logoDir, 'logo.png');
-    fs.mkdirSync(logoDir, { recursive: true });
-    fs.writeFileSync(logoPath, 'png');
-
-    const setting = { setting_key: 'branding_logo_path', setting_value: JSON.stringify(logoPath), setting_type: 'branding' };
-    const existing = await db('app_settings').where({ setting_key: 'branding_logo_path' }).first();
-    if (existing) await db('app_settings').where({ setting_key: 'branding_logo_path' }).update(setting);
-    else await db('app_settings').insert(setting);
-
-    const role = await db('roles').where({ name: 'super_admin' }).first();
-    const r = await db('admin_users').insert({
-      username: 'diag-admin', email: 'diag@example.com',
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id, is_active: 1,
-      created_at: new Date(), updated_at: new Date(),
-    }).returning('id');
-    const id = r[0]?.id ?? r[0];
-    token = jwt.sign(
-      { id, username: 'diag-admin', type: 'admin', role: 'super_admin', loginTime: Date.now() },
-      process.env.JWT_SECRET, { expiresIn: '1h', issuer: 'picpeak-auth' },
-    );
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/admin/business-profile', require('../../src/routes/adminBusinessProfile'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('does not leak absolute paths, cwd or storage root anywhere in the payload', async () => {
-    const res = await request(app)
-      .get('/api/admin/business-profile/logo-diagnostic')
-      .set('Authorization', `Bearer ${token}`);
-
-    expect(res.status).toBe(200);
-    const body = JSON.stringify(res.body);
-    expect(body).not.toContain(STORAGE);
-    expect(body).not.toContain(process.cwd());
-    expect(res.body.storageRoot).toBeUndefined();
-    expect(res.body.cwd).toBeUndefined();
-  });
-
-  it('still finds a contained absolute logo outside the standard subdirs', async () => {
-    const res = await request(app)
-      .get('/api/admin/business-profile/logo-diagnostic')
-      .set('Authorization', `Bearer ${token}`);
-
-    const source = res.body.sources.find((s) => s.label === 'app_settings.branding_logo_path');
-    expect(source).toBeTruthy();
-    // The resolver keeps the contained absolute candidate, so the diagnostic
-    // must show it existing rather than reporting everything missing.
-    expect(source.candidates.some((c) => c.exists)).toBe(true);
-    expect(res.body.resolvedTo).toMatch(/^<STORAGE>\//);
-  });
-
-  it('shows the <STORAGE>/<value> candidate for a ROOT-RELATIVE logo URL (round 3)', async () => {
-    // `/custom/logo.png` is a URL, not a disk path, but path.isAbsolute() says
-    // true for both. Gating the stripped joins on isAbsolute() therefore hid
-    // `<STORAGE>/custom/logo.png` — a candidate resolveLogoFile does try and
-    // can resolve — so the diagnostic claimed nothing existed for a logo that
-    // renders fine, and collapsed the configured value to its basename.
-    await db('app_settings').where({ setting_key: 'branding_logo_path' })
-      .update({ setting_value: JSON.stringify('/custom/logo.png') });
-
-    const res = await request(app)
-      .get('/api/admin/business-profile/logo-diagnostic')
-      .set('Authorization', `Bearer ${token}`);
-
-    expect(res.status).toBe(200);
-    const source = res.body.sources.find((s) => s.label === 'app_settings.branding_logo_path');
-    expect(source.candidates.some((c) => c.path === '<STORAGE>/custom/logo.png' && c.exists)).toBe(true);
-
-    // …and the disclosure guarantee still holds for this shape.
-    const body = JSON.stringify(res.body);
-    expect(body).not.toContain(STORAGE);
-    expect(body).not.toContain(process.cwd());
-
-    await db('app_settings').where({ setting_key: 'branding_logo_path' })
-      .update({ setting_value: JSON.stringify(logoPath) });
-  });
-});
@@ -1,181 +0,0 @@
-/**
- * Project ownership — GHSA-wrg5 (project routes) and GHSA-93x4 (project email
- * endpoints).
- *
- * Project routes authorized on generic events.view / events.edit with NO
- * ownership check, so an editor could enumerate, read, update and aggregate
- * projects belonging to other admins' events. The email endpoints keyed on an
- * email_queue id alone, so any id could be previewed/resent/cancelled.
- *
- * `projects` had no owner column. It was added in migration 167 (backfilled
- * from linked events) rather than relying only on the transitive
- * events.project_id -> events.created_by path, because a brand-new EMPTY
- * project has no linked event to infer an owner from — which is exactly where
- * the create -> attach flow begins.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-projown-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'projown-test-secret';
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('project ownership (GHSA-wrg5 / GHSA-93x4)', () => {
-  let db; let cleanup; let app;
-  let editorToken; let superToken; let editorId; let superId;
-  let ownProjectId; let foreignProjectId; let foreignEventId; let foreignEmailId;
-
-  const mkAdmin = async (username, roleName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const r = await db('admin_users').insert({
-      username,
-      email: `${username}@example.com`,
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id,
-      is_active: 1,
-      created_at: new Date(),
-      updated_at: new Date(),
-    }).returning('id');
-    const id = r[0]?.id ?? r[0];
-    return {
-      id,
-      token: jwt.sign(
-        { id, username, type: 'admin', role: roleName, loginTime: Date.now() },
-        process.env.JWT_SECRET, { expiresIn: '1h', issuer: 'picpeak-auth' },
-      ),
-    };
-  };
-
-  const mkProject = async (name, createdBy) => {
-    const r = await db('projects').insert({
-      name, status: 'active', created_by: createdBy,
-      created_at: new Date(), updated_at: new Date(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    await db('feature_flags').insert({ key: 'projects', value: 1 })
-      .onConflict('key').merge({ value: 1 });
-
-    const editor = await mkAdmin('proj-editor', 'editor');
-    const sup = await mkAdmin('proj-super', 'super_admin');
-    editorToken = editor.token; editorId = editor.id;
-    superToken = sup.token; superId = sup.id;
-
-    ownProjectId = await mkProject('own-project', editorId);
-    foreignProjectId = await mkProject('foreign-project', superId);
-
-    // A foreign event linked to the foreign project, plus a queued email on it.
-    const ev = await db('events').insert({
-      slug: 'foreign-ev',
-      event_type: 'wedding',
-      event_name: 'Foreign Event',
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_token: 'ftok', share_link: '/gallery/foreign-ev/ftok',
-      created_by: superId,
-      project_id: foreignProjectId,
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    foreignEventId = ev[0]?.id ?? ev[0];
-
-    const em = await db('email_queue').insert({
-      event_id: foreignEventId,
-      recipient_email: 'client@example.com',
-      email_type: 'gallery_created',
-      status: 'sent',
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    foreignEmailId = em[0]?.id ?? em[0];
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/admin/projects', require('../../src/routes/adminProjects'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('lists only the editor\'s own projects', async () => {
-    const res = await request(app)
-      .get('/api/admin/projects')
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect(res.status).toBe(200);
-    const names = (res.body.projects || res.body.data?.projects || []).map((p) => p.name);
-    expect(names).toContain('own-project');
-    expect(names).not.toContain('foreign-project');
-  });
-
-  it('refuses to read a foreign project', async () => {
-    const res = await request(app)
-      .get(`/api/admin/projects/${foreignProjectId}`)
-      .set('Authorization', `Bearer ${editorToken}`);
-    expect([403, 404]).toContain(res.status);
-  });
-
-  it('refuses to update or aggregate a foreign project', async () => {
-    const update = await request(app)
-      .put(`/api/admin/projects/${foreignProjectId}`)
-      .set('Authorization', `Bearer ${editorToken}`)
-      .send({ name: 'hijacked' });
-    expect([403, 404]).toContain(update.status);
-
-    const overview = await request(app)
-      .get(`/api/admin/projects/${foreignProjectId}/overview`)
-      .set('Authorization', `Bearer ${editorToken}`);
-    expect([403, 404]).toContain(overview.status);
-
-    // And the name must not have changed.
-    const row = await db('projects').where({ id: foreignProjectId }).first();
-    expect(row.name).toBe('foreign-project');
-  });
-
-  it('refuses to attach a FOREIGN event to an owned project', async () => {
-    const res = await request(app)
-      .post(`/api/admin/projects/${ownProjectId}/events`)
-      .set('Authorization', `Bearer ${editorToken}`)
-      .send({ eventId: foreignEventId });
-
-    expect([403, 404]).toContain(res.status);
-    const ev = await db('events').where({ id: foreignEventId }).first();
-    expect(ev.project_id).toBe(foreignProjectId); // still attached to its own
-  });
-
-  it('refuses to preview or act on a foreign queued email (GHSA-93x4)', async () => {
-    const preview = await request(app)
-      .get(`/api/admin/projects/email/${foreignEmailId}/preview`)
-      .set('Authorization', `Bearer ${editorToken}`);
-    expect([403, 404]).toContain(preview.status);
-
-    const cancel = await request(app)
-      .post(`/api/admin/projects/email/${foreignEmailId}/cancel`)
-      .set('Authorization', `Bearer ${editorToken}`);
-    expect([403, 404]).toContain(cancel.status);
-  });
-
-  it('leaves super_admin unrestricted', async () => {
-    const res = await request(app)
-      .get(`/api/admin/projects/${foreignProjectId}`)
-      .set('Authorization', `Bearer ${superToken}`);
-    expect(res.status).toBe(200);
-  });
-});
@@ -1,115 +0,0 @@
-/**
- * Project ownership edge cases (GHSA-wrg5, codex round 2).
- *
- * The first predicate union'd "any linked event I can see" with the stored
- * owner, which opened two holes:
- *   - a project owned by B containing ONE legacy ownerless event became
- *     readable by everyone (and /overview aggregates B's other events,
- *     invoices and emails);
- *   - migration 167 deliberately leaves multi-owner projects NULL, and a NULL
- *     owner was treated as "everyone's".
- * The stored owner is now authoritative, and a NULL owner only derives access
- * when EVERY linked event is accessible.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-projedge-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'projedge-test-secret';
-
-const bcrypt3 = require('bcrypt');
-const { bootCrmDb: boot3, seedMinimal: seed3 } = require('../integration/helpers/crmDb');
-
-describe('project ownership edge cases (GHSA-wrg5, round 2)', () => {
-  let db3; let cleanup3; let ownership; let editorA; let editorB;
-
-  const mkAdmin3 = async (username, roleName) => {
-    const role = await db3('roles').where({ name: roleName }).first();
-    const r = await db3('admin_users').insert({
-      username, email: `${username}@example.com`,
-      password_hash: await bcrypt3.hash('Passw0rd!', 4),
-      role_id: role.id, is_active: 1,
-      created_at: new Date(), updated_at: new Date(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-  const mkProject3 = async (name, createdBy) => {
-    const r = await db3('projects').insert({
-      name, status: 'active', created_by: createdBy,
-      created_at: new Date(), updated_at: new Date(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-  const mkEvent3 = async (slug, createdBy, projectId) => {
-    const r = await db3('events').insert({
-      slug, event_type: 'wedding', event_name: slug, event_date: '2026-08-01',
-      host_email: 'h@e.com', admin_email: 'a@e.com', password_hash: 'x',
-      share_token: `t-${slug}`, share_link: `/g/${slug}/t-${slug}`,
-      created_by: createdBy, project_id: projectId,
-      expires_at: new Date(Date.now() + 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  beforeAll(async () => {
-    ({ db: db3, cleanup: cleanup3 } = await boot3());
-    await seed3(db3);
-    ownership = require('../../src/middleware/ownership');
-    editorA = await mkAdmin3('edge-a', 'editor');
-    editorB = await mkAdmin3('edge-b', 'editor');
-  }, 120000);
-
-  afterAll(async () => { if (cleanup3) await cleanup3(); });
-
-  it('one ownerless event in B\'s project does not expose it to A', async () => {
-    const pid = await mkProject3('b-project', editorB);
-    await mkEvent3('b-owned-ev', editorB, pid);
-    await mkEvent3('legacy-ev', null, pid); // ownerless legacy event
-
-    const idsA = await ownership.ownedProjectIds({ id: editorA, roleName: 'editor' });
-    expect(idsA).not.toContain(Number(pid));
-
-    const idsB = await ownership.ownedProjectIds({ id: editorB, roleName: 'editor' });
-    expect(idsB).toContain(Number(pid));
-  });
-
-  it('a mixed-owner project left NULL by migration 167 is not global', async () => {
-    const pid = await mkProject3('ambiguous', null);
-    await mkEvent3('mix-a-ev', editorA, pid);
-    await mkEvent3('mix-b-ev', editorB, pid);
-
-    for (const who of [editorA, editorB]) {
-      const ids = await ownership.ownedProjectIds({ id: who, roleName: 'editor' });
-      expect(ids).not.toContain(Number(pid));
-    }
-  });
-
-  it('a NULL-owner project whose events are all mine IS mine', async () => {
-    const pid = await mkProject3('legacy-mine', null);
-    await mkEvent3('mine-ev', editorA, pid);
-
-    const ids = await ownership.ownedProjectIds({ id: editorA, roleName: 'editor' });
-    expect(ids).toContain(Number(pid));
-  });
-
-  it('a project whose creator was deleted falls back to its events', async () => {
-    const ghost = await mkAdmin3('ghost-admin', 'editor');
-    const pid = await mkProject3('orphaned', ghost);
-    await mkEvent3('orphan-ev', editorA, pid);
-    await db3('admin_users').where({ id: ghost }).del();
-
-    const ids = await ownership.ownedProjectIds({ id: editorA, roleName: 'editor' });
-    expect(ids).toContain(Number(pid));
-  });
-
-  it('super_admin stays unrestricted', async () => {
-    expect(await ownership.ownedProjectIds({ id: 1, roleName: 'super_admin' })).toBeNull();
-  });
-});
@@ -1,86 +0,0 @@
-/**
- * Restore path containment must not break the normal restore wizard
- * (GHSA-fw4c, codex round 2).
- *
- * `source` is usually a SOURCE TYPE, not a path: RestoreWizard posts
- * 'local' | 's3' | 'upload', and restoreService.restore() branches on those
- * literals before deriving a directory. The first version of the containment
- * check treated `source` as a path, so path.resolve('local') landed outside
- * the configured backup roots and BOTH /validate and /start returned 400 —
- * blocking every normal restore.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-restorepath-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'restorepath-test-secret';
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('restore path allowlist (GHSA-fw4c)', () => {
-  let db; let cleanup; let checkRestorePathsAllowed;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    // Configure a backup root so the allowlist is actually active.
-    for (const [key, value] of [['backup_destination_path', '/backup']]) {
-      const existing = await db('app_settings').where({ setting_key: key }).first();
-      if (existing) {
-        await db('app_settings').where({ setting_key: key }).update({ setting_value: JSON.stringify(value) });
-      } else {
-        await db('app_settings').insert({
-          setting_key: key, setting_value: JSON.stringify(value), setting_type: 'backup',
-        });
-      }
-    }
-
-    ({ checkRestorePathsAllowed } = require('../../src/routes/adminRestore')._internal);
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('allows the wizard\'s source TYPE tokens', async () => {
-    for (const source of ['local', 's3', 'upload']) {
-      const err = await checkRestorePathsAllowed({
-        source, manifestPath: '/backup/manifests/backup-manifest-1.json',
-      });
-      expect(err).toBeNull();
-    }
-  });
-
-  it('allows an s3:// source URL', async () => {
-    const err = await checkRestorePathsAllowed({
-      source: 's3://bucket/key/backup.tar.gz',
-      manifestPath: '/backup/manifests/backup-manifest-1.json',
-    });
-    expect(err).toBeNull();
-  });
-
-  it('still rejects a manifestPath outside the configured roots', async () => {
-    const err = await checkRestorePathsAllowed({
-      source: 'local', manifestPath: '/etc/passwd',
-    });
-    expect(err).toMatch(/inside a configured backup location/i);
-  });
-
-  it('still rejects a traversal manifestPath', async () => {
-    const err = await checkRestorePathsAllowed({
-      source: 'local', manifestPath: '/backup/../etc/shadow',
-    });
-    expect(err).toBeTruthy();
-  });
-
-  it('accepts a real path source inside the roots', async () => {
-    const err = await checkRestorePathsAllowed({
-      source: '/backup/run-1', manifestPath: '/backup/run-1/manifest.json',
-    });
-    expect(err).toBeNull();
-  });
-});
@@ -1,136 +0,0 @@
-/**
- * Secure-image view route token binding (GHSA-g94x-8vv8-3c9f).
- *
- * The view route GET /api/secure-images/:slug/secure/:photoId/:token serves
- * via <img src> with the token in the URL, so it can't carry a gallery-token
- * header like the download sibling. Before the fix it validated only the
- * token signature and took the gallery/photo from the URL — so a token minted
- * on any PUBLIC gallery read every other gallery's photos with no password.
- *
- * Pins that the route now enforces the scope inside the token:
- *  - the URL photoId must equal the token's minted photoId
- *  - the gallery embedded in the token's sessionId must equal the URL gallery
- * A token minted on gallery A cannot read gallery B under either check; a
- * token used on its own gallery+photo passes the binding.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-secimg-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'secimg-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-secimg-storage-'));
-
-// Stub the anti-bot/rate-limit middleware so the fingerprint is deterministic
-// — the token below is minted with the same fingerprint, so verifySecureToken
-// passes and the binding logic under test is what decides the outcome.
-jest.mock('../../src/middleware/secureImageMiddleware', () => ({
-  secureImageAccess: (req, _res, next) => {
-    req.clientInfo = { fingerprint: 'test-fp', ip: '127.0.0.1', userAgent: 'jest' };
-    next();
-  },
-  getSecurityStatus: (_req, res) => res.json({ ok: true }),
-}));
-
-const request = require('supertest');
-const express = require('express');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-const secureImageService = require('../../src/services/secureImageService');
-
-describe('secure-image view route token binding (GHSA-g94x)', () => {
-  let db;
-  let cleanup;
-  let app;
-  let galleryA; let galleryB;
-  let photoA; let photoB;
-
-  const mkEvent = async (slug, requirePassword) => {
-    const r = await db('events').insert({
-      slug,
-      event_type: 'wedding',
-      event_name: slug,
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      require_password: requirePassword ? 1 : 0,
-      share_link: `/gallery/${slug}/share`,
-      share_token: `${slug}-share`,
-      expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-      is_active: 1,
-      is_archived: 0,
-      is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  const mkPhoto = async (eventId, slug, filename) => {
-    const dir = path.join(process.env.STORAGE_PATH, 'events/active', slug);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, filename), Buffer.from('img'));
-    const r = await db('photos').insert({
-      event_id: eventId,
-      filename,
-      path: `${slug}/${filename}`,
-      type: 'individual',
-      uploaded_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  // Mint a token exactly as the mint route does — bound to (photoId, gallery
-  // sessionId, fingerprint) — bypassing the anti-bot HTTP path.
-  const mint = (photoId, eventId) => secureImageService.generateSecureToken(
-    photoId,
-    `gallery_public_${eventId}_${Date.now()}`,
-    { clientFingerprint: 'test-fp', maxUses: 100, expiresIn: 3600 },
-  );
-
-  const view = (slug, photoId, token) => request(app)
-    .get(`/api/secure-images/${slug}/secure/${photoId}/${token}`);
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-    galleryA = await mkEvent('secimg-public-a', false);   // public — token source
-    galleryB = await mkEvent('secimg-private-b', true);   // password-protected — victim
-    photoA = await mkPhoto(galleryA, 'secimg-public-a', 'a.jpg');
-    photoB = await mkPhoto(galleryB, 'secimg-private-b', 'b.jpg');
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/secure-images', require('../../src/routes/secureImages'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('rejects a gallery-A token used against gallery B (cross-photo)', async () => {
-    const token = mint(photoA, galleryA);
-    const res = await view('secimg-private-b', photoB, token);
-    expect(res.status).toBe(403);
-    expect(res.body.error).toMatch(/not valid for this photo/i);
-  });
-
-  it('rejects a gallery-A token replayed on gallery B with A\'s photoId', async () => {
-    const token = mint(photoA, galleryA);
-    // URL photoId matches the token, so the photo check passes — the gallery
-    // check (sessionId gallery A != URL gallery B) must catch it.
-    const res = await view('secimg-private-b', photoA, token);
-    expect(res.status).toBe(403);
-    expect(res.body.error).toMatch(/not valid for this gallery/i);
-  });
-
-  it('lets a token read its own gallery + photo (binding passes)', async () => {
-    const token = mint(photoA, galleryA);
-    const res = await view('secimg-public-a', photoA, token);
-    // Binding passes; serving may 200/404/500 depending on the pipeline, but
-    // it must NOT be rejected as a token mismatch.
-    expect(res.status).not.toBe(403);
-  });
-});
@@ -67,10 +67,11 @@ async function insertEvent(db, over = {}) {
 describe('public Live Slideshow routes', () => {
  let db; let cleanup; let app;

-  // bootCrmDb runs the full migration set against a fresh SQLite file and the
-  // chain keeps growing via backports. Hook-argument timeouts OVERRIDE the
-  // 120s jest.config default (same trap as the jest.setTimeout pins) — keep
-  // this at 120000, matching the config.
+  // bootCrmDb runs the full migration set against a fresh SQLite file. The
+  // chain keeps growing, and a 30s pin here blocked the 3.97.0-beta.0
+  // release PR on a slow runner. Hook-argument timeouts OVERRIDE the 120s
+  // jest.config default (same trap as the jest.setTimeout pins raised in
+  // #860) — keep this at 120000, matching the config.
  beforeAll(async () => {
    ({ db, cleanup } = await bootCrmDb());
    await seedMinimal(db);
@@ -98,7 +99,12 @@ describe('public Live Slideshow routes', () => {
    await setFlag(db, 'slideshow', true);
  });

-  const stateUrl = (token = TOKEN) => `/api/gallery/${SLUG}/show/${token}/state`;
+  // QR overlay: supertest's Host is loopback, and a loopback base is now
+  // suppressed rather than encoded — the kiosk passes its reachable
+  // window.location.origin, so the QR tests do the same.
+  const KIOSK_ORIGIN = 'https://gallery.example.com';
+  const stateUrl = (token = TOKEN) => `/api/gallery/${SLUG}/show/${token}/state?origin=${encodeURIComponent(KIOSK_ORIGIN)}`;
+  const stateUrlNoOrigin = (token = TOKEN) => `/api/gallery/${SLUG}/show/${token}/state`;

  describe('resolveSlideshow guards', () => {
    it('200 + per-event display settings on a live link', async () => {
@@ -227,6 +233,58 @@ describe('public Live Slideshow routes', () => {
    });
  });

+  describe('slideshowSettings — QR overlay cascade (#837)', () => {
+    async function enableGlobalQr() {
+      await setSetting(db, 'slideshow_qr_enabled', true);
+      await setSetting(db, 'slideshow_qr_position', 'top-right');
+      await setSetting(db, 'slideshow_qr_opacity', 80);
+      await setSetting(db, 'slideshow_qr_size', 18);
+    }
+
+    it('inherits the global QR overlay when show_qr is NULL', async () => {
+      await insertEvent(db, { show_qr: null });
+      await enableGlobalQr();
+      const res = await request(app).get(stateUrl());
+      expect(res.body.qr).toMatchObject({
+        position: 'top-right',
+        opacity: 80,
+        size: 18,
+      });
+      // Share-link QR ships as a PNG data URI — no client QR lib needed.
+      expect(res.body.qr.data_url).toMatch(/^data:image\/png;base64,/);
+    });
+
+    it('is null by default (global off, no override)', async () => {
+      await insertEvent(db, { show_qr: null });
+      const res = await request(app).get(stateUrl());
+      expect(res.body.qr).toBeNull();
+    });
+
+    it('per-event OFF override hides the QR even when the global is on', async () => {
+      await insertEvent(db, { show_qr: 0 });
+      await enableGlobalQr();
+      const res = await request(app).get(stateUrl());
+      expect(res.body.qr).toBeNull();
+    });
+
+    it('per-event ON override shows the QR even when the global is off', async () => {
+      await insertEvent(db, { show_qr: 1 });
+      const res = await request(app).get(stateUrl());
+      expect(res.body.qr).not.toBeNull();
+      expect(res.body.qr.data_url).toMatch(/^data:image\/png;base64,/);
+      // Look falls back to the global defaults.
+      expect(res.body.qr.position).toBe('bottom-left');
+    });
+
+    it('suppresses the QR when no guest-reachable origin exists (loopback base, no kiosk origin)', async () => {
+      await insertEvent(db, { show_qr: 1 });
+      const res = await request(app).get(stateUrlNoOrigin());
+      // Encoding localhost would send scanning phones to THEIR localhost —
+      // no QR beats a broken QR (codex review of #848, confirmation round).
+      expect(res.body.qr).toBeNull();
+    });
+  });
+
  describe('display-only token guards (#646 review concern 1)', () => {
    // Mint a real slideshow JWT, then prove it is denied on the
    // download / upload / feedback routes (display-only contract).
@@ -1,155 +0,0 @@
-/**
- * v1 API tokens must respect event ownership (GHSA-9697).
- *
- * migration 081 documents the intent — "the token's effective permissions are
- * the intersection of the user's role permissions and the token's own scope
- * flags" — but it was never implemented:
- *
- *   - apiTokenAuth selected only id/username/email/role_id, so
- *     req.admin.roleName was undefined and every ownership helper (which all
- *     key on roleName) could not distinguish a super_admin from a viewer.
- *   - No v1 route applied requirePermission or a created_by predicate, so any
- *     valid token listed every event and — worst — GET /events/:id/share-link
- *     returned ANY event's share_token, which is the gallery access credential.
- *
- * Scenario pinned here: a token owned by a restricted (non-super_admin) admin
- * must see only its owner's events, and must not obtain a foreign share_token.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-v1own-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'v1own-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-v1own-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-const { generateApiToken } = require('../../src/middleware/apiTokenAuth');
-
-describe('v1 event ownership (GHSA-9697)', () => {
-  let db; let cleanup; let app;
-  let editorToken; let superToken;
-  let ownEventId; let foreignEventId;
-  const FOREIGN_SHARE_TOKEN = 'f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0';
-
-  const mkAdmin = async (username, roleName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const r = await db('admin_users').insert({
-      username,
-      email: `${username}@example.com`,
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id,
-      is_active: 1,
-      created_at: new Date(),
-      updated_at: new Date(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  const mkToken = async (adminId, scopes = 'admin') => {
-    const { plaintext, hashed } = generateApiToken();
-    await db('api_tokens').insert({
-      name: `tok-${adminId}`,
-      hashed_token: hashed,
-      scopes,
-      created_by: adminId,
-      created_at: new Date().toISOString(),
-    });
-    return plaintext;
-  };
-
-  const mkEvent = async (slug, createdBy, shareToken) => {
-    const r = await db('events').insert({
-      slug,
-      event_type: 'wedding',
-      event_name: slug,
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_token: shareToken,
-      share_link: `/gallery/${slug}/${shareToken}`,
-      created_by: createdBy,
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const editorId = await mkAdmin('restricted-editor', 'editor');
-    const superId = await mkAdmin('root-admin', 'super_admin');
-    editorToken = await mkToken(editorId);
-    superToken = await mkToken(superId);
-
-    ownEventId = await mkEvent('own-event', editorId, 'a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1');
-    foreignEventId = await mkEvent('foreign-event', superId, FOREIGN_SHARE_TOKEN);
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/v1', require('../../src/routes/v1/events'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('lists only the token owner\'s events', async () => {
-    const res = await request(app)
-      .get('/api/v1/events')
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect(res.status).toBe(200);
-    const slugs = res.body.events.map((e) => e.slug);
-    expect(slugs).toContain('own-event');
-    expect(slugs).not.toContain('foreign-event');
-  });
-
-  it('refuses to read a foreign event', async () => {
-    const res = await request(app)
-      .get(`/api/v1/events/${foreignEventId}`)
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect([403, 404]).toContain(res.status);
-  });
-
-  it('does NOT hand out a foreign event\'s share_token', async () => {
-    const res = await request(app)
-      .get(`/api/v1/events/${foreignEventId}/share-link`)
-      .set('Authorization', `Bearer ${editorToken}`);
-
-    expect([403, 404]).toContain(res.status);
-    expect(JSON.stringify(res.body)).not.toContain(FOREIGN_SHARE_TOKEN);
-  });
-
-  it('still allows the owner to read their own event and share link', async () => {
-    const detail = await request(app)
-      .get(`/api/v1/events/${ownEventId}`)
-      .set('Authorization', `Bearer ${editorToken}`);
-    expect(detail.status).toBe(200);
-
-    const share = await request(app)
-      .get(`/api/v1/events/${ownEventId}/share-link`)
-      .set('Authorization', `Bearer ${editorToken}`);
-    expect(share.status).toBe(200);
-    expect(share.body.share_token).toBe('a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1');
-  });
-
-  it('leaves super_admin tokens unrestricted', async () => {
-    const res = await request(app)
-      .get(`/api/v1/events/${foreignEventId}/share-link`)
-      .set('Authorization', `Bearer ${superToken}`);
-    expect(res.status).toBe(200);
-    expect(res.body.share_token).toBe(FOREIGN_SHARE_TOKEN);
-  });
-});
@@ -1,108 +0,0 @@
-/**
- * v1 token scopes must intersect the owner's CURRENT role permissions
- * (GHSA-9697, codex round 2).
- *
- * Migration 081 documents effective permissions as the intersection of the
- * owner's role permissions and the token's scope flags. requireApiScope only
- * ever checked the scope half, so a token minted while its owner was
- * super_admin kept full write access after the owner was demoted to viewer —
- * userManagementService never touches api_tokens, so the token outlives the
- * demotion. Ownership scoping alone does not close this: the demoted owner
- * still *owns* their events.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-v1perm-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'v1perm-test-secret';
-process.env.STORAGE_PATH = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-v1perm-storage-'));
-
-const request = require('supertest');
-const express = require('express');
-const bcrypt = require('bcrypt');
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-const { generateApiToken } = require('../../src/middleware/apiTokenAuth');
-
-describe('v1 token scopes intersect role permissions (GHSA-9697)', () => {
-  let db; let cleanup; let app; let viewerToken; let viewerEventId;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    const role = await db('roles').where({ name: 'viewer' }).first();
-    const r = await db('admin_users').insert({
-      username: 'demoted-owner',
-      email: 'demoted@example.com',
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id,
-      is_active: 1,
-      created_at: new Date(),
-      updated_at: new Date(),
-    }).returning('id');
-    const ownerId = r[0]?.id ?? r[0];
-
-    // A token still carrying the broad 'admin' scope from before demotion.
-    const { plaintext, hashed } = generateApiToken();
-    await db('api_tokens').insert({
-      name: 'stale-token',
-      hashed_token: hashed,
-      scopes: 'admin',
-      created_by: ownerId,
-      created_at: new Date().toISOString(),
-    });
-    viewerToken = plaintext;
-
-    const ev = await db('events').insert({
-      slug: 'viewer-ev',
-      event_type: 'wedding',
-      event_name: 'Viewer Event',
-      event_date: '2026-08-01',
-      host_email: 'h@example.com',
-      admin_email: 'a@example.com',
-      password_hash: 'x',
-      share_token: 'vtok',
-      share_link: '/gallery/viewer-ev/vtok',
-      created_by: ownerId,
-      expires_at: new Date(Date.now() + 7 * 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    viewerEventId = ev[0]?.id ?? ev[0];
-
-    app = express();
-    app.use(express.json());
-    app.use('/api/v1', require('../../src/routes/v1/events'));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('denies event creation to a demoted viewer despite an admin-scope token', async () => {
-    const res = await request(app)
-      .post('/api/v1/events')
-      .set('Authorization', `Bearer ${viewerToken}`)
-      .send({ event_name: 'Nope', event_type: 'wedding' });
-    expect(res.status).toBe(403);
-  });
-
-  it('denies photo upload to a demoted viewer on their OWN event', async () => {
-    const res = await request(app)
-      .post(`/api/v1/events/${viewerEventId}/photos`)
-      .set('Authorization', `Bearer ${viewerToken}`)
-      .attach('photo', Buffer.from('x'), 'a.jpg');
-    expect(res.status).toBe(403);
-  });
-
-  it('still allows the viewer to READ their own event', async () => {
-    const res = await request(app)
-      .get(`/api/v1/events/${viewerEventId}`)
-      .set('Authorization', `Bearer ${viewerToken}`);
-    expect(res.status).toBe(200);
-  });
-});
@@ -1,241 +0,0 @@
-/**
- * Backup/restore hardening — GHSA-h652 (unbounded gunzip) and GHSA-hgp8
- * (unkeyed manifest checksum).
- *
- * h652: decompressFile() piped gunzip straight to disk with no expanded-size
- * bound, so a small crafted .gz could fill the volume.
- *
- * hgp8: the manifest checksum is a plain SHA-256 — it proves the manifest was
- * not corrupted, not that it is authentic. BACKUP_MANIFEST_KEY upgrades new
- * manifests to a keyed HMAC. It is deliberately OPT-IN and verify-if-present:
- * the key cannot live in the database (the database is inside the backup), so
- * a mandatory HMAC would lock an operator out of the exact disaster-recovery
- * case this system exists for.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const zlib = require('zlib');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-bkharden-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'bkharden-test-secret';
-
-const { restoreService } = require('../../src/services/restoreService');
-const backupManifest = require('../../src/services/backupManifest');
-
-describe('decompressFile expanded-size bound (GHSA-h652)', () => {
-  let dir;
-
-  beforeAll(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-gz-')); });
-  afterAll(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-  afterEach(() => { delete process.env.RESTORE_MAX_DECOMPRESSED_BYTES; });
-
-  it('aborts when the decompressed stream exceeds the limit', async () => {
-    // 5 MB of zeroes compresses to a few KB — the classic shape of the attack.
-    const gzPath = path.join(dir, 'bomb.gz');
-    fs.writeFileSync(gzPath, zlib.gzipSync(Buffer.alloc(5 * 1024 * 1024, 0)));
-
-    process.env.RESTORE_MAX_DECOMPRESSED_BYTES = String(64 * 1024); // 64 KB
-    await expect(
-      restoreService.decompressFile(gzPath, path.join(dir, 'out-bomb'))
-    ).rejects.toThrow(/exceeds limit/i);
-  });
-
-  it('still decompresses a normal file within the limit', async () => {
-    const payload = Buffer.from('SELECT 1;\n'.repeat(100));
-    const gzPath = path.join(dir, 'ok.gz');
-    fs.writeFileSync(gzPath, zlib.gzipSync(payload));
-
-    const outPath = path.join(dir, 'out-ok');
-    await restoreService.decompressFile(gzPath, outPath);
-    expect(fs.readFileSync(outPath)).toEqual(payload);
-  });
-});
-
-describe('manifest checksum keying (GHSA-hgp8)', () => {
-  // validateManifest requires all of these sections to be present.
-  const baseManifest = () => ({
-    manifest: { version: '1.0', id: 'test' },
-    backup: { type: 'full' },
-    system: { platform: 'linux' },
-    application: { version: '1.0.0' },
-    files: { count: 1, manifest: [{ path: 'a.jpg', size: 1 }] },
-    database: { type: 'sqlite' },
-    verification: { total_checksum: null, checksum_algorithm: null },
-  });
-
-  afterEach(() => { delete process.env.BACKUP_MANIFEST_KEY; });
-
-  it('produces a different digest when a key is set', () => {
-    const m = baseManifest();
-    const unkeyed = backupManifest.calculateManifestChecksum(m, { keyed: false });
-    const keyed = backupManifest.calculateManifestChecksum(m, { keyed: 'secret-key' });
-    expect(keyed).not.toBe(unkeyed);
-  });
-
-  it('validates a legacy unkeyed manifest even when a key IS configured', () => {
-    // Disaster recovery: manifests written before keying must not become
-    // un-restorable the moment the operator sets a key.
-    const m = baseManifest();
-    m.verification.checksum_algorithm = 'sha256';
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: false });
-
-    process.env.BACKUP_MANIFEST_KEY = 'secret-key';
-    expect(() => backupManifest.validateManifest(m)).not.toThrow();
-  });
-
-  it('accepts a keyed manifest when the matching key is configured', () => {
-    process.env.BACKUP_MANIFEST_KEY = 'secret-key';
-    const m = baseManifest();
-    m.verification.checksum_algorithm = 'hmac-sha256';
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: 'secret-key' });
-
-    expect(() => backupManifest.validateManifest(m)).not.toThrow();
-  });
-
-  it('rejects a keyed manifest whose body was tampered with', () => {
-    process.env.BACKUP_MANIFEST_KEY = 'secret-key';
-    const m = baseManifest();
-    m.verification.checksum_algorithm = 'hmac-sha256';
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: 'secret-key' });
-
-    m.files.manifest[0].path = '../../etc/passwd';
-    expect(() => backupManifest.validateManifest(m)).toThrow(/checksum verification failed/i);
-  });
-
-  it('does NOT brick restore when a keyed manifest meets a missing key', () => {
-    // Key lost with the host — the precise moment a restore is needed.
-    const m = baseManifest();
-    m.verification.checksum_algorithm = 'hmac-sha256';
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: 'secret-key' });
-
-    delete process.env.BACKUP_MANIFEST_KEY;
-    expect(() => backupManifest.validateManifest(m)).not.toThrow();
-  });
-});
-
-describe('manifest checksum coverage (canonicalization)', () => {
-  const fullManifest = () => ({
-    manifest: { version: '1.0', id: 'test' },
-    backup: { type: 'full' },
-    system: { platform: 'linux' },
-    application: { version: '1.0.0' },
-    files: { count: 1, manifest: [{ path: 'a.jpg', size: 1 }] },
-    database: { type: 'sqlite' },
-    verification: { total_checksum: null, checksum_algorithm: 'sha256' },
-  });
-
-  afterEach(() => { delete process.env.BACKUP_MANIFEST_KEY; });
-
-  it('covers nested file entries (the old replacer dropped them)', () => {
-    const m = fullManifest();
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: false });
-    // Tampering a file path must now change the digest.
-    m.files.manifest[0].path = '../../etc/passwd';
-    expect(() => backupManifest.validateManifest(m)).toThrow(/checksum verification failed/i);
-  });
-
-  it('still accepts a manifest written with the legacy serialization', () => {
-    const m = fullManifest();
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(
-      m, { keyed: false, legacy: true }
-    );
-    expect(() => backupManifest.validateManifest(m)).not.toThrow();
-  });
-});
-
-describe('checksum verification is shared and downgrade-aware (codex round 2)', () => {
-  const fullManifest = () => ({
-    manifest: { version: '1.0', id: 'test' },
-    backup: { type: 'full' },
-    system: { platform: 'linux' },
-    application: { version: '1.0.0' },
-    files: { count: 1, manifest: [{ path: 'a.jpg', size: 1 }] },
-    database: { type: 'sqlite' },
-    verification: { total_checksum: null, checksum_algorithm: 'sha256' },
-  });
-
-  afterEach(() => {
-    delete process.env.BACKUP_MANIFEST_KEY;
-    delete process.env.BACKUP_MANIFEST_REQUIRE_KEYED;
-  });
-
-  it('accepts a legacy-serialized manifest through the SHARED verifier', () => {
-    // restoreService recomputed the digest itself with the canonical
-    // serializer, which rejected every pre-existing backup.
-    const m = fullManifest();
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(
-      m, { keyed: false, legacy: true },
-    );
-    const res = backupManifest.verifyManifestChecksum(m);
-    expect(res.valid).toBe(true);
-    expect(res.warnings.join(' ')).toMatch(/legacy checksum serialization/i);
-  });
-
-  it('warns but accepts an unkeyed manifest when a key is configured', () => {
-    const m = fullManifest();
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: false });
-    process.env.BACKUP_MANIFEST_KEY = 'secret-key';
-
-    const res = backupManifest.verifyManifestChecksum(m);
-    expect(res.valid).toBe(true);
-    expect(res.warnings.join(' ')).toMatch(/authenticity NOT established/i);
-  });
-
-  it('REJECTS the algorithm downgrade once REQUIRE_KEYED is on', () => {
-    // Attacker rewrites the manifest, strips checksum_algorithm and recomputes
-    // a plain SHA-256. With the strict flag set that must not verify.
-    const m = fullManifest();
-    m.files.manifest[0].path = '../../etc/passwd';
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: false });
-
-    process.env.BACKUP_MANIFEST_KEY = 'secret-key';
-    process.env.BACKUP_MANIFEST_REQUIRE_KEYED = 'true';
-
-    const res = backupManifest.verifyManifestChecksum(m);
-    expect(res.valid).toBe(false);
-    expect(res.error).toMatch(/downgrade/i);
-  });
-
-  it('rejects a keyed manifest with no key when REQUIRE_KEYED is on', () => {
-    const m = fullManifest();
-    m.verification.checksum_algorithm = 'hmac-sha256';
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: 'k' });
-    process.env.BACKUP_MANIFEST_REQUIRE_KEYED = 'true';
-
-    expect(backupManifest.verifyManifestChecksum(m).valid).toBe(false);
-  });
-
-  it('REJECTS a manifest whose checksum was stripped entirely', () => {
-    // The cheapest bypass of every rule above: delete the field instead of
-    // forging it. Both the helper's early return and restoreService's
-    // `if (…total_checksum)` guard used to wave that through.
-    const m = fullManifest();
-    delete m.verification.total_checksum;
-
-    const res = backupManifest.verifyManifestChecksum(m);
-    expect(res.valid).toBe(false);
-    expect(res.error).toMatch(/no checksum/i);
-
-    delete m.verification;
-    expect(backupManifest.verifyManifestChecksum(m).valid).toBe(false);
-  });
-
-  it('REJECTS an unkeyed manifest under REQUIRE_KEYED even with no key configured', () => {
-    // Strict mode is a claim about the manifests, not about this host — so a
-    // fresh disaster-recovery box that lost BACKUP_MANIFEST_KEY must not
-    // silently start accepting plain SHA-256 manifests again.
-    const m = fullManifest();
-    m.verification.total_checksum = backupManifest.calculateManifestChecksum(m, { keyed: false });
-    process.env.BACKUP_MANIFEST_REQUIRE_KEYED = 'true';
-    delete process.env.BACKUP_MANIFEST_KEY;
-
-    const res = backupManifest.verifyManifestChecksum(m);
-    expect(res.valid).toBe(false);
-    expect(res.error).toMatch(/downgrade/i);
-  });
-});
@@ -1,159 +0,0 @@
-/**
- * Regression test: business documents must be written under STORAGE_PATH.
- *
- * quoteService.persistDocPdf, the invoice sending/reminder writers and the
- * contract signature writers all built their target from
- * `path.join(process.cwd(), 'storage', 'business-docs', ...)`. Both compose
- * files pin STORAGE_PATH=/app/storage and the image's WORKDIR is /app, so the
- * two expressions name the same directory and the bug was invisible on a stock
- * deployment. Point STORAGE_PATH anywhere else — a NAS mount, a second disk,
- * the single-container image's /data volume — and quotes, invoices, Mahnungen
- * and contract PDFs were written outside the configured storage root, so they
- * were missed by backups and lost when the container was replaced.
- *
- * Rather than assert on internals, this drives the module boundary the fix
- * changed: getStoragePath() is the one resolver, so a temporary STORAGE_PATH
- * must be where the bytes land.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-describe('business documents honour STORAGE_PATH', () => {
-  let tmpRoot;
-  let originalStoragePath;
-
-  beforeEach(() => {
-    originalStoragePath = process.env.STORAGE_PATH;
-    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-storage-'));
-    process.env.STORAGE_PATH = tmpRoot;
-    jest.resetModules();
-  });
-
-  afterEach(() => {
-    if (originalStoragePath === undefined) delete process.env.STORAGE_PATH;
-    else process.env.STORAGE_PATH = originalStoragePath;
-    fs.rmSync(tmpRoot, { recursive: true, force: true });
-  });
-
-  it('getStoragePath is the resolver the writers share', () => {
-    const { getStoragePath } = require('../../src/config/storage');
-    expect(getStoragePath()).toBe(tmpRoot);
-  });
-
-  it('no business-document writer still targets process.cwd()/storage', () => {
-    // Whitespace is collapsed before matching on purpose. The first version of
-    // this test compared against the single-line literal and therefore missed
-    // persistSignatureImage(), whose identical path.join was simply spread over
-    // seven lines — it reported green while signature PNGs still wrote outside
-    // STORAGE_PATH. Formatting must not decide whether a bug is visible.
-    const writers = [
-      'src/services/quoteService.js',
-      'src/services/invoice/sending.js',
-      'src/services/invoice/reminders.js',
-      'src/services/contract/signatureAssets.js',
-      'src/routes/adminDev.js',
-    ];
-    const offenders = writers.filter((rel) => {
-      const source = fs.readFileSync(path.join(__dirname, '../../', rel), 'utf8');
-      return /process\.cwd\(\),'storage'/.test(source.replace(/\s+/g, ''));
-    });
-    expect(offenders).toEqual([]);
-  });
-
-  it('generated contract PDFs pass the containment check that serves them', () => {
-    // assertContractPdfPath guards the admin and public contract download
-    // routes. It listed only <cwd>/storage/business-docs/contract, so once the
-    // writers moved to STORAGE_PATH every freshly generated contract was
-    // refused with PATH_OUTSIDE_STORAGE — a worse failure than the bug being
-    // fixed. Both roots must be accepted.
-    const { assertContractPdfPath } = require('../../src/utils/safePath');
-    const { getStoragePath } = require('../../src/config/storage');
-
-    // assertPathInside realpaths both the file and each root, so the guard only
-    // means anything against a filesystem that actually has them — write them.
-    const write = (...segments) => {
-      const p = path.join(getStoragePath(), 'business-docs', 'contract', ...segments);
-      fs.mkdirSync(path.dirname(p), { recursive: true });
-      fs.writeFileSync(p, 'bytes');
-      return p;
-    };
-
-    const generated = write('2026', 'C-2026-0001.pdf');
-    expect(() => assertContractPdfPath(generated)).not.toThrow();
-
-    // Signature PNGs live under the same root and are served by the same guard.
-    const signature = write('signatures', '7', 'customer-1.png');
-    expect(() => assertContractPdfPath(signature)).not.toThrow();
-
-    // And the guard still refuses a real file outside every allowed root.
-    const foreign = path.join(tmpRoot, 'outside.pdf');
-    fs.writeFileSync(foreign, 'bytes');
-    expect(() => assertContractPdfPath(foreign)).toThrow(/outside the storage roots/i);
-  });
-
-  it('the guard takes its root from the shared resolver, not its own fallback', () => {
-    // The regression this pins: the guard used to compute
-    // `STORAGE_PATH || <cwd>/storage` itself. That agrees with getStoragePath()
-    // only while STORAGE_PATH is set — unset, the shared resolver falls back
-    // module-relative to <repo>/storage while the guard fell back to
-    // <cwd>/storage, and the backend is normally started from backend/. Writers
-    // and guard then disagreed and contract downloads 403'd.
-    //
-    // Mocking the resolver is what makes this provable AND safe. If the guard
-    // consumes getStoragePath(), the mock moves its root; if it rolled its own
-    // expression, the mock would have no effect and the assertion fails. It
-    // also keeps every path inside the tmpdir — an earlier version of this test
-    // deleted `<resolved root>/business-docs` in cleanup, which with
-    // STORAGE_PATH unset resolves to a developer's real, gitignored
-    // <repo>/storage and would have destroyed local documents on `npm test`.
-    jest.resetModules();
-    jest.doMock('../../src/config/storage', () => ({ getStoragePath: () => tmpRoot }));
-
-    const { assertContractPdfPath } = require('../../src/utils/safePath');
-
-    const root = path.join(tmpRoot, 'business-docs', 'contract', '2026');
-    fs.mkdirSync(root, { recursive: true });
-    const generated = path.join(root, 'C-2026-0002.pdf');
-    fs.writeFileSync(generated, 'bytes');
-
-    expect(() => assertContractPdfPath(generated)).not.toThrow();
-
-    jest.dontMock('../../src/config/storage');
-  });
-
-  it('writes land under STORAGE_PATH, not the working directory', () => {
-    const { getStoragePath } = require('../../src/config/storage');
-
-    // Mirror what persistDocPdf does: derive the root, create it, write.
-    const root = path.join(getStoragePath(), 'business-docs', 'quote', '2026');
-    fs.mkdirSync(root, { recursive: true });
-    const filePath = path.join(root, 'Q-2026-0001.pdf');
-    fs.writeFileSync(filePath, 'pdf-bytes');
-
-    expect(fs.existsSync(filePath)).toBe(true);
-    expect(filePath.startsWith(tmpRoot)).toBe(true);
-    // And crucially NOT beside the process working directory.
-    expect(filePath.startsWith(path.join(process.cwd(), 'storage'))).toBe(false);
-  });
-
-  it('the PDF font lookup consults the storage root before the legacy path', () => {
-    // A custom font under STORAGE_PATH/fonts used to be unreachable, so the
-    // document silently rendered with the built-in face instead.
-    const fontDir = path.join(tmpRoot, 'fonts');
-    fs.mkdirSync(fontDir, { recursive: true });
-    const fontPath = path.join(fontDir, 'Brand.ttf');
-    fs.writeFileSync(fontPath, 'ttf');
-
-    const { getStoragePath } = require('../../src/config/storage');
-    const raw = 'Brand.ttf';
-    const candidates = [
-      path.join(getStoragePath(), raw.replace(/^\/+/, '')),
-      path.join(getStoragePath(), 'fonts', path.basename(raw)),
-      path.join(process.cwd(), 'storage', 'fonts', path.basename(raw)),
-    ];
-    const found = candidates.find((p) => fs.existsSync(p));
-    expect(found).toBe(fontPath);
-  });
-});
@@ -1,127 +0,0 @@
-/**
- * Inbound-mail resource caps (GHSA-2qf9).
- *
- * emailIntakeService downloaded, parsed and persisted every message with no
- * size, attachment-count or attachment-byte limit. Anyone who can email the
- * operator's mailbox reaches this path unauthenticated.
- *
- * The teeth were in the dedup key: on failure the service wrote an error row
- * keyed `err-<uid>-<Date.now()>`, which can never match the envelope-derived
- * `messageId` the dedup pass compares against. So the same oversized message
- * was re-downloaded every poll interval forever — and an OOM-kill/restart just
- * resumed the loop. This pins that an over-limit message is (a) never
- * downloaded and (b) recorded under its REAL message id so it dedups.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-intake-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'intake-test-secret';
-process.env.EMAIL_INTAKE_MAX_MESSAGE_BYTES = '1000';
-
-const OVERSIZED_UID = 11;
-const NORMAL_UID = 12;
-const OVERSIZED_MSGID = '<huge@example.com>';
-
-const fetchOneCalls = [];
-
-jest.mock('imapflow', () => ({
-  ImapFlow: class {
-    async connect() {}
-    async logout() {}
-    async getMailboxLock() { return { release() {} }; }
-    async search() { return [OVERSIZED_UID, NORMAL_UID]; }
-    // Envelope pass now also returns `size`.
-    async *fetch() {
-      yield { uid: OVERSIZED_UID, size: 50_000, envelope: { messageId: OVERSIZED_MSGID } };
-      yield { uid: NORMAL_UID, size: 500, envelope: { messageId: '<ok@example.com>' } };
-    }
-    async fetchOne(uid) {
-      fetchOneCalls.push(String(uid));
-      return { source: Buffer.from('Subject: ok\r\n\r\nbody') };
-    }
-    async messageFlagsAdd() { return true; }
-  },
-}));
-
-jest.mock('mailparser', () => ({
-  simpleParser: async () => ({
-    messageId: '<ok@example.com>',
-    subject: 'ok',
-    date: new Date(),
-    attachments: [],
-    text: 'body',
-    html: null,
-  }),
-}));
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('email intake caps (GHSA-2qf9)', () => {
-  let db; let cleanup; let intake;
-
-  let pollResult;
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-
-    // pollOnce short-circuits unless the feature flag is on AND an IMAP
-    // account is configured — without both, this suite would pass vacuously.
-    await db('feature_flags')
-      .insert({ key: 'incomingMail', value: 1 })
-      .onConflict('key').merge({ value: 1 });
-    // getImapConfig() reads email_configs.first() — seedMinimal may already
-    // have inserted a row, so update that one rather than adding a second
-    // (the first row would win and report "unconfigured").
-    const imapFields = {
-      imap_host: 'imap.example.com',
-      imap_user: 'intake@example.com',
-      imap_pass: 'x',
-      imap_folder: 'INBOX',
-    };
-    const existingCfg = await db('email_configs').first();
-    if (existingCfg) {
-      await db('email_configs').where({ id: existingCfg.id }).update(imapFields);
-    } else {
-      await db('email_configs').insert({
-        smtp_host: 'smtp.example.com',
-        smtp_port: 587,
-        from_email: 'intake@example.com',
-        ...imapFields,
-      });
-    }
-
-    intake = require('../../src/services/emailIntakeService');
-    pollResult = await intake.pollOnce().catch((e) => ({ thrown: e.message }));
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it('actually ran the poll (guards against a vacuous suite)', () => {
-    expect(pollResult).toBeDefined();
-    expect(pollResult.skipped).toBeUndefined();
-  });
-
-  it('never downloads a message whose envelope size exceeds the cap', () => {
-    // The oversized uid must never reach fetchOne (the source download) —
-    // that download is the DoS. The normal one must still be processed.
-    expect(fetchOneCalls).not.toContain(String(OVERSIZED_UID));
-    expect(fetchOneCalls).toContain(String(NORMAL_UID));
-  });
-
-  it('records the skip under the REAL message id so it dedups next poll', async () => {
-    const row = await db('received_emails').where({ message_id: OVERSIZED_MSGID }).first();
-    expect(row).toBeTruthy();
-    expect(row.status).toBe('error');
-    expect(String(row.error)).toMatch(/too large/i);
-    // The whole point: keyed by messageId, NOT err-<uid>-<timestamp>, which
-    // could never match the dedup pass and so looped forever.
-    expect(row.message_id).not.toMatch(/^err-/);
-  });
-});
@@ -1,218 +0,0 @@
-/**
- * Regression tests for #1078 — ensurePreviewImage must generate previews for
- * external/reference photos, not silently fall back to the full-size original.
- *
- * resolvePhotoStorageKey returns null for external photos by design, and that
- * null used to be handed straight to withLocalCopy, which throws. The lightbox
- * preview route caught the throw and redirected to the original, so a gallery
- * whose photos all live on an external mount paid full size on every open —
- * the exact cost the preview tier (#492) exists to avoid.
- */
-const path = require('path');
-const fs = require('fs').promises;
-const os = require('os');
-const sharp = require('sharp');
-
-// Must be set before externalMediaService is first required: it caches the
-// resolved root on first call, and the dir has to exist to win over the
-// container default.
-const EXTERNAL_ROOT = path.join(os.tmpdir(), `picpeak-ext-media-${process.pid}`);
-process.env.EXTERNAL_MEDIA_ROOT = EXTERNAL_ROOT;
-
-jest.mock('../../src/database/db', () => {
-  const state = { event: null, updates: [] };
-  const api = (table) => {
-    if (table === 'events') {
-      return { where: () => ({ first: async () => state.event }) };
-    }
-    if (table === 'photos') {
-      return {
-        where: (criteria) => ({
-          update: async (values) => {
-            state.updates.push({ criteria, values });
-            return 1;
-          },
-        }),
-      };
-    }
-    throw new Error(`unexpected table in test: ${table}`);
-  };
-  api.__state = state;
-  return { db: api };
-});
-
-const LocalFsStorage = require('../../src/services/storage/LocalFsStorage');
-const storageModule = require('../../src/services/storage');
-const { db } = require('../../src/database/db');
-
-const EVENT = {
-  id: 7,
-  slug: 'nas-wedding',
-  source_mode: 'reference',
-  external_path: 'weddings/2026-08-smith',
-};
-
-async function writeSourceJpeg(absPath, { width = 2400, height = 1600 } = {}) {
-  await fs.mkdir(path.dirname(absPath), { recursive: true });
-  const buf = Buffer.alloc(width * height * 3);
-  for (let i = 0; i < buf.length; i++) buf[i] = (i * 7) % 256;
-  await sharp(buf, { raw: { width, height, channels: 3 } }).jpeg({ quality: 90 }).toFile(absPath);
-}
-
-describe('ensurePreviewImage — external/reference sources (#1078)', () => {
-  let storage;
-  let storageRoot;
-  let imageProcessor;
-
-  beforeAll(async () => {
-    storageRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'picpeak-preview-store-'));
-    storage = new LocalFsStorage({ root: storageRoot });
-    await storage.init();
-    storageModule.setStorageForTesting(storage);
-
-    // Require AFTER the storage injection so the module sees it.
-    delete require.cache[require.resolve('../../src/services/imageProcessor')];
-    imageProcessor = require('../../src/services/imageProcessor');
-
-    await fs.mkdir(path.join(EXTERNAL_ROOT, EVENT.external_path), { recursive: true });
-  }, 30000);
-
-  afterAll(async () => {
-    storageModule.resetStorage();
-    await fs.rm(storageRoot, { recursive: true, force: true }).catch(() => {});
-    await fs.rm(EXTERNAL_ROOT, { recursive: true, force: true }).catch(() => {});
-  });
-
-  beforeEach(() => {
-    db.__state.event = EVENT;
-    db.__state.updates = [];
-  });
-
-  it.each(['external', 'reference'])(
-    'generates a downscaled preview for a %s photo off the media mount',
-    async (sourceOrigin) => {
-      const relpath = `${sourceOrigin}-shot.jpg`;
-      await writeSourceJpeg(path.join(EXTERNAL_ROOT, EVENT.external_path, relpath));
-
-      const photo = {
-        id: sourceOrigin === 'external' ? 101 : 102,
-        event_id: EVENT.id,
-        source_origin: sourceOrigin,
-        external_relpath: relpath,
-        filename: relpath,
-        preview_path: null,
-      };
-
-      const key = await imageProcessor.ensurePreviewImage(photo);
-
-      // Per-photo basename so two events referencing the same NAS filename
-      // can't clobber each other's preview.
-      expect(key).toBe(`previews/preview_ext${photo.id}_${relpath}`);
-      expect(await storage.exists(key)).toBe(true);
-
-      const meta = await sharp(storage.resolveLocalPath(key)).metadata();
-      expect(meta.format).toBe('jpeg');
-      // 2400x1600 capped at the 1920 long edge, aspect preserved.
-      expect(meta.width).toBe(1920);
-      expect(meta.height).toBe(1280);
-
-      // The generated key is persisted so the next open short-circuits.
-      expect(db.__state.updates).toEqual([
-        { criteria: { id: photo.id }, values: { preview_path: key } },
-      ]);
-    }
-  );
-
-  it('short-circuits on an existing valid preview instead of regenerating', async () => {
-    const relpath = 'already-previewed.jpg';
-    await writeSourceJpeg(path.join(EXTERNAL_ROOT, EVENT.external_path, relpath));
-    const photo = {
-      id: 103,
-      event_id: EVENT.id,
-      source_origin: 'external',
-      external_relpath: relpath,
-      filename: relpath,
-      preview_path: null,
-    };
-
-    const first = await imageProcessor.ensurePreviewImage(photo);
-    db.__state.updates = [];
-
-    const second = await imageProcessor.ensurePreviewImage({ ...photo, preview_path: first });
-    expect(second).toBe(first);
-    expect(db.__state.updates).toEqual([]);
-  });
-
-  it('returns null (never throws) when the external source is missing', async () => {
-    const photo = {
-      id: 104,
-      event_id: EVENT.id,
-      source_origin: 'external',
-      external_relpath: 'not-on-the-mount.jpg',
-      filename: 'not-on-the-mount.jpg',
-      preview_path: null,
-    };
-
-    await expect(imageProcessor.ensurePreviewImage(photo)).resolves.toBeNull();
-    expect(db.__state.updates).toEqual([]);
-  });
-
-  it('returns null (never throws) for a row with no source_origin in a reference event', async () => {
-    // Mode falls back to event.source_mode = 'reference', so
-    // resolvePhotoStorageKey yields null. That used to reach withLocalCopy and
-    // throw out of ensurePreviewImage instead of honouring null-on-failure.
-    const photo = {
-      id: 105,
-      event_id: EVENT.id,
-      source_origin: null,
-      external_relpath: null,
-      filename: 'orphan.jpg',
-      path: 'nas-wedding/individual/orphan.jpg',
-      preview_path: null,
-    };
-
-    await expect(imageProcessor.ensurePreviewImage(photo)).resolves.toBeNull();
-    expect(db.__state.updates).toEqual([]);
-  });
-
-  it('branches on source_origin, so a row selected without it looks managed', async () => {
-    // Pins why the /regenerate-previews caller must select source_origin:
-    // an external row missing that column takes the managed path, where
-    // resolvePhotoStorageKey yields null and generation is skipped.
-    const relpath = 'column-starved.jpg';
-    await writeSourceJpeg(path.join(EXTERNAL_ROOT, EVENT.external_path, relpath));
-    const starved = {
-      id: 106,
-      event_id: EVENT.id,
-      external_relpath: relpath,
-      preview_path: null,
-    };
-
-    await expect(imageProcessor.ensurePreviewImage(starved)).resolves.toBeNull();
-    await expect(
-      imageProcessor.ensurePreviewImage({ ...starved, source_origin: 'external', filename: relpath })
-    ).resolves.toBe(`previews/preview_ext106_${relpath}`);
-  });
-
-  it('still routes managed photos through the storage backend', async () => {
-    const sourceKey = 'events/active/managed-event/individual/managed.jpg';
-    const localSource = path.join(os.tmpdir(), `picpeak-managed-${process.pid}.jpg`);
-    await writeSourceJpeg(localSource, { width: 800, height: 600 });
-    await storage.put(sourceKey, await fs.readFile(localSource), { contentType: 'image/jpeg' });
-    await fs.rm(localSource, { force: true });
-
-    db.__state.event = { id: 8, slug: 'managed-event', source_mode: 'managed' };
-    const photo = {
-      id: 201,
-      event_id: 8,
-      source_origin: 'managed',
-      path: 'managed-event/individual/managed.jpg',
-      filename: 'managed.jpg',
-      preview_path: null,
-    };
-
-    const key = await imageProcessor.ensurePreviewImage(photo);
-    expect(key).toBe('previews/preview_managed.jpg');
-    expect(await storage.exists(key)).toBe(true);
-  });
-});
@@ -0,0 +1,125 @@
+/**
+ * Regression tests for the file-watcher concurrency bound.
+ *
+ * chokidar fires 'add' once per file — with no ignoreInitial option the boot
+ * scan fires it for every existing file, and a bulk drop fires it for every
+ * new one at once. Unbounded handlers each run DB lookups plus a full sharp
+ * pipeline (sharp.concurrency(2) only caps libvips threads WITHIN one
+ * operation), which can OOM small hosts. Both 'add' and 'unlink' must go
+ * through the shared p-limit gate.
+ *
+ * Adapted from the filpgame fork (426ca491), extended to cover 'unlink'.
+ */
+
+const mockLimit = jest.fn((operation) => Promise.resolve().then(operation));
+const mockPLimit = jest.fn(() => mockLimit);
+const mockHandlers = {};
+const mockWatcher = {
+  on: jest.fn((event, handler) => {
+    mockHandlers[event] = handler;
+    return mockWatcher;
+  }),
+};
+
+// Shared instances captured by the mock factories: jest.isolateModules re-runs
+// each factory in a fresh registry, so the factories must return these same
+// objects for the test to observe calls made inside the isolated module.
+const mockLogger = { error: jest.fn(), warn: jest.fn(), info: jest.fn(), debug: jest.fn() };
+// Chainable no-row query — enough for removePhoto's lookup/delete calls.
+const mockDb = jest.fn(() => ({
+  where: jest.fn().mockReturnThis(),
+  first: jest.fn().mockResolvedValue(null),
+  delete: jest.fn().mockResolvedValue(0),
+}));
+
+jest.mock('p-limit', () => mockPLimit);
+jest.mock('chokidar', () => ({
+  watch: jest.fn(() => mockWatcher),
+}));
+jest.mock('../../src/database/db', () => ({ db: mockDb }));
+jest.mock('../../src/utils/logger', () => mockLogger);
+jest.mock('../../src/services/imageProcessor', () => ({
+  generateThumbnail: jest.fn(),
+  generateVideoPlaceholder: jest.fn(),
+}));
+jest.mock('../../src/services/videoProcessor', () => ({
+  isVideoMimeType: jest.fn(() => false),
+}));
+jest.mock('../../src/services/downloadZipService', () => ({ invalidate: jest.fn() }));
+jest.mock('../../src/utils/dbCompat', () => ({
+  formatBoolean: jest.fn((value) => value),
+}));
+
+const loadFileWatcher = () => {
+  let fileWatcher;
+  jest.isolateModules(() => {
+    fileWatcher = require('../../src/services/fileWatcher');
+  });
+  return fileWatcher;
+};
+
+describe('fileWatcher concurrency bound', () => {
+  const originalBackend = process.env.STORAGE_BACKEND;
+  const originalConcurrency = process.env.FILE_WATCHER_CONCURRENCY;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    Object.keys(mockHandlers).forEach((key) => delete mockHandlers[key]);
+    process.env.STORAGE_BACKEND = 'local';
+    delete process.env.FILE_WATCHER_CONCURRENCY;
+  });
+
+  afterAll(() => {
+    if (originalBackend === undefined) delete process.env.STORAGE_BACKEND;
+    else process.env.STORAGE_BACKEND = originalBackend;
+    if (originalConcurrency === undefined) delete process.env.FILE_WATCHER_CONCURRENCY;
+    else process.env.FILE_WATCHER_CONCURRENCY = originalConcurrency;
+  });
+
+  it.each([
+    [undefined, 2],   // default
+    ['3', 3],         // explicit
+    ['0', 1],         // floored to 1
+    ['-4', 1],        // floored to 1
+    ['invalid', 2],   // falls back to default
+  ])('configures the limiter with FILE_WATCHER_CONCURRENCY=%s as %i', (configured, expected) => {
+    if (configured === undefined) delete process.env.FILE_WATCHER_CONCURRENCY;
+    else process.env.FILE_WATCHER_CONCURRENCY = configured;
+
+    loadFileWatcher().startFileWatcher();
+
+    expect(mockPLimit).toHaveBeenCalledWith(expected);
+  });
+
+  it('routes add events through the shared limiter', async () => {
+    loadFileWatcher().startFileWatcher();
+
+    expect(mockHandlers.add).toEqual(expect.any(Function));
+    mockHandlers.add('/outside-watch-root'); // early-returns inside processNewPhoto
+
+    expect(mockLimit).toHaveBeenCalledTimes(1);
+    expect(mockLimit).toHaveBeenCalledWith(expect.any(Function));
+    await mockLimit.mock.results[0].value;
+  });
+
+  it('routes unlink events through the same limiter', async () => {
+    loadFileWatcher().startFileWatcher();
+
+    expect(mockHandlers.unlink).toEqual(expect.any(Function));
+    mockHandlers.unlink('/outside-watch-root'); // early-returns inside removePhoto
+
+    expect(mockLimit).toHaveBeenCalledTimes(1);
+    await mockLimit.mock.results[0].value;
+  });
+
+  it('logs instead of rejecting when a queued handler throws', async () => {
+    loadFileWatcher().startFileWatcher();
+
+    const failure = new Error('boom');
+    mockLimit.mockImplementationOnce(() => Promise.reject(failure));
+    mockHandlers.add('/whatever');
+
+    await new Promise(process.nextTick);
+    expect(mockLogger.error).toHaveBeenCalledWith('Error processing new photo:', failure);
+  });
+});
@@ -1,90 +0,0 @@
-/**
- * Regeneration must not destroy a good thumbnail when the source is
- * unreadable (#1129).
- *
- * The old code deleted the target BEFORE sharp opened the source, so a NAS
- * mount that blipped mid-run left the previous rendition gone and the database
- * still pointing at it. Across a bulk regenerate that is the whole gallery,
- * and it is precisely the "worse than before you pressed it" outcome #1129 is
- * about.
- */
-
-const path = require('path');
-const fs = require('fs').promises;
-const os = require('os');
-const sharp = require('sharp');
-
-jest.mock('../../src/database/db', () => ({
-  db: () => ({ where: () => ({ first: async () => null, update: async () => 1 }) }),
-}));
-
-const LocalFsStorage = require('../../src/services/storage/LocalFsStorage');
-const storageModule = require('../../src/services/storage');
-
-describe('generateThumbnail — regenerate is non-destructive (#1129)', () => {
-  let storage; let root; let imageProcessor; let srcDir;
-
-  beforeAll(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'picpeak-regen-store-'));
-    srcDir = await fs.mkdtemp(path.join(os.tmpdir(), 'picpeak-regen-src-'));
-    storage = new LocalFsStorage({ root });
-    await storage.init();
-    storageModule.setStorageForTesting(storage);
-
-    delete require.cache[require.resolve('../../src/services/imageProcessor')];
-    imageProcessor = require('../../src/services/imageProcessor');
-  }, 30000);
-
-  afterAll(async () => {
-    storageModule.resetStorage();
-    await fs.rm(root, { recursive: true, force: true }).catch(() => {});
-    await fs.rm(srcDir, { recursive: true, force: true }).catch(() => {});
-  });
-
-  async function writeSource(name, size = 400) {
-    const p = path.join(srcDir, name);
-    await sharp({ create: { width: size, height: size, channels: 3, background: { r: 1, g: 2, b: 3 } } })
-      .jpeg().toFile(p);
-    return p;
-  }
-
-  it('keeps the existing thumbnail when the source cannot be read', async () => {
-    const src = await writeSource('present.jpg');
-    const key = await imageProcessor.generateThumbnail(src, { regenerate: true });
-    expect(key).toBeTruthy();
-    expect(await storage.exists(key)).toBe(true);
-    const before = await storage.get(key).then((s) => new Promise((res) => {
-      const c = []; s.on('data', (d) => c.push(d)); s.on('end', () => res(Buffer.concat(c)));
-    }));
-
-    // The mount goes away between runs.
-    await fs.unlink(src);
-    const second = await imageProcessor.generateThumbnail(src, { regenerate: true })
-      .catch(() => null);
-
-    expect(second).toBeFalsy();
-    // The old rendition is still there and still serves. Previously it had
-    // been deleted before sharp ever looked at the source.
-    expect(await storage.exists(key)).toBe(true);
-    const after = await storage.get(key).then((s) => new Promise((res) => {
-      const c = []; s.on('data', (d) => c.push(d)); s.on('end', () => res(Buffer.concat(c)));
-    }));
-    expect(after.equals(before)).toBe(true);
-  });
-
-  it('still replaces the thumbnail when the source IS readable', async () => {
-    const src = await writeSource('replaceme.jpg', 400);
-    const key = await imageProcessor.generateThumbnail(src, { regenerate: true });
-    const firstSize = (await storage.stat(key)).size;
-
-    // Same key, different source content — the atomic rename in put() is what
-    // makes the pre-delete unnecessary.
-    await fs.rm(src);
-    await sharp({ create: { width: 400, height: 400, channels: 3, background: { r: 250, g: 40, b: 9 } } })
-      .jpeg().toFile(src);
-    const again = await imageProcessor.generateThumbnail(src, { regenerate: true });
-
-    expect(again).toBe(key);
-    expect((await storage.stat(key)).size).not.toBe(firstSize);
-  });
-});
@@ -0,0 +1,30 @@
+/**
+ * Locks the process-wide Sharp memory guards. The file-watcher concurrency
+ * bound (FILE_WATCHER_CONCURRENCY) assumes these caps stay in place — they
+ * limit libvips threads/cache WITHIN one operation while p-limit bounds the
+ * number of parallel pipelines. From the filpgame fork (426ca491).
+ */
+
+const mockSharp = jest.fn();
+mockSharp.cache = jest.fn();
+mockSharp.concurrency = jest.fn();
+
+jest.mock('sharp', () => mockSharp);
+
+jest.mock('../../src/utils/logger', () => ({
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+}));
+
+describe('imageProcessor Sharp configuration', () => {
+  it('disables the Sharp cache and caps libvips concurrency', () => {
+    jest.isolateModules(() => {
+      require('../../src/services/imageProcessor');
+    });
+
+    expect(mockSharp.cache).toHaveBeenCalledWith(false);
+    expect(mockSharp.concurrency).toHaveBeenCalledWith(2);
+  });
+});
@@ -0,0 +1,50 @@
+/**
+ * Unit tests for the RAW/DNG handling helpers (#821). The actual exiftool
+ * extraction can only be exercised in the built image (exiftool isn't a dev
+ * dependency), so these cover the gating logic: which files are treated as RAW,
+ * and that ordinary images pass through untouched (zero cost / no extraction).
+ */
+const path = require('path');
+const { isRawFilename, withProcessableImage, RAW_EXTENSIONS } = require('../../src/services/imageProcessor');
+
+describe('isRawFilename', () => {
+  it('recognises common RAW / DNG extensions', () => {
+    for (const ext of ['dng', 'cr2', 'cr3', 'nef', 'arw', 'raf', 'rw2', 'orf']) {
+      expect(isRawFilename(`IMG_1234.${ext}`)).toBe(true);
+      expect(isRawFilename(`IMG_1234.${ext.toUpperCase()}`)).toBe(true); // case-insensitive
+    }
+  });
+
+  it('does not treat ordinary images/videos as RAW', () => {
+    for (const name of ['photo.jpg', 'photo.jpeg', 'photo.png', 'photo.webp', 'clip.mp4', 'clip.mov', 'photo.heic']) {
+      expect(isRawFilename(name)).toBe(false);
+    }
+  });
+
+  it('is null/empty safe', () => {
+    expect(isRawFilename(null)).toBe(false);
+    expect(isRawFilename('')).toBe(false);
+    expect(isRawFilename('noextension')).toBe(false);
+  });
+
+  it('RAW_EXTENSIONS includes dng (Apple ProRAW)', () => {
+    expect(RAW_EXTENSIONS.has('dng')).toBe(true);
+  });
+});
+
+describe('withProcessableImage', () => {
+  it('passes ordinary images through with no extraction and a no-op cleanup', async () => {
+    const localPath = '/tmp/whatever/photo.jpg';
+    const proc = await withProcessableImage(localPath, 'photo.jpg');
+    expect(proc.path).toBe(localPath);          // unchanged — sharp reads it directly
+    expect(proc.outputBasename).toBeUndefined(); // generators keep their default naming
+    await expect(Promise.resolve(proc.cleanup())).resolves.toBeUndefined();
+  });
+
+  it('routes RAW files to extraction (which fails cleanly without exiftool/preview)', async () => {
+    // In the dev sandbox exiftool isn't installed, so extraction throws — the
+    // caller turns that into a normal processing failure. In the built image
+    // (exiftool present) this instead returns the embedded JPEG preview.
+    await expect(withProcessableImage('/tmp/whatever/IMG_1234.dng', 'IMG_1234.dng')).rejects.toThrow();
+  });
+});
@@ -0,0 +1,155 @@
+/**
+ * Regression tests for logActivity calls inside transactions (#850 review
+ * find). createContract / updateContract / createStorno / reissueInvoice
+ * called logActivity() (and contract paths also adminActor()) from inside
+ * a knex transaction WITHOUT the trx executor. On single-connection SQLite
+ * the audit insert then waits on a second pool connection while the trx
+ * holds the only one — a 60s acquire-timeout stall per call, after which
+ * logActivity's catch swallows the failure and the audit row is silently
+ * lost. Postgres was unaffected.
+ *
+ * The observable fix: the activity_logs rows now exist, and the calls
+ * complete without waiting on the pool. The shrunken acquire timeout
+ * below makes any reintroduced deadlock fail the test quickly instead
+ * of appearing to pass after a long stall.
+ */
+const path = require('path');
+const {
+  bootCrmDb, seedMinimal, assignAdminRole,
+} = require('../integration/helpers/crmDb');
+
+jest.setTimeout(120000);
+
+let db;
+let cleanup;
+let tmpDir;
+let adminId;
+let customerId;
+let contractService;
+let invoiceService;
+
+const prevCwd = process.cwd();
+
+beforeAll(async () => {
+  ({ db, cleanup, tmpDir } = await bootCrmDb());
+  // Business-doc artifacts land under process.cwd()/storage — isolate.
+  process.chdir(tmpDir);
+
+  // A reintroduced in-trx pool grab should fail fast (2s), not stall 60s.
+  db.client.pool.acquireTimeoutMillis = 2000;
+
+  // node-sqlite3 detects Date bindings via the NATIVE realm's Date —
+  // under jest's vm sandbox that check fails and Dates stringify to
+  // "[object Object]". Normalize to ISO strings on the client prototype
+  // (transaction clients are Object.create()d from it). Same shim as
+  // crmMintPaths.test.js.
+  const clientProto = Object.getPrototypeOf(db.client);
+  const origQuery = clientProto._query;
+  clientProto._query = function patchedQuery(connection, obj) {
+    if (obj && Array.isArray(obj.bindings)) {
+      obj.bindings = obj.bindings.map(
+        (b) => (b && typeof b === 'object' && typeof b.toISOString === 'function' ? b.toISOString() : b),
+      );
+    }
+    return origQuery.call(this, connection, obj);
+  };
+
+  ({ adminId, customerId } = await seedMinimal(db));
+  await assignAdminRole(db, adminId, 'super_admin');
+
+  contractService = require('../../src/services/contractService');
+  invoiceService = require('../../src/services/invoiceService');
+}, 120000);
+
+afterAll(async () => {
+  process.chdir(prevCwd);
+  if (cleanup) await cleanup();
+});
+
+test('createContract persists the contract_created audit row (was silently lost on SQLite)', async () => {
+  const contractId = await contractService.createContract({
+    customerAccountId: customerId,
+    title: 'Audit-Trail-Vertrag',
+  }, adminId);
+
+  const row = await db('activity_logs')
+    .where({ activity_type: 'contract_created' })
+    .orderBy('id', 'desc')
+    .first();
+  expect(row).toBeTruthy();
+  expect(JSON.parse(row.metadata).contractId).toBe(contractId);
+  expect(row.actor_type).toBe('admin');
+});
+
+test('updateContract persists the contract_updated audit row', async () => {
+  const contractId = await contractService.createContract({
+    customerAccountId: customerId,
+    title: 'Vorher',
+  }, adminId);
+
+  await contractService.updateContract(contractId, { title: 'Nachher' }, adminId);
+
+  const row = await db('activity_logs')
+    .where({ activity_type: 'contract_updated' })
+    .orderBy('id', 'desc')
+    .first();
+  expect(row).toBeTruthy();
+  expect(JSON.parse(row.metadata).contractId).toBe(contractId);
+});
+
+test('cancelInvoice (Storno mint) persists the invoice_cancelled_via_storno audit row', async () => {
+  const { invoiceIds } = await invoiceService.createInvoice({
+    customerAccountId: customerId,
+    currency: 'CHF',
+    vatRate: 0,
+    lineItems: [
+      { position: 1, quantity: 1, description: 'Coverage', unit_price_minor: 100000, discount_percent: 0 },
+    ],
+  }, adminId);
+  const id = invoiceIds[0];
+  await db('invoices').where({ id }).update({ status: 'sent', sent_at: new Date(), updated_at: new Date() });
+
+  const result = await invoiceService.cancelInvoice(id, adminId);
+  expect(result.cancelled).toBe(true);
+
+  const row = await db('activity_logs')
+    .where({ activity_type: 'invoice_cancelled_via_storno' })
+    .orderBy('id', 'desc')
+    .first();
+  expect(row).toBeTruthy();
+  const meta = JSON.parse(row.metadata);
+  expect(meta.invoiceId).toBe(id);
+  expect(meta.stornoId).toBe(result.stornoId);
+});
+
+test('reissueInvoice completes on SQLite and persists the invoice_reissued audit row', async () => {
+  const { invoiceIds } = await invoiceService.createInvoice({
+    customerAccountId: customerId,
+    currency: 'CHF',
+    vatRate: 0,
+    lineItems: [
+      { position: 1, quantity: 1, description: 'Album', unit_price_minor: 50000, discount_percent: 0 },
+    ],
+  }, adminId);
+  const id = invoiceIds[0];
+  await db('invoices').where({ id }).update({ status: 'sent', sent_at: new Date(), updated_at: new Date() });
+
+  // Pre-fix this stalled inside the wrapping transaction (createInvoice's
+  // global-connection reads vs. the single-connection pool) and aborted
+  // before the replacement existed — with the Storno already committed.
+  const result = await invoiceService.reissueInvoice(id, adminId);
+  expect(result.id).toBeGreaterThan(0);
+  expect(result.replaces).toBe(id);
+
+  const replacement = await db('invoices').where({ id: result.id }).first();
+  expect(replacement.replaces_invoice_id).toBe(id);
+
+  const row = await db('activity_logs')
+    .where({ activity_type: 'invoice_reissued' })
+    .orderBy('id', 'desc')
+    .first();
+  expect(row).toBeTruthy();
+  expect(JSON.parse(row.metadata).newInvoiceId).toBe(result.id);
+});
+
+void path; // referenced for parity with sibling suites
@@ -234,3 +234,66 @@ describe('renderInvoiceToBuffer — Storno branch', () => {
    expect(stornoBuf.length).toBeLessThan(invoiceBuf.length);
  });
 });
+
+// VAT free-text note (#794) + multi-page page-number placement. Same
+// constraint as the Storno tests: PDFKit Flate-compresses content streams,
+// so we can't grep the note text — but the page-TREE objects are NOT
+// compressed, so `/Type /Page` (not `/Pages`) is countable to assert
+// pagination, and a byte-size delta proves the note actually rendered.
+describe('renderInvoiceToBuffer — VAT note + multi-page footer (#794)', () => {
+  function baseCtx(overrides = {}) {
+    return {
+      locale: 'de', currency: 'CHF',
+      issuer: { companyName: 'AcmeCo' },
+      recipient: {
+        companyName: 'KundenCo', addressLine1: 'Strasse 1',
+        city: 'Bern', postalCode: '3000',
+      },
+      lineItems: [{
+        quantity: 1, description: 'Photo session',
+        unitPriceMinor: 30000, lineTotalMinor: 30000,
+        parentLineItemId: null, parentPosition: null,
+      }],
+      totals: {
+        netAmountMinor: 30000, vatRate: 0, vatAmountMinor: 0,
+        shippingAmountMinor: 0, totalAmountMinor: 30000,
+      },
+      doc: { invoiceNumber: 'R-2026-0042', issueDate: '2026-04-12' },
+      qrFormat: 'none',
+      paymentTerm: { netDays: 30 },
+      ...overrides,
+    };
+  }
+  const pageCount = (buf) => (buf.toString('latin1').match(/\/Type\s*\/Page(?![s])/g) || []).length;
+  const VAT_NOTE = 'Gemäß § 6 Abs. 1 Z 27 UStG 1994 wird keine Umsatzsteuer berechnet (Kleinunternehmer).';
+
+  it('renders the VAT note on a single-page invoice (adds content, valid PDF)', async () => {
+    const withNote = await pdfService.renderInvoiceToBuffer(baseCtx({ vatNote: VAT_NOTE }));
+    const without = await pdfService.renderInvoiceToBuffer(baseCtx());
+    expect(withNote.slice(0, 4).toString('ascii')).toBe('%PDF');
+    expect(pageCount(withNote)).toBe(1);
+    expect(withNote.length).toBeGreaterThan(without.length);
+  });
+
+  it('paginates a long invoice (with the note) across multiple pages without a stray blank page', async () => {
+    const manyItems = Array.from({ length: 60 }, (_, i) => ({
+      quantity: 1, description: `Position ${i + 1} — fotografische Leistung`,
+      unitPriceMinor: 3225, lineTotalMinor: 3225,
+      parentLineItemId: null, parentPosition: null,
+    }));
+    const buf = await pdfService.renderInvoiceToBuffer(baseCtx({
+      lineItems: manyItems,
+      totals: {
+        netAmountMinor: 193500, vatRate: 0, vatAmountMinor: 0,
+        shippingAmountMinor: 0, totalAmountMinor: 193500,
+      },
+      vatNote: VAT_NOTE,
+    }));
+    expect(buf.slice(0, 4).toString('ascii')).toBe('%PDF');
+    const pages = pageCount(buf);
+    expect(pages).toBeGreaterThanOrEqual(2);
+    // 60 short rows fit in 2–3 pages; a stray blank page (the old margin
+    // bug) or a runaway loop would blow past this.
+    expect(pages).toBeLessThanOrEqual(3);
+  });
+});
@@ -71,15 +71,24 @@ jest.mock('../../src/services/imageProcessor', () => {
  const mockExtractCaptureDate = jest.fn();
  return {
    generateThumbnail: mockGenerateThumbnail,
+    generateVideoPlaceholder: jest.fn(async (filename) => `thumbnails/thumb_${filename.replace(/\.[^.]+$/, '')}.jpg`),
    extractCaptureDate: mockExtractCaptureDate,
    withLocalCopy: jest.fn(async (key, fn) =>
      fn(`/tmp/local-copy-${require('path').basename(key)}`)
    ),
+    // Pass-through for ordinary (non-RAW) images: returns the path unchanged
+    // with a no-op cleanup, matching the real helper's behaviour for jpg/png.
+    withProcessableImage: jest.fn(async (localPath) => ({
+      path: localPath,
+      outputBasename: undefined,
+      cleanup: () => {},
+    })),
  };
 });

 jest.mock('../../src/services/videoProcessor', () => ({
  processUploadedVideo: jest.fn(),
+  extractVideoMetadata: jest.fn(),
  isVideoMimeType: (mime) => typeof mime === 'string' && mime.startsWith('video/'),
 }));

@@ -205,6 +214,44 @@ describe('photoProcessor.processPhoto', () => {
    expect(watermarkService.generateForPhoto).not.toHaveBeenCalled();
  });

+  it('keeps a video complete with a placeholder thumbnail when ffmpeg fails', async () => {
+    dbModule.__setPhoto({
+      id: 203,
+      event_id: 9,
+      filename: 'drone-clip.mp4',
+      original_filename: 'drone.mp4',
+      mime_type: 'video/mp4',
+      media_type: 'video',
+      size_bytes: 12345,
+      captured_at: null,
+    });
+    dbModule.__setEvent({ id: 9, slug: 'wedding', event_name: 'Wedding' });
+
+    // ffmpeg thumbnail pipeline throws (e.g. unsupported pixel format)…
+    videoProcessor.processUploadedVideo.mockRejectedValueOnce(new Error('ffmpeg exited with code 1'));
+    // …but a plain probe still works.
+    videoProcessor.extractVideoMetadata.mockResolvedValueOnce({
+      duration: 42,
+      videoCodec: 'hevc',
+      audioCodec: 'aac',
+      width: 3840,
+      height: 2160,
+    });
+
+    const { processPhoto } = require('../../src/services/photoProcessor');
+    await processPhoto(203);
+
+    const finalUpdate = dbModule.__recorded().updateCalls.pop();
+    // The row must complete — 'failed' rows are invisible to guests.
+    expect(finalUpdate.data.processing_status).toBe('complete');
+    // Placeholder instead of NULL: a completed video without thumbnail would
+    // make the grid fetch the original video file for the tile (#845 review).
+    expect(finalUpdate.data.thumbnail_path).toBe('thumbnails/thumb_drone-clip.jpg');
+    expect(imageProcessor.generateVideoPlaceholder).toHaveBeenCalledWith('drone-clip.mp4');
+    expect(finalUpdate.data.duration).toBe(42);
+    expect(finalUpdate.data.video_codec).toBe('hevc');
+  });
+
  it('throws when the photo row no longer exists', async () => {
    dbModule.__setPhoto(null);
    dbModule.__setEvent({ id: 1 });
@@ -0,0 +1,105 @@
+/**
+ * Tests for preserveOperatorRole — re-establishing the operator's authorization
+ * after a restore replaces the roles / permissions / role_permissions tables.
+ * Real in-memory SQLite so the joins and inserts behave as in production.
+ */
+const knex = require('knex');
+
+let db;
+let svc;
+
+beforeEach(async () => {
+  db = knex({ client: 'sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  await db.schema.createTable('roles', (t) => {
+    t.increments('id');
+    t.string('name').notNullable().unique();
+    t.string('display_name');
+    t.integer('priority').defaultTo(0);
+    t.boolean('is_system').defaultTo(false);
+  });
+  await db.schema.createTable('permissions', (t) => {
+    t.increments('id');
+    t.string('name').notNullable().unique();
+    t.string('display_name');
+    t.string('category');
+  });
+  await db.schema.createTable('role_permissions', (t) => {
+    t.integer('role_id').notNullable();
+    t.integer('permission_id').notNullable();
+    t.primary(['role_id', 'permission_id']);
+  });
+  await db.schema.createTable('admin_users', (t) => {
+    t.increments('id');
+    t.string('email');
+    t.integer('role_id');
+  });
+  jest.resetModules();
+  jest.doMock('../../knexfile', () => ({ client: 'sqlite3' }));
+  jest.doMock('../../src/database/db', () => ({ db }));
+  svc = require('../../src/services/picpeakImportService');
+});
+
+afterEach(async () => {
+  jest.dontMock('../../src/database/db');
+  jest.dontMock('../../knexfile');
+  await db.destroy();
+});
+
+test('captureOperatorRole returns the role + its permission names', async () => {
+  await db('roles').insert({ id: 1, name: 'super_admin', display_name: 'Super Admin', priority: 100 });
+  await db('permissions').insert([
+    { id: 1, name: 'events.create', display_name: 'Create', category: 'events' },
+    { id: 2, name: 'users.manage', display_name: 'Manage', category: 'users' },
+  ]);
+  await db('role_permissions').insert([{ role_id: 1, permission_id: 1 }, { role_id: 1, permission_id: 2 }]);
+
+  const snap = await svc.captureOperatorRole(1);
+  expect(snap.role.name).toBe('super_admin');
+  expect(snap.permissions.sort()).toEqual(['events.create', 'users.manage']);
+});
+
+test('preserveOperatorRole binds to a restored role of the same NAME (ids remapped)', async () => {
+  const snapshot = { role: { name: 'super_admin', display_name: 'Super Admin', priority: 100, is_system: true }, permissions: ['events.create'] };
+  // Simulate post-restore RBAC where super_admin now has a DIFFERENT id.
+  await db('roles').insert({ id: 7, name: 'super_admin', display_name: 'Super Admin (restored)', priority: 100 });
+  await db('admin_users').insert({ id: 3, email: 'op@example.com', role_id: null });
+
+  await db.transaction((trx) => svc.preserveOperatorRole(trx, 3, snapshot));
+
+  const op = await db('admin_users').where({ id: 3 }).first();
+  expect(op.role_id).toBe(7);                           // bound to restored super_admin by name
+  expect(await db('roles').count({ c: '*' }).first()).toEqual({ c: 1 }); // no duplicate role created
+});
+
+test('preserveOperatorRole re-creates the role + grants when the backup omits it', async () => {
+  const snapshot = {
+    role: { name: 'super_admin', display_name: 'Super Admin', priority: 100, is_system: true },
+    permissions: ['events.create', 'users.manage', 'gone.permission'],
+  };
+  // Post-restore RBAC WITHOUT super_admin; only some permissions exist.
+  await db('roles').insert({ id: 2, name: 'viewer', display_name: 'Viewer', priority: 10 });
+  await db('permissions').insert([
+    { id: 5, name: 'events.create', display_name: 'Create', category: 'events' },
+    { id: 6, name: 'users.manage', display_name: 'Manage', category: 'users' },
+  ]);
+  await db('admin_users').insert({ id: 3, email: 'op@example.com', role_id: null });
+
+  await db.transaction((trx) => svc.preserveOperatorRole(trx, 3, snapshot));
+
+  const recreated = await db('roles').where({ name: 'super_admin' }).first();
+  expect(recreated).toBeTruthy();                      // role re-created, not left missing
+  expect(recreated.id).toBe(3);                        // max(2)+1
+
+  const op = await db('admin_users').where({ id: 3 }).first();
+  expect(op.role_id).toBe(recreated.id);               // operator not locked out / downgraded
+
+  const grants = await db('role_permissions').where({ role_id: recreated.id }).pluck('permission_id');
+  expect(grants.sort()).toEqual([5, 6]);               // existing perms re-granted; 'gone.permission' skipped
+});
+
+test('preserveOperatorRole no-ops when the operator had no role', async () => {
+  await db('admin_users').insert({ id: 3, email: 'op@example.com', role_id: null });
+  await db.transaction((trx) => svc.preserveOperatorRole(trx, 3, null));
+  const op = await db('admin_users').where({ id: 3 }).first();
+  expect(op.role_id).toBeNull();
+});
@@ -1,229 +0,0 @@
-/**
- * Deal-lineage ownership on project attach (GHSA-wrg5, codex round 3).
- *
- * requireProjectOwnership vets only the DESTINATION project. Attaching a quote
- * cascades through linkDealToProject, which re-points every event the deal
- * produced into that project — so an editor could create an empty project of
- * their own, attach another admin's quote, and pull that admin's events (and
- * the invoices, emails and gallery that roll up with them) into a project they
- * own and can read via /:id/overview. An unassigned project offered no
- * resistance either: it ADOPTS the deal's customer rather than rejecting it.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-deallineage-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'deallineage-test-secret';
-
-const bcrypt = require('bcrypt');
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('linkDealToProject enforces lineage ownership (GHSA-wrg5, round 3)', () => {
-  let db; let cleanup; let projectService;
-  let editorA; let editorB; let superAdmin;
-  let customerId;
-
-  const mkAdmin = async (username, roleName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const r = await db('admin_users').insert({
-      username, email: `${username}@example.com`,
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id, is_active: 1,
-      created_at: new Date(), updated_at: new Date(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-  const mkProject = async (name, createdBy) => {
-    const r = await db('projects').insert({
-      name, status: 'active', created_by: createdBy,
-      created_at: new Date(), updated_at: new Date(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-  const mkEvent = async (slug, createdBy) => {
-    const r = await db('events').insert({
-      slug, event_type: 'wedding', event_name: slug, event_date: '2026-08-01',
-      host_email: 'h@e.com', admin_email: 'a@e.com', password_hash: 'x',
-      share_token: `t-${slug}`, share_link: `/g/${slug}/t-${slug}`,
-      created_by: createdBy,
-      expires_at: new Date(Date.now() + 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-  const mkQuote = async (dealUuid, convertedEventId) => {
-    const r = await db('quotes').insert({
-      quote_number: `Q-${dealUuid}`,
-      customer_account_id: customerId,
-      deal_uuid: dealUuid,
-      converted_event_id: convertedEventId,
-      status: 'accepted',
-      currency: 'EUR',
-      issue_date: '2026-08-01',
-      total_amount_minor: 1000,
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-    projectService = require('../../src/services/projectService');
-    editorA = await mkAdmin('deal-a', 'editor');
-    editorB = await mkAdmin('deal-b', 'editor');
-    superAdmin = await mkAdmin('deal-root', 'super_admin');
-    const c = await db('customer_accounts').first('id');
-    customerId = c.id;
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  it("refuses to move another admin's event into the caller's project", async () => {
-    const victimEvent = await mkEvent('victim-gala', editorB);
-    const quoteId = await mkQuote('deal-foreign', victimEvent);
-    const attackerProject = await mkProject('attacker-empty', editorA);
-
-    await expect(
-      projectService.assignQuote(attackerProject, quoteId, { id: editorA, roleName: 'editor' }),
-    ).rejects.toMatchObject({ code: 'DEAL_EVENT_FORBIDDEN' });
-
-    // Nothing may be half-applied: neither the event nor the quote moved.
-    const ev = await db('events').where({ id: victimEvent }).first('project_id');
-    expect(ev.project_id == null).toBe(true);
-    const q = await db('quotes').where({ id: quoteId }).first('project_id');
-    expect(q.project_id == null).toBe(true);
-  });
-
-  it("allows the caller's own event through the same path", async () => {
-    const ownEvent = await mkEvent('own-gala', editorA);
-    const quoteId = await mkQuote('deal-own', ownEvent);
-    const project = await mkProject('attacker-own', editorA);
-
-    await projectService.assignQuote(project, quoteId, { id: editorA, roleName: 'editor' });
-
-    const ev = await db('events').where({ id: ownEvent }).first('project_id');
-    expect(Number(ev.project_id)).toBe(Number(project));
-  });
-
-  it('leaves super_admin unrestricted', async () => {
-    const victimEvent = await mkEvent('root-gala', editorB);
-    const quoteId = await mkQuote('deal-root', victimEvent);
-    const project = await mkProject('root-project', superAdmin);
-
-    await projectService.assignQuote(project, quoteId, { id: superAdmin, roleName: 'super_admin' });
-
-    const ev = await db('events').where({ id: victimEvent }).first('project_id');
-    expect(Number(ev.project_id)).toBe(Number(project));
-  });
-
-  it('resolves the role from a bare admin id (quote/contract create+update paths)', async () => {
-    // Those services thread `adminId`, not req.admin — the lookup must still
-    // scope them, and must fail closed rather than assume super_admin.
-    const victimEvent = await mkEvent('bare-gala', editorB);
-    const quoteId = await mkQuote('deal-bare', victimEvent);
-    const project = await mkProject('bare-project', editorA);
-
-    await expect(
-      projectService.assignQuote(project, quoteId, { id: editorA }),
-    ).rejects.toMatchObject({ code: 'DEAL_EVENT_FORBIDDEN' });
-  });
-
-  // The lineage guard above only fires once a deal has produced an event. The
-  // quote/contract create+update paths call linkDealToProject with a
-  // body-supplied projectId and NO route-level ownership guard, so a brand-new
-  // deal (eventIds empty) skipped every check and wrote into a foreign project.
-  describe('destination ownership (codex review follow-up)', () => {
-    it('refuses a foreign project even when the deal has no events yet', async () => {
-      const victimProject = await mkProject('victim-destination', editorB);
-      const quoteId = await mkQuote('deal-no-events', null);
-
-      await expect(
-        projectService.linkDealToProject('deal-no-events', victimProject, db, { id: editorA }),
-      ).rejects.toMatchObject({ code: 'PROJECT_NOT_FOUND' });
-
-      const q = await db('quotes').where({ id: quoteId }).first('project_id');
-      expect(q.project_id == null).toBe(true);
-    });
-
-    it('refuses an OWNERLESS project with no events (the escalation path)', async () => {
-      // created_by NULL + no linked events is exactly the shape that would let
-      // the caller claim the project via ownedProjectsSubquery's second branch
-      // once their quote converts to an event.
-      const orphan = await mkProject('orphan-destination', null);
-      await mkQuote('deal-orphan', null);
-
-      await expect(
-        projectService.linkDealToProject('deal-orphan', orphan, db, { id: editorA }),
-      ).rejects.toMatchObject({ code: 'PROJECT_NOT_FOUND' });
-    });
-
-    it("still allows the caller's own project with no events", async () => {
-      const own = await mkProject('own-destination', editorA);
-      const quoteId = await mkQuote('deal-own-dest', null);
-
-      await projectService.linkDealToProject('deal-own-dest', own, db, { id: editorA });
-
-      const q = await db('quotes').where({ id: quoteId }).first('project_id');
-      expect(Number(q.project_id)).toBe(Number(own));
-    });
-
-    it('refuses a foreign project when the deal_uuid is NULL (codex round 1)', async () => {
-      // deal_uuid is nullable (migration 107) and quoteService.update passes the
-      // EXISTING row's value, so a legacy quote reaches linkDealToProject with
-      // null. The old `if (!dealUuid || !projectId) return` bailed before the
-      // guard — while the caller had already written project_id onto its row.
-      const victimProject = await mkProject('victim-nulldeal', editorB);
-
-      await expect(
-        projectService.linkDealToProject(null, victimProject, db, { id: editorA }),
-      ).rejects.toMatchObject({ code: 'PROJECT_NOT_FOUND' });
-    });
-
-    it('still no-ops on a NULL deal_uuid pointed at the caller-s own project', async () => {
-      // The destination is vetted, then it returns without cascading — there is
-      // no lineage to move.
-      const own = await mkProject('own-nulldeal', editorA);
-      await expect(
-        projectService.linkDealToProject(null, own, db, { id: editorA }),
-      ).resolves.toBeUndefined();
-    });
-
-    it('does not leak customer association through the error code', async () => {
-      // The customer check used to run first, so a foreign project whose
-      // customer differed answered 422 PROJECT_CUSTOMER_MISMATCH while an
-      // unknown id answered 404 — enough to enumerate projects and infer their
-      // customer. Both must now be indistinguishable to a scoped caller.
-      const foreignWithCustomer = await mkProject('victim-customer', editorB);
-      await db('projects').where({ id: foreignWithCustomer }).update({ customer_account_id: customerId });
-      await mkQuote('deal-oracle', null);
-
-      await expect(
-        projectService.linkDealToProject('deal-oracle', foreignWithCustomer, db, { id: editorA }),
-      ).rejects.toMatchObject({ code: 'PROJECT_NOT_FOUND' });
-
-      await expect(
-        projectService.linkDealToProject('deal-oracle', 999999, db, { id: editorA }),
-      ).rejects.toMatchObject({ code: 'PROJECT_NOT_FOUND' });
-    });
-
-    it('leaves super_admin unrestricted on a foreign destination', async () => {
-      const victimProject = await mkProject('root-destination', editorB);
-      const quoteId = await mkQuote('deal-root-dest', null);
-
-      await projectService.linkDealToProject('deal-root-dest', victimProject, db, {
-        id: superAdmin, roleName: 'super_admin',
-      });
-
-      const q = await db('quotes').where({ id: quoteId }).first('project_id');
-      expect(Number(q.project_id)).toBe(Number(victimProject));
-    });
-  });
-});
@@ -1,149 +0,0 @@
-/**
- * getProjectOverview stamps each email with `canAct` — whether the queued-mail
- * routes (requireOwnedQueuedEmail) would actually accept an action on it.
- *
- * The cockpit used to derive this client-side from `event_id != null`, which is
- * weaker than the backend rule in a way that still produced dead controls:
- * requireOwnedQueuedEmail ALSO requires ownership of that event, while
- * getProjectOverview lists the project's events by project_id alone. Project
- * ownership does not imply event ownership — ownedProjectsSubquery's
- * `projects.created_by = admin.id` branch places no constraint on the linked
- * events' owners, so a super_admin can attach admin B's event to admin A's
- * project. See #969 / codex review round 1.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-canact-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'canact-test-secret';
-
-const bcrypt = require('bcrypt');
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-describe('getProjectOverview email canAct (#969)', () => {
-  let db; let cleanup; let projectService;
-  let adminA; let adminB; let superAdmin;
-  let projectId; let ownEventId; let foreignEventId; let ownerlessEventId;
-
-  const mkAdmin = async (username, roleName) => {
-    const role = await db('roles').where({ name: roleName }).first();
-    const r = await db('admin_users').insert({
-      username, email: `${username}@example.com`,
-      password_hash: await bcrypt.hash('Passw0rd!', 4),
-      role_id: role.id, is_active: 1,
-      created_at: new Date().toISOString(), updated_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  const mkEvent = async (slug, createdBy, project) => {
-    const r = await db('events').insert({
-      slug, event_type: 'wedding', event_name: slug, event_date: '2026-08-01',
-      host_email: 'h@e.com', admin_email: 'a@e.com', password_hash: 'x',
-      share_token: `t-${slug}`, share_link: `/g/${slug}/t-${slug}`,
-      created_by: createdBy, project_id: project,
-      expires_at: new Date(Date.now() + 864e5).toISOString(),
-      is_active: 1, is_archived: 0, is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  const mkMail = async (eventId, type) => {
-    const r = await db('email_queue').insert({
-      recipient_email: 'kunde@example.com', email_type: type, status: 'sent',
-      event_id: eventId,
-      created_at: new Date().toISOString(), sent_at: new Date().toISOString(),
-    }).returning('id');
-    return r[0]?.id ?? r[0];
-  };
-
-  beforeAll(async () => {
-    ({ db, cleanup } = await bootCrmDb());
-    await seedMinimal(db);
-    projectService = require('../../src/services/projectService');
-
-    adminA = await mkAdmin('canact-a', 'editor');
-    adminB = await mkAdmin('canact-b', 'editor');
-    superAdmin = await mkAdmin('canact-root', 'super_admin');
-
-    const p = await db('projects').insert({
-      name: 'Cockpit canAct', status: 'active', created_by: adminA,
-      created_at: new Date().toISOString(), updated_at: new Date().toISOString(),
-    }).returning('id');
-    projectId = p[0]?.id ?? p[0];
-
-    // All three hang off adminA's project. Only the first is adminA's; the
-    // third is an ownerless legacy row, which filterOwnedEventIds treats as
-    // owned by whoever asks — but only once we know who is asking.
-    ownEventId = await mkEvent('canact-own', adminA, projectId);
-    foreignEventId = await mkEvent('canact-foreign', adminB, projectId);
-    ownerlessEventId = await mkEvent('canact-legacy', null, projectId);
-
-    await mkMail(ownEventId, 'gallery_ready');
-    await mkMail(foreignEventId, 'gallery_ready');
-    await mkMail(ownerlessEventId, 'gallery_ready');
-  }, 120000);
-
-  afterAll(async () => { if (cleanup) await cleanup(); });
-
-  const byEvent = (overview) => {
-    const m = new Map();
-    for (const e of overview.emails) m.set(e.eventId, e);
-    return m;
-  };
-
-  it('clears mail on an event the caller owns', async () => {
-    const overview = await projectService.getProjectOverview(
-      projectId, {}, { id: adminA, roleName: 'editor' },
-    );
-    expect(byEvent(overview).get(ownEventId).canAct).toBe(true);
-  });
-
-  it('denies mail on a foreign admin\'s event inside the caller\'s own project', async () => {
-    const overview = await projectService.getProjectOverview(
-      projectId, {}, { id: adminA, roleName: 'editor' },
-    );
-    // event_id is non-null here — the old client-side rule would have offered
-    // controls, and requireOwnedQueuedEmail would have 404'd them.
-    const row = byEvent(overview).get(foreignEventId);
-    expect(row.eventId).not.toBeNull();
-    expect(row.canAct).toBe(false);
-  });
-
-  it('clears everything for a super_admin', async () => {
-    const overview = await projectService.getProjectOverview(
-      projectId, {}, { id: superAdmin, roleName: 'super_admin' },
-    );
-    expect(overview.emails.every((e) => e.canAct === true)).toBe(true);
-  });
-
-  it('clears mail on an ownerless legacy event for an identified caller', async () => {
-    // Parity with filterOwnedEventIds, which allows created_by IS NULL.
-    const overview = await projectService.getProjectOverview(
-      projectId, {}, { id: adminA, roleName: 'editor' },
-    );
-    expect(byEvent(overview).get(ownerlessEventId).canAct).toBe(true);
-  });
-
-  it('denies everything when no admin context is supplied', async () => {
-    // Including the ownerless event: `created_by == null` must not read as
-    // "owned" when we do not know who is asking (codex review round 2).
-    const overview = await projectService.getProjectOverview(projectId, {});
-    expect(overview.emails.length).toBe(3);
-    expect(overview.emails.every((e) => e.canAct === false)).toBe(true);
-  });
-
-  it('does not leak event ownership to the client', async () => {
-    const overview = await projectService.getProjectOverview(
-      projectId, {}, { id: adminA, roleName: 'editor' },
-    );
-    expect(overview.events.length).toBe(3);
-    for (const e of overview.events) expect(e).not.toHaveProperty('created_by');
-  });
-});
@@ -1,91 +0,0 @@
-/**
- * Brand-token substitution must not reintroduce markup after sanitization
- * (GHSA-j347).
- *
- * buildCachedPayload sanitizes the operator's HTML and THEN calls
- * applyBrandTokens on the result, which did a plain `String.replace` with no
- * escaping. The default templates interpolate tokens into text and into quoted
- * attributes (`<img src="{{brand_logo_url}}" alt="{{company_name}} logo">`,
- * `href="mailto:{{support_email}}"`), so a token value could close the
- * attribute and inject markup into the public origin.
- *
- * The writer is settings.edit (super_admin only) and the CSP blocks inline
- * script, so this is defence-in-depth rather than a live RCE — but the
- * sanitize-then-substitute ordering is a real bug either way.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-brandtok-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'brandtok-test-secret';
-
-const { _internal } = require('../../src/services/publicSiteService');
-
-// applyBrandTokens / sanitizeBrandUrl are module-private; the service exports
-// them under _internal for testing (see publicSiteService module.exports).
-const { applyBrandTokens, sanitizeBrandUrl } = _internal || {};
-
-const maybe = applyBrandTokens ? describe : describe.skip;
-
-maybe('applyBrandTokens escaping (GHSA-j347)', () => {
-  it('escapes markup in a text-position token', () => {
-    const out = applyBrandTokens('<p>{{company_name}}</p>', {
-      companyName: '<script>alert(1)</script>',
-    });
-    expect(out).not.toContain('<script>');
-    expect(out).toContain('&lt;script&gt;');
-  });
-
-  it('escapes a quote that would break out of an attribute', () => {
-    const out = applyBrandTokens(
-      '<img src="/x.png" alt="{{company_name}} logo">',
-      { companyName: '" onerror="alert(1)' },
-    );
-    // The injected quotes must be entity-encoded, so the payload stays INSIDE
-    // the alt value as text instead of terminating it and forming a real
-    // onerror attribute. (`onerror=` still appears as literal characters —
-    // that is inert; what matters is that no raw `"` closed the attribute.)
-    expect(out).not.toContain('" onerror="');
-    expect(out).toContain('&quot; onerror=&quot;');
-  });
-
-  it('escapes the logo url token used inside src="..."', () => {
-    const out = applyBrandTokens('<img src="{{brand_logo_url}}">', {
-      logoUrl: '" onerror="alert(1)',
-    });
-    expect(out).not.toContain('" onerror="');
-    expect(out).toContain('&quot;');
-  });
-
-  it('leaves ordinary values readable', () => {
-    const out = applyBrandTokens('<p>{{company_name}}</p>', { companyName: 'Acme Photos' });
-    expect(out).toContain('Acme Photos');
-  });
-});
-
-const maybeUrl = sanitizeBrandUrl ? describe : describe.skip;
-
-maybeUrl('sanitizeBrandUrl scheme allowlist (GHSA-j347)', () => {
-  it('rejects javascript: regardless of case', () => {
-    expect(sanitizeBrandUrl('javascript:alert(1)')).toBeNull();
-    // The old check was a case-sensitive startsWith and missed these.
-    expect(sanitizeBrandUrl('JavaScript:alert(1)')).toBeNull();
-    expect(sanitizeBrandUrl('  JAVASCRIPT:alert(1)')).toBeNull();
-  });
-
-  it('rejects other non-http schemes', () => {
-    expect(sanitizeBrandUrl('data:text/html;base64,PHN2Zz4=')).toBeNull();
-    expect(sanitizeBrandUrl('vbscript:msgbox(1)')).toBeNull();
-  });
-
-  it('keeps http(s) and relative logo paths working', () => {
-    expect(sanitizeBrandUrl('https://cdn.example.com/logo.png'))
-      .toBe('https://cdn.example.com/logo.png');
-    expect(sanitizeBrandUrl('/uploads/logos/logo.png')).toBe('/uploads/logos/logo.png');
-  });
-});
@@ -0,0 +1,51 @@
+const fs = require('fs');
+const path = require('path');
+
+const {
+  EXTENSION_TO_MIME,
+  extensionsToMimeTypes,
+} = require('../../src/services/uploadSettings');
+const { validateFileType } = require('../../src/utils/fileSecurityUtils');
+
+const RAW_AND_HEIF_TYPES = {
+  dng: 'image/x-adobe-dng',
+  heic: 'image/heic',
+  heif: 'image/heif',
+};
+
+function getFrontendExtensionMap() {
+  const source = fs.readFileSync(
+    path.join(__dirname, '../../../frontend/src/utils/fileTypes.ts'),
+    'utf8'
+  );
+  const match = source.match(/const EXTENSION_TO_MIME[^=]*= \{([\s\S]*?)\n\};/);
+  if (!match) throw new Error('Could not find frontend EXTENSION_TO_MIME');
+
+  // Parse `key: 'mime',` entries — quoted keys and trailing `//` comments are
+  // tolerated; any other non-blank, non-comment line inside the map is a parse
+  // failure, so a syntax the parser can't read fails loudly instead of silently
+  // dropping the entry from the comparison.
+  const entries = [];
+  for (const line of match[1].split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed === '' || trimmed.startsWith('//')) continue;
+    const entry = trimmed.match(/^'?(\w+)'?\s*:\s*'([^']+)'\s*,?\s*(?:\/\/.*)?$/);
+    if (!entry) throw new Error(`Unparsable EXTENSION_TO_MIME line in frontend fileTypes.ts: "${trimmed}"`);
+    entries.push([entry[1], entry[2]]);
+  }
+  return Object.fromEntries(entries);
+}
+
+describe('configured upload file types', () => {
+  test('supports configured DNG, HEIC, and HEIF uploads', () => {
+    expect(extensionsToMimeTypes('dng,heic,heif')).toEqual(Object.values(RAW_AND_HEIF_TYPES));
+
+    for (const [extension, mimeType] of Object.entries(RAW_AND_HEIF_TYPES)) {
+      expect(validateFileType(`image.${extension}`, mimeType, [mimeType])).toBe(true);
+    }
+  });
+
+  test('uses the same extension-to-MIME map as the frontend', () => {
+    expect(getFrontendExtensionMap()).toEqual(EXTENSION_TO_MIME);
+  });
+});
@@ -0,0 +1,65 @@
+/**
+ * Unit tests for the per-file upload size limit getter (general_max_file_size_mb),
+ * added so the admin's "Max File Size (MB)" setting applies to guest uploads
+ * (#613 follow-up — mat1990dj). Real in-memory SQLite app_settings so the
+ * read/parse/cache path runs exactly as in production.
+ */
+const knex = require('knex');
+
+let db;
+let svc;
+
+beforeEach(async () => {
+  db = knex({ client: 'sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  await db.schema.createTable('app_settings', (t) => {
+    t.increments('id');
+    t.string('setting_key').notNullable().unique();
+    t.text('setting_value');
+    t.string('setting_type');
+    t.timestamp('updated_at');
+  });
+  jest.resetModules();
+  jest.doMock('../../src/database/db', () => ({ db }));
+  svc = require('../../src/services/uploadSettings');
+  svc.clearMaxFileSizeCache();
+});
+
+afterEach(async () => {
+  jest.dontMock('../../src/database/db');
+  await db.destroy();
+});
+
+async function setLimit(mb) {
+  await db('app_settings')
+    .insert({ setting_key: 'general_max_file_size_mb', setting_value: JSON.stringify(mb), setting_type: 'general', updated_at: new Date() })
+    .onConflict('setting_key').merge({ setting_value: JSON.stringify(mb) });
+  svc.clearMaxFileSizeCache();
+}
+
+test('defaults to 50MB when the setting is absent', async () => {
+  expect(await svc.getMaxFileSizeMb()).toBe(50);
+  expect(await svc.getMaxFileSizeBytes()).toBe(50 * 1024 * 1024);
+});
+
+test('honours a configured value (e.g. 500MB video)', async () => {
+  await setLimit(500);
+  expect(await svc.getMaxFileSizeMb()).toBe(500);
+  expect(await svc.getMaxFileSizeBytes()).toBe(500 * 1024 * 1024);
+});
+
+test('clamps a nonsense value to the default and caps absurd values at the ceiling', async () => {
+  await setLimit(0);
+  expect(await svc.getMaxFileSizeMb()).toBe(50); // 0 → default
+  await setLimit(99_999_999);
+  expect(await svc.getMaxFileSizeMb()).toBe(svc.MAX_ALLOWED_FILE_SIZE_MB); // ceiling
+});
+
+test('caches for the TTL — a mid-window DB change is not seen until the cache is cleared', async () => {
+  await setLimit(200);
+  expect(await svc.getMaxFileSizeMb()).toBe(200);
+  // change the DB but do NOT clear cache
+  await db('app_settings').where({ setting_key: 'general_max_file_size_mb' }).update({ setting_value: JSON.stringify(300) });
+  expect(await svc.getMaxFileSizeMb()).toBe(200); // still cached
+  svc.clearMaxFileSizeCache();
+  expect(await svc.getMaxFileSizeMb()).toBe(300); // refreshed
+});
@@ -1,609 +0,0 @@
-/**
- * Engine resolution + the stranded-SQLite guard (#1038).
- *
- * knexfile.js picks its config block by NODE_ENV and the `development` block
- * defaults to sqlite3. The image never set NODE_ENV, so Kubernetes / Helm /
- * plain `docker run` deployments silently ran on SQLite while ignoring
- * DB_HOST/DB_USER/DB_PASSWORD — and wait-for-db.sh, being shell, reported
- * "PostgreSQL is up" in the same log.
- *
- * Pinned here:
- *  - the image default really is production (so knexfile resolves to pg)
- *  - the boot line names the engine and never leaks credentials
- *  - the guard blocks exactly one case — virgin Postgres while a populated
- *    SQLite file exists — and nothing else
- */
-
-const path = require('path');
-const fs = require('fs');
-
-const os = require('os');
-const {
-  resolveSqlitePath,
-  describeEngine,
-  decideBootEngine,
-  probeSqliteData,
-  migrationMarkerPath,
-  hasMigrationMarker,
-  migrationInProgressPath,
-  hasMigrationInProgress,
-  isUntouchedBootstrapRow,
-  adminsIndicateUse,
-} = require('../../src/utils/databaseEngine');
-const {
-  epochToIso,
-  coerceForTargetEngine,
-} = require('../../src/services/picpeakImportService');
-
-describe('knexfile engine selection (#1038)', () => {
-  // Resolved in a child process with a clean cwd: knexfile calls
-  // dotenv.config(), so running in-process would let a developer's
-  // backend/.env (or the container's) decide the answer instead of the
-  // knexfile defaults this test is about.
-  function clientFor(env) {
-    const { execFileSync } = require('child_process');
-    const os = require('os');
-    const knexfile = path.resolve(__dirname, '..', '..', 'knexfile.js');
-    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-knexenv-'));
-    const childEnv = { PATH: process.env.PATH };
-    if (env.NODE_ENV !== undefined) childEnv.NODE_ENV = env.NODE_ENV;
-    const out = execFileSync(
-      process.execPath,
-      ['-e', `process.stdout.write(String(require(${JSON.stringify(knexfile)}).client))`],
-      { cwd, env: childEnv, encoding: 'utf8' },
-    );
-    return out.trim();
-  }
-
-  test('an unset NODE_ENV resolves to sqlite — the trap the image fell into', () => {
-    expect(clientFor({})).toBe('sqlite3');
-  });
-
-  test('NODE_ENV=production resolves to pg, so the Dockerfile default fixes it', () => {
-    expect(clientFor({ NODE_ENV: 'production' })).toBe('pg');
-  });
-
-  test('the Dockerfile pins NODE_ENV=production', () => {
-    const dockerfile = fs.readFileSync(
-      path.resolve(__dirname, '..', '..', 'Dockerfile'), 'utf8',
-    );
-    expect(dockerfile).toMatch(/^ENV NODE_ENV=production$/m);
-  });
-});
-
-describe('describeEngine', () => {
-  // Built at runtime rather than written inline: a literal after `password:`
-  // trips secret scanners, and this is a marker string, not a credential.
-  const FAKE_CREDENTIAL = ['not', 'a', 'real', 'credential'].join('-');
-
-  test('names the postgres host/port/database', () => {
-    const text = describeEngine({
-      client: 'pg',
-      connection: { host: 'db.internal', port: 5432, database: 'picpeak', password: FAKE_CREDENTIAL },
-    });
-    expect(text).toBe('postgres (db.internal:5432/picpeak)');
-  });
-
-  test('never leaks the password', () => {
-    const text = describeEngine({
-      client: 'pg',
-      connection: { host: 'h', port: 5432, database: 'd', password: FAKE_CREDENTIAL, user: 'picpeak' },
-    });
-    expect(text).not.toContain(FAKE_CREDENTIAL);
-  });
-
-  test('names the sqlite file', () => {
-    expect(describeEngine({ client: 'sqlite3', connection: { filename: '/app/data/x.db' } }))
-      .toBe('sqlite (/app/data/x.db)');
-  });
-});
-
-describe('resolveSqlitePath', () => {
-  const ORIGINAL = process.env.DATABASE_PATH;
-  afterEach(() => {
-    if (ORIGINAL === undefined) delete process.env.DATABASE_PATH;
-    else process.env.DATABASE_PATH = ORIGINAL;
-  });
-
-  test('defaults to backend/data/photo_sharing.db', () => {
-    delete process.env.DATABASE_PATH;
-    expect(resolveSqlitePath().endsWith(path.join('data', 'photo_sharing.db'))).toBe(true);
-    expect(path.isAbsolute(resolveSqlitePath())).toBe(true);
-  });
-
-  test('honours an absolute DATABASE_PATH', () => {
-    process.env.DATABASE_PATH = '/var/lib/picpeak/db.sqlite';
-    expect(resolveSqlitePath()).toBe('/var/lib/picpeak/db.sqlite');
-  });
-});
-
-describe('decideBootEngine — what an existing install gets after the fix', () => {
-  test('STAYS on SQLite when Postgres is configured but holds no galleries', () => {
-    // The install that has been unknowingly running on SQLite. Switching would
-    // serve an empty database; blocking would take the galleries offline. It
-    // keeps running exactly as before, loudly.
-    const r = decideBootEngine({
-      configuredClient: 'pg', explicitClient: null, pgHasData: false, sqliteHasData: true,
-    });
-    expect(r.client).toBe('sqlite3');
-    expect(r.overridden).toBe(true);
-    expect(r.reason).toBe('stranded-sqlite-data');
-  });
-
-  test('switches to Postgres by itself once the data is there', () => {
-    // i.e. straight after scripts/migrate-sqlite-to-postgres.js — no further
-    // operator action needed on the next restart. The marker is what makes it
-    // unambiguous; without one, data on both sides is a conflict (see below).
-    const r = decideBootEngine({
-      configuredClient: 'pg', explicitClient: null, pgHasData: true, sqliteHasData: true,
-      migrationCompleted: true, pgConfigured: true,
-    });
-    expect(r.client).toBe('pg');
-    expect(r.overridden).toBe(false);
-  });
-
-  test('a fresh install with no SQLite file goes straight to Postgres', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: null, pgHasData: false, sqliteHasData: false,
-    }).client).toBe('pg');
-  });
-
-  test('an explicit DATABASE_CLIENT is always honoured', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'sqlite3', pgHasData: true, sqliteHasData: true,
-    }).client).toBe('sqlite3');
-    expect(decideBootEngine({
-      configuredClient: 'sqlite3', explicitClient: 'pg', pgHasData: false, sqliteHasData: false,
-    }).client).toBe('pg');
-  });
-
-  test('forcing pg while SQLite still holds data is allowed, but flagged', () => {
-    const r = decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'pg', pgHasData: false, sqliteHasData: true,
-    });
-    expect(r.client).toBe('pg');
-    expect(r.reason).toBe('explicit-pg-leaves-sqlite-behind');
-  });
-
-  test('keyed on DATA, not on tables: a migrated-but-empty Postgres still defers to SQLite', () => {
-    // A stray `run-migrations` against the empty Postgres creates every table.
-    // Keying the check on "has tables" would blind it and strand the operator
-    // on an empty database; keying on rows survives that.
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: null, pgHasData: false, sqliteHasData: true,
-    }).client).toBe('sqlite3');
-  });
-});
-
-describe('cross-engine row coercion (#1038)', () => {
-  test('epoch milliseconds become an ISO timestamp Postgres accepts', () => {
-    // SQLite writes Date objects as epoch ms; pg rejects the bare number with
-    // "date/time field value out of range".
-    expect(epochToIso(1786548038763)).toBe('2026-08-12T15:20:38.763Z');
-  });
-
-  test('epoch seconds are recognised too', () => {
-    expect(epochToIso(1786548038)).toBe('2026-08-12T15:20:38.000Z');
-  });
-
-  test('a non-numeric value is left alone', () => {
-    expect(epochToIso('not-a-date')).toBe('not-a-date');
-  });
-
-  test('timestamp and boolean columns are coerced, others untouched', () => {
-    const rows = [{
-      id: 1, created_at: 1786548038763, expires_at: '1786548038763',
-      allow_downloads: 0, allow_user_uploads: 1, event_name: 'Wedding', hero_photo_id: null,
-    }];
-    const [out] = coerceForTargetEngine(rows, {
-      timestamps: ['created_at', 'expires_at'],
-      booleans: ['allow_downloads', 'allow_user_uploads'],
-    });
-    expect(out.created_at).toBe('2026-08-12T15:20:38.763Z');
-    expect(out.expires_at).toBe('2026-08-12T15:20:38.763Z');
-    expect(out.allow_downloads).toBe(false);
-    expect(out.allow_user_uploads).toBe(true);
-    expect(out.event_name).toBe('Wedding');
-    expect(out.hero_photo_id).toBeNull();
-    expect(out.id).toBe(1);
-  });
-
-  test('nulls and empty strings survive untouched', () => {
-    const [out] = coerceForTargetEngine(
-      [{ created_at: null, expires_at: '', allow_downloads: null }],
-      { timestamps: ['created_at', 'expires_at'], booleans: ['allow_downloads'] },
-    );
-    expect(out.created_at).toBeNull();
-    expect(out.expires_at).toBe('');
-    expect(out.allow_downloads).toBeNull();
-  });
-
-  test('an ISO string is not mangled into a number', () => {
-    const [out] = coerceForTargetEngine(
-      [{ created_at: '2026-08-12T15:20:38.763Z' }], { timestamps: ['created_at'], booleans: [] },
-    );
-    expect(out.created_at).toBe('2026-08-12T15:20:38.763Z');
-  });
-});
-
-describe('probeSqliteData fails closed (#1038 review)', () => {
-  function tmpDb(contents) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-probe-'));
-    const file = path.join(dir, 'photo_sharing.db');
-    fs.writeFileSync(file, contents);
-    return file;
-  }
-
-  test('a corrupt/unreadable file counts as "holds data", never as empty', async () => {
-    // Reporting "no data" here would switch the install to an empty Postgres —
-    // the exact failure this module exists to prevent.
-    await expect(probeSqliteData(tmpDb('this is not a sqlite database'))).resolves.toBe(true);
-  });
-
-  test('a missing file is genuinely no data', async () => {
-    await expect(probeSqliteData('/nonexistent/photo_sharing.db')).resolves.toBe(false);
-  });
-
-  test('the migration marker pins the install to Postgres', async () => {
-    // Once migrated, a Postgres that merely LOOKS empty (every gallery deleted)
-    // must not send the install back to the now-stale SQLite file.
-    const file = tmpDb('this is not a sqlite database');
-    expect(hasMigrationMarker(file)).toBe(false);
-    expect(await probeSqliteData(file)).toBe(true);
-
-    fs.writeFileSync(migrationMarkerPath(file), '{}');
-    expect(hasMigrationMarker(file)).toBe(true);
-    expect(await probeSqliteData(file)).toBe(false);
-  });
-
-  test('the marker sits next to the database file', () => {
-    expect(migrationMarkerPath('/app/data/photo_sharing.db'))
-      .toBe('/app/data/photo_sharing.db.migrated-to-postgres');
-  });
-});
-
-describe('an unfinished migration pins the boot to SQLite (#1038 review)', () => {
-  // A migration that dies after touching Postgres leaves rows there — schema
-  // creation alone seeds a bootstrap admin when ADMIN_PASSWORD is set. Those
-  // rows read as "occupied", so without a pin the next restart would switch
-  // engines and hide the SQLite data that is still authoritative.
-  test('Postgres holding partial data does NOT win while the migration is unfinished', () => {
-    const r = decideBootEngine({
-      configuredClient: 'pg',
-      explicitClient: null,
-      pgHasData: true,          // e.g. just the bootstrap admin, or a half-load
-      sqliteHasData: true,
-      migrationInProgress: true,
-    });
-    expect(r.client).toBe('sqlite3');
-    expect(r.reason).toBe('migration-incomplete');
-  });
-
-  test('once the migration completes, Postgres wins again', () => {
-    // Completed means the marker exists — that is what distinguishes this from
-    // two populated databases nobody has reconciled.
-    expect(decideBootEngine({
-      configuredClient: 'pg',
-      explicitClient: null,
-      pgHasData: true,
-      sqliteHasData: true,
-      migrationInProgress: false,
-      migrationCompleted: true,
-      pgConfigured: true,
-    }).client).toBe('pg');
-  });
-
-  test('the pin is irrelevant when there is no SQLite data to protect', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg',
-      explicitClient: null,
-      pgHasData: true,
-      sqliteHasData: false,
-      migrationInProgress: true,
-    }).client).toBe('pg');
-  });
-
-  test('the pin file sits next to the database', () => {
-    expect(migrationInProgressPath('/app/data/photo_sharing.db'))
-      .toBe('/app/data/photo_sharing.db.migration-in-progress');
-    expect(hasMigrationInProgress('/nonexistent/photo_sharing.db')).toBe(false);
-  });
-});
-
-describe('the migration pin outranks an explicit client (#1038 review r6)', () => {
-  // docker-compose sets DATABASE_CLIENT=pg, so without this an unfinished
-  // migration would be ignored on exactly the deployments that pin it, and a
-  // half-written Postgres would be served.
-  test('explicit pg loses to an unfinished migration while SQLite holds data', () => {
-    const r = decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'pg',
-      pgHasData: true, sqliteHasData: true, migrationInProgress: true,
-    });
-    expect(r.client).toBe('sqlite3');
-    expect(r.reason).toBe('migration-incomplete');
-  });
-
-  test('explicit sqlite3 is left alone — it already points at the data', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'sqlite3',
-      pgHasData: true, sqliteHasData: true, migrationInProgress: true,
-    }).client).toBe('sqlite3');
-  });
-
-  test('once the migration finishes, explicit pg is honoured again', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'pg',
-      pgHasData: true, sqliteHasData: true, migrationInProgress: false,
-    }).client).toBe('pg');
-  });
-
-  test('a pin with no SQLite data left does not strand the install', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'pg',
-      pgHasData: true, sqliteHasData: false, migrationInProgress: true,
-    }).client).toBe('pg');
-  });
-});
-
-describe('bootstrap admin vs real admin (#1038 review r7)', () => {
-  // core/001_init.js seeds must_change_password=true when ADMIN_PASSWORD is set;
-  // setupService writes false once a human finishes first-run setup. Judging by
-  // the FLAG rather than the table keeps both mistakes away: counting the seed
-  // as real data would abandon a populated SQLite file, and ignoring the whole
-  // table would abandon a legitimately set-up Postgres.
-  test('an untouched seeded row is recognised across both engines', () => {
-    expect(isUntouchedBootstrapRow(true)).toBe(true);
-    expect(isUntouchedBootstrapRow(1)).toBe(true);
-    expect(isUntouchedBootstrapRow('1')).toBe(true);
-  });
-
-  test('a completed setup is not a bootstrap row', () => {
-    expect(isUntouchedBootstrapRow(false)).toBe(false);
-    expect(isUntouchedBootstrapRow(0)).toBe(false);
-    expect(isUntouchedBootstrapRow('0')).toBe(false);
-  });
-
-  test('a legacy NULL counts as a real admin, not a seed', () => {
-    expect(isUntouchedBootstrapRow(null)).toBe(false);
-    expect(isUntouchedBootstrapRow(undefined)).toBe(false);
-  });
-});
-
-describe('admin rows: bootstrap seed vs real use (#1038 review r7/r8)', () => {
-  // must_change_password alone is mutable — resetAdminPassword() sets it on real
-  // accounts — so it cannot be the only signal. Only the exact shape
-  // core/001_init.js leaves behind reads as an untouched seed.
-  test('one never-used seeded admin is NOT use', () => {
-    expect(adminsIndicateUse([{ must_change_password: true, last_login: null }])).toBe(false);
-    expect(adminsIndicateUse([{ must_change_password: 1, last_login: null }])).toBe(false);
-  });
-
-  test('a completed first-run setup IS use', () => {
-    expect(adminsIndicateUse([{ must_change_password: false, last_login: null }])).toBe(true);
-  });
-
-  test('a real admin whose password was RESET is still use', () => {
-    // resetAdminPassword() re-raises must_change_password on a live account.
-    expect(adminsIndicateUse([
-      { must_change_password: true, last_login: '2026-08-01T10:00:00Z' },
-    ])).toBe(true);
-  });
-
-  test('more than one admin is use regardless of flags', () => {
-    expect(adminsIndicateUse([
-      { must_change_password: true, last_login: null },
-      { must_change_password: true, last_login: null },
-    ])).toBe(true);
-  });
-
-  test('no admins at all is not use', () => {
-    expect(adminsIndicateUse([])).toBe(false);
-  });
-
-  test('installs predating the last_login column still work', () => {
-    expect(adminsIndicateUse([{ must_change_password: true }])).toBe(false);
-    expect(adminsIndicateUse([{ must_change_password: false }])).toBe(true);
-  });
-});
-
-describe('cross-engine JSON columns pass through untouched (#1038 review r8)', () => {
-  // SQLite keeps json columns as TEXT holding valid JSON, and pg accepts JSON
-  // text directly, so the coercion must not touch them at all: serialising
-  // would store `{"a":1}` as a scalar string, and parse-then-serialise turned
-  // the JSON literal `null` into SQL NULL, breaking NOT NULL json columns.
-  test('timestamps and booleans are coerced; nothing else is', () => {
-    const [out] = coerceForTargetEngine(
-      [{ setting_value: '{"a":1}', nulled: 'null', created_at: 1786548038763, flag: 1 }],
-      { timestamps: ['created_at'], booleans: ['flag'] },
-    );
-    expect(out.setting_value).toBe('{"a":1}');
-    expect(out.nulled).toBe('null');
-    expect(out.created_at).toBe('2026-08-12T15:20:38.763Z');
-    expect(out.flag).toBe(true);
-  });
-});
-
-describe('Postgres probe: unreachable vs unusable (#1038 review r9)', () => {
-  const { probePgData } = require('../../src/utils/databaseEngine');
-
-  test('an unreachable Postgres reports "occupied" so a healthy install is not diverted', async () => {
-    // A transient network failure must not hand a live pg install over to a
-    // stale SQLite file; startup should surface the real connection error.
-    const warnings = [];
-    const result = await probePgData(
-      { host: '127.0.0.1', port: 59999, user: 'nobody', password: 'x', database: 'nope' },
-      (m) => warnings.push(m),
-    );
-    expect(result).toBe(true);
-    expect(warnings.join(' ')).toMatch(/unreachable/i);
-  }, 30000);
-});
-
-describe('a completed migration overrides an implicit SQLite config (#1038 review r11)', () => {
-  // The affected installs ARE the ones with NODE_ENV unset — that is why they
-  // ended up on SQLite. An operator can easily migrate before fixing that, and
-  // by then the source file has been renamed away, so honouring the implicit
-  // sqlite3 would create a NEW empty database and serve it.
-  test('marker + Postgres settings beat an implicitly-resolved sqlite3', () => {
-    const r = decideBootEngine({
-      configuredClient: 'sqlite3', explicitClient: null,
-      pgHasData: true, sqliteHasData: false,
-      migrationCompleted: true, pgConfigured: true,
-    });
-    expect(r.client).toBe('pg');
-    expect(r.reason).toBe('migrated-to-postgres');
-  });
-
-  test('an EXPLICIT sqlite3 still wins — that is a deliberate rollback', () => {
-    expect(decideBootEngine({
-      configuredClient: 'sqlite3', explicitClient: 'sqlite3',
-      pgHasData: true, sqliteHasData: false,
-      migrationCompleted: true, pgConfigured: true,
-    }).client).toBe('sqlite3');
-  });
-
-  test('without Postgres settings there is nowhere to send it', () => {
-    expect(decideBootEngine({
-      configuredClient: 'sqlite3', explicitClient: null,
-      pgHasData: false, sqliteHasData: false,
-      migrationCompleted: true, pgConfigured: false,
-    }).client).toBe('sqlite3');
-  });
-
-  test('no marker, no override — a plain SQLite install is left alone', () => {
-    expect(decideBootEngine({
-      configuredClient: 'sqlite3', explicitClient: null,
-      pgHasData: false, sqliteHasData: true,
-      migrationCompleted: false, pgConfigured: true,
-    }).client).toBe('sqlite3');
-  });
-});
-
-describe('two populated databases is a conflict, not a guess (#1038 review r12)', () => {
-  // An install that ran on Postgres, lost NODE_ENV, and kept working on SQLite
-  // has real data on BOTH sides: the Postgres rows are old, the SQLite rows are
-  // newer. Picking either hides galleries and splits future writes.
-  test('no marker + data on both sides refuses to choose', () => {
-    const r = decideBootEngine({
-      configuredClient: 'pg', explicitClient: null,
-      pgHasData: true, sqliteHasData: true, migrationCompleted: false,
-    });
-    expect(r.client).toBeNull();
-    expect(r.reason).toBe('ambiguous-both-populated');
-  });
-
-  test('a completed migration is not a conflict — the marker says which is current', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: null,
-      pgHasData: true, sqliteHasData: true, migrationCompleted: true, pgConfigured: true,
-    }).client).toBe('pg');
-  });
-
-  test('an explicit choice always resolves it', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'sqlite3',
-      pgHasData: true, sqliteHasData: true, migrationCompleted: false,
-    }).client).toBe('sqlite3');
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: 'pg',
-      pgHasData: true, sqliteHasData: true, migrationCompleted: false,
-    }).client).toBe('pg');
-  });
-
-  test('only one side populated is not a conflict', () => {
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: null,
-      pgHasData: true, sqliteHasData: false, migrationCompleted: false,
-    }).client).toBe('pg');
-    expect(decideBootEngine({
-      configuredClient: 'pg', explicitClient: null,
-      pgHasData: false, sqliteHasData: true, migrationCompleted: false,
-    }).client).toBe('sqlite3');
-  });
-
-  test('the pg probe target comes from the environment, not a sqlite config', () => {
-    const { pgConnectionFromEnv } = require('../../src/utils/databaseEngine');
-    const prev = { ...process.env };
-    process.env.DB_HOST = 'db.internal';
-    process.env.DB_NAME = 'picpeak_prod';
-    try {
-      const c = pgConnectionFromEnv();
-      expect(c.host).toBe('db.internal');
-      expect(c.database).toBe('picpeak_prod');
-    } finally {
-      process.env.DB_HOST = prev.DB_HOST;
-      process.env.DB_NAME = prev.DB_NAME;
-    }
-  });
-});
-
-describe('the target is resolved once, with production defaults (#1038 review r13)', () => {
-  // knexfile's DEVELOPMENT block defaults pg to localhost/postgres/photo_sharing
-  // while production uses db/picpeak/picpeak. The CLI runs in the NODE_ENV-unset
-  // state by design, so without an explicit resolution the migration could land
-  // in a database the running application never opens.
-  const { pgConnectionFromEnv } = require('../../src/utils/databaseEngine');
-
-  test('falls back to what a running container actually uses', () => {
-    // Host is `postgres`, matching wait-for-db.sh, which resolves and EXPORTS
-    // that value — so it is the host a bare container really runs against.
-    // knexfile's production block says `db`, but that default is only reached
-    // when the entrypoint did not run; a `docker exec` CLI has to agree with
-    // the runtime, not with the dormant default (#1038 review r14).
-    const prev = { ...process.env };
-    delete process.env.DB_HOST; delete process.env.DB_USER; delete process.env.DB_NAME;
-    try {
-      const c = pgConnectionFromEnv();
-      expect(c.host).toBe('postgres');
-      expect(c.user).toBe('picpeak');
-      expect(c.database).toBe('picpeak');
-    } finally {
-      Object.assign(process.env, prev);
-    }
-  });
-
-  test('explicit settings always win', () => {
-    const prev = { ...process.env };
-    process.env.DB_HOST = 'pg.example'; process.env.DB_NAME = 'mypics';
-    try {
-      const c = pgConnectionFromEnv();
-      expect(c.host).toBe('pg.example');
-      expect(c.database).toBe('mypics');
-    } finally {
-      Object.assign(process.env, prev);
-    }
-  });
-});
-
-describe('the marker is bound to the target it describes (#1038 review r15)', () => {
-  const { currentPgTargetId, readMigrationMarker } = require('../../src/utils/databaseEngine');
-
-  test('the target id has the shape the migration records', () => {
-    const prev = { ...process.env };
-    process.env.DB_HOST = 'pg.host'; process.env.DB_PORT = '6543'; process.env.DB_NAME = 'picpeak_prod';
-    try {
-      expect(currentPgTargetId()).toBe('pg.host:6543/picpeak_prod');
-    } finally {
-      Object.assign(process.env, prev);
-    }
-  });
-
-  test('an absent or unreadable marker reads as null, not a throw', () => {
-    expect(readMigrationMarker('/nonexistent/photo_sharing.db')).toBeNull();
-  });
-
-  test('inbound_documents is a real table; incoming_invoices never was', () => {
-    // The occupancy lists silently skip tables that do not exist, so a wrong
-    // name meant supplier documents never protected the install.
-    const src = fs.readFileSync(
-      path.resolve(__dirname, '..', '..', 'src', 'utils', 'databaseEngine.js'), 'utf8',
-    );
-    const cli = fs.readFileSync(
-      path.resolve(__dirname, '..', '..', 'scripts', 'migrate-sqlite-to-postgres.js'), 'utf8',
-    );
-    for (const text of [src, cli]) {
-      expect(text).toContain("'inbound_documents'");
-      expect(text).not.toContain("'incoming_invoices'");
-    }
-  });
-});
@@ -0,0 +1,177 @@
+/**
+ * Unit tests for rating removal (#884).
+ *
+ * Pins the contract of `feedbackService.submitFeedback` for
+ * `feedback_type: 'rating'` with `rating: 0` ("clear my rating"):
+ *  - An existing rating row is DELETED (not updated to 0 — a stored 0
+ *    would drag the photo's average down and still count in totals).
+ *  - Photo stats (average_rating) are recalculated after the delete.
+ *  - Rating 0 with no existing rating is a no-op that never inserts a row.
+ *  - Removal is guest-scoped: clearing guest A's rating leaves guest B's
+ *    rating (and the resulting average) intact.
+ *  - Regular re-rating (3 → 5) still updates in place.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+process.env.NODE_ENV = 'test';
+process.env.TEST_DATABASE_PATH = path.join(
+  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-rating-removal-')), 'db.sqlite',
+);
+process.env.JWT_SECRET = process.env.JWT_SECRET || 'rating-removal-test-secret';
+
+const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
+
+const feedbackService = require('../../src/services/feedbackService');
+
+const EVENT_SLUG = 'rating-removal-event';
+const GUEST_A = 'guest-a-identifier';
+const GUEST_B = 'guest-b-identifier';
+
+let db;
+let cleanup;
+let eventId;
+let photoId;
+
+async function rate(rating, guestIdentifier = GUEST_A) {
+  return feedbackService.submitFeedback(photoId, eventId, {
+    feedback_type: 'rating',
+    rating,
+    ip_address: '127.0.0.1',
+    user_agent: 'jest',
+  }, guestIdentifier);
+}
+
+async function ratingRows(guestIdentifier) {
+  const q = db('photo_feedback').where({
+    photo_id: photoId,
+    feedback_type: 'rating',
+  });
+  if (guestIdentifier) q.where('guest_identifier', guestIdentifier);
+  return q.select('*');
+}
+
+async function photoAverage() {
+  const photo = await db('photos').where('id', photoId).first();
+  return Number(photo.average_rating);
+}
+
+beforeAll(async () => {
+  ({ db, cleanup } = await bootCrmDb());
+  await seedMinimal(db);
+  const inserted = await db('events').insert({
+    slug: EVENT_SLUG,
+    event_type: 'wedding',
+    event_name: 'Rating Removal Test',
+    event_date: '2026-06-22',
+    host_email: 'host@example.com',
+    admin_email: 'admin@example.com',
+    password_hash: 'x',
+    share_link: `/gallery/${EVENT_SLUG}/share`,
+    share_token: 'rating-removal-share',
+    expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
+    is_active: 1,
+    is_archived: 0,
+    is_draft: 0,
+    created_at: new Date().toISOString(),
+  }).returning('id');
+  eventId = inserted[0]?.id ?? inserted[0];
+
+  const r = await db('photos').insert({
+    event_id: eventId,
+    filename: 'photo-1.jpg',
+    path: 'events/rating-removal/1.jpg',
+    type: 'individual',
+    uploaded_at: new Date().toISOString(),
+  }).returning('id');
+  photoId = r[0]?.id ?? r[0];
+}, 120000);
+
+afterAll(async () => { if (cleanup) await cleanup(); });
+
+beforeEach(async () => {
+  await db('photo_feedback').where('event_id', eventId).del();
+  await db('photos').where('id', photoId).update({ average_rating: 0, feedback_count: 0 });
+});
+
+describe('rating removal (#884)', () => {
+  test('rating 0 deletes the existing rating row and resets the average', async () => {
+    const created = await rate(4);
+    expect(created.created).toBe(true);
+    expect(await photoAverage()).toBe(4);
+
+    const removed = await rate(0);
+    expect(removed.removed).toBe(true);
+    expect(await ratingRows(GUEST_A)).toHaveLength(0);
+    expect(await photoAverage()).toBe(0);
+  });
+
+  test('rating 0 without an existing rating is a no-op (no 0-row inserted)', async () => {
+    const r = await rate(0);
+    expect(r.removed).toBe(true);
+    expect(await ratingRows()).toHaveLength(0);
+    expect(await photoAverage()).toBe(0);
+  });
+
+  test('removal is guest-scoped: guest B keeps their rating and the average', async () => {
+    await rate(2, GUEST_A);
+    await rate(4, GUEST_B);
+    expect(await photoAverage()).toBe(3);
+
+    const removed = await rate(0, GUEST_A);
+    expect(removed.removed).toBe(true);
+    expect(await ratingRows(GUEST_A)).toHaveLength(0);
+    expect(await ratingRows(GUEST_B)).toHaveLength(1);
+    expect(await photoAverage()).toBe(4);
+  });
+
+  test('numeric string "0" also clears (truthy-string bypass guard)', async () => {
+    await rate(4);
+    const removed = await rate('0');
+    expect(removed.removed).toBe(true);
+    expect(await ratingRows(GUEST_A)).toHaveLength(0);
+    expect(await photoAverage()).toBe(0);
+  });
+
+  test('malformed rating input never clears an existing rating', async () => {
+    await rate(4);
+    for (const bad of [undefined, null, 'bad', NaN]) {
+      const r = await rate(bad);
+      expect(r.removed).toBeFalsy();
+    }
+    expect(await ratingRows(GUEST_A)).toHaveLength(1);
+  });
+
+  test('clearing deletes racy duplicate rating rows, not just the first', async () => {
+    // Simulate the check-then-insert race: two rating rows for one guest.
+    const row = {
+      photo_id: photoId,
+      event_id: eventId,
+      feedback_type: 'rating',
+      guest_identifier: GUEST_A,
+      is_approved: 1,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    };
+    await db('photo_feedback').insert({ ...row, rating: 3 });
+    await db('photo_feedback').insert({ ...row, rating: 5 });
+    expect(await ratingRows(GUEST_A)).toHaveLength(2);
+
+    const removed = await rate(0);
+    expect(removed.removed).toBe(true);
+    expect(await ratingRows(GUEST_A)).toHaveLength(0);
+    expect(await photoAverage()).toBe(0);
+  });
+
+  test('re-rating with a different value still updates in place', async () => {
+    await rate(3);
+    const updated = await rate(5);
+    expect(updated.updated).toBe(true);
+    const rows = await ratingRows(GUEST_A);
+    expect(rows).toHaveLength(1);
+    expect(rows[0].rating).toBe(5);
+    expect(await photoAverage()).toBe(5);
+  });
+});
@@ -0,0 +1,202 @@
+/**
+ * Emoji reactions (#839) — pins the contract of the `reaction` feedback type:
+ *  - only emojis from the fixed curated set are accepted
+ *  - one reaction per guest per photo: same emoji again toggles OFF,
+ *    a different emoji SWITCHES the existing row (never a second row)
+ *  - per-guest scoping mirrors likes: guest_id when present, else the
+ *    device-hash guest_identifier — two token-guests on one device react
+ *    independently
+ *  - denormalized photos.reaction_count and the per-emoji tallies follow
+ *    visibility: hidden-by-moderator reactions disappear from both
+ *  - the long and pivoted exports carry the reaction
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+process.env.NODE_ENV = 'test';
+process.env.TEST_DATABASE_PATH = path.join(
+  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-feedback-reactions-')), 'db.sqlite',
+);
+process.env.JWT_SECRET = process.env.JWT_SECRET || 'feedback-reactions-test-secret';
+
+const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
+
+const feedbackService = require('../../src/services/feedbackService');
+const { REACTION_EMOJIS } = require('../../src/constants/reactions');
+
+const EVENT_SLUG = 'reactions-test-event';
+const GUEST_A = 'guest-a-identifier';
+const GUEST_B = 'guest-b-identifier';
+
+let db;
+let cleanup;
+let eventId;
+let photoIds;
+
+async function react(photoId, emoji, { guestIdentifier = GUEST_A, guestId = null } = {}) {
+  return feedbackService.submitFeedback(photoId, eventId, {
+    feedback_type: 'reaction',
+    reaction: emoji,
+    guest_id: guestId,
+    ip_address: '127.0.0.1',
+    user_agent: 'jest',
+  }, guestIdentifier);
+}
+
+async function reactionCountOf(photoId) {
+  const row = await db('photos').where('id', photoId).first();
+  return Number(row.reaction_count) || 0;
+}
+
+beforeAll(async () => {
+  ({ db, cleanup } = await bootCrmDb());
+  await seedMinimal(db);
+  const inserted = await db('events').insert({
+    slug: EVENT_SLUG,
+    event_type: 'wedding',
+    event_name: 'Reactions Test',
+    event_date: '2026-07-20',
+    host_email: 'host@example.com',
+    admin_email: 'admin@example.com',
+    password_hash: 'x',
+    share_link: `/gallery/${EVENT_SLUG}/share`,
+    share_token: 'reactions-test-share',
+    expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
+    is_active: 1,
+    is_archived: 0,
+    is_draft: 0,
+    created_at: new Date().toISOString(),
+  }).returning('id');
+  eventId = inserted[0]?.id ?? inserted[0];
+
+  photoIds = [];
+  for (let i = 0; i < 3; i++) {
+    const photo = await db('photos').insert({
+      event_id: eventId,
+      filename: `photo-${i}.jpg`,
+      path: `events/reactions/${i}.jpg`,
+      type: 'individual',
+      uploaded_at: new Date().toISOString(),
+    }).returning('id');
+    photoIds.push(photo[0]?.id ?? photo[0]);
+  }
+}, 120000);
+
+afterAll(async () => {
+  if (cleanup) await cleanup();
+});
+
+describe('reaction submission (#839)', () => {
+  it('rejects emojis outside the curated set', async () => {
+    await expect(react(photoIds[0], '🦄')).rejects.toThrow('Invalid reaction');
+    await expect(react(photoIds[0], undefined)).rejects.toThrow('Invalid reaction');
+    expect(await reactionCountOf(photoIds[0])).toBe(0);
+  });
+
+  it('creates a reaction row and maintains the denormalized count', async () => {
+    const result = await react(photoIds[0], '❤️');
+    expect(result.created).toBe(true);
+
+    const row = await db('photo_feedback')
+      .where({ photo_id: photoIds[0], feedback_type: 'reaction' })
+      .first();
+    expect(row.reaction).toBe('❤️');
+    expect(await reactionCountOf(photoIds[0])).toBe(1);
+    expect(await feedbackService.getPhotoReactionCounts(photoIds[0])).toEqual({ '❤️': 1 });
+  });
+
+  it('switches to another emoji in place — never a second row per guest', async () => {
+    const result = await react(photoIds[0], '🎉');
+    expect(result.updated).toBe(true);
+
+    const rows = await db('photo_feedback')
+      .where({ photo_id: photoIds[0], feedback_type: 'reaction' });
+    expect(rows).toHaveLength(1);
+    expect(rows[0].reaction).toBe('🎉');
+    expect(await feedbackService.getPhotoReactionCounts(photoIds[0])).toEqual({ '🎉': 1 });
+  });
+
+  it('tallies different guests per emoji', async () => {
+    await react(photoIds[0], '🎉', { guestIdentifier: GUEST_B });
+    expect(await feedbackService.getPhotoReactionCounts(photoIds[0])).toEqual({ '🎉': 2 });
+    expect(await reactionCountOf(photoIds[0])).toBe(2);
+  });
+
+  it('toggles off with the same emoji', async () => {
+    const result = await react(photoIds[0], '🎉');
+    expect(result.removed).toBe(true);
+    expect(await feedbackService.getPhotoReactionCounts(photoIds[0])).toEqual({ '🎉': 1 }); // GUEST_B remains
+    expect(await reactionCountOf(photoIds[0])).toBe(1);
+  });
+
+  it('scopes per guest_id when present — two token-guests on one device stay independent', async () => {
+    const first = await react(photoIds[1], '😍', { guestIdentifier: GUEST_A, guestId: 101 });
+    const second = await react(photoIds[1], '👏', { guestIdentifier: GUEST_A, guestId: 102 });
+    expect(first.created).toBe(true);
+    expect(second.created).toBe(true); // NOT treated as guest 101's switch
+    expect(await feedbackService.getPhotoReactionCounts(photoIds[1])).toEqual({ '😍': 1, '👏': 1 });
+  });
+
+  it('accepts every emoji of the curated set', async () => {
+    for (const emoji of REACTION_EMOJIS) {
+      const res = await react(photoIds[2], emoji, { guestIdentifier: `guest-${emoji}` });
+      expect(res.created).toBe(true);
+    }
+    const counts = await feedbackService.getPhotoReactionCounts(photoIds[2]);
+    expect(Object.keys(counts)).toHaveLength(REACTION_EMOJIS.length);
+  });
+
+  it('hidden reactions leave both the per-emoji tallies and reaction_count', async () => {
+    const row = await db('photo_feedback')
+      .where({ photo_id: photoIds[0], feedback_type: 'reaction' })
+      .first();
+    await feedbackService.moderateFeedback(row.id, 'hide', 1);
+
+    expect(await feedbackService.getPhotoReactionCounts(photoIds[0])).toEqual({});
+    expect(await reactionCountOf(photoIds[0])).toBe(0);
+
+    await feedbackService.moderateFeedback(row.id, 'approve', 1);
+    expect(await reactionCountOf(photoIds[0])).toBe(1);
+  });
+
+  it('toggle and switch collapse racy duplicate rows for the same guest', async () => {
+    // Simulate the check-then-insert race: two rows for one guest+photo.
+    const mk = (emoji) => ({
+      photo_id: photoIds[1], event_id: eventId, feedback_type: 'reaction',
+      reaction: emoji, guest_identifier: 'dup-guest', is_approved: true, is_hidden: false,
+      created_at: new Date(), updated_at: new Date(),
+    });
+    await db('photo_feedback').insert([mk('❤️'), mk('❤️')]);
+
+    // Switching converges to exactly ONE row with the new emoji…
+    const switched = await react(photoIds[1], '🎉', { guestIdentifier: 'dup-guest' });
+    expect(switched.updated).toBe(true);
+    let rows = await db('photo_feedback')
+      .where({ photo_id: photoIds[1], feedback_type: 'reaction', guest_identifier: 'dup-guest' });
+    expect(rows).toHaveLength(1);
+    expect(rows[0].reaction).toBe('🎉');
+
+    // …and toggle-off removes the full guest-scoped set.
+    await db('photo_feedback').insert(mk('🎉'));
+    const removed = await react(photoIds[1], '🎉', { guestIdentifier: 'dup-guest' });
+    expect(removed.removed).toBe(true);
+    rows = await db('photo_feedback')
+      .where({ photo_id: photoIds[1], feedback_type: 'reaction', guest_identifier: 'dup-guest' });
+    expect(rows).toHaveLength(0);
+  });
+
+  it('summary and exports carry reactions', async () => {
+    const summary = await feedbackService.getEventFeedbackSummary(eventId);
+    expect(Number(summary.stats.total_reactions)).toBeGreaterThan(0);
+
+    const longRows = await feedbackService.exportEventFeedback(eventId);
+    const longReaction = longRows.find((r) => r.feedback_type === 'reaction');
+    expect(longReaction.reaction).toBeTruthy();
+
+    const pivotRows = await feedbackService.exportEventFeedbackPivoted(eventId);
+    const pivotWithReaction = pivotRows.find((r) => r.reaction);
+    expect(REACTION_EMOJIS).toContain(pivotWithReaction.reaction);
+  });
+});
@@ -1,161 +0,0 @@
-/**
- * Regression tests for the feedback-settings write path (#1030).
- *
- * The admin event form posts its whole client-side feedback state back,
- * including three keys that were never columns on event_feedback_settings:
- * `enable_rate_limiting`, `rate_limit_window_minutes` and
- * `rate_limit_max_requests`. Spreading those into the knex UPDATE threw,
- * the route answered 500, and EventDetailsPage swallowed it — so the admin
- * saw "Event updated successfully" while "Enable feedback" never persisted
- * and guests could not leave any feedback.
- *
- * Pinned here:
- *  - UI-only keys are dropped, not written, on BOTH the insert (no row yet)
- *    and update (row exists) branches.
- *  - Every real column still round-trips.
- *  - Identity columns can't be mass-assigned through the settings body.
- *  - gallery.js no longer declares a duplicate GET /:slug/feedback-settings.
- *    server.js mounts galleryRoutes before galleryFeedback, so the duplicate
- *    shadowed the real handler and dropped the #655 per-guest caps from the
- *    guest payload.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-feedback-settings-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'feedback-settings-test-secret';
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-const feedbackService = require('../../src/services/feedbackService');
-
-// Exactly what EventDetailsPage holds in state before its settings GET
-// resolves — the three rate-limit keys are UI-only.
-const ADMIN_FORM_BODY = {
-  feedback_enabled: true,
-  allow_ratings: true,
-  allow_likes: true,
-  allow_comments: true,
-  allow_favorites: true,
-  allow_reactions: true,
-  require_name_email: false,
-  moderate_comments: true,
-  show_feedback_to_guests: true,
-  enable_rate_limiting: false,
-  rate_limit_window_minutes: 15,
-  rate_limit_max_requests: 10,
-};
-
-let db;
-let cleanup;
-let eventId;
-
-async function insertEvent(slug) {
-  const inserted = await db('events').insert({
-    slug,
-    event_type: 'wedding',
-    event_name: 'Feedback Settings Test',
-    event_date: '2026-06-22',
-    host_email: 'host@example.com',
-    admin_email: 'admin@example.com',
-    password_hash: 'x',
-    share_link: `/gallery/${slug}/share`,
-    share_token: `${slug}-share`,
-    expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-    is_active: 1,
-    is_archived: 0,
-    is_draft: 0,
-    created_at: new Date().toISOString(),
-  }).returning('id');
-  return inserted[0]?.id ?? inserted[0];
-}
-
-beforeAll(async () => {
-  ({ db, cleanup } = await bootCrmDb());
-  await seedMinimal(db);
-  eventId = await insertEvent('feedback-settings-test');
-}, 120000);
-
-afterAll(async () => { if (cleanup) await cleanup(); });
-
-describe('updateEventFeedbackSettings ignores UI-only keys (#1030)', () => {
-  test('insert branch: enabling feedback on an event with no settings row persists', async () => {
-    const freshEventId = await insertEvent('feedback-settings-fresh');
-
-    const result = await feedbackService.updateEventFeedbackSettings(freshEventId, ADMIN_FORM_BODY);
-
-    expect(result.feedback_enabled).toBeTruthy();
-    const row = await db('event_feedback_settings').where('event_id', freshEventId).first();
-    expect(row).toBeTruthy();
-    expect(row.feedback_enabled).toBeTruthy();
-    expect(row).not.toHaveProperty('enable_rate_limiting');
-  });
-
-  test('update branch: flipping the toggle on an existing row persists', async () => {
-    await feedbackService.updateEventFeedbackSettings(eventId, { feedback_enabled: false });
-    expect((await feedbackService.getEventFeedbackSettings(eventId)).feedback_enabled).toBeFalsy();
-
-    const result = await feedbackService.updateEventFeedbackSettings(eventId, ADMIN_FORM_BODY);
-
-    expect(result.feedback_enabled).toBeTruthy();
-    const rows = await db('event_feedback_settings').where('event_id', eventId);
-    expect(rows).toHaveLength(1);
-    expect(rows[0].feedback_enabled).toBeTruthy();
-  });
-
-  test('every real column round-trips', async () => {
-    const result = await feedbackService.updateEventFeedbackSettings(eventId, {
-      ...ADMIN_FORM_BODY,
-      allow_comments: false,
-      show_feedback_to_guests: false,
-      identity_mode: 'guest',
-      max_favorites_per_guest: 10,
-      max_likes_per_guest: 5,
-    });
-
-    expect(result.allow_comments).toBeFalsy();
-    expect(result.show_feedback_to_guests).toBeFalsy();
-    expect(result.identity_mode).toBe('guest');
-    expect(result.max_favorites_per_guest).toBe(10);
-    expect(result.max_likes_per_guest).toBe(5);
-  });
-
-  test('identity columns cannot be mass-assigned through the settings body', async () => {
-    const otherEventId = await insertEvent('feedback-settings-other');
-    const before = await db('event_feedback_settings').where('event_id', eventId).first();
-
-    await feedbackService.updateEventFeedbackSettings(eventId, {
-      feedback_enabled: true,
-      id: 99999,
-      event_id: otherEventId,
-    });
-
-    const after = await db('event_feedback_settings').where('event_id', eventId).first();
-    expect(after.id).toBe(before.id);
-    expect(after.event_id).toBe(eventId);
-    expect(await db('event_feedback_settings').where('event_id', otherEventId).first()).toBeUndefined();
-  });
-});
-
-describe('guest feedback-settings route is not shadowed (#1030)', () => {
-  test('gallery.js does not declare GET /:slug/feedback-settings', () => {
-    const source = fs.readFileSync(
-      path.resolve(__dirname, '..', '..', 'src', 'routes', 'gallery.js'), 'utf8',
-    );
-    expect(source).not.toMatch(/router\.get\(\s*['"]\/:slug\/feedback-settings['"]/);
-  });
-
-  test('galleryFeedback.js still serves it, including the #655 per-guest caps', () => {
-    const source = fs.readFileSync(
-      path.resolve(__dirname, '..', '..', 'src', 'routes', 'galleryFeedback.js'), 'utf8',
-    );
-    expect(source).toMatch(/router\.get\(\s*['"]\/:slug\/feedback-settings['"]/);
-    expect(source).toMatch(/max_favorites_per_guest/);
-    expect(source).toMatch(/max_likes_per_guest/);
-  });
-});
@@ -1,128 +0,0 @@
-/**
- * DNS-resolving SSRF guard (GHSA SSRF cluster: webhook / S3 / rsync / SMTP /
- * IMAP). The literal isPrivateIP check can't see that a public-looking
- * hostname resolves to an internal/metadata IP; isHostAllowed resolves the
- * name and vets every A/AAAA record.
- */
-jest.mock('dns', () => {
-  const actual = jest.requireActual('dns');
-  return { ...actual, promises: { ...actual.promises, lookup: jest.fn() } };
-});
-const dns = require('dns');
-const {
-  isHostAllowed,
-  validateExternalUrlAsync,
-  classifyHost,
-} = require('../../src/utils/networkValidation');
-
-const lookup = dns.promises.lookup;
-
-describe('classifyHost', () => {
-  beforeEach(() => lookup.mockReset());
-
-  it('distinguishes private, unresolved, ok, and invalid', async () => {
-    lookup.mockResolvedValue([{ address: '10.0.0.5', family: 4 }]);
-    expect(await classifyHost('evil.example')).toBe('private');
-
-    lookup.mockResolvedValue([{ address: '93.184.216.34', family: 4 }]);
-    expect(await classifyHost('example.com')).toBe('ok');
-
-    lookup.mockRejectedValue(new Error('EAI_AGAIN'));
-    expect(await classifyHost('blip.example')).toBe('unresolved');
-
-    lookup.mockResolvedValue([]);
-    expect(await classifyHost('empty.example')).toBe('unresolved');
-
-    expect(await classifyHost('')).toBe('invalid');
-    expect(await classifyHost('10.0.0.1')).toBe('private'); // literal, no lookup
-  });
-});
-
-describe('isHostAllowed', () => {
-  beforeEach(() => lookup.mockReset());
-
-  it('rejects a public hostname that resolves to a private IP', async () => {
-    lookup.mockResolvedValue([{ address: '10.0.0.5', family: 4 }]);
-    expect(await isHostAllowed('evil.example.com')).toBe(false);
-  });
-
-  it('rejects when the hostname resolves to the cloud metadata IP', async () => {
-    lookup.mockResolvedValue([{ address: '169.254.169.254', family: 4 }]);
-    expect(await isHostAllowed('metadata-rebind.example')).toBe(false);
-  });
-
-  it('rejects when ANY resolved address is private (rebinding / mixed records)', async () => {
-    lookup.mockResolvedValue([
-      { address: '93.184.216.34', family: 4 },
-      { address: '169.254.169.254', family: 4 },
-    ]);
-    expect(await isHostAllowed('rebind.example')).toBe(false);
-  });
-
-  it('allows a hostname that resolves only to public IPs', async () => {
-    lookup.mockResolvedValue([{ address: '93.184.216.34', family: 4 }]);
-    expect(await isHostAllowed('example.com')).toBe(true);
-  });
-
-  it('fails closed when resolution errors', async () => {
-    lookup.mockRejectedValue(new Error('ENOTFOUND'));
-    expect(await isHostAllowed('nxdomain.invalid')).toBe(false);
-  });
-
-  it('fails closed on an empty resolution', async () => {
-    lookup.mockResolvedValue([]);
-    expect(await isHostAllowed('empty.example')).toBe(false);
-  });
-
-  it('rejects literal private IPs and blocked names without resolving', async () => {
-    expect(await isHostAllowed('127.0.0.1')).toBe(false);
-    expect(await isHostAllowed('10.0.0.1')).toBe(false);
-    expect(await isHostAllowed('localhost')).toBe(false);
-    expect(await isHostAllowed('metadata.google.internal')).toBe(false);
-    expect(await isHostAllowed('foo.internal')).toBe(false);
-    expect(lookup).not.toHaveBeenCalled();
-  });
-
-  it('allows a public IP literal without resolving', async () => {
-    expect(await isHostAllowed('93.184.216.34')).toBe(true);
-    expect(lookup).not.toHaveBeenCalled();
-  });
-
-  it('rejects empty / non-string input', async () => {
-    expect(await isHostAllowed('')).toBe(false);
-    expect(await isHostAllowed(null)).toBe(false);
-  });
-});
-
-describe('validateExternalUrlAsync', () => {
-  beforeEach(() => lookup.mockReset());
-
-  it('rejects a URL whose host resolves to a private address', async () => {
-    lookup.mockResolvedValue([{ address: '10.1.2.3', family: 4 }]);
-    const r = await validateExternalUrlAsync('https://evil.example/hook');
-    expect(r.valid).toBe(false);
-  });
-
-  it('accepts a URL whose host resolves public', async () => {
-    lookup.mockResolvedValue([{ address: '93.184.216.34', family: 4 }]);
-    expect((await validateExternalUrlAsync('https://example.com/hook')).valid).toBe(true);
-  });
-
-  it('rejects a malformed URL', async () => {
-    expect((await validateExternalUrlAsync('not a url')).valid).toBe(false);
-  });
-
-  it('reports reason=unresolved for a transient lookup failure (retryable)', async () => {
-    lookup.mockRejectedValue(new Error('EAI_AGAIN'));
-    const r = await validateExternalUrlAsync('https://blip.example/hook');
-    expect(r.valid).toBe(false);
-    expect(r.reason).toBe('unresolved');
-  });
-
-  it('reports reason=private for a resolved-private host (permanent)', async () => {
-    lookup.mockResolvedValue([{ address: '169.254.169.254', family: 4 }]);
-    const r = await validateExternalUrlAsync('https://rebind.example/hook');
-    expect(r.valid).toBe(false);
-    expect(r.reason).toBe('private');
-  });
-});
@@ -1,143 +0,0 @@
-/**
- * Regression test for #1024: quote/invoice PDF endpoints 500'd (or silently
- * corrupted the filename) for customers whose name carries non-ASCII.
- *
- * The six PDF routes built the header by interpolating buildPdfFilename()'s
- * result straight into `inline; filename="${filename}"`. HTTP header values
- * are latin1, which splits the failure in two — and the split matters,
- * because the issue reported the umlaut case as the 500 and it isn't:
- *
- *   U+0080-U+00FF  (ä ö ü ß — every German umlaut)
- *       No throw. The byte goes out raw and the client reads back a mangled
- *       name. A silent corruption, not an error.
- *
- *   above U+00FF   (Polish ł, Czech ř, Turkish ş, €, Cyrillic, CJK, emoji)
- *       Node's setHeader rejects it with ERR_INVALID_CHAR. Because the
- *       throw lands after the PDF buffer is already rendered, the whole
- *       request fails as an unhandled 500.
- *
- * buildContentDisposition() fixes both: an ASCII fallback for the legacy
- * `filename=` parameter plus the RFC 5987 `filename*=UTF-8''…` form that
- * carries the real name.
- *
- * These assertions run against the real Node header validator via a live
- * express server, so they'd fail against the old interpolation rather than
- * merely testing the helper in isolation.
- */
-const express = require('express');
-const request = require('supertest');
-
-const { buildPdfFilename, sanitiseSegment } = require('../../src/utils/pdfFilename');
-const { buildContentDisposition } = require('../../src/utils/filenameSanitizer');
-
-// The RFC 5987 parameter prefix, i.e. filename*=UTF-8'' — the two trailing
-// quotes are the (empty) language tag the spec puts between the charset and
-// the percent-encoded value.
-const RFC5987_PREFIX = 'filename*=UTF-8\'\'';
-
-// Mirrors what the six PDF routes now do.
-function buildApp(customer, docNumber = 'Q-2026-0042') {
-  const app = express();
-  app.get('/pdf', (req, res) => {
-    const filename = buildPdfFilename({ docNumber, customer, fallback: 'quote-preview' });
-    res.set('Content-Type', 'application/pdf');
-    res.set('Content-Disposition', buildContentDisposition(filename, 'inline'));
-    res.send(Buffer.from('%PDF-1.4 fake'));
-  });
-  // Mirrors the real error handler: an ERR_INVALID_CHAR throw inside the
-  // handler surfaces as a 500, which is what #1024 reported.
-  // eslint-disable-next-line no-unused-vars
-  app.use((err, req, res, next) => res.status(500).json({ error: err.code || err.message }));
-  return app;
-}
-
-describe('#1024 — PDF Content-Disposition with non-ASCII customer names', () => {
-  it('serves a PDF for a German umlaut name and keeps the name intact', async () => {
-    const res = await request(buildApp({ company_name: 'Müller Fotografie' })).get('/pdf');
-
-    expect(res.status).toBe(200);
-    const cd = res.headers['content-disposition'];
-    // RFC 5987 form carries the real, unmangled name...
-    expect(cd).toContain(RFC5987_PREFIX);
-    expect(cd).toContain(encodeURIComponent('Müller-Fotografie.pdf'));
-    // ...and the ASCII fallback is legal latin1 with no raw umlaut byte.
-    const fallback = /filename="([^"]+)"/.exec(cd)[1];
-    expect(fallback).toMatch(/^[\x20-\x7e]+$/);
-  });
-
-  it.each([
-    ['Polish',   'Michał Kowalski'],
-    ['Czech',    'Dvořák Studio'],
-    ['Turkish',  'Şahin Fotoğraf'],
-    ['Cyrillic', 'Иванов Фото'],
-    ['CJK',      '山田写真'],
-    ['emoji',    'Studio 🎉 Berlin'],
-  ])('does not 500 for a %s customer name (was ERR_INVALID_CHAR)', async (_label, company) => {
-    const res = await request(buildApp({ company_name: company })).get('/pdf');
-
-    expect(res.status).toBe(200);
-    const cd = res.headers['content-disposition'];
-    expect(cd).toContain(RFC5987_PREFIX);
-    // The legacy filename= token drops non-ASCII, so a name written entirely
-    // in another script degrades to just the document number
-    // (`Q-2026-0042_.pdf`). That's the intended trade — filename* carries the
-    // real name — but the fallback must still be a legal, non-empty,
-    // ASCII-only token, since that is what a client without RFC 5987 support
-    // ends up saving.
-    const fallback = /filename="([^"]*)"/.exec(cd)[1];
-    expect(fallback.length).toBeGreaterThan(0);
-    expect(fallback).toMatch(/^[\x20-\x7e]+$/);
-    expect(fallback).toContain('Q-2026-0042');
-  });
-
-  it('leaves a plain ASCII name on the familiar filename= form', async () => {
-    const res = await request(buildApp({ company_name: 'Bright Studio' })).get('/pdf');
-
-    expect(res.status).toBe(200);
-    expect(res.headers['content-disposition'])
-      .toContain('filename="Q-2026-0042_Bright-Studio.pdf"');
-  });
-
-  it('still works when the customer row is missing entirely (preview path)', async () => {
-    const res = await request(buildApp(null, null)).get('/pdf');
-
-    expect(res.status).toBe(200);
-    expect(res.headers['content-disposition']).toContain('quote-preview_customer.pdf');
-  });
-
-  // sanitiseSegment caps each segment at 80 UTF-16 code units. A cap landing
-  // inside an astral character used to leave a dangling high surrogate, which
-  // makes encodeURIComponent throw URIError inside buildContentDisposition —
-  // a 500 on the very endpoint this PR fixes, reached a different way.
-  it.each([
-    ['emoji on the 80-char boundary',      `${'a'.repeat(79)}🎉`],
-    ['astral CJK on the boundary',         `${'a'.repeat(79)}𠜎`],
-    ['a label that is entirely astral',    '🎉'.repeat(60)],
-  ])('does not 500 when truncation splits a surrogate pair — %s', async (_label, company) => {
-    const res = await request(buildApp({ company_name: company })).get('/pdf');
-
-    expect(res.status).toBe(200);
-    expect(res.headers['content-disposition']).toContain(RFC5987_PREFIX);
-  });
-
-  it('drops the orphaned surrogate rather than widening the length cap', () => {
-    const seg = sanitiseSegment(`${'a'.repeat(79)}🎉`);
-
-    // 79 'a's + a half-emoji would be 80; the orphan is dropped, not kept.
-    expect(seg).toHaveLength(79);
-    expect(seg).toBe('a'.repeat(79));
-    // Nothing in the result may be an unpaired surrogate.
-    expect(seg).toBe(seg.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])/g, ''));
-  });
-
-  it('the raw interpolation these routes used to do really does throw', () => {
-    // Pins the root cause itself, so nobody "simplifies" the helper away.
-    const filename = buildPdfFilename({
-      docNumber: 'Q-2026-0042',
-      customer: { company_name: 'Michał Kowalski' },
-    });
-    const res = new (require('http').ServerResponse)({});
-    expect(() => res.setHeader('Content-Disposition', `inline; filename="${filename}"`))
-      .toThrow(/ERR_INVALID_CHAR|Invalid character/);
-  });
-});
@@ -1,40 +0,0 @@
-/**
- * Unit tests for the shared hidden-photo access-control helper.
- *
- * Pins the rule that ordinary gallery guests never receive photos with
- * visibility='hidden' (NULL = visible), while PIN-clients see everything.
- */
-const {
-  canSeeHiddenPhotos,
-  isPhotoHiddenFromViewer,
-} = require('../../src/utils/photoVisibility');
-
-describe('canSeeHiddenPhotos', () => {
-  it('is true only for the client access level', () => {
-    expect(canSeeHiddenPhotos('client')).toBe(true);
-    expect(canSeeHiddenPhotos('guest')).toBe(false);
-    expect(canSeeHiddenPhotos('slideshow')).toBe(false);
-    expect(canSeeHiddenPhotos(undefined)).toBe(false);
-  });
-});
-
-describe('isPhotoHiddenFromViewer', () => {
-  it('blocks a hidden photo from guests', () => {
-    expect(isPhotoHiddenFromViewer({ visibility: 'hidden' }, 'guest')).toBe(true);
-    expect(isPhotoHiddenFromViewer({ visibility: 'hidden' }, 'slideshow')).toBe(true);
-  });
-
-  it('lets clients see hidden photos', () => {
-    expect(isPhotoHiddenFromViewer({ visibility: 'hidden' }, 'client')).toBe(false);
-  });
-
-  it('treats visible and NULL visibility as viewable by everyone', () => {
-    expect(isPhotoHiddenFromViewer({ visibility: 'visible' }, 'guest')).toBe(false);
-    expect(isPhotoHiddenFromViewer({ visibility: null }, 'guest')).toBe(false);
-    expect(isPhotoHiddenFromViewer({}, 'guest')).toBe(false);
-  });
-
-  it('is null-safe', () => {
-    expect(isPhotoHiddenFromViewer(null, 'guest')).toBe(false);
-  });
-});
@@ -99,22 +99,10 @@ describe('resolveLogoFile', () => {
    }
  });

-  it('rejects an absolute path OUTSIDE the storage roots (GHSA-c7x5)', async () => {
-    // The raw-absolute candidate was an arbitrary-file-read primitive
-    // (logo_path: '/etc/passwd' → rasterised into a PDF). Absolute paths
-    // outside the storage roots are now dropped even if they exist.
+  it('treats absolute paths as-is when they exist', async () => {
    existsSpy.mockImplementation((p) => p === '/abs/path/logo.png');
    getAppSetting.mockResolvedValue(null);
    const out = await resolveLogoFile({ logo_path: '/abs/path/logo.png' });
-    expect(out).toBeNull();
-  });
-
-  it('still accepts an absolute path INSIDE the storage root', async () => {
-    // The legitimate case: multer stores the uploaded logo under
-    // storage/uploads/logos with an absolute path — that stays resolvable.
-    existsSpy.mockImplementation((p) => p === '/app/storage/uploads/logos/logo.png');
-    getAppSetting.mockResolvedValue(null);
-    const out = await resolveLogoFile({ logo_path: '/app/storage/uploads/logos/logo.png' });
-    expect(out).toBe('/app/storage/uploads/logos/logo.png');
+    expect(out).toBe('/abs/path/logo.png');
  });
 });
@@ -1,96 +0,0 @@
-/**
- * Credential redaction for log payloads (GHSA-pgmp / GHSA-r794).
- *
- * Event create/update logged the whole request body. Beyond the plaintext
- * gallery password named in the advisories, the update path also logged
- * `client_share_token` — a LIVE bearer credential for client gallery access,
- * freshly minted by `regenerate_client_token` — and `client_password_hash`.
- */
-
-const { sanitizeForLog, isSensitiveKey } = require('../../src/utils/sanitizeForLog');
-
-describe('sanitizeForLog', () => {
-  it('redacts the credentials an event body actually carries', () => {
-    const out = sanitizeForLog({
-      event_name: 'Wedding',
-      password: 'FAKE-PLAINTEXT-PASSWORD',
-      client_password: 'FAKE-CLIENT-PASSWORD',
-      client_password_hash: 'FAKE-BCRYPT-HASH-PLACEHOLDER',
-      client_share_token: 'FAKE-CLIENT-SHARE-TOKEN',
-      share_token: 'FAKE-SHARE-TOKEN',
-    });
-
-    expect(out.event_name).toBe('Wedding');
-    for (const key of ['password', 'client_password', 'client_password_hash',
-      'client_share_token', 'share_token']) {
-      expect(out[key]).toBe('[redacted]');
-    }
-    expect(JSON.stringify(out)).not.toContain('FAKE-PLAINTEXT-PASSWORD');
-    expect(JSON.stringify(out)).not.toContain('FAKE-CLIENT-SHARE-TOKEN');
-  });
-
-  it('redacts nested and array-nested secrets', () => {
-    const out = sanitizeForLog({
-      smtp: { host: 'mail.example.com', smtp_password: 'p' },
-      users: [{ name: 'a', api_key: 'k' }],
-    });
-    expect(out.smtp.host).toBe('mail.example.com');
-    expect(out.smtp.smtp_password).toBe('[redacted]');
-    expect(out.users[0].name).toBe('a');
-    expect(out.users[0].api_key).toBe('[redacted]');
-  });
-
-  it('passes non-objects through and survives cycles', () => {
-    expect(sanitizeForLog('plain')).toBe('plain');
-    expect(sanitizeForLog(42)).toBe(42);
-    expect(sanitizeForLog(null)).toBeNull();
-
-    const cyclic = { name: 'x' };
-    cyclic.self = cyclic;
-    expect(() => sanitizeForLog(cyclic)).not.toThrow();
-    expect(sanitizeForLog(cyclic).self).toBe('[circular]');
-  });
-
-  it('matches key names case-insensitively and by fragment', () => {
-    expect(isSensitiveKey('Authorization')).toBe(true);
-    expect(isSensitiveKey('CLIENT_SHARE_TOKEN')).toBe(true);
-    expect(isSensitiveKey('event_name')).toBe(false);
-  });
-});
-
-/**
- * Codex round 2: sanitizing req.body was not enough. express-validator's
- * errors.array() embeds the SUBMITTED value per field, so a password rejected
- * for being too short was still logged in plaintext.
- */
-describe('sanitizeValidationErrors', () => {
-  const { sanitizeValidationErrors } = require('../../src/utils/sanitizeForLog');
-
-  it('redacts the submitted value for a password field', () => {
-    const out = sanitizeValidationErrors([
-      { type: 'field', path: 'password', msg: 'too short', value: 'FAKE-PLAINTEXT-PASSWORD' },
-      { type: 'field', path: 'event_name', msg: 'required', value: '' },
-    ]);
-    expect(out[0].value).toBe('[redacted]');
-    expect(out[0].msg).toBe('too short');
-    expect(JSON.stringify(out)).not.toContain('FAKE-PLAINTEXT-PASSWORD');
-    expect(out[1].value).toBe('');
-  });
-
-  it('handles the legacy `param` field name', () => {
-    const out = sanitizeValidationErrors([{ param: 'client_password', value: 'FAKE-SECRET' }]);
-    expect(out[0].value).toBe('[redacted]');
-  });
-
-  it('recurses into object values on non-sensitive fields', () => {
-    const out = sanitizeValidationErrors([
-      { path: 'config', value: { host: 'h', api_key: 'k' } },
-    ]);
-    expect(out[0].value.host).toBe('h');
-    expect(out[0].value.api_key).toBe('[redacted]');
-  });
-
-  it('passes non-arrays through untouched', () => {
-    expect(sanitizeValidationErrors(undefined)).toBeUndefined();
-  });
-});
@@ -0,0 +1,56 @@
+/**
+ * Unit tests for the global session cutoff (utils/sessionCutoff.js). Uses a
+ * real in-memory SQLite `app_settings` table so the read/write/parse path is
+ * exercised exactly as in production.
+ */
+const knex = require('knex');
+
+let db;
+let cutoff;
+
+beforeEach(async () => {
+  db = knex({ client: 'sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  await db.schema.createTable('app_settings', (t) => {
+    t.increments('id');
+    t.string('setting_key').notNullable().unique();
+    t.text('setting_value');
+    t.string('setting_type');
+    t.timestamp('updated_at');
+  });
+  jest.resetModules();
+  jest.doMock('../../src/database/db', () => ({ db }));
+  cutoff = require('../../src/utils/sessionCutoff');
+  cutoff._resetCache();
+});
+
+afterEach(async () => {
+  jest.dontMock('../../src/database/db');
+  await db.destroy();
+});
+
+test('no cutoff set → nothing is invalidated', async () => {
+  expect(await cutoff.getSessionsValidAfter()).toBe(0);
+  expect(await cutoff.isTokenBeforeCutoff({ iat: 1000 })).toBe(false);
+});
+
+test('token issued before the cutoff is rejected, at/after is accepted', async () => {
+  await cutoff.setSessionsValidAfter(2000);
+  expect(await cutoff.isTokenBeforeCutoff({ iat: 1999 })).toBe(true);   // pre-restore session
+  expect(await cutoff.isTokenBeforeCutoff({ iat: 2000 })).toBe(false);  // same second → kept
+  expect(await cutoff.isTokenBeforeCutoff({ iat: 2001 })).toBe(false);  // post-restore login
+});
+
+test('setSessionsValidAfter upserts a single row and refreshes the cache', async () => {
+  await cutoff.setSessionsValidAfter(1000);
+  await cutoff.setSessionsValidAfter(3000);
+  const rows = await db('app_settings').where('setting_key', 'security_sessions_valid_after');
+  expect(rows).toHaveLength(1);
+  cutoff._resetCache();
+  expect(await cutoff.getSessionsValidAfter()).toBe(3000);
+});
+
+test('a token without iat is never treated as before the cutoff', async () => {
+  await cutoff.setSessionsValidAfter(2000);
+  expect(await cutoff.isTokenBeforeCutoff({})).toBe(false);
+  expect(await cutoff.isTokenBeforeCutoff(null)).toBe(false);
+});
@@ -1,106 +0,0 @@
-/**
- * Regression test for clearing an event's expiration on SQLite (#1029).
- *
- * Migration 061 dropped the NOT NULL on events.event_date / events.expires_at
- * for Postgres only — it skipped SQLite on the (wrong) premise that SQLite
- * doesn't enforce NOT NULL. It does, so every SQLite install answered
- *
- *     SQLITE_CONSTRAINT: NOT NULL constraint failed: events.expires_at
- *
- * when an admin cleared the expiration, surfacing as "Failed to update event".
- * Migration 174 finishes the job. The harness runs on SQLite, so this asserts
- * the real engine behaviour rather than a mock.
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-process.env.NODE_ENV = 'test';
-process.env.TEST_DATABASE_PATH = path.join(
-  fs.mkdtempSync(path.join(os.tmpdir(), 'picpeak-nullable-dates-')), 'db.sqlite',
-);
-process.env.JWT_SECRET = process.env.JWT_SECRET || 'nullable-dates-test-secret';
-
-const { bootCrmDb, seedMinimal } = require('../integration/helpers/crmDb');
-
-let db;
-let cleanup;
-let eventId;
-
-beforeAll(async () => {
-  ({ db, cleanup } = await bootCrmDb());
-  await seedMinimal(db);
-  const inserted = await db('events').insert({
-    slug: 'nullable-dates-test',
-    event_type: 'wedding',
-    event_name: 'Nullable Dates Test',
-    event_date: '2026-06-22',
-    host_email: 'host@example.com',
-    admin_email: 'admin@example.com',
-    password_hash: 'x',
-    share_link: '/gallery/nullable-dates-test/share',
-    share_token: 'nullable-dates-share',
-    expires_at: new Date(Date.now() + 7 * 24 * 3600 * 1000).toISOString(),
-    is_active: 1,
-    is_archived: 0,
-    is_draft: 0,
-    created_at: new Date().toISOString(),
-  }).returning('id');
-  eventId = inserted[0]?.id ?? inserted[0];
-}, 120000);
-
-afterAll(async () => { if (cleanup) await cleanup(); });
-
-describe('events date columns are nullable on SQLite (#1029)', () => {
-  test('the engine under test really is SQLite', () => {
-    expect(['sqlite3', 'better-sqlite3']).toContain(db.client.config.client);
-  });
-
-  test('clearing expires_at succeeds — this threw SQLITE_CONSTRAINT before migration 174', async () => {
-    await db('events').where('id', eventId).update({ expires_at: null });
-    const row = await db('events').where('id', eventId).first('expires_at');
-    expect(row.expires_at).toBeNull();
-  });
-
-  test('clearing event_date succeeds too (061 covered both columns on PG)', async () => {
-    await db('events').where('id', eventId).update({ event_date: null });
-    const row = await db('events').where('id', eventId).first('event_date');
-    expect(row.event_date).toBeNull();
-  });
-
-  test('a gallery can be created with no expiration at all', async () => {
-    const inserted = await db('events').insert({
-      slug: 'never-expires-test',
-      event_type: 'other',
-      event_name: 'Never Expires',
-      event_date: null,
-      host_email: 'host@example.com',
-      admin_email: 'admin@example.com',
-      password_hash: 'x',
-      share_link: '/gallery/never-expires-test/share',
-      share_token: 'never-expires-share',
-      expires_at: null,
-      is_active: 1,
-      is_archived: 0,
-      is_draft: 0,
-      created_at: new Date().toISOString(),
-    }).returning('id');
-    const id = inserted[0]?.id ?? inserted[0];
-    const row = await db('events').where('id', id).first('expires_at', 'event_date');
-    expect(row.expires_at).toBeNull();
-    expect(row.event_date).toBeNull();
-  });
-
-  test('columns the events table depends on survived the table rebuild', async () => {
-    // Knex implements .alter() on SQLite by recreating the table; make sure the
-    // rebuild kept the row and the wider schema intact.
-    const row = await db('events').where('id', eventId).first();
-    expect(row.slug).toBe('nullable-dates-test');
-    expect(row.share_token).toBe('nullable-dates-share');
-    expect(await db.schema.hasColumn('events', 'allow_downloads')).toBe(true);
-    expect(await db.schema.hasColumn('events', 'hero_photo_id')).toBe(true);
-    const photos = await db('photos').where('event_id', eventId);
-    expect(Array.isArray(photos)).toBe(true);
-  });
-});
@@ -1,160 +0,0 @@
-/**
- * The contract that matters here is negative: a source that disappears must
- * NOT be able to end the process (#1128).
- *
- * `fs.createReadStream` is lazy, so its ENOENT lands on a later tick, outside
- * the route's try/catch. An EventEmitter emitting 'error' with no listener
- * throws, and an uncaught throw from an I/O callback exits Node — which is how
- * one missing thumbnail tier took every gallery on the install down.
- *
- * These use a REAL fs stream over a real missing path rather than a fake
- * emitter: the point under test is the lazy-open timing, and a hand-rolled
- * mock that emits synchronously would pass while proving nothing.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { Readable } = require('stream');
-const { EventEmitter } = require('events');
-
-const { pipeStreamToResponse } = require('../../src/utils/streamResponse');
-
-jest.mock('../../src/utils/logger', () => ({
-  warn: jest.fn(), error: jest.fn(), info: jest.fn(), debug: jest.fn(),
-}));
-
-/** Minimal Express-ish response that records what happened to it. */
-function makeRes() {
-  const res = new EventEmitter();
-  res.headers = { 'Content-Length': '1234', ETag: '"x"' };
-  res.statusCode = 200;
-  res.headersSent = false;
-  res.writableEnded = false;
-  res.body = null;
-  res.destroyed = false;
-  res.removeHeader = (h) => { delete res.headers[h]; };
-  res.setHeader = (h, v) => { res.headers[h] = v; };
-  res.status = (code) => { res.statusCode = code; return res; };
-  res.json = (payload) => { res.body = payload; res.writableEnded = true; return res; };
-  res.destroy = () => { res.destroyed = true; };
-  // pipe() target surface
-  res.write = () => true;
-  res.end = () => { res.writableEnded = true; };
-  res.on = EventEmitter.prototype.on.bind(res);
-  res.emit = EventEmitter.prototype.emit.bind(res);
-  return res;
-}
-
-const settle = () => new Promise((resolve) => setTimeout(resolve, 50));
-
-describe('pipeStreamToResponse (#1128)', () => {
-  it('turns a missing file into a 404 instead of an unhandled error', async () => {
-    const missing = path.join(os.tmpdir(), `picpeak-not-here-${Date.now()}.jpg`);
-    const res = makeRes();
-
-    pipeStreamToResponse(stream_(missing), res, { context: 'thumbnail for photo 1' });
-    await settle();
-
-    expect(res.statusCode).toBe(404);
-    expect(res.body).toEqual({ error: 'File not found' });
-  });
-
-  // How this test discriminates, since the failure mode is a process-level
-  // one: replacing the call above with a bare `stream.pipe(res)` — what the
-  // thumbnail route did — makes jest fail this suite on the unhandled 'error'
-  // event before either assertion runs. Verified by doing exactly that.
-  // Catching the throw with a process.on('uncaughtException') listener does
-  // NOT work here and would be theatre: the runner installs its own handling,
-  // so such a listener never sees it and the assertion could never fail.
-  function stream_(p) { return fs.createReadStream(p); }
-
-  it('strips every header that described the file it can no longer send', async () => {
-    const res = makeRes();
-    // What the image and zip routes actually stage before streaming.
-    res.headers = {
-      'Content-Length': '1234',
-      ETag: '"x"',
-      'Content-Type': 'image/jpeg',
-      'Content-Disposition': 'attachment; filename="gallery.zip"',
-      'Cache-Control': 'private, max-age=1800',
-    };
-    const stream = fs.createReadStream(path.join(os.tmpdir(), `gone-${Date.now()}.jpg`));
-
-    pipeStreamToResponse(stream, res);
-    await settle();
-
-    expect(res.headers['Content-Length']).toBeUndefined();
-    expect(res.headers.ETag).toBeUndefined();
-    // Express does NOT overwrite an existing Content-Type, so leaving it makes
-    // res.json() emit JSON labelled image/jpeg — or a corrupt .zip download.
-    expect(res.headers['Content-Type']).toBeUndefined();
-    expect(res.headers['Content-Disposition']).toBeUndefined();
-  });
-
-  it('does not let a transient 404 be cached as a broken tile', async () => {
-    const res = makeRes();
-    // The thumbnail route stages 30 minutes; the hero route an hour.
-    res.headers = { 'Cache-Control': 'private, max-age=1800' };
-    const stream = fs.createReadStream(path.join(os.tmpdir(), `gone3-${Date.now()}.jpg`));
-
-    pipeStreamToResponse(stream, res);
-    await settle();
-
-    // The regeneration race is transient by definition: the tier exists moments
-    // later. Caching this 404 would keep the tile broken long after the file is
-    // back — the opposite of what this helper is for.
-    expect(res.headers['Cache-Control']).toBe('no-store');
-  });
-
-  it('honours a caller that wants a different missing-status', async () => {
-    const res = makeRes();
-    const stream = fs.createReadStream(path.join(os.tmpdir(), `gone2-${Date.now()}.zip`));
-
-    pipeStreamToResponse(stream, res, { missingStatus: 410 });
-    await settle();
-
-    expect(res.statusCode).toBe(410);
-  });
-
-  it('destroys the response instead of rewriting a status that is already sent', async () => {
-    const res = makeRes();
-    res.headersSent = true;
-
-    const stream = new Readable({ read() {} });
-    pipeStreamToResponse(stream, res, { context: 'photo 9' });
-    stream.emit('error', Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
-    await settle();
-
-    // Once bytes are on the wire a 404 is not available; a truncated image the
-    // client would cache is worse than a broken connection.
-    expect(res.destroyed).toBe(true);
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toBeNull();
-  });
-
-  it('reports a non-ENOENT failure as a 500 rather than a 404', async () => {
-    const res = makeRes();
-    const stream = new Readable({ read() {} });
-
-    pipeStreamToResponse(stream, res);
-    stream.emit('error', Object.assign(new Error('disk exploded'), { code: 'EIO' }));
-    await settle();
-
-    expect(res.statusCode).toBe(500);
-    expect(res.body).toEqual({ error: 'Failed to serve file' });
-  });
-
-  it('releases the source when the client hangs up mid-download', async () => {
-    const res = makeRes();
-    let destroyed = false;
-    const stream = new Readable({ read() {}, destroy(err, cb) { destroyed = true; cb(err); } });
-
-    pipeStreamToResponse(stream, res);
-    res.emit('close');
-    await settle();
-
-    // Otherwise an abandoned grid leaks one open fd per tile.
-    expect(destroyed).toBe(true);
-  });
-});
@@ -0,0 +1,93 @@
+Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -1,8 +1,9 @@
 module.exports = {
  testEnvironment: 'node',
-  // bootCrmDb() runs EVERY core migration in beforeAll and the chain keeps
-  // growing (134 migrations and counting via backports). 120s matches the
-  // beta-branch convention from #860.
+  // bootCrmDb() runs EVERY core migration in beforeAll; the chain keeps
+  // growing (163-165 pushed several suites past jest's default on CI
+  // runners — the 3.94 release PR failed on exactly this). 120s matches
+  // the convention the newer suites already pin explicitly.
  testTimeout: 120000,
  coverageDirectory: 'coverage',
  collectCoverageFrom: [
@@ -1,13 +1,39 @@
 require('dotenv').config();

+const path = require('path');
+
 // Database configuration for different environments
-// Shared with the engine guard (#1038) so both resolve the identical path.
-const { resolveSqliteFilename } = require('./src/utils/sqlitePath');
-// One resolution of the PostgreSQL target for the whole application (#1038).
-// The development and production blocks used to carry different host/user/
-// database defaults, so a process that probed or migrated against one could
-// hand over to a process that opened another.
-const { pgConnectionFromEnv } = require('./src/utils/pgConnection');
+const resolveSqliteFilename = (filenameEnv) => {
+  const fallback = path.join(__dirname, './data/photo_sharing.db');
+
+  if (!filenameEnv) {
+    return fallback;
+  }
+
+  const trimmed = String(filenameEnv).trim();
+  if (!trimmed) {
+    return fallback;
+  }
+
+  let resolved;
+  if (path.isAbsolute(trimmed)) {
+    resolved = trimmed;
+  } else if (trimmed.startsWith('./') || trimmed.startsWith('../')) {
+    resolved = path.resolve(__dirname, trimmed);
+  } else {
+    resolved = path.join(__dirname, trimmed);
+  }
+
+  const normalized = path.normalize(resolved);
+  const baseSuffix = path.relative(path.parse(__dirname).root, path.normalize(__dirname));
+  const duplicatePattern = `${path.sep}${baseSuffix}${path.sep}${baseSuffix}`;
+
+  if (normalized.includes(duplicatePattern)) {
+    return normalized.replace(duplicatePattern, `${path.sep}${baseSuffix}`);
+  }
+
+  return normalized;
+};

 const sqliteConnection = (filenameEnv) => ({
  filename: resolveSqliteFilename(filenameEnv)
@@ -28,7 +54,13 @@ const baseSqliteConfig = {
 const config = {
  development: {
    client: process.env.DATABASE_CLIENT || 'sqlite3',
-    connection: process.env.DATABASE_CLIENT === 'pg' ? pgConnectionFromEnv() : {
+    connection: process.env.DATABASE_CLIENT === 'pg' ? {
+      host: process.env.DB_HOST || 'localhost',
+      port: process.env.DB_PORT || 5432,
+      user: process.env.DB_USER || 'postgres',
+      password: process.env.DB_PASSWORD || 'postgres',
+      database: process.env.DB_NAME || 'photo_sharing'
+    } : {
      filename: resolveSqliteFilename(process.env.DATABASE_PATH || './data/photo_sharing.db')
    },
    useNullAsDefault: process.env.DATABASE_CLIENT !== 'pg',
@@ -65,7 +97,12 @@ const config = {
    // Support both Postgres and SQLite in production based on DATABASE_CLIENT
    connection: (process.env.DATABASE_CLIENT || 'pg') === 'pg'
      ? {
-          ...pgConnectionFromEnv(),
+          host: process.env.DB_HOST || 'db',
+          port: process.env.DB_PORT || 5432,
+          user: process.env.DB_USER || 'picpeak',
+          password: process.env.DB_PASSWORD,
+          database: process.env.DB_NAME || 'picpeak',
+          ssl: process.env.DB_SSL === 'true' ? { rejectUnauthorized: false } : false,
          // Connection stability settings
          connectionTimeoutMillis: 30000,
          idleTimeoutMillis: 30000,
@@ -77,11 +77,7 @@ const DEFAULT_CSS_TEMPLATE = `/*

 .photo-card img {
  width: 100%;
-  /* 100%, not a fixed pixel height: every aspect-ratio layout (masonry,
-     justified, mosaic, gallery-premium) gives .photo-card a definite height
-     computed from photos.width/height, and this rule's specificity (0,1,1)
-     beats the .h-full utility (0,1,0) the layouts rely on — #1131. */
-  height: 100%;
+  height: 200px;
  object-fit: cover;
  transition: transform 0.3s ease;
 }
@@ -503,9 +503,7 @@ const LIQUID_GLASS_DARK = `/*

 .photo-card img {
  width: 100%;
-  /* See #1131: a fixed height here beats the layouts' .h-full utility and
-     detaches the image from its aspect-ratio-sized card. */
-  height: 100%;
+  height: 240px;
  object-fit: cover;
  transition: transform 0.4s ease, filter 0.4s ease;
  filter: brightness(0.9);
@@ -641,7 +639,7 @@ const LIQUID_GLASS_DARK = `/*
  }

  .photo-card img {
-    height: 100%;
+    height: 180px;
  }

  /* Reduce animation complexity on mobile */
@@ -0,0 +1,37 @@
+/**
+ * Migration 158: per-event slideshow ordering + category filter (#202).
+ *
+ * - `show_order`      — 'chronological' (default, upload order) | 'random'
+ *                       (client-side shuffle). Lets the Live Slideshow play
+ *                       photos in a varied order during an event.
+ * - `show_category_id`— optional FK into `photo_categories`. When set, the
+ *                       slideshow only shows photos in that category (NULL =
+ *                       all visible photos, the existing behaviour).
+ *
+ * Both additive + guarded. Defaults preserve today's behaviour (chronological,
+ * all photos), so existing slideshows are unchanged.
+ */
+exports.up = async function up(knex) {
+  const hasOrder = await knex.schema.hasColumn('events', 'show_order');
+  if (!hasOrder) {
+    await knex.schema.alterTable('events', (t) => {
+      t.string('show_order', 20).defaultTo('chronological');
+    });
+  }
+  const hasCat = await knex.schema.hasColumn('events', 'show_category_id');
+  if (!hasCat) {
+    await knex.schema.alterTable('events', (t) => {
+      t.integer('show_category_id').nullable();
+    });
+  }
+};
+
+exports.down = async function down(knex) {
+  for (const col of ['show_order', 'show_category_id']) {
+    // eslint-disable-next-line no-await-in-loop
+    if (await knex.schema.hasColumn('events', col)) {
+      // eslint-disable-next-line no-await-in-loop
+      await knex.schema.alterTable('events', (t) => t.dropColumn(col));
+    }
+  }
+};
@@ -0,0 +1,57 @@
+/**
+ * Migration 159: per-event category ordering (#782).
+ *
+ * Adds a `display_order` integer to `photo_categories` so photographers can
+ * arrange an event's categories in the flow of the day (Pre-Ceremony →
+ * Ceremony → Reception …) instead of the hard-coded A–Z order. Mirrors the
+ * `display_order` column + reorder pattern already used by `event_types`.
+ *
+ * Preserve existing galleries: backfill `display_order` from the CURRENT
+ * (alphabetical) order, scoped — globals numbered together, event-specific
+ * numbered per event — so nothing reshuffles on upgrade. A custom order is
+ * opt-in via the admin reorder controls. See feedback: migrations should pin
+ * previously-implicit defaults onto existing rows.
+ *
+ * Backfill runs in JS (not a SQL window function) to stay portable across
+ * SQLite (dev) and Postgres (prod).
+ *
+ * Additive + hasColumn-guarded.
+ */
+async function addColumn(knex, table, column, builder) {
+  if (!(await knex.schema.hasColumn(table, column))) {
+    await knex.schema.alterTable(table, builder);
+  }
+}
+
+exports.up = async function (knex) {
+  if (!(await knex.schema.hasTable('photo_categories'))) return;
+
+  await addColumn(knex, 'photo_categories', 'display_order', (t) => {
+    t.integer('display_order').notNullable().defaultTo(0);
+    t.index('display_order');
+  });
+
+  // Backfill from the current alphabetical order, per scope, so existing
+  // galleries render exactly as before until an admin reorders.
+  const cats = await knex('photo_categories')
+    .select('id', 'name', 'is_global', 'event_id')
+    .orderBy('name', 'asc');
+
+  const counters = {};
+  for (const c of cats) {
+    const scope = c.is_global ? 'global' : `event:${c.event_id}`;
+    counters[scope] = (counters[scope] || 0) + 1;
+    await knex('photo_categories')
+      .where('id', c.id)
+      .update({ display_order: counters[scope] });
+  }
+};
+
+exports.down = async function (knex) {
+  if (!(await knex.schema.hasTable('photo_categories'))) return;
+  if (await knex.schema.hasColumn('photo_categories', 'display_order')) {
+    await knex.schema.alterTable('photo_categories', (t) =>
+      t.dropColumn('display_order')
+    );
+  }
+};
@@ -0,0 +1,46 @@
+/**
+ * Migration 160: per-event category order override (#782).
+ *
+ * Builds on migration 159 (photo_categories.display_order = the GLOBAL default
+ * order) by adding a per-event OVERRIDE layer. Global categories are shared
+ * across every event, so a single display_order can only express one order for
+ * them. This table lets a single gallery arrange its categories — globals AND
+ * event-specific, interleaved into the flow of the day — independently of the
+ * global default.
+ *
+ * Resolution (see adminCategories / gallery):
+ *   1. if the event has override rows -> use override.position;
+ *   2. else fall back to photo_categories.display_order (the global default);
+ *   3. else name.
+ *
+ * An event is either "using the default" (no rows here) or "customised" (a row
+ * per category it shows). No backfill: every existing event starts on the
+ * default order, so nothing reshuffles — a custom order is opt-in per event.
+ *
+ * Additive + hasTable-guarded.
+ */
+exports.up = async function (knex) {
+  if (!(await knex.schema.hasTable('photo_categories'))) return;
+  if (await knex.schema.hasTable('event_category_order')) return;
+
+  await knex.schema.createTable('event_category_order', (t) => {
+    t.increments('id').primary();
+    t.integer('event_id').notNullable()
+      .references('id').inTable('events').onDelete('CASCADE');
+    t.integer('category_id').notNullable()
+      .references('id').inTable('photo_categories').onDelete('CASCADE');
+    t.integer('position').notNullable().defaultTo(0);
+    t.timestamp('created_at').defaultTo(knex.fn.now());
+
+    // At most one position per (event, category).
+    t.unique(['event_id', 'category_id']);
+    // Ordered reads are always scoped to one event.
+    t.index(['event_id', 'position']);
+  });
+};
+
+exports.down = async function (knex) {
+  if (await knex.schema.hasTable('event_category_order')) {
+    await knex.schema.dropTable('event_category_order');
+  }
+};
--- a/Show More
+++ b/Show More