From 31a027c93a713366864a7a912ee0ded61230865f Mon Sep 17 00:00:00 2001
From: Marc <me_honeyy@proton.me>
Date: Mon, 24 Aug 2026 09:25:36 +0200
Subject: [PATCH] =?UTF-8?q?feat(aether):=20initial=20commit=20=E2=80=93=20?=
 =?UTF-8?q?self-hosted=20Cloud,=20Phasen=201=E2=80=937?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Go-Backend (chi, pgx, golang-migrate) + React/TS-Frontend als PWA.
Enthalten: Auth inkl. OIDC, Dateien mit Versionen und Papierkorb,
Freigaben (Links + intern), WebDAV, Gruppenordner, Admin/Theming,
Volltextsuche mit OCR, eigener PDF-Betrachter und WOPI-Office
(Collabora/OnlyOffice).

Nicht im Repo: deploy/.env (Sitzungsschlüssel, DB- und Admin-Passwort)
sowie alle Daten- und Build-Verzeichnisse – siehe .gitignore.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .dockerignore                                 |   26 +
 .gitignore                                    |   28 +
 CLAUDE.md                                     |  165 +
 README.md                                     |  417 ++
 TESTING.md                                    | 1079 +++
 backend/cmd/aether/main.go                    |  622 ++
 backend/db/migrations/000001_init.down.sql    |   12 +
 backend/db/migrations/000001_init.up.sql      |  103 +
 backend/db/migrations/000002_phase2.down.sql  |    3 +
 backend/db/migrations/000002_phase2.up.sql    |   35 +
 .../db/migrations/000003_favorites.down.sql   |    1 +
 backend/db/migrations/000003_favorites.up.sql |   11 +
 .../migrations/000004_phase3_admin.down.sql   |    4 +
 .../db/migrations/000004_phase3_admin.up.sql  |   35 +
 backend/db/migrations/000005_oidc.down.sql    |    1 +
 backend/db/migrations/000005_oidc.up.sql      |    3 +
 .../000006_file_versioning.down.sql           |    1 +
 .../migrations/000006_file_versioning.up.sql  |   11 +
 .../db/migrations/000007_user_colors.down.sql |    3 +
 .../db/migrations/000007_user_colors.up.sql   |    9 +
 .../000008_use_custom_theme.down.sql          |    1 +
 .../migrations/000008_use_custom_theme.up.sql |   13 +
 .../migrations/000009_app_passwords.down.sql  |    1 +
 .../db/migrations/000009_app_passwords.up.sql |   15 +
 .../db/migrations/000010_audit_log.down.sql   |    1 +
 backend/db/migrations/000010_audit_log.up.sql |   27 +
 .../db/migrations/000011_acl_entries.down.sql |    1 +
 .../db/migrations/000011_acl_entries.up.sql   |   51 +
 .../migrations/000012_group_folders.down.sql  |   18 +
 .../db/migrations/000012_group_folders.up.sql |   35 +
 .../migrations/000013_search_indexes.down.sql |    5 +
 .../migrations/000013_search_indexes.up.sql   |   12 +
 .../migrations/000014_document_text.down.sql  |    2 +
 .../db/migrations/000014_document_text.up.sql |   63 +
 backend/db/migrations/000015_tags.down.sql    |    4 +
 backend/db/migrations/000015_tags.up.sql      |   75 +
 .../db/migrations/000016_text_pages.down.sql  |    1 +
 .../db/migrations/000016_text_pages.up.sql    |   13 +
 .../migrations/000017_correspondents.down.sql |    3 +
 .../migrations/000017_correspondents.up.sql   |   52 +
 .../db/migrations/000018_tag_icons.down.sql   |    2 +
 backend/db/migrations/000018_tag_icons.up.sql |   15 +
 backend/go.mod                                |   34 +
 backend/go.sum                                |  124 +
 backend/internal/acl/acl.go                   |  351 +
 backend/internal/acl/acl_test.go              |   60 +
 backend/internal/acl/handler.go               |  263 +
 backend/internal/acl/store.go                 |  288 +
 backend/internal/admin/appicon.go             |  142 +
 backend/internal/admin/appicon_test.go        |  122 +
 backend/internal/admin/audit_handler.go       |   99 +
 backend/internal/admin/branding_handler.go    |  416 ++
 backend/internal/admin/groupfolder_handler.go |  115 +
 backend/internal/admin/handler.go             |  490 ++
 backend/internal/admin/manifest_handler.go    |   95 +
 backend/internal/admin/model.go               |   41 +
 backend/internal/admin/store.go               |  297 +
 backend/internal/audit/audit.go               |  207 +
 backend/internal/auth/apppassword.go          |  264 +
 backend/internal/auth/apppassword_test.go     |   66 +
 backend/internal/auth/handler.go              |  266 +
 backend/internal/auth/middleware.go           |   67 +
 backend/internal/auth/model.go                |   37 +
 backend/internal/auth/oidclink_test.go        |   90 +
 backend/internal/auth/password.go             |   49 +
 backend/internal/auth/password_test.go        |   39 +
 backend/internal/auth/session.go              |  118 +
 backend/internal/auth/store.go                |  211 +
 backend/internal/documents/diskspace.go       |   66 +
 backend/internal/documents/extract.go         |  302 +
 backend/internal/documents/handler.go         |   86 +
 backend/internal/documents/store.go           |  315 +
 backend/internal/documents/worker.go          |  239 +
 backend/internal/files/access.go              |   63 +
 backend/internal/files/groupfolder.go         |  165 +
 backend/internal/files/handler.go             |  781 ++
 backend/internal/files/handler_favorites.go   |  131 +
 backend/internal/files/handler_folders.go     |  273 +
 backend/internal/files/handler_text.go        |   50 +
 backend/internal/files/handler_trash.go       |  144 +
 backend/internal/files/handler_versions.go    |  202 +
 backend/internal/files/handler_zip.go         |  210 +
 backend/internal/files/mime_test.go           |   37 +
 backend/internal/files/model.go               |   64 +
 backend/internal/files/naming.go              |  108 +
 backend/internal/files/quota.go               |   63 +
 backend/internal/files/replace.go             |   93 +
 backend/internal/files/search.go              |  199 +
 backend/internal/files/search_test.go         |   22 +
 backend/internal/files/store.go               |  535 ++
 backend/internal/files/store_favorites.go     |  129 +
 backend/internal/files/store_folders.go       |  209 +
 backend/internal/files/store_webdav.go        |  102 +
 backend/internal/files/store_zip.go           |  120 +
 backend/internal/gc/gc.go                     |  245 +
 backend/internal/gc/gc_test.go                |   28 +
 backend/internal/office/discovery.go          |  200 +
 backend/internal/office/handler.go            |  305 +
 backend/internal/office/office.go             |  167 +
 backend/internal/oidc/handler.go              |  196 +
 backend/internal/sharing/handler.go           |  202 +
 backend/internal/sharing/model.go             |   18 +
 backend/internal/sharing/store.go             |  123 +
 backend/internal/storage/localfs.go           |  280 +
 backend/internal/storage/localfs_test.go      |  223 +
 backend/internal/storage/storage.go           |   70 +
 backend/internal/tags/correspondents.go       |  235 +
 backend/internal/tags/handler.go              |  362 +
 backend/internal/tags/store.go                |  535 ++
 backend/internal/thumbnails/thumbnails.go     |   95 +
 backend/internal/webdav/fs.go                 |  873 +++
 backend/internal/webdav/fs_test.go            |   59 +
 backend/internal/webdav/handler.go            |  155 +
 backend/internal/webdav/scope.go              |  310 +
 backend/internal/webdav/scope_test.go         |   64 +
 backend/pkg/config/config.go                  |  271 +
 backend/pkg/db/db.go                          |  107 +
 .../pkg/db/migrations/000001_init.down.sql    |   12 +
 backend/pkg/db/migrations/000001_init.up.sql  |  103 +
 .../pkg/db/migrations/000002_phase2.down.sql  |    3 +
 .../pkg/db/migrations/000002_phase2.up.sql    |   35 +
 .../db/migrations/000003_favorites.down.sql   |    1 +
 .../pkg/db/migrations/000003_favorites.up.sql |   11 +
 .../migrations/000004_phase3_admin.down.sql   |    4 +
 .../db/migrations/000004_phase3_admin.up.sql  |   35 +
 .../pkg/db/migrations/000005_oidc.down.sql    |    1 +
 backend/pkg/db/migrations/000005_oidc.up.sql  |    3 +
 .../000006_file_versioning.down.sql           |    1 +
 .../migrations/000006_file_versioning.up.sql  |   11 +
 .../db/migrations/000007_user_colors.down.sql |    3 +
 .../db/migrations/000007_user_colors.up.sql   |    9 +
 .../000008_use_custom_theme.down.sql          |    1 +
 .../migrations/000008_use_custom_theme.up.sql |   13 +
 .../migrations/000009_app_passwords.down.sql  |    1 +
 .../db/migrations/000009_app_passwords.up.sql |   15 +
 .../db/migrations/000010_audit_log.down.sql   |    1 +
 .../pkg/db/migrations/000010_audit_log.up.sql |   27 +
 .../db/migrations/000011_acl_entries.down.sql |    1 +
 .../db/migrations/000011_acl_entries.up.sql   |   51 +
 .../migrations/000012_group_folders.down.sql  |   18 +
 .../db/migrations/000012_group_folders.up.sql |   35 +
 .../migrations/000013_search_indexes.down.sql |    5 +
 .../migrations/000013_search_indexes.up.sql   |   12 +
 .../migrations/000014_document_text.down.sql  |    2 +
 .../db/migrations/000014_document_text.up.sql |   63 +
 .../pkg/db/migrations/000015_tags.down.sql    |    4 +
 backend/pkg/db/migrations/000015_tags.up.sql  |   75 +
 .../db/migrations/000016_text_pages.down.sql  |    1 +
 .../db/migrations/000016_text_pages.up.sql    |   13 +
 .../migrations/000017_correspondents.down.sql |    3 +
 .../migrations/000017_correspondents.up.sql   |   52 +
 .../db/migrations/000018_tag_icons.down.sql   |    2 +
 .../pkg/db/migrations/000018_tag_icons.up.sql |   15 +
 backend/pkg/middleware/failurelimit.go        |  102 +
 backend/pkg/middleware/failurelimit_test.go   |   63 +
 backend/pkg/middleware/logger.go              |   43 +
 backend/pkg/middleware/proxy.go               |   75 +
 backend/pkg/middleware/security.go            |   55 +
 backend/pkg/response/response.go              |   27 +
 cloud-projekt-plan.md                         |  596 ++
 deploy/.env.example                           |  160 +
 deploy/Dockerfile                             |   58 +
 deploy/docker-compose.yml                     |  137 +
 frontend/index.html                           |   22 +
 frontend/package-lock.json                    | 6522 +++++++++++++++++
 frontend/package.json                         |   31 +
 frontend/public/icon-192.png                  |  Bin 0 -> 6372 bytes
 frontend/public/icon-512.png                  |  Bin 0 -> 13418 bytes
 frontend/public/icon-maskable-512.png         |  Bin 0 -> 36793 bytes
 frontend/public/icon.svg                      |   12 +
 frontend/src/App.tsx                          |   63 +
 frontend/src/api/client.ts                    |  813 ++
 frontend/src/components/AppPasswords.tsx      |  217 +
 frontend/src/components/AppSwitcher.tsx       |  114 +
 frontend/src/components/Breadcrumb.tsx        |   87 +
 frontend/src/components/ConfirmDialog.tsx     |   55 +
 frontend/src/components/ContextMenu.tsx       |  110 +
 frontend/src/components/Dialog.tsx            |   66 +
 frontend/src/components/FileCover.tsx         |  144 +
 frontend/src/components/FileInfoDialog.tsx    |  185 +
 frontend/src/components/FilePreview.tsx       |  373 +
 frontend/src/components/FileViews.tsx         |  511 ++
 frontend/src/components/MoveTo.tsx            |  320 +
 frontend/src/components/OfficeEditor.tsx      |  137 +
 frontend/src/components/PageHeader.tsx        |  193 +
 frontend/src/components/PdfViewer.tsx         |  957 +++
 frontend/src/components/SearchBox.tsx         |  258 +
 frontend/src/components/ShareDialog.tsx       |  190 +
 frontend/src/components/ShareWithDialog.tsx   |  272 +
 frontend/src/components/Shell.tsx             |  101 +
 frontend/src/components/Sidebar.tsx           |  745 ++
 frontend/src/components/Tabs.tsx              |   45 +
 frontend/src/components/TagChip.tsx           |   84 +
 frontend/src/components/TagDialog.tsx         |  340 +
 frontend/src/components/TagEditDialog.tsx     |  322 +
 frontend/src/components/UploadQueue.tsx       |   57 +
 frontend/src/components/UserMenu.tsx          |  204 +
 frontend/src/components/VersionsDialog.tsx    |  216 +
 frontend/src/components/filetypes.ts          |   80 +
 frontend/src/components/icons.tsx             |  256 +
 frontend/src/components/pdf.css               |  208 +
 frontend/src/hooks/useAppSettings.tsx         |  115 +
 frontend/src/hooks/useAuth.ts                 |   55 +
 frontend/src/hooks/useNavHistory.ts           |  176 +
 frontend/src/hooks/useOverlayDismiss.ts       |   25 +
 frontend/src/index.css                        |   82 +
 frontend/src/main.tsx                         |   12 +
 frontend/src/pages/AdminPage.tsx              |   54 +
 frontend/src/pages/FileBrowser.tsx            | 1072 +++
 frontend/src/pages/LoginPage.tsx              |  163 +
 frontend/src/pages/ProfilePage.tsx            |  429 ++
 frontend/src/pages/SharePage.tsx              |  177 +
 frontend/src/pages/SharedPage.tsx             |  170 +
 frontend/src/pages/SharedWithMePage.tsx       |  129 +
 frontend/src/pages/TagsPage.tsx               |  221 +
 frontend/src/pages/TrashPage.tsx              |  198 +
 frontend/src/pages/admin/AuditTab.tsx         |  329 +
 frontend/src/pages/admin/GroupsTab.tsx        |  357 +
 frontend/src/pages/admin/ThemingTab.tsx       |  295 +
 frontend/src/pages/admin/UsersTab.tsx         |  264 +
 frontend/src/pages/admin/ui.tsx               |  119 +
 frontend/src/test-setup.ts                    |    1 +
 frontend/src/theme.ts                         |   43 +
 frontend/tsconfig.json                        |   23 +
 frontend/vite.config.ts                       |  104 +
 225 files changed, 38042 insertions(+)
 create mode 100644 .dockerignore
 create mode 100644 .gitignore
 create mode 100644 CLAUDE.md
 create mode 100644 README.md
 create mode 100644 TESTING.md
 create mode 100644 backend/cmd/aether/main.go
 create mode 100644 backend/db/migrations/000001_init.down.sql
 create mode 100644 backend/db/migrations/000001_init.up.sql
 create mode 100644 backend/db/migrations/000002_phase2.down.sql
 create mode 100644 backend/db/migrations/000002_phase2.up.sql
 create mode 100644 backend/db/migrations/000003_favorites.down.sql
 create mode 100644 backend/db/migrations/000003_favorites.up.sql
 create mode 100644 backend/db/migrations/000004_phase3_admin.down.sql
 create mode 100644 backend/db/migrations/000004_phase3_admin.up.sql
 create mode 100644 backend/db/migrations/000005_oidc.down.sql
 create mode 100644 backend/db/migrations/000005_oidc.up.sql
 create mode 100644 backend/db/migrations/000006_file_versioning.down.sql
 create mode 100644 backend/db/migrations/000006_file_versioning.up.sql
 create mode 100644 backend/db/migrations/000007_user_colors.down.sql
 create mode 100644 backend/db/migrations/000007_user_colors.up.sql
 create mode 100644 backend/db/migrations/000008_use_custom_theme.down.sql
 create mode 100644 backend/db/migrations/000008_use_custom_theme.up.sql
 create mode 100644 backend/db/migrations/000009_app_passwords.down.sql
 create mode 100644 backend/db/migrations/000009_app_passwords.up.sql
 create mode 100644 backend/db/migrations/000010_audit_log.down.sql
 create mode 100644 backend/db/migrations/000010_audit_log.up.sql
 create mode 100644 backend/db/migrations/000011_acl_entries.down.sql
 create mode 100644 backend/db/migrations/000011_acl_entries.up.sql
 create mode 100644 backend/db/migrations/000012_group_folders.down.sql
 create mode 100644 backend/db/migrations/000012_group_folders.up.sql
 create mode 100644 backend/db/migrations/000013_search_indexes.down.sql
 create mode 100644 backend/db/migrations/000013_search_indexes.up.sql
 create mode 100644 backend/db/migrations/000014_document_text.down.sql
 create mode 100644 backend/db/migrations/000014_document_text.up.sql
 create mode 100644 backend/db/migrations/000015_tags.down.sql
 create mode 100644 backend/db/migrations/000015_tags.up.sql
 create mode 100644 backend/db/migrations/000016_text_pages.down.sql
 create mode 100644 backend/db/migrations/000016_text_pages.up.sql
 create mode 100644 backend/db/migrations/000017_correspondents.down.sql
 create mode 100644 backend/db/migrations/000017_correspondents.up.sql
 create mode 100644 backend/db/migrations/000018_tag_icons.down.sql
 create mode 100644 backend/db/migrations/000018_tag_icons.up.sql
 create mode 100644 backend/go.mod
 create mode 100644 backend/go.sum
 create mode 100644 backend/internal/acl/acl.go
 create mode 100644 backend/internal/acl/acl_test.go
 create mode 100644 backend/internal/acl/handler.go
 create mode 100644 backend/internal/acl/store.go
 create mode 100644 backend/internal/admin/appicon.go
 create mode 100644 backend/internal/admin/appicon_test.go
 create mode 100644 backend/internal/admin/audit_handler.go
 create mode 100644 backend/internal/admin/branding_handler.go
 create mode 100644 backend/internal/admin/groupfolder_handler.go
 create mode 100644 backend/internal/admin/handler.go
 create mode 100644 backend/internal/admin/manifest_handler.go
 create mode 100644 backend/internal/admin/model.go
 create mode 100644 backend/internal/admin/store.go
 create mode 100644 backend/internal/audit/audit.go
 create mode 100644 backend/internal/auth/apppassword.go
 create mode 100644 backend/internal/auth/apppassword_test.go
 create mode 100644 backend/internal/auth/handler.go
 create mode 100644 backend/internal/auth/middleware.go
 create mode 100644 backend/internal/auth/model.go
 create mode 100644 backend/internal/auth/oidclink_test.go
 create mode 100644 backend/internal/auth/password.go
 create mode 100644 backend/internal/auth/password_test.go
 create mode 100644 backend/internal/auth/session.go
 create mode 100644 backend/internal/auth/store.go
 create mode 100644 backend/internal/documents/diskspace.go
 create mode 100644 backend/internal/documents/extract.go
 create mode 100644 backend/internal/documents/handler.go
 create mode 100644 backend/internal/documents/store.go
 create mode 100644 backend/internal/documents/worker.go
 create mode 100644 backend/internal/files/access.go
 create mode 100644 backend/internal/files/groupfolder.go
 create mode 100644 backend/internal/files/handler.go
 create mode 100644 backend/internal/files/handler_favorites.go
 create mode 100644 backend/internal/files/handler_folders.go
 create mode 100644 backend/internal/files/handler_text.go
 create mode 100644 backend/internal/files/handler_trash.go
 create mode 100644 backend/internal/files/handler_versions.go
 create mode 100644 backend/internal/files/handler_zip.go
 create mode 100644 backend/internal/files/mime_test.go
 create mode 100644 backend/internal/files/model.go
 create mode 100644 backend/internal/files/naming.go
 create mode 100644 backend/internal/files/quota.go
 create mode 100644 backend/internal/files/replace.go
 create mode 100644 backend/internal/files/search.go
 create mode 100644 backend/internal/files/search_test.go
 create mode 100644 backend/internal/files/store.go
 create mode 100644 backend/internal/files/store_favorites.go
 create mode 100644 backend/internal/files/store_folders.go
 create mode 100644 backend/internal/files/store_webdav.go
 create mode 100644 backend/internal/files/store_zip.go
 create mode 100644 backend/internal/gc/gc.go
 create mode 100644 backend/internal/gc/gc_test.go
 create mode 100644 backend/internal/office/discovery.go
 create mode 100644 backend/internal/office/handler.go
 create mode 100644 backend/internal/office/office.go
 create mode 100644 backend/internal/oidc/handler.go
 create mode 100644 backend/internal/sharing/handler.go
 create mode 100644 backend/internal/sharing/model.go
 create mode 100644 backend/internal/sharing/store.go
 create mode 100644 backend/internal/storage/localfs.go
 create mode 100644 backend/internal/storage/localfs_test.go
 create mode 100644 backend/internal/storage/storage.go
 create mode 100644 backend/internal/tags/correspondents.go
 create mode 100644 backend/internal/tags/handler.go
 create mode 100644 backend/internal/tags/store.go
 create mode 100644 backend/internal/thumbnails/thumbnails.go
 create mode 100644 backend/internal/webdav/fs.go
 create mode 100644 backend/internal/webdav/fs_test.go
 create mode 100644 backend/internal/webdav/handler.go
 create mode 100644 backend/internal/webdav/scope.go
 create mode 100644 backend/internal/webdav/scope_test.go
 create mode 100644 backend/pkg/config/config.go
 create mode 100644 backend/pkg/db/db.go
 create mode 100644 backend/pkg/db/migrations/000001_init.down.sql
 create mode 100644 backend/pkg/db/migrations/000001_init.up.sql
 create mode 100644 backend/pkg/db/migrations/000002_phase2.down.sql
 create mode 100644 backend/pkg/db/migrations/000002_phase2.up.sql
 create mode 100644 backend/pkg/db/migrations/000003_favorites.down.sql
 create mode 100644 backend/pkg/db/migrations/000003_favorites.up.sql
 create mode 100644 backend/pkg/db/migrations/000004_phase3_admin.down.sql
 create mode 100644 backend/pkg/db/migrations/000004_phase3_admin.up.sql
 create mode 100644 backend/pkg/db/migrations/000005_oidc.down.sql
 create mode 100644 backend/pkg/db/migrations/000005_oidc.up.sql
 create mode 100644 backend/pkg/db/migrations/000006_file_versioning.down.sql
 create mode 100644 backend/pkg/db/migrations/000006_file_versioning.up.sql
 create mode 100644 backend/pkg/db/migrations/000007_user_colors.down.sql
 create mode 100644 backend/pkg/db/migrations/000007_user_colors.up.sql
 create mode 100644 backend/pkg/db/migrations/000008_use_custom_theme.down.sql
 create mode 100644 backend/pkg/db/migrations/000008_use_custom_theme.up.sql
 create mode 100644 backend/pkg/db/migrations/000009_app_passwords.down.sql
 create mode 100644 backend/pkg/db/migrations/000009_app_passwords.up.sql
 create mode 100644 backend/pkg/db/migrations/000010_audit_log.down.sql
 create mode 100644 backend/pkg/db/migrations/000010_audit_log.up.sql
 create mode 100644 backend/pkg/db/migrations/000011_acl_entries.down.sql
 create mode 100644 backend/pkg/db/migrations/000011_acl_entries.up.sql
 create mode 100644 backend/pkg/db/migrations/000012_group_folders.down.sql
 create mode 100644 backend/pkg/db/migrations/000012_group_folders.up.sql
 create mode 100644 backend/pkg/db/migrations/000013_search_indexes.down.sql
 create mode 100644 backend/pkg/db/migrations/000013_search_indexes.up.sql
 create mode 100644 backend/pkg/db/migrations/000014_document_text.down.sql
 create mode 100644 backend/pkg/db/migrations/000014_document_text.up.sql
 create mode 100644 backend/pkg/db/migrations/000015_tags.down.sql
 create mode 100644 backend/pkg/db/migrations/000015_tags.up.sql
 create mode 100644 backend/pkg/db/migrations/000016_text_pages.down.sql
 create mode 100644 backend/pkg/db/migrations/000016_text_pages.up.sql
 create mode 100644 backend/pkg/db/migrations/000017_correspondents.down.sql
 create mode 100644 backend/pkg/db/migrations/000017_correspondents.up.sql
 create mode 100644 backend/pkg/db/migrations/000018_tag_icons.down.sql
 create mode 100644 backend/pkg/db/migrations/000018_tag_icons.up.sql
 create mode 100644 backend/pkg/middleware/failurelimit.go
 create mode 100644 backend/pkg/middleware/failurelimit_test.go
 create mode 100644 backend/pkg/middleware/logger.go
 create mode 100644 backend/pkg/middleware/proxy.go
 create mode 100644 backend/pkg/middleware/security.go
 create mode 100644 backend/pkg/response/response.go
 create mode 100644 cloud-projekt-plan.md
 create mode 100644 deploy/.env.example
 create mode 100644 deploy/Dockerfile
 create mode 100644 deploy/docker-compose.yml
 create mode 100644 frontend/index.html
 create mode 100644 frontend/package-lock.json
 create mode 100644 frontend/package.json
 create mode 100644 frontend/public/icon-192.png
 create mode 100644 frontend/public/icon-512.png
 create mode 100644 frontend/public/icon-maskable-512.png
 create mode 100644 frontend/public/icon.svg
 create mode 100644 frontend/src/App.tsx
 create mode 100644 frontend/src/api/client.ts
 create mode 100644 frontend/src/components/AppPasswords.tsx
 create mode 100644 frontend/src/components/AppSwitcher.tsx
 create mode 100644 frontend/src/components/Breadcrumb.tsx
 create mode 100644 frontend/src/components/ConfirmDialog.tsx
 create mode 100644 frontend/src/components/ContextMenu.tsx
 create mode 100644 frontend/src/components/Dialog.tsx
 create mode 100644 frontend/src/components/FileCover.tsx
 create mode 100644 frontend/src/components/FileInfoDialog.tsx
 create mode 100644 frontend/src/components/FilePreview.tsx
 create mode 100644 frontend/src/components/FileViews.tsx
 create mode 100644 frontend/src/components/MoveTo.tsx
 create mode 100644 frontend/src/components/OfficeEditor.tsx
 create mode 100644 frontend/src/components/PageHeader.tsx
 create mode 100644 frontend/src/components/PdfViewer.tsx
 create mode 100644 frontend/src/components/SearchBox.tsx
 create mode 100644 frontend/src/components/ShareDialog.tsx
 create mode 100644 frontend/src/components/ShareWithDialog.tsx
 create mode 100644 frontend/src/components/Shell.tsx
 create mode 100644 frontend/src/components/Sidebar.tsx
 create mode 100644 frontend/src/components/Tabs.tsx
 create mode 100644 frontend/src/components/TagChip.tsx
 create mode 100644 frontend/src/components/TagDialog.tsx
 create mode 100644 frontend/src/components/TagEditDialog.tsx
 create mode 100644 frontend/src/components/UploadQueue.tsx
 create mode 100644 frontend/src/components/UserMenu.tsx
 create mode 100644 frontend/src/components/VersionsDialog.tsx
 create mode 100644 frontend/src/components/filetypes.ts
 create mode 100644 frontend/src/components/icons.tsx
 create mode 100644 frontend/src/components/pdf.css
 create mode 100644 frontend/src/hooks/useAppSettings.tsx
 create mode 100644 frontend/src/hooks/useAuth.ts
 create mode 100644 frontend/src/hooks/useNavHistory.ts
 create mode 100644 frontend/src/hooks/useOverlayDismiss.ts
 create mode 100644 frontend/src/index.css
 create mode 100644 frontend/src/main.tsx
 create mode 100644 frontend/src/pages/AdminPage.tsx
 create mode 100644 frontend/src/pages/FileBrowser.tsx
 create mode 100644 frontend/src/pages/LoginPage.tsx
 create mode 100644 frontend/src/pages/ProfilePage.tsx
 create mode 100644 frontend/src/pages/SharePage.tsx
 create mode 100644 frontend/src/pages/SharedPage.tsx
 create mode 100644 frontend/src/pages/SharedWithMePage.tsx
 create mode 100644 frontend/src/pages/TagsPage.tsx
 create mode 100644 frontend/src/pages/TrashPage.tsx
 create mode 100644 frontend/src/pages/admin/AuditTab.tsx
 create mode 100644 frontend/src/pages/admin/GroupsTab.tsx
 create mode 100644 frontend/src/pages/admin/ThemingTab.tsx
 create mode 100644 frontend/src/pages/admin/UsersTab.tsx
 create mode 100644 frontend/src/pages/admin/ui.tsx
 create mode 100644 frontend/src/test-setup.ts
 create mode 100644 frontend/src/theme.ts
 create mode 100644 frontend/tsconfig.json
 create mode 100644 frontend/vite.config.ts

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..5c9e027
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,26 @@
+# Node — muss im Image via `npm ci` frisch gebaut werden,
+# sonst überschreibt der Host-Stand die Builder-Stage (tsc: Permission denied)
+frontend/node_modules/
+frontend/dist/
+
+# Go
+backend/aether
+backend/*.test
+backend/vendor/
+
+# Secrets — Werte kommen zur Laufzeit über env_file, nie ins Image
+deploy/.env
+.env
+
+# Daten
+data/
+backend/data/
+
+# Git / IDE / OS
+.git/
+.gitignore
+.idea/
+.vscode/
+*.swp
+.DS_Store
+Thumbs.db
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ccf0641
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,28 @@
+# Secrets
+deploy/.env
+.env
+
+# Go
+backend/aether
+backend/*.test
+backend/vendor/
+
+# Node
+frontend/node_modules/
+frontend/dist/
+
+# Data (never commit real data)
+data/
+backend/data/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# Von vite.config.ts aus node_modules kopiert (PDF.js-Standardschriften)
+frontend/public/pdfjs/
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..94d5b5a
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,165 @@
+# Aether – Projektkonventionen für Claude Code
+
+## Projekt-Überblick
+
+Self-hosted Cloud-Alternative zu Nextcloud. Go-Backend + React-Frontend, modularer Monolith.
+Projektplan: `cloud-projekt-plan.md`
+
+## Monorepo-Struktur
+
+```
+aether/
+├── backend/          # Go – modularer Monolith
+│   ├── cmd/aether/   # main.go – Einstiegspunkt
+│   ├── internal/     # Domänen-Pakete (nie von außen importieren)
+│   │   ├── auth/         # Login, Sessions, CSRF, Argon2id, OIDC-User-Anlage
+│   │   ├── storage/      # Storage-Interface + LocalFS (atomar, SHA-256)
+│   │   ├── files/        # Datei-/Ordner-CRUD, Trash, Versionen, Favoriten
+│   │   ├── sharing/      # Öffentliche Share-Links
+│   │   ├── admin/        # Admin-Panel: User, Gruppen(-mitgliedschaft), Settings/Theming
+│   │   ├── oidc/         # OIDC-Login (optional, via .env)
+│   │   ├── webdav/       # WebDAV-Endpoint /dav/ (Basic Auth – nur App-Passwörter)
+│   │   ├── acl/          # Interne Freigaben an User/Gruppen (Rechteauflösung)
+│   │   ├── audit/        # Audit-Log (Schreibpfad; Endpunkte liegen in admin/)
+│   │   ├── gc/           # Blob-GC: Platte gegen DB abgleichen
+│   │   ├── thumbnails/   # Vorschaubild-Generierung
+│   │   ├── groups/       # LEERER STUB – Gruppenordner liegen in files/groupfolder.go
+│   │   ├── documents/    # Volltext: OCR-Warteschlange + Arbeiter (Phase 6, Teil 1)
+│   │   ├── tags/         # Ordnungsmerkmale einer Datei: Etiketten, Belegdatum, Absender
+│   │   └── office/       # WOPI-Host: Collabora/OnlyOffice, ein Adapter fuer beide
+│   ├── db/migrations/    # SQL-Migrations – Spiegelkopie (siehe Migrations-Regeln!)
+│   └── pkg/              # Hilfspakete: config, middleware, response, db (embed migrations)
+├── frontend/         # React + TS + Vite + Tailwind
+│   └── src/
+│       ├── components/
+│       ├── pages/
+│       ├── api/          # Typed API-Client
+│       └── hooks/
+├── deploy/           # Docker Compose, Dockerfile, .env.example
+└── CLAUDE.md
+```
+
+## Backend-Konventionen (Go)
+
+- **Module-Pfad**: `aether`
+- **Go-Version**: 1.25 (siehe `go.mod`)
+- **Router**: `github.com/go-chi/chi/v5`
+- **DB-Treiber**: `github.com/jackc/pgx/v5` (pgxpool für Connection-Pool)
+- **Migrations**: `github.com/golang-migrate/migrate/v4`
+- **Logging**: `github.com/rs/zerolog` – strukturiert, immer mit Kontext (`log.Ctx(ctx)`)
+- **Hashing**: `golang.org/x/crypto/argon2` (Argon2id) – App-Passwörter dagegen SHA-256 (zufälliges Token, jeder WebDAV-Request authentifiziert einzeln)
+- **Sessions**: `github.com/gorilla/sessions` mit securecookie
+
+### Paket-Regeln
+
+- Alle Domänen-Pakete unter `internal/` – kein Import von außen
+- Keine zirkulären Abhängigkeiten; Dependency-Richtung: `cmd → internal/* → pkg/*`
+- Handler in `internal/<domain>/handler.go`, Business-Logic in `internal/<domain>/service.go`, DB in `internal/<domain>/store.go`
+- Interfaces für alle externen Abhängigkeiten (Storage, DB) → leicht mockbar
+
+### Code-Stil
+
+- `gofmt` + `goimports` – immer formatiert
+- Fehler nie ignorieren (`_`), immer wrappen mit `fmt.Errorf("context: %w", err)`
+- Keine Magic-Numbers – Konstanten mit sprechenden Namen
+- HTTP-Handler signieren: `func (h *Handler) MethodName(w http.ResponseWriter, r *http.Request)`
+- Middleware-Chain: Auth → CSRF → RateLimit → Handler
+
+### Tests
+
+- Testdatei neben der Quelldatei: `auth_test.go` neben `auth.go`
+- Integrationstests mit echtem Postgres via `testcontainers-go`
+- Pflicht-Tests: Path-Traversal, Upload-Abbruch, Checksum-Verifikation, Soft-Delete-Recovery
+- `go test ./...` muss grün sein vor jedem Commit
+
+## Frontend-Konventionen (React + TS)
+
+- **Bundler**: Vite
+- **Styling**: Tailwind CSS + CSS-Variablen für Design-Tokens
+- **Testing**: Vitest + Testing Library; E2E: Playwright
+- **API-Client**: typed fetch-Wrapper unter `src/api/`
+
+### Design-Tokens (CSS-Variablen)
+
+Alle Farben laufen über CSS-Custom-Properties:
+
+```css
+:root {
+  --color-primary: ...;
+  --color-accent: ...;
+  --color-background: ...;
+  --color-surface: ...;
+  --color-text: ...;
+}
+```
+
+Admin setzt globale Tokens; User-Override nur für eigene Palette (Scope: `[data-user-theme]`).
+
+### Komponenten-Regeln
+
+- Komponenten in `PascalCase.tsx`
+- Kein `dangerouslySetInnerHTML` mit User-Input (XSS)
+- API-Calls nur über `src/api/`-Funktionen, nie direkt `fetch` in Komponenten
+
+## Sicherheits-Pflichten
+
+- Path-Traversal: jeden Dateipfad kanonisieren und gegen Storage-Root prüfen
+- CSRF: Double-Submit-Cookie oder synchronizer-Token
+- Rate-Limiting: Login-Endpunkt + Admin-Login strenger
+- Auth-Check: jede Route serverseitig prüfen – nie Frontend vertrauen
+- SQL: ausschließlich parametrisierte Queries (pgx unterstützt das nativ)
+- Uploads: außerhalb Webroot, keine ausführbaren Rechte, MIME-Prüfung
+- WebDAV: **nur App-Passwörter**, nie das Kontopasswort – es ist zugleich der Admin-Zugang
+- Kein Zugriff auf fremde IDs → `404`, nicht `403`: sonst verrät die Antwort die Existenz
+- Listen und Suche schneiden den erreichbaren Bereich **in der Abfrage** zu, nie nachträglich im Handler
+- Hochgeladene Dateien nur für eine Positivliste harmloser Typen `inline` ausliefern (sonst läuft fremdes HTML im eigenen Ursprung)
+
+## Datenintegrität (nicht verhandelbar)
+
+1. **Atomares Schreiben**: Temp-Datei → `fsync` → `rename`. Niemals in-place.
+2. **SHA-256**: beim Upload berechnen + in DB; beim Download verifizieren.
+3. **Soft-Delete only**: kein hartes Löschen. Bytes erst per GC entfernen.
+4. **DB-Commit nach Blob-Write**: Metadaten erst committen, wenn Blob erfolgreich.
+
+## Migrations-Regeln
+
+- Dateien: `000001_init.up.sql` / `000001_init.down.sql`
+- **Jede Migration in BEIDE Verzeichnisse legen:** `backend/pkg/db/migrations/` (wird ins Binary embedded und beim Start ausgeführt) UND `backend/db/migrations/` (Spiegelkopie). Beide müssen identisch sein.
+- Keine destruktiven Änderungen ohne explizites Down-Migration
+- Migration beim App-Start automatisch ausführen (via `migrate.Up()`)
+- Aktueller Stand: bis `000018_tag_icons` (Emoji an Etiketten und Absendern)
+
+## Commit-Regeln
+
+Format: `<typ>(<scope>): <kurze Beschreibung>`
+
+Typen: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`, `security`
+
+Beispiele:
+- `feat(auth): add argon2id password hashing`
+- `test(storage): add checksum verification test`
+- `security(admin): enforce server-side admin check on all routes`
+
+Kein Commit ohne grüne Tests.
+
+## Reverse Proxy & Proxy-Awareness
+
+- **Kein Proxy-Container** in docker-compose.yml – TLS und Domain gehören zum Wirt,
+  nicht ins Projekt. Nichts hier soll einen mitgelieferten Proxy voraussetzen.
+- App lauscht auf reinem HTTP (`APP_LISTEN_ADDR`). TLS = externer Proxy.
+- `X-Forwarded-For` / `X-Forwarded-Proto` werden **nur** von `TRUSTED_PROXIES` (IPs/CIDRs) akzeptiert.
+- Echte Client-IP immer über `middleware.RealIP(r)` abrufen – niemals `r.RemoteAddr` direkt.
+- `Secure`-Cookie-Flag: über `middleware.IsHTTPS(r)` setzen (berücksichtigt Forwarded-Proto).
+- `PUBLIC_URL` für OIDC-Redirects, WOPI-Callbacks und Share-Links verwenden.
+- HSTS gehört auf den Edge-Proxy, **nicht** in die App-Header.
+
+## Docker & Secrets
+
+- **Backend immer via Docker starten/laufen lassen (`docker compose ...` in `deploy/`), nie `go run`.** Der Host hat kein Go-Toolchain installiert; Builds/Compile-Checks laufen über das `golang:1.25-alpine`-Image. Migrations + DB-Verbindung sind auf die Compose-Umgebung ausgelegt.
+- Secrets **nur** über `.env` / Compose-Env – nie im Image oder Repo
+- Multi-Stage-Build: Builder-Stage (Go-Compiler) → Alpine final
+- `.env` ist in `.gitignore`; `.env.example` zeigt alle Keys ohne Werte
+
+## Phasen-Stopp
+
+Nach Phase 1: **STOPP** – Zusammenfassung + Phase-2-Vorschlag, erst nach OK weitermachen.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..913a067
--- /dev/null
+++ b/README.md
@@ -0,0 +1,417 @@
+# Aether
+
+Self-hosted cloud storage — schnelle, schlanke Alternative zu Nextcloud.
+
+**Stack:** Go + chi · React + TS + Vite · PostgreSQL · Docker Compose
+
+---
+
+## Reverse Proxy (Pflicht)
+
+Aether lauscht intern auf reinem HTTP. TLS wird von deinem eigenen Reverse Proxy terminiert.
+**nginx, Traefik, Cloudflare Tunnel** – alles funktioniert. Dieses Projekt
+liefert bewusst **keinen** Proxy mit: TLS, Zertifikate und Domain gehören in
+deine Hand, nicht in ein Compose-File, das du ohnehin überschreiben müsstest.
+
+Der Proxy muss folgende Headers setzen:
+
+```
+X-Forwarded-For:   <echte Client-IP>
+X-Forwarded-Proto: https
+```
+
+Die IP deines Proxys muss in `TRUSTED_PROXIES` stehen – sonst ignoriert Aether diese Header
+(Sicherheitsmaßnahme gegen IP-Spoofing).
+
+Der Proxy muss folgendes durchreichen (keine eigene Verarbeitung):
+- Alle HTTP-Methoden inkl. `PROPFIND`, `MKCOL`, `MOVE`, `COPY` (für WebDAV)
+- Große Uploads (Timeout und Body-Size-Limit großzügig setzen)
+- WebSocket-Verbindungen (für Office-Co-Editing, Phase 6)
+- HSTS-Header setzen (z. B. `Strict-Transport-Security: max-age=31536000; includeSubDomains`)
+
+## Schnellstart (lokal)
+
+### Voraussetzungen
+
+- Docker + Docker Compose
+- Go 1.25+ und Node 20+ **nur**, wenn du aus dem Quelltext bauen willst –
+  zum Betreiben genügt das fertige Abbild (siehe Schritt 3)
+
+### 1. Repository klonen
+
+```bash
+git clone <repo-url> aether
+cd aether
+```
+
+### 2. `.env` anlegen
+
+```bash
+cp deploy/.env.example deploy/.env
+```
+
+Dann in `deploy/.env` ausfüllen:
+
+```env
+SESSION_SECRET=$(openssl rand -hex 32)
+DB_PASSWORD=<sicheres_passwort>
+PUBLIC_URL=https://cloud.example.com
+TRUSTED_PROXIES=<IP-deines-Proxys>
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=<sicheres_admin_passwort>
+```
+
+### 3. Starten
+
+```bash
+cd deploy
+docker login gitea.honeyy.duckdns.org   # nur beim ersten Mal
+docker compose up -d
+```
+
+Das Compose zieht ein **fertiges Abbild** aus der eigenen Registry
+(`gitea.honeyy.duckdns.org/honey/aether`). Für eine neue Umgebung reichen damit
+drei Dateien – `docker-compose.yml`, `.env` und das Datenverzeichnis. Backend
+und Frontend müssen dort nicht liegen und nicht gebaut werden.
+
+Wer aus dem Quelltext bauen will, kommentiert in `docker-compose.yml` `image:`
+aus und den `build:`-Block ein, dann:
+
+```bash
+docker compose build app && docker compose up -d
+```
+
+Aktualisieren:
+
+```bash
+docker compose pull app && docker compose up -d app
+```
+
+Beim ersten Start:
+- Postgres-Migrations laufen automatisch
+- Der erste Admin-Account wird aus `ADMIN_USERNAME` / `ADMIN_PASSWORD` angelegt
+- Nach dem Start: `ADMIN_PASSWORD` aus `.env` entfernen oder leer lassen
+
+### 4. Öffnen
+
+Die App ist über deinen Reverse Proxy erreichbar (z. B. `https://cloud.example.com`).
+Direkt (ohne Proxy): http://localhost:8080/health
+
+---
+
+## Abbild bauen und veröffentlichen
+
+```bash
+# im Wurzelverzeichnis des Projekts, nicht in deploy/
+IMG=gitea.honeyy.duckdns.org/honey/aether
+docker build -f deploy/Dockerfile -t $IMG:$(date +%Y.%m.%d) -t $IMG:latest .
+docker push $IMG:$(date +%Y.%m.%d)
+docker push $IMG:latest
+```
+
+**Zwei Tags, mit Absicht.** `latest` ist der bewegliche Name zum Aufbauen, der
+datierte der feste zum Zurückrollen. Wer nur `latest` fährt, hat im Fehlerfall
+nichts, worauf er zurück kann – der Name zeigt dann schon auf die Fassung, die
+gerade Ärger macht.
+
+Das Abbild wiegt rund **540 MB**. Den Löwenanteil machen `ocrmypdf`,
+`tesseract` samt Sprachmodellen und `poppler-utils` aus – ohne sie wären es
+etwa 210 MB, aber auch keine Volltextsuche in Scans. Wer das nicht braucht,
+streicht die zweite `apk`-Zeile im Dockerfile und setzt `OCR_ENABLED=false`;
+der Server prüft beim Start selbst, ob die Programme da sind, und läuft sonst
+ohne Volltextsuche weiter.
+
+Gebaut wird für die Architektur des Wirts. Für ein anderes Ziel (etwa ein
+ARM-Gerät) braucht es `docker buildx build --platform linux/arm64`.
+
+---
+
+## Lokale Entwicklung
+
+### Backend (immer via Docker)
+
+Das Backend wird **ausschließlich über Docker Compose** gestartet – nie mit `go run`.
+Postgres-Migrations und DB-Verbindung sind auf die Compose-Umgebung ausgelegt.
+
+```bash
+cd deploy
+docker compose up -d --build       # Backend + Postgres starten
+docker compose logs -f app         # Logs verfolgen
+docker compose down                # stoppen
+```
+
+Code-Änderungen am Backend: `docker compose up -d --build` neu ausführen (Image neu bauen).
+
+**Compile-Check ohne lokales Go-Toolchain** (der Host hat kein Go installiert):
+
+```bash
+docker run --rm -v "$PWD/../backend":/src -w /src golang:1.25-alpine go build ./...
+```
+
+### Frontend
+
+```bash
+cd frontend
+npm install
+npm run dev      # http://localhost:5173 (Vite dev server, spricht Backend auf :8080 an)
+npm run build    # Production-Build (wird vom Backend-Image mitgebaut)
+```
+
+### Tests
+
+```bash
+# Backend (im Go-Image, da Host kein Go hat)
+docker run --rm -v "$PWD/backend":/src -w /src golang:1.25-alpine go test ./...
+
+# Frontend
+cd frontend && npm test
+```
+
+---
+
+## Struktur
+
+```
+aether/
+├── backend/
+│   ├── cmd/aether/         # Einstiegspunkt
+│   ├── internal/           # Domänen-Pakete (auth, storage, files, …)
+│   ├── db/migrations/      # SQL-Migrations
+│   └── pkg/                # Shared utils (config, middleware, response)
+├── frontend/
+│   └── src/
+│       ├── api/            # Typed API-Client
+│       ├── components/
+│       ├── hooks/
+│       └── pages/
+├── deploy/
+│   ├── docker-compose.yml  # app + postgres (kein Proxy-Container)
+│   ├── Dockerfile
+│   └── .env.example
+└── CLAUDE.md               # Projektkonventionen
+```
+
+---
+
+## Wo die Dateien liegen
+
+Nicht in einem Docker-Volume, sondern in einem gewöhnlichen Verzeichnis auf dem
+Wirt – `DATA_PATH` in der `.env`. Der Aufbau darin ist derselbe wie in der
+Oberfläche:
+
+```
+<DATA_PATH>/
+├── users/<benutzername>/home/…      ← die eigenen Dateien, echte Namen
+│                       /.trash/…    ← Papierkorb
+│                       /.versions/… ← frühere Fassungen
+├── groups/<gruppen-id>/home/…       ← Gruppenordner
+├── thumbs/                          ← Vorschaubilder
+├── branding/                        ← Logo und App-Symbol
+└── tmp/                             ← Zwischendateien, wird selbst geräumt
+```
+
+**Warum das so ist:** Ein Archiv ist nur dann eines, wenn man ohne die
+Anwendung an seine Unterlagen kommt. Hier reicht dafür `scp -r` oder ein Blick
+in den Dateimanager – keine Datenbank, kein Export, kein laufender Container
+nötig. Bei einem benannten Volume läge alles unter
+`/var/lib/docker/volumes/…` und gehörte `root`.
+
+Damit die Dateien **dir** gehören und nicht einem Container-Nutzer, läuft der
+Container unter deiner Kennung (`APP_UID`/`APP_GID`, siehe `.env`). Damit
+funktioniert SFTP direkt:
+
+```bash
+sftp dein-nutzer@dein-server
+get -r /pfad/zu/aether-data/users/deinname/home
+```
+
+> **Nur lesen.** Wer von Hand eine Datei hineinlegt, hat sie auf der Platte,
+> aber nicht in der Datenbank: Die Cloud sieht sie nicht, und die
+> Speicherbereinigung räumt sie irgendwann weg. Zum Hineinlegen ist WebDAV der
+> Weg (siehe unten).
+
+### Von einem benannten Volume umsteigen
+
+Ältere Installationen hatten ein Volume `deploy_data`. Umzug mit Prüfung:
+
+```bash
+cd deploy
+docker compose stop app
+mkdir -p /pfad/zu/aether-data
+docker run --rm -v deploy_data:/src:ro -v /pfad/zu/aether-data:/dst alpine:3.20 \
+  sh -c 'cp -a /src/. /dst/ && chown -R $(id -u):$(id -g) /dst'
+
+# Prüfen, bevor umgeschaltet wird: beide Summen müssen gleich sein
+docker run --rm -v deploy_data:/src:ro alpine:3.20 \
+  sh -c 'cd /src && find . -type f -exec sha256sum {} \; | LC_ALL=C sort | sha256sum'
+(cd /pfad/zu/aether-data && find . -type f -exec sha256sum {} \; | LC_ALL=C sort | sha256sum)
+
+# erst dann DATA_PATH in die .env eintragen und starten
+docker compose up -d app
+```
+
+Das alte Volume **nicht sofort löschen**. Es ist der Rückfall, solange nicht
+alles geprüft ist; `docker volume rm deploy_data` kann warten, bis du sicher
+bist.
+
+---
+
+## WebDAV
+
+Adresse: `https://<deine-domain>/dav/`
+
+Angemeldet wird sich mit dem **Benutzernamen** und einem **App-Passwort**
+(Profil → App passwords). Das Kontopasswort wird an `/dav/` **abgelehnt** – es
+ist zugleich der Admin-Zugang und hat auf Geräten nichts verloren. Ein
+App-Passwort gilt nur für WebDAV, nie fürs Web-Login, und lässt sich einzeln
+widerrufen, ohne die anderen Geräte auszusperren.
+
+Der Aufbau entspricht dem der Weboberfläche: eigene Ordner und Gruppenordner
+liegen nebeneinander in der Wurzel, Freigaben von Personen unter
+`/dav/Shared/<Person>/<Freigabe>/`. Trägt ein Gruppenordner denselben Namen wie
+ein eigener, behält der eigene ihn und der Gruppenordner bekommt den
+Gruppennamen angehängt (`Projekt (Buero)`).
+
+Nach zehn Fehlanmeldungen in 15 Minuten sperrt die IP für den Rest des Fensters
+(`429`). Normale Anfragen zählen nicht mit – Sync-Clients senden legitim
+hunderte pro Minute.
+
+---
+
+## Office (Collabora / OnlyOffice)
+
+Aether ist **WOPI-Host**. Das ist die Schnittstelle, über die Office-Server
+sich eine Datei holen und wieder zurückschreiben – **Collabora und OnlyOffice
+sprechen beide dieselbe.** Deshalb wird hier *ein* Adapter gebaut und der
+Anbieter per `.env` umgeschaltet, statt zweimal dasselbe zu integrieren.
+
+### Was dazukommt
+
+| | |
+|---|---|
+| `OFFICE_PROVIDER` | `collabora`, `onlyoffice` oder leer (aus) |
+| `OFFICE_URL` | wo das **Backend** den Office-Server erreicht |
+| `OFFICE_PUBLIC_URL` | wo der **Browser** ihn erreicht (leer = wie oben) |
+| `OFFICE_WOPI_URL` | wo der **Office-Server** Aether erreicht (leer = `PUBLIC_URL`) |
+| `OFFICE_ALLOWED_HOSTS` | Ziele, die das Backend anfragen darf – gegen SSRF |
+
+**Drei Adressen für drei Richtungen.** Das wirkt übertrieben, bis man es einmal
+aufgebaut hat: Im Compose-Netz heißt der Office-Server `collabora`, im Browser
+muss dort ein auflösbarer Name stehen, und der Office-Server wiederum erreicht
+Aether unter `app:8080` – „localhost" ist aus seinem Container heraus er selbst.
+
+Der Container startet nur mit dem Profil, sonst kostet er Arbeitsspeicher, ohne
+gebraucht zu werden:
+
+```bash
+docker compose --profile office up -d
+```
+
+### Welche Dateien, und wie gut
+
+Bearbeitet wird nur, was auf der **Positivliste** steht:
+`odt docx doc rtf txt · ods xlsx xls csv · odp pptx ppt · odg`.
+PDF steht bewusst **nicht** darauf – es hat seinen eigenen Betrachter, und ein
+Office-Server würde beim Speichern ein anderes Dokument daraus machen.
+
+Collabora Online *ist* LibreOffice, mit derselben Datei-Unterstützung. Für die
+Microsoft-Formate heißt das:
+
+| | |
+|---|---|
+| `docx`, `xlsx`, `pptx` | öffnen und speichern zuverlässig, Format bleibt erhalten |
+| Alte `doc`, `xls`, `ppt` | gehen, sind aber Rückwärtskompatibilität – kein Ziel der Entwicklung |
+| Komplexes Layout | Seitenumbrüche und Schriftabstände können um Kleinigkeiten abweichen |
+| Sehr große Tabellen, Pivot, seltene Formeln | die häufigste Stelle für echte Abweichungen |
+| Makros (VBA) | laufen nicht – und das ist Absicht, nicht Mangel |
+
+Fehlende **Schriften** sind der häufigste Grund für „sieht anders aus": Der
+Container bringt Calibri und Cambria nicht mit. Wer Dokumente von außen
+bearbeitet, legt die Schriften nach.
+
+Für ein Belegarchiv ist das unkritisch – da wird gelesen und selten geändert.
+Für den täglichen Umgang mit fremden Word-Dateien gilt: **Rundlauf prüfen**,
+nicht darauf vertrauen.
+
+### Wie das zusammenspielt
+
+Der Office-Server ist **kein Client deines Browsers allein** – er holt die
+Datei selbst beim Backend ab:
+
+```
+Browser ──────────► Office-Server        (Bedienoberfläche im <iframe>)
+Office-Server ────► Aether  /wopi/...    (Datei holen, Datei zurückschreiben)
+```
+
+Beide Pfeile müssen funktionieren. Das ist der Punkt, an dem solche
+Installationen scheitern: Der Office-Server muss **Aether unter seiner
+öffentlichen Adresse erreichen** (`PUBLIC_URL`), nicht nur unter
+`localhost`. Ein Zugriffstoken mit kurzer Laufzeit hängt an jedem Aufruf; ohne
+gültiges Token liefert der WOPI-Endpunkt nichts.
+
+### Was beim Aufbau schiefgeht
+
+Alles hier ist beim Testen tatsächlich passiert, in dieser Reihenfolge:
+
+| Symptom | Ursache |
+|---|---|
+| Rahmen bleibt leer, Konsole: *„Framing … violates default-src 'self'"* | Unsere eigene Sicherheitsrichtlinie. `frame-src` fällt auf `default-src` zurück; der Office-Ursprung muss ausdrücklich erlaubt sein. Passiert automatisch, sobald `OFFICE_PROVIDER` gesetzt ist. |
+| Editor lädt, Dokument bleibt weiß | `ssl.termination=true` ohne HTTPS davor. Collabora sagt dem Browser dann `wss://`, das es nicht gibt. Im HTTP-Test `OFFICE_SSL_TERMINATION=false`. |
+| Log: *„CheckFileInfo returned 0 … ECONNREFUSED"* | `OFFICE_WOPI_URL` zeigt auf `127.0.0.1:8090`. Der Port ist auf loopback gebunden – aus einem Container nicht erreichbar. Im Compose den Dienstnamen nehmen. |
+| Log: *„WOPISrc must be URI-encoded"* | Behoben; die Adresse wird vollständig kodiert. |
+| Log: *„Failed to exec coolmount … needs CAP_SYS_ADMIN"* | Gelöst über `--o:mount_jail_tree=false` im Compose. |
+| Fehlende Symbole (404 auf `.svg`) | Lücken im Collabora-Image selbst. Kosmetisch. |
+
+### Sicherheit
+
+- **SSRF:** Das Backend ruft den Office-Server auf. Ausgehende Ziele werden auf
+  `OFFICE_ALLOWED_HOSTS` beschränkt – sonst wird aus einer Adresse in der
+  Konfiguration ein Weg ins interne Netz.
+- **Tokens sind dateibezogen und kurzlebig.** Ein Token für Datei A öffnet
+  Datei B nicht, auch nicht mit derselben Sitzung.
+- **Schreiben folgt derselben Regel wie ein Upload:** atomar schreiben,
+  SHA-256 neu berechnen, Version anlegen, wenn Versionierung an ist. Ein
+  Office-Server ist kein Sonderweg an der Datenintegrität vorbei.
+
+### Speicherbedarf – vor der Entscheidung lesen
+
+Der Office-Server ist der mit Abstand hungrigste Teil dieser Anlage:
+
+| | Bedarf | Bemerkung |
+|---|---|---|
+| **Collabora (CODE)** | ~1 GB im Leerlauf, +100–200 MB je offenem Dokument | LibreOffice-Kern, startet pro Dokument einen Prozess |
+| **OnlyOffice Docs** | 2 GB Minimum, **4 GB empfohlen**, dazu Swap | bringt eigenes Postgres, RabbitMQ und Node mit |
+
+Dazu kommt, was schon läuft: Postgres, Aether und – nicht unterschätzen – die
+**Texterkennung**. ocrmypdf und ghostscript nehmen sich bei einem großen Scan
+kurzzeitig mehrere hundert Megabyte.
+
+### Welchen nehmen?
+
+- **Collabora**, wenn der Speicher knapp ist oder Herkunft und ODF zählen.
+  LibreOffice-Kern, europäisch, deutlich genügsamer.
+- **OnlyOffice**, wenn `.docx`/`.xlsx` zwischen Desktop-Office und Web hin und
+  her wandern. Beste Treue bei OOXML, weil es nativ damit arbeitet.
+- **EuroOffice** ist ein junger OnlyOffice-Fork und nutzt **denselben
+  WOPI-Weg**. Eine Entscheidung für OnlyOffice heute verbaut ihn nicht: Es wäre
+  ein Wechsel des Containers und eine Zeile in der `.env`.
+
+---
+
+## Phasen-Roadmap
+
+| Phase | Inhalt | Status |
+|-------|--------|--------|
+| 0 | Fundament (Monorepo, Docker, Migrations, Backend-Skeleton) | ✅ |
+| 1 | Auth (Argon2id, Sessions), Storage (atomar + SHA-256), Datei-CRUD, Frontend | ✅ |
+| 2 | Uploads mit Fortschritt, Papierkorb, Versionen, Share-Links, Thumbnails | ✅ |
+| 2.5 | Sidebar-Favoriten, Ordner verschieben/hochladen, „Verschieben nach…" | ✅ |
+| 3 | Admin-Panel, Gruppen(-mitgliedschaft), Theming, User-Profil | ✅ |
+| 4 | WebDAV (`/dav/`), OIDC (optional) | ✅ (im Test) |
+| 4.5 | Härtung (Quota, Audit-Log, App-Passwörter), interne Shares, Gruppenordner, Logo/App-Symbol | ✅ (im Test) |
+| 5 | UI (Suche, Vorschau, Sortierung, Vor/Zurück) – Design-Rest offen | 🔄 |
+| 6 | Dokumente: OCR + Volltextsuche ✅, Etiketten ✅, Absender ✅, PDF-Betrachter ✅ – Inbox vertagt | 🔄 |
+| 7 | Office (WOPI-Host, Collabora / OnlyOffice) – [Anleitung](#office-collabora--onlyoffice) | ✅ (im Test) |
+| 8 | Härtung, 2FA, Observability, Extension-Points | 🔲 |
+
+> Manuelle Test-Checkliste für die fertigen Phasen: siehe [`TESTING.md`](TESTING.md).
diff --git a/TESTING.md b/TESTING.md
new file mode 100644
index 0000000..e4b6875
--- /dev/null
+++ b/TESTING.md
@@ -0,0 +1,1079 @@
+# Aether – Test-Checkliste
+
+Manuelle Test-Checkliste für die fertigen Phasen. Abhaken beim Durchtesten.
+
+- ⚠️ = bekannte Lücke, muss *nicht* getestet werden
+- 🔎 = von Claude per `curl`/API gegen ein Wegwerf-Konto geprüft und grün.
+  Bewusst **nicht** abgehakt: eine API-Prüfung ersetzt nicht den Test in der
+  Oberfläche bzw. mit einem echten Client. Beim Durchgehen selbst abhaken.
+
+---
+
+## Phase 3 – Admin, Gruppen, Theming, Profil
+
+### Admin-Panel: Zugriff & Sicherheit
+- [X] Admin-Link erscheint **nur** für Admin-User in der Sidebar
+- [X] Normaler User sieht den Admin-Link **nicht**
+- [X] Normaler User, der `/api/v1/admin/users` direkt aufruft, bekommt `403` (serverseitiger Check)
+- [X] Nach Logout ist kein Admin-Endpunkt erreichbar (`401`)
+
+### Admin: Benutzerverwaltung
+- [x] Benutzerliste zeigt alle User mit verwendetem Speicher + Quota + Rolle
+- [x] Neuen User anlegen (Username, Anzeigename, Passwort, Quota, Admin-Flag)
+- [x] Anlegen mit existierendem Username → Fehler „bereits vergeben" (`409`)
+- [x] User bearbeiten (Anzeigename, Quota, Admin-Flag ändern)
+- [x] **Selbst-Schutz:** eigenen Admin-Status kann man **nicht** entfernen (Fehlermeldung)
+- [x] *Selbst-Schutz:** eigenes Konto kann man **nicht** löschen
+- [x] Passwort-Reset generiert neues Passwort und zeigt es **einmalig** an
+- [x] Neuer User kann sich mit dem zurückgesetzten Passwort einloggen
+- [ ] User löschen entfernt den User (und seine Dateien) 🔎
+
+### Admin: Gruppen
+- [x] Gruppen-Tab lädt ohne schwarzen Bildschirm (war der Bug – jetzt gefixt)
+- [x] Gruppe anlegen (Name + Beschreibung)
+- [x] Gruppe aufklappen zeigt Mitglieder
+- [x] Mitglied über Dropdown hinzufügen → Zähler steigt
+- [x] Mitglied entfernen → Zähler sinkt
+- [x] Gruppe mit doppeltem Namen → Fehler (`409`)
+- [x] Gruppe löschen (auch mit Mitgliedern – Cascade)
+- [ ] ⚠️ *Gruppen haben noch keine Funktion (keine Gruppenordner) – Phase 4.5/C, offen*
+
+### Admin: Theming
+- [x] Cloud-Name ändern → erscheint nach Reload überall (Login-Seite, Sidebar)
+- [x] Primärfarbe ändern → Buttons/Akzente übernehmen die Farbe sofort
+- [x] Akzentfarbe ändern → Vorschau aktualisiert live
+- [x] Nach Reload sind die Farben persistent
+- [ ] ⚠️ *Logo-Upload noch nicht vorhanden – Phase 4.5/D, offen*
+
+### Profil-Seite (jeder User)
+- [x] Avatar/Name unten in der Sidebar öffnet die Profil-Seite
+- [x] Speicheranzeige (Balken) stimmt mit tatsächlicher Nutzung
+- [ ] Anzeigename ändern → wird gespeichert (✓-Bestätigung) 🔎
+- [x] Passwort ändern: falsches aktuelles Passwort → Fehler
+- [x] Passwort ändern: neue Passwörter stimmen nicht überein → Fehler
+- [x] Passwort ändern: < 8 Zeichen → Fehler
+- [x] Passwort erfolgreich ändern → Logout → Login mit neuem Passwort klappt
+- [x] Persönliche Farben ändern → werden angewendet
+- [x] Logout-Button im Profil-Bereich funktioniert (ohne Profil zu öffnen)
+
+---
+
+## Phase 4 – WebDAV & OIDC
+
+### WebDAV – Verbindung
+Verbinden mit `https://<deine-domain>/dav/` oder lokal direkt mit
+`http://127.0.0.1:8090/dav/`. **Achtung Port:** die App lauscht *im Container* auf
+8080, Compose bildet das auf dem Host aber auf **8090** ab (`127.0.0.1:8090->8080`).
+Vom Host aus gilt immer 8090 – und nur vom Host, die Bindung ist auf localhost.
+
+Anmeldung mit dem Benutzernamen und einem **App-Passwort** (Profil → App passwords).
+Das Kontopasswort wird hier **abgelehnt** – es ist zugleich der Admin-Zugang und
+hat auf Geräten nichts verloren.
+
+Clients: KDE/Dolphin, macOS Finder, Windows Explorer, `cadaver`, `rclone`, Cyberduck.
+
+> **Hintergrund zu Dolphin/KIO:** KIO schickt Zugangsdaten nie vorab, sondern
+> immer erst auf den `401` hin – und beginnt dabei sofort mit dem Rumpf, ohne
+> `Expect: 100-continue` abzuwarten. Große Uploads scheiterten deshalb mit
+> „unerwarteter Fehler 0", während kleine Dateien durchliefen. Behoben am
+> 22.08.2026: Der Server liest den Rumpf einer unauthentifizierten Anfrage weg,
+> bevor er die Anmeldeaufforderung schickt, damit die Verbindung stehen bleibt
+> und KIO die `401` überhaupt zu sehen bekommt.
+
+> Alle Punkte hier wurden am 19.08.2026 per `curl` gegen ein Wegwerf-Konto
+> geprüft und waren grün (🔎). Was das **nicht** abdeckt: ein echter Client
+> (Finder, Explorer, Cyberduck, rclone) verlangt andere PROPFIND-Properties und
+> nutzt Locking – deshalb stehen die Haken offen.
+
+- [x] Login mit Username + **App-Passwort** → Verbindung steht 🔎
+- [x] Login mit falschem Passwort → abgelehnt (`401`) 🔎
+- [x] Login mit dem **Kontopasswort** → abgelehnt (`401`), auch wenn es stimmt 🔎
+- [x] Ordnerstruktur entspricht der in der Web-App (gleiche Ordner sichtbar) 🔎
+
+### WebDAV – Lesen
+- [x] Ordner auflisten (PROPFIND) zeigt Dateien + Unterordner 🔎
+- [x] Datei herunterladen → Inhalt korrekt 🔎
+- [x] Datei, die in der Web-App hochgeladen wurde, ist via WebDAV sichtbar 🔎
+
+### WebDAV – Schreiben
+- [x] Datei hochladen (PUT) → erscheint danach in der Web-App 🔎
+- [x] Neuen Ordner anlegen (MKCOL) → erscheint in der Web-App 🔎
+- [x] Datei umbenennen (MOVE im selben Ordner) 🔎
+- [x] Datei in anderen Ordner verschieben (MOVE) 🔎
+- [x] Ordner umbenennen 🔎
+- [x] Datei löschen (DELETE) → landet im Papierkorb der Web-App (nicht hart gelöscht!) 🔎
+- [x] Bestehende Datei überschreiben → bei **aktivierter** Versionierung landet die
+      alte Fassung in der Historie; bei deaktivierter wird ersetzt (so gewollt,
+      Versionierung ist pro Datei opt-in) 🔎
+- [ ] Checksumme/Integrität: hochgeladene Datei wieder runterladen → identisch 🔎
+- [x] **Große Datei (100 MB+) per Dolphin hochladen** – war der Fehler
+      „unerwarteter Fehler 0" 🔎
+- [ ] Quota wird bei WebDAV-Upload geprüft → `507 Insufficient Storage` 🔎
+- [ ] Abgebrochener Upload (Kontingent voll oder Verbindung weg) hinterlässt
+      **nichts** – keine abgeschnittene Datei, kein verwaistes Blob 🔎
+- [ ] Rate-Limit/Lockout am WebDAV-Login (10 Fehlversuche / 15 min → `429`) 🔎
+- [ ] App-Passwort ist der **einzige** WebDAV-Zugang, gilt nicht fürs Web-Login,
+      und ist nach dem Widerruf sofort tot 🔎
+
+### App-Passwörter (Profil → App passwords)
+- [ ] App-Passwort anlegen → Klartext erscheint **einmalig**, „Copy" kopiert es
+- [ ] Damit einen WebDAV-Client verbinden (Username = normaler Benutzername)
+- [ ] Liste zeigt „Last used" nach der ersten Nutzung
+- [ ] Widerrufen → Client kommt sofort nicht mehr rein
+- [ ] Kontopasswort im WebDAV-Client → abgelehnt; der Anmeldedialog nennt den
+      Grund im Realm-Text 🔎
+- [ ] Kontopasswort funktioniert weiterhin fürs **Web-Login** 🔎
+- [ ] App-Passwort funktioniert **nicht** fürs Web-Login 🔎
+
+### Audit-Log (Admin → Activity)
+- [ ] Tab zeigt Einträge, neueste zuerst 🔎
+- [ ] Fehlgeschlagene Anmeldung erscheint rot als „Sign-in failed" 🔎
+- [ ] Anmeldung, Passwortwechsel, User-/Gruppen-Änderungen, Freigaben und
+      Löschungen tauchen auf 🔎
+- [ ] Filter-Dropdown schränkt auf eine Aktion ein
+- [ ] Blättern funktioniert (ab 50 Einträgen)
+- [ ] Gelöschtes Konto: Eintrag bleibt lesbar, Name mit „(deleted account)"
+- [ ] Passwort-Reset steht im Protokoll – **ohne** das Passwort selbst
+- [ ] Normaler User bekommt auf `/api/v1/admin/audit` ein `403`
+
+### Speicher-Bereinigung (Admin → Activity → „Run now")
+- [ ] „Run now" meldet „Nothing to clean up", solange alles in Ordnung ist 🔎
+- [ ] Verwaiste Datei älter als 24 h wird entfernt, Ergebnis wird angezeigt 🔎
+- [ ] Frisch angelegte verwaiste Datei bleibt liegen (Schonfrist) 🔎
+- [ ] Echte Dateien bleiben nach dem Lauf unangetastet 🔎
+- [ ] Der Lauf erscheint anschließend selbst im Audit-Log
+
+---
+
+## Phase 4.5/B – Interne Freigaben
+
+### Freigeben (Rechtsklick → „Share with people…")
+- [ ] Ordner an eine **Person** freigeben, Recht „Can view"
+- [ ] Empfänger sieht ihn unter **Shared with me**, mit „View only"
+- [ ] Empfänger kann hineinsehen und herunterladen
+- [ ] Empfänger kann **nicht** umbenennen, löschen, hochladen (Meldung statt Fehler)
+- [ ] Recht auf „Can edit" ändern → wird ersetzt, **kein** zweiter Eintrag
+- [ ] Empfänger kann jetzt umbenennen und hochladen
+- [ ] Einzelne **Datei** freigeben → Empfänger sieht nur sie, nicht den Ordner drumherum
+- [ ] An eine **Gruppe** freigeben → alle Mitglieder sehen es, mit Hinweis „via <Gruppe>"
+- [ ] Mitglied aus der Gruppe entfernen → Zugriff sofort weg
+- [ ] „Remove" im Dialog → Zugriff sofort weg
+
+### Grenzen (das Wichtige)
+- [ ] Empfänger kann die Freigabe **nicht weitergeben** (nur der Eigentümer teilt)
+- [ ] Dateien bleiben beim Eigentümer: Speicherbalken des **Eigentümers** wächst,
+      wenn der Empfänger etwas hochlädt – nicht der des Empfängers
+- [ ] Unterordner, den ein Empfänger anlegt, gehört dem **Eigentümer**
+- [ ] Empfänger kann eine geteilte Datei **nicht** in seinen eigenen Ordner verschieben
+- [ ] Ohne Freigabe liefert ein direkter Aufruf mit bekannter ID `404` (nicht `403` –
+      sonst verriete die Antwort, dass die ID existiert)
+- [ ] Freigaben tauchen im Audit-Log als `share.grant` / `share.revoke` auf
+
+> Über WebDAV erscheinen Freigaben unter `/dav/Shared/<Eigentümer>/<Freigabe>/`
+> – siehe eigener Abschnitt weiter unten.
+
+---
+
+---
+
+## Phase 4.5/C – Gruppenordner
+
+### Anlegen (Admin → Groups)
+- [ ] Gruppe wählen, Namen eingeben, „Create" → Ordner erscheint in der Liste
+- [ ] Zweiter Ordner für dieselbe Gruppe → Fehler „already has a folder" (`409`) 🔎
+- [ ] Übersicht zeigt Gruppe, Mitgliederzahl und belegten Platz
+
+### Beim Nutzer
+- [ ] **Kein** Mitglied: Ordner ist nicht sichtbar 🔎
+- [ ] Mitglied hinzufügen → Ordner erscheint in dessen Wurzel, beschriftet
+      als „Group folder" 🔎
+- [ ] Zwei Mitglieder arbeiten darin: hochladen, herunterladen, umbenennen,
+      Unterordner anlegen 🔎
+- [ ] Mitglied entfernen → Ordner verschwindet sofort 🔎
+
+### Der Ordner selbst ist geschützt
+- [ ] Rechtsklick auf den Gruppenordner: **kein** Löschen, Umbenennen,
+      Verschieben, Teilen – nur Öffnen und Favorit
+- [ ] Er lässt sich nicht per Drag & Drop verschieben
+- [ ] Direkter API-Aufruf (`DELETE /folders/{id}`) → `403` 🔎
+- [ ] **Innerhalb** des Ordners ist alles normal löschbar 🔎
+
+### Speicher und Papierkorb
+- [ ] Dateien liegen unter `groups/<id>/home/…`, nicht bei einem Nutzer 🔎
+- [ ] Kontingent zählt gegen die **Gruppe**, bei keinem Mitglied 🔎
+- [ ] Gruppenkontingent überschritten → `413` 🔎
+- [ ] Gelöschte Gruppendatei erscheint im Papierkorb **jedes Mitglieds** und
+      lässt sich wiederherstellen 🔎
+- [ ] Admin löscht den Gruppenordner → Daten und Verzeichnis restlos weg 🔎
+
+### Geteiltes und Gruppenordner über WebDAV
+
+Der Aufbau bildet die Weboberfläche nach: Gruppenordner liegen **in der Wurzel**
+neben den eigenen, Personen-Freigaben gebündelt unter `Shared/`.
+
+- [ ] Gruppenordner erscheint in der WebDAV-Wurzel, gleiche Liste wie in der
+      Weboberfläche 🔎
+- [ ] Hineinnavigieren, hochladen, Unterordner anlegen 🔎
+- [ ] **Namensgleichheit:** eigener Ordner `Projekt` + Gruppenordner `Projekt`
+      → eigener behält den Namen, Gruppenordner heißt `Projekt (<Gruppe>)`,
+      beide erreichbar, Schreibvorgänge landen jeweils richtig 🔎
+- [ ] Nach Austritt aus der Gruppe verschwindet er aus der Wurzel 🔎
+- [ ] `Shared` erscheint nur, wenn eine **Person** etwas geteilt hat 🔎
+- [ ] `/Shared/` listet die Personen, `/Shared/<Person>/` deren Freigaben 🔎
+- [ ] Datei im geteilten Ordner lesen und schreiben (bei „Can edit") 🔎
+- [ ] Einzeln geteilte Datei erscheint als **Datei**, nicht als Ordner 🔎
+- [ ] Nur-Lesen: Schreiben und Löschen → `403` (nicht `404`/`405`) 🔎
+- [ ] In `/Shared/` selbst lässt sich nichts anlegen oder löschen (`403`) 🔎
+- [ ] Verschieben über Eigentumsgrenzen → `403` 🔎
+- [ ] Nicht Vorhandenes bleibt `404` – verrät nichts 🔎
+- [ ] Entzug der Freigabe / Austritt aus der Gruppe → sofort `404` 🔎
+- [ ] Bens Upload landet im Bereich des **Eigentümers** und zählt gegen dessen
+      Kontingent 🔎
+- [ ] Prüfsumme über den geliehenen Pfad: Upload → WebDAV-GET → Web-Download,
+      alles identisch 🔎
+- [ ] Mit einem echten Client (Dolphin) durchgehen
+
+### OIDC (nur falls konfiguriert)
+OIDC ist optional. Test nur, wenn `OIDC_ISSUER` etc. in `.env` gesetzt sind.
+**Wichtig:** `OIDC_REDIRECT_URL` muss auf `<PUBLIC_URL>/api/v1/auth/oidc/callback` zeigen
+und exakt so beim IdP registriert sein.
+
+- [ ] Ohne OIDC-Config: **kein** SSO-Button auf der Login-Seite (Standardfall)
+- [ ] Mit OIDC-Config: SSO-Button erscheint
+- [ ] Klick auf SSO → Weiterleitung zum IdP
+- [ ] Nach erfolgreichem IdP-Login → zurück in Aether, eingeloggt
+- [ ] Beim ersten OIDC-Login wird automatisch ein User angelegt (aus `preferred_username`)
+- [ ] Zweiter OIDC-Login desselben Accounts → gleicher User (kein Duplikat)
+- [ ] Username-Kollision → automatischer Suffix (`name2`, `name3`, …)
+- [ ] Manipulierter/abgebrochener Callback → Redirect mit Fehler, kein Login
+- [ ] CSRF/State: Login mit falschem `state`-Cookie → abgelehnt
+
+---
+
+## Phase 4.5/D – Logo & App-Symbol
+
+### Admin → Theming: Logo
+- [x] Logo hochladen → erscheint sofort in der Vorschau, Seitenleiste und
+      auf der Anmeldeseite (ohne Speichern-Klick) 🔎
+- [x] Logo austauschen → neues Bild sofort sichtbar, altes ist von der
+      Platte verschwunden 🔎
+- [ ] „Remove" → Standard-Wolke ist zurück 🔎
+- [ ] SVG, Textdatei, getarnte EXE → abgelehnt (`415`) 🔎
+- [ ] Datei über 2 MB → `413` mit klarer Meldung 🔎
+- [ ] Normaler Nutzer kann weder hochladen noch löschen (`403`) 🔎
+- [ ] Logo ist **ohne** Anmeldung abrufbar (die Anmeldeseite braucht es) 🔎
+
+### Admin → Theming: App-Symbol
+Ein Upload für beides – Tab-Symbol und installierte App. Der Server rechnet
+64, 192, 512 und die maskable-Fassung daraus.
+
+- [ ] Quadratisches PNG (am besten 512×512) hochladen → Symbol im Tab wechselt
+      ohne Neuladen 🔎
+- [ ] Anderer, schon offener Tab zieht beim nächsten Laden nach
+- [ ] Austauschen → neues Symbol sofort da, altes Verzeichnis von der Platte
+      verschwunden 🔎
+- [ ] „Remove" → Standard-Symbol ist zurück, Verzeichnis gelöscht 🔎
+- [ ] Vorlage kleiner als 192×192 → `422` mit klarer Meldung 🔎
+- [ ] Vorlage mit 256×256 → es entsteht **kein** 512er, das Manifest nennt ihn
+      auch nicht (nie hochskalieren) 🔎
+- [ ] Nicht quadratisches Bild → wird gerahmt, **nicht** beschnitten 🔎
+- [ ] SVG und ICO → abgelehnt (`415`); Datei über 2 MB → `413` 🔎
+- [ ] Ohne Anmeldung abrufbar (der Browser fragt das Tab-Symbol vor dem
+      Anmelden ab) 🔎
+- [ ] Speicher-Bereinigung („Run now") löscht den Symbol-Satz **nicht** 🔎
+
+### Manifest (`/manifest.webmanifest`)
+- [ ] Direkt aufrufen → nennt Cloud-Namen und Primärfarbe aus dem
+      Admin-Bereich, nicht die fest eingebauten Werte 🔎
+- [ ] Ohne eigenes Symbol fällt es auf die mitgelieferten Bilder zurück 🔎
+- [ ] Auf dem Handy „Zum Startbildschirm hinzufügen" → Name und Symbol stimmen
+- [ ] **Bereits installierte App:** Symbol wechselt erst nach ein, zwei Tagen –
+      Chrome fragt das Manifest von selbst nach, aber nicht sofort. Sicher
+      sofort nur nach Deinstallieren und neu Installieren.
+
+---
+
+## Vor und Zurück im Verlauf
+
+- [ ] In mehrere Ordner nacheinander wechseln → **Zurück** (Browser-Taste,
+      Seitentaste der Maus oder Wischgeste) geht die Reihenfolge rückwärts,
+      **Vor** wieder nach vorn
+- [ ] In der Werkzeugleiste stehen **keine** eigenen Vor/Zurück-Pfeile mehr –
+      das macht allein der Browser
+- [ ] Über die Seitenleiste die Ansicht wechseln (Papierkorb, Freigaben,
+      Admin, Profil) → Zurück führt zur vorigen Ansicht
+- [ ] Aus einer anderen Ansicht zurück zu „Files" → der zuletzt geöffnete
+      Ordner ist wieder da, nicht die Wurzel
+- [ ] Über die Brotkrumen nach oben springen → zählt als eigener Schritt,
+      Zurück führt wieder nach unten
+- [ ] Auf einen Favoriten in der Seitenleiste klicken → eigener Schritt im
+      Verlauf
+- [ ] Zweimal denselben Ordner öffnen, in dem man schon steht → erzeugt
+      **keinen** zweiten Schritt (Zurück springt nicht ins Leere)
+- [ ] Seite neu laden (`F5`) → man landet wieder im selben Ordner
+- [ ] Adresse zeigt die Ansicht (`/admin`, `/trash`); direkt eingegeben lädt
+      sie auch. Der Ordner steht **nicht** in der Adresse – ein Link auf einen
+      tiefen Ordner ist also nicht teilbar (bewusst, siehe Projektplan)
+
+---
+
+## Suche
+
+Feld in der Werkzeugleiste, rechts neben den Brotkrumen. Sucht in **Namen** von
+Dateien und Ordnern – und seit dem 23.08.2026 zusätzlich im **Inhalt** von PDFs
+und Bildern (siehe „Volltext über den Inhalt" weiter unten).
+
+- [ ] Ab zwei Zeichen erscheinen Treffer, ein Zeichen tut nichts
+- [ ] Unter jedem Treffer steht der Ordner, in dem er liegt
+- [ ] Ordner-Treffer anklicken → Ordner wird geöffnet
+- [ ] Datei-Treffer anklicken → springt **nur** in den Ordner. Es öffnet sich
+      **keine** Vorschau 🔎
+- [ ] Die gesuchte Datei ist dort kurz umrandet und wird in den sichtbaren
+      Bereich geholt; die Markierung verschwindet nach knapp drei Sekunden von
+      selbst 🔎
+- [ ] Geöffnet wird weiterhin per **Doppelklick** auf die Datei
+- [ ] Das gilt in Kachel- **und** Listenansicht
+- [ ] Pfeiltasten wählen aus, Enter öffnet, Esc schließt
+- [ ] Schnell tippen → keine veralteten Treffer (jede Anfrage bricht die
+      vorige ab)
+- [ ] Papierkorb bleibt außen vor: gelöschte Datei erscheint nicht 🔎
+
+### Volltext über den Inhalt (OCR)
+
+Der Punkt, für den ein Rechnungsarchiv überhaupt gebaut wird: Ein Beleg namens
+`scan_0042.pdf` muss über das zu finden sein, was **drin** steht.
+
+Wichtig zum Verständnis beim Prüfen: Die Erkennung läuft **im Hintergrund**.
+Direkt nach dem Hochladen findet die Suche den Inhalt noch nicht – bei einem
+PDF mit Textebene nach etwa einer Sekunde, bei einem Scan nach rund einer
+Minute je Seite. Der Stand steht in `GET /api/v1/admin/ocr` (noch ohne
+Oberfläche) und im Log (`docker compose logs app | grep component=ocr`).
+
+- [ ] PDF **mit** Textebene hochladen → nach ein paar Sekunden findet ein Wort
+      aus dem Text die Datei; im Log steht `source=layer` 🔎
+- [ ] Eingescannte oder abfotografierte Rechnung hochladen → nach etwa einer
+      Minute je Seite findet ein Wort daraus die Datei; im Log `source=ocr` 🔎
+- [ ] Unter dem Treffer steht die **Fundstelle** mit hervorgehobenem Suchwort,
+      und der Name allein hätte nicht gepasst 🔎
+- [ ] Die Fundstelle läuft über **zwei Zeilen** und bricht am Ende der zweiten
+      mit „…" ab – nicht mitten in der ersten 🔎
+- [ ] Links daneben eine dünne Linie in derselben Farbe wie das hervorgehobene
+      Wort; sie trennt das Zitat vom Ordnernamen darüber 🔎
+- [ ] Ein Dokument mit `<script>` im Text zeigt das als **sichtbaren Text**,
+      führt es nicht aus (die Marken kommen als `[[hl]]`, nicht als HTML)
+- [ ] Ordner- und Dateinamen beginnen in der Trefferliste auf **derselben**
+      linken Kante (gemessen: alle bei x=616) 🔎
+- [ ] Datei, deren **Name** passt, steht **vor** den Inhaltstreffern 🔎
+- [ ] Eine Datei, bei der Name *und* Inhalt passen, erscheint **einmal**, nicht
+      zweimal 🔎
+- [ ] **Das Original ist unverändert:** Größe und Prüfsumme nach der Erkennung
+      identisch, keine neue Version in der Historie, WebDAV lädt die Datei
+      nicht erneut 🔎
+- [ ] Bestandsdateien von vor dem Einbau sind ebenfalls durchsuchbar (werden
+      beim ersten Start nachgetragen) 🔎
+- [ ] Gelöschte Datei erscheint auch bei Inhaltstreffern nicht
+- [ ] Ein anderer Nutzer findet **nichts** über den Inhalt fremder Dokumente –
+      der Umfang ist derselbe wie bei der Namenssuche
+- [ ] Word-/Excel-Datei liefert keinen Inhaltstreffer (bewusst nicht gebaut),
+      wird aber weiterhin über den Namen gefunden
+- [ ] Erstes Dokument nach einem frischen Container-Start gelingt beim
+      **ersten** Versuch (kein „Tesseract failed to report available
+      languages" im Log) 🔎
+- [ ] `OCR_ENABLED=false` in der `.env` → Cloud läuft normal, nur ohne
+      Inhaltstreffer; `/api/v1/admin/ocr` meldet `enabled:false`
+
+**Platte** (OCR ist das Einzige, was von allein Platz verbraucht):
+
+- [ ] Während der Erkennung eines großen Scans bleibt `/data/tmp` fast leer –
+      `docker compose exec app du -sh /data/tmp` sollte im Kilobyte-Bereich
+      liegen, nicht im Megabyte-Bereich 🔎
+- [ ] Nach der Erkennung liegen dort keine `ocr-*`-Dateien mehr 🔎
+- [ ] `docker kill` mitten in einer Erkennung → beim nächsten Start meldet das
+      Log „Zwischendateien eines früheren Laufs entfernt"
+- [ ] Bei weniger als 2 GiB freiem Platz pausiert die Erkennung mit einer
+      Warnung im Log, statt weiterzuarbeiten; die Cloud bleibt bedienbar
+
+### Suche und Berechtigungen (das Wichtige)
+Am 23.08.2026 mit zwei Wegwerf-Konten durchgespielt – die Punkte sind grün,
+aber ein zweites Augenpaar auf der Oberfläche schadet nicht.
+
+- [ ] Fremde Dateien tauchen **nie** auf, auch nicht mit passendem Namen 🔎
+- [ ] Nach einer Freigabe erscheinen die Dateien des anderen – auch die in
+      **Unterordnern** der Freigabe (Vererbung nach unten) 🔎
+- [ ] Nach Entzug der Freigabe sind sie sofort wieder weg 🔎
+- [ ] Gruppenordner erscheinen bei Mitgliedern, bei anderen nicht 🔎
+- [ ] Nach Austritt aus der Gruppe sofort weg 🔎
+- [ ] Suchwort mit `%` oder `_` sucht diese Zeichen wörtlich, nicht als
+      Platzhalter (`%e` findet **nicht** alles mit „e") 🔎
+
+## Vorschau
+
+Doppelklick auf eine Datei zeigt sie, statt sie herunterzuladen. Der
+Download-Knopf und das Kontextmenü laden weiter herunter.
+
+- [ ] Bild, PDF, Textdatei, Video, Tondatei → werden angezeigt
+- [ ] **PDF** öffnet den eingebauten Betrachter mit Seitenleiste, Zoom und
+      Drucken 🔎
+- [ ] Speicherbalken zeigt direkt nach der Anmeldung den echten Wert, nicht
+      0 B 🔎
+- [ ] ZIP, EXE und anderes → Doppelklick lädt weiter herunter
+- [ ] Pfeile links/rechts blättern durch die anzeigbaren Dateien des Ordners,
+      Pfeiltasten ebenso
+- [ ] Esc schließt, Klick auf den dunklen Rand ebenso
+- [ ] „Download" in der Vorschau lädt die Datei
+- [ ] Textdatei über 2 MB → Hinweis statt Anzeige
+- [ ] **Video/Ton:** in der Abspielleiste vor- und zurückspringen, auch an eine
+      Stelle, die noch nicht geladen war 🔎
+- [ ] Bild behält sein Seitenverhältnis, egal wie das Fenster steht
+- [ ] Textansicht ist ein Blatt in der Mitte, nicht die ganze Fläche
+
+### Textdatei bearbeiten
+- [ ] „Edit" → Textfeld, „Save" schreibt zurück, Liste zeigt neue Größe
+- [ ] Bei eingeschalteter Versionierung landet die alte Fassung in der Historie
+- [ ] „Cancel" verwirft, Schließen mit ungesicherten Änderungen fragt nach
+- [ ] Pfeiltasten schreiben im Textfeld, statt zu blättern
+- [ ] Nur-Lese-Freigabe → „Save" meldet fehlenden Schreibzugriff
+- [ ] **Sicherheit:** eine hochgeladene HTML-Datei wird auch mit `?inline=1`
+      als Download ausgeliefert, nicht angezeigt 🔎
+- [ ] Fremde Datei über `?inline=1` → `404` wie beim normalen Download 🔎
+
+## Kachel-Cover nach Dateityp
+
+- [x] Ton, Video, Archiv, Tabelle, **Präsentation**, Code, PDF und Dokument
+      haben je eigenes Symbol und eigene Farbe
+- [x] Word (blau), Excel (grün), PowerPoint (orangerot) sind auf einen Blick
+      auseinanderzuhalten – auch die OpenDocument-Entsprechungen
+      (`.odt`, `.ods`, `.odp`) 🔎
+- [x] PDF und Word-Dokument haben **verschiedene** Symbole, nicht nur
+      verschiedene Farben
+- [x] `.md` und `.txt` zählen als Text (grau), nicht als Office-Dokument
+- [x] Unten links steht die Endung als Aufkleber (`MP3`, `TAR.GZ`, `CSV`)
+- [ ] Ton und Video tragen zusätzlich ein Abspielzeichen
+- [ ] `.tar.gz` wird als Archiv erkannt, obwohl die Endung zweiteilig ist 🔎
+- [x] Bilder zeigen weiterhin ihr Vorschaubild – mit Aufkleber darüber, damit
+      PNG, JPG, GIF und SVG unterscheidbar bleiben
+- [ ] Ordner: zweilagige Form mit Reiter und heller Oberkante, nicht mehr
+      flachgedrückt; Gruppenordner in der Primärfarbe mit `GROUP`-Aufkleber
+- [ ] Auch in „Verschieben nach…", „Shared with me" und im Admin-Bereich
+      dieselbe Form – dort waren die Ordner vorher **schwarz** 🔎
+- [ ] Ziel beim Ziehen hebt sich weiterhin ab
+- [ ] Listenansicht und Suchtreffer zeigen denselben Ordner wie die Kacheln
+
+## Dateitypen (MIME)
+
+- [ ] Neu hochgeladene `.mp3` erscheint als `audio/mpeg`, nicht als
+      `application/octet-stream` 🔎
+- [ ] **Bestandsdatei** mit falschem Typ lässt sich trotzdem abspielen – der
+      Typ wird beim Ausliefern aus dem Namen neu bestimmt 🔎
+
+## Kopfleiste in allen Ansichten
+
+Alle sechs Ansichten teilen sich dieselbe Leiste (`components/PageHeader.tsx`),
+feste Höhe 57 px.
+
+- [ ] Zwischen Home, Papierkorb, „Shared with me", Freigabe-Links, Admin und
+      Profil umschalten → die Leiste **springt nicht**, der Inhalt darunter
+      beginnt überall auf derselben Kante
+- [ ] Symbol (18 px) und Titel (15 px, Stärke 600) sitzen überall gleich –
+      auch „Home" in den Brotkrumen. Beim Umschalten springt nichts 🔎
+      (nachgemessen: Symbol x=240, Titel x=268 in allen sechs Ansichten)
+- [ ] Alle Kopfsymbole haben runde Strichenden
+- [ ] Bedienelemente stehen überall rechts
+- [ ] Schmales Fenster: die Leiste bleibt einzeilig, nichts bricht um
+
+## Einstellungen und Admin-Zugang (23.08.2026)
+
+- [ ] „Admin" steht **nicht mehr** in der Seitenleiste – der Weg dorthin führt
+      über das Nutzermenü oben rechts 🔎
+- [ ] Die Seitenleiste zeigt nur noch Orte: Home, Trash, Shared with me,
+      Shared links, Favoriten 🔎
+- [ ] Die Einstellungen heißen „Settings" (nicht mehr „Profile") und sind in
+      **Reiter** unterteilt wie der Admin-Bereich:
+      **Account** → **Access** → **Appearance** → **Storage** 🔎
+- [ ] Die Reiterleiste sieht in Einstellungen und Admin-Bereich **gleich** aus –
+      beide benutzen `components/Tabs.tsx`. Gemessen: Höhe 39, Schrift 14 px,
+      aktiver Reiter fett und unterstrichen 🔎
+- [ ] Der Speicherbalken steht am **Ende**, nicht mehr ganz oben 🔎
+- [ ] Bei „App passwords" steht der Hinweis dabei, dass das Kontopasswort an
+      `/dav/` bewusst abgelehnt wird
+- [ ] Ein Nutzer **ohne** Adminrechte sieht „Admin panel" im Menü nicht und
+      kommt über `/admin` auch nicht hinein
+
+## Stand der Texterkennung im Admin-Bereich (23.08.2026)
+
+Admin panel → Activity, oberhalb von „Storage cleanup".
+
+- [ ] „Full-text indexing" zeigt die Zahl der gelesenen Dokumente 🔎
+- [ ] Während die Warteschlange abgearbeitet wird: gelber Punkt, Drehrädchen
+      und „… to go"; die Zahl aktualisiert sich von selbst alle fünf Sekunden
+- [ ] Steht die Warteschlange still, hört das Nachfragen auf (im Netzwerk-Reiter
+      der Entwicklerwerkzeuge zu sehen) – sonst liefe alle fünf Sekunden eine
+      Anfrage ins Leere
+- [ ] Grüner Punkt, wenn alles gelesen ist
+- [ ] Bei `OCR_ENABLED=false`: gedämpfter Punkt und ein Hinweis, was fehlt
+- [ ] Nicht lesbare Dateien werden mitgezählt („n could not be read")
+
+### Eigener Stand für jeden Nutzer
+
+Settings → Storage → „Document search". Der Admin-Bereich zeigt den ganzen
+Server; hier sieht **jeder** Nutzer seine eigenen Dateien.
+
+- [ ] Als normaler Nutzer (ohne Adminrechte) ist die Karte sichtbar und zeigt
+      eine Zahl 🔎
+- [ ] Die Zahl umfasst **nur die eigenen** Dateien – ein zweites Konto mit
+      eigenen PDFs sieht seine eigene Zahl, nicht die des Servers 🔎
+- [ ] `GET /api/v1/ocr` ohne Anmeldung → `401` 🔎
+- [ ] Während der Erkennung: gelber Punkt und „… still to go", danach grün
+- [ ] Kein Adminrecht nötig, um die eigene Zahl zu sehen
+
+## Etiketten und Belegdatum (23.08.2026)
+
+Rechtsklick auf eine Datei → „Tags…".
+
+- [ ] Neues Etikett im Dialog anlegen; es erscheint sofort gewählt 🔎
+- [ ] Derselbe Name in anderer Schreibweise wird abgelehnt („STEUER-2026"
+      neben „steuer-2026") 🔎
+- [ ] Leerer Name wird abgelehnt 🔎
+- [ ] Etiketten erscheinen als Aufkleber an der Kachel **und** in der
+      Listenansicht 🔎
+- [ ] Seitenleiste zeigt sie unter den Favoriten mit Farbpunkt und Zählstand 🔎
+- [ ] Klick darauf zeigt alles mit diesem Etikett – **über Ordnergrenzen
+      hinweg** 🔎
+- [ ] Die Adresse `/tags/<id>` ist verlinkbar und übersteht ein Neuladen 🔎
+- [ ] Zurück-Taste des Browsers führt vom Etikett zurück
+- [ ] Gelöschte Dateien zählen nicht mit und erscheinen nicht
+
+**Belegdatum**
+
+- [ ] Datum setzen, Dialog erneut öffnen → das Datum steht drin (nicht leer) 🔎
+- [ ] Die Etikettenansicht sortiert nach Belegdatum, neueste zuerst; Dateien
+      ohne Datum stehen am Ende 🔎
+- [ ] Datum wieder leeren funktioniert
+
+**Was nicht schiefgehen darf**
+
+- [ ] Ungültiges Datum → Fehlermeldung, und die Etiketten bleiben **unverändert**
+      (nicht halb gespeichert) 🔎
+- [ ] Eine Datei in einem **Gruppenordner** kann nur Gruppen-Etiketten tragen;
+      der Dialog zeigt dort auch nur diese 🔎
+- [ ] Ein zweites Konto sieht die eigenen Etiketten **nicht**
+- [ ] Wer eine Datei nur lesen darf, kann sie nicht etikettieren
+- [ ] Etikett löschen entfernt nur die Ordnung, **keine Dateien** 🔎
+
+## Sammel-Download als ZIP (23.08.2026)
+
+Drei Wege dorthin - Auswahl, Ordner, Etikett.
+
+**Auswahl**
+
+- [ ] `Strg`-Klick (oder Klick aufs Kaestchen) waehlt eine Datei aus; das
+      Kaestchen erscheint beim Ueberfahren 🔎
+- [ ] Ist etwas ausgewaehlt, genuegt ein einfacher Klick fuer die naechste
+- [ ] `Umschalt`-Klick waehlt den **Bereich** in der angezeigten Reihenfolge
+- [ ] Die Kopfleiste zeigt "n selected" mit "Download as ZIP" und "Clear" 🔎
+- [ ] Ordnerwechsel verwirft die Auswahl (sonst laedt man ungesehen mit) 🔎
+- [ ] **Escape** hebt die Auswahl auf 🔎
+- [ ] Ist die Vorschau offen, schliesst das erste Escape **nur die Vorschau** –
+      die Auswahl bleibt; erst das zweite hebt sie auf 🔎
+- [ ] Waehrend man in ein Feld tippt, verwirft Escape die Eingabe und nicht
+      die Auswahl
+- [ ] Ein einfacher Klick waehlt **nichts** aus, auch nicht wenn schon etwas
+      markiert ist – dafuer gibt es Kaestchen, Strg und Umschalt 🔎
+- [ ] Ein Doppelklick oeffnet die Vorschau und **aendert die Auswahl nicht** 🔎
+- [ ] Funktioniert in Kachel- **und** Listenansicht
+
+**Ordner und Etikett**
+
+- [ ] Rechtsklick auf einen Ordner -> "Download as ZIP" laedt den ganzen Inhalt 🔎
+- [ ] **Unterordner behalten ihre Struktur** im Archiv 🔎
+- [ ] Etikettenansicht -> "Download all as ZIP" laedt alles mit diesem Etikett
+- [ ] Das Archiv heisst nach Ordner bzw. Etikett 🔎
+
+**Was nicht schiefgehen darf**
+
+- [ ] Ohne Anmeldung -> `401`, ohne CSRF-Token -> `403` 🔎
+- [ ] Eine erfundene Datei-Kennung landet **nicht** im Archiv 🔎
+- [ ] Fremde Dateien sind nicht enthalten, auch nicht bei geratener Kennung
+- [ ] Zwei gleichnamige Dateien werden zu "name" und "name (2)" - nicht
+      stillschweigend zu einer 🔎
+- [ ] `paket.tar.gz` doppelt -> "paket (2).tar.gz", nicht "paket.tar (2).gz" 🔎
+- [ ] Umlaute im Dateinamen kommen im entpackten Archiv richtig an
+- [ ] Ein grosser Ordner startet **sofort** (gestreamt) statt erst zu sammeln 🔎
+- [ ] Ueber 2000 Dateien -> klare Meldung statt endlosem Warten
+- [ ] Bereits gepackte Formate (.zip, .deb, .jpg, .pdf) werden nur gelagert,
+      nicht erneut komprimiert 🔎
+
+## Bedienung am Finger (24.08.2026)
+
+**Auf dem Handy öffnete gar nichts.** Ordner und Dateien hingen an
+`onDoubleClick` – und den doppelten Klick gibt es auf einem Touchscreen
+praktisch nicht: Man trifft nicht zweimal denselben Pixel, der Browser meldet
+zwei einzelne Berührungen. Der Doppelklick ist eine Mausgeste.
+
+Unterschieden wird jetzt nach `pointer: coarse`, also nach dem **Zeigegerät**,
+nicht nach der Fensterbreite: Ein schmales Fenster am Schreibtisch bleibt eine
+Maus, ein Tablet im Querformat bleibt ein Finger.
+
+- [ ] Handy: **ein Tipp** öffnet Ordner 🔎 und Dateien 🔎 (Kachel und Liste)
+- [ ] Läuft eine Auswahl, schaltet der Tipp die Auswahl um statt zu öffnen –
+      ohne Strg/Umschalt wäre Mehrfachauswahl am Telefon sonst unbedienbar
+- [ ] Langes Drücken öffnet das Kontextmenü (**bitte am Gerät prüfen** – die
+      Kacheln sind auch ziehbar, und der Browser könnte stattdessen eine
+      Ziehbewegung beginnen)
+- [ ] Desktop **unverändert**: Doppelklick öffnet, einfacher Klick bleibt frei,
+      Strg/Umschalt wählt aus 🔎
+
+> **Falle, die zweimal zuschlug:** In JSX gewinnt die zuletzt notierte
+> Eigenschaft. Ein per Spread eingesetztes `onClick` wurde vom danach
+> notierten `onClick` stillschweigend überschrieben – der Tipp auf ein PDF tat
+> nichts, während der auf einen Ordner ging. Dateien schreiben ihren Handler
+> deshalb aus, statt ihn zusammenzusetzen. Dieselbe Sorte Fehler wie
+> Inline-Stil gegen Klasse: Es wird gesetzt und sofort überschrieben.
+
+---
+
+## Zoom „ganze Breite" bei gemischten Formaten (24.08.2026)
+
+Gerechnet wird gegen die **häufigste** Seitenbreite, nicht mehr gegen die
+breiteste.
+
+- [ ] Zehnseitiges Dokument mit **einer** Querformat-Seite: die hochkanten
+      Seiten füllen die Breite 🔎 (gemessen 384 von 412 px; vorher 46 % statt
+      65 %, weil eine einzige Seite das ganze Dokument bestimmte)
+- [ ] Die Querformat-Seite ragt über den Rand und lässt sich seitlich
+      schieben – das ist bei ihr ohnehin gewollt
+- [ ] Reines Hochformat: unverändert
+
+---
+
+## Handy: eine Kopfzeile statt zwei (24.08.2026)
+
+Die eigene Leiste über der Kopfzeile („☰ Aether") ist weg. Sie enthielt nur
+das Menü-Symbol und den Namen der Cloud – und der stand ohnehin in der
+Seitenleiste, die sie öffnete. Gemessen kostete sie 57 der 915 Pixel.
+
+- [ ] Handy: **eine** Kopfzeile – ☰, Ort („Home"/Ordner), rechts das Konto 🔎
+      (gemessen 120 px statt 205 px)
+- [ ] Das Konto steht in der **Titelzeile**, nicht in der Reihe mit
+      „+ Folder" und „Upload" 🔎
+- [ ] ☰ öffnet die Seitenleiste 🔎
+- [ ] Desktop **unverändert**: Kopfzeile 56 px, kein ☰, Konto ganz rechts
+      hinter der Trennlinie 🔎
+
+### Sichere Bereiche – der Abstand wirkte nirgends
+
+`.aether-safe-top` und Geschwister waren Klassen; alle drei Stellen setzen
+ihren Abstand aber als **Inline-Stil**, und der schlägt jede Klasse. Der
+Abstand wurde berechnet und sofort überschrieben. Jetzt Variablen
+(`--safe-top`, `--safe-bottom`, `--safe-left`).
+
+Nur in der **installierten** App zu sehen (im Browser ist der Wert 0):
+
+- [ ] Kopfzeile klebt nicht an der Statusleiste / Uhr
+- [ ] Speicherbalken der Seitenleiste liegt nicht hinter dem Wischbalken
+- [ ] Querformat mit Aussparung: Seitenleiste beginnt neben der Kamera
+
+---
+
+## Handy und PWA (23.08.2026)
+
+Die Kopfleiste war auf schmalen Schirmen **kaputt**: eine Zeile ohne Umbruch,
+die ihren Inhalt gequetscht statt umgebrochen hat. Gemessen bei 390 px:
+Brotkrume auf einen Strich zusammengeschoben, Suchfeld über der
+Sortierauswahl, Ansichts-Umschalter verschwunden, Nutzerbereich abgeschnitten.
+
+- [ ] Auf dem Handy sind **alle** Bedienelemente sichtbar und erreichbar:
+      Brotkrume, Suche, Sortierung, Umschalter, „+ Folder", Upload, Nutzer 🔎
+- [ ] Nichts läuft seitlich aus dem Bild (kein waagerechtes Scrollen) 🔎
+- [ ] Auf dem Desktop bleibt die Leiste **einzeilig, 56 px** wie vorher 🔎
+- [ ] Die Trefferliste der Suche passt auf den Schirm, ohne über den Rand zu
+      gehen
+- [ ] Etikettendialog und „Edit tag" sind auf dem Handy vollständig bedienbar
+- [ ] Als PWA installiert dasselbe prüfen – dort fehlt die Adressleiste, die
+      Leiste sitzt also weiter oben
+- [ ] Drehen ins Querformat und zurück
+
+**Installierte App**
+
+- [ ] Der Inhalt reicht bis an die Ränder, steht aber **nicht** hinter Uhr
+      oder Wischbalken 🔎
+- [ ] Der Speicherbalken unten links ist erreichbar, nicht hinter dem
+      Wischbalken 🔎
+- [ ] Die Statusleiste hat die eingestellte Primärfarbe (nicht mehr das
+      voreingestellte Indigo) 🔎
+- [ ] Das Symbol auf dem Startbildschirm ist das hochgeladene 🔎
+- [ ] Die Seite lässt sich am Anschlag **nicht** gummiartig überziehen
+- [ ] **Offline:** Die App startet und zeigt die Anmeldeseite – mehr geht
+      nicht, weil jede Datei vom Server kommt. Kein Fehlerbildschirm 🔎
+
+## Etiketten anpassen (23.08.2026)
+
+- [ ] Beim Anlegen erscheint eine Farbwahl, sobald man tippt 🔎
+- [ ] Zwei nacheinander angelegte Etiketten bekommen **verschiedene** Farben
+- [ ] **Rechtsklick** auf ein Etikett in der Seitenleiste öffnet ein kleines
+      Menü mit „Edit…" und „Delete" – **nicht** sofort einen Dialog 🔎
+- [ ] „Edit…" öffnet Umbenennen und Farbwahl (ohne Löschknopf daneben) 🔎
+- [ ] „Delete" fragt zurück und nennt die Zahl der betroffenen Dateien 🔎
+- [ ] Umbenennen wirkt sofort – auch an den Aufklebern der Kacheln, ohne
+      Neuladen 🔎
+- [ ] Farbe ändern wirkt sofort an Punkt und Aufklebern
+- [ ] Die Rückfrage sagt ausdrücklich, dass die **Dateien bleiben** 🔎
+- [ ] Nach dem Löschen verschwinden die Aufkleber an den Kacheln sofort 🔎
+- [ ] Der Zählstand in der Seitenleiste geht direkt hoch, wenn man etikettiert 🔎
+
+## OIDC scharf schalten (23.08.2026)
+
+Der Durchgang vor dem Produktivgang. **Reihenfolge zählt hier**: Zuerst
+`OIDC_LINK_BY_USERNAME=true` setzen, *dann* zum ersten Mal über PocketID
+anmelden. Andersherum entsteht ein zweites Konto, und die Dateien liegen danach
+auf zwei Konten verteilt.
+
+- [ ] `.env`: `OIDC_ISSUER`, `OIDC_CLIENT_ID`, `OIDC_CLIENT_SECRET`,
+      `OIDC_REDIRECT_URL` gesetzt; Redirect-URL zeigt auf
+      `https://<domain>/api/v1/auth/oidc/callback` und ist bei PocketID
+      **identisch** hinterlegt
+- [ ] `OIDC_LINK_BY_USERNAME=true` **vor** dem ersten Login
+- [ ] Der Benutzername bei PocketID (`preferred_username`) ist derselbe wie in
+      Aether – sonst greift die Verknüpfung nicht
+- [ ] Anmeldeseite zeigt den SSO-Knopf 🔎
+- [ ] Erster OIDC-Login landet auf dem **bestehenden** Konto: gleiche Dateien,
+      Adminrechte noch da 🔎
+- [ ] Danach steht in Settings → Account der Hinweis statt des
+      Passwortformulars 🔎
+- [ ] Zweiter Login findet dasselbe Konto (kein `name2` in der Nutzerliste) 🔎
+- [ ] **WebDAV funktioniert weiter** – App-Passwörter sind von OIDC unberührt
+- [ ] Das Kontopasswort funktioniert für den Web-Login **nicht** mehr
+      (Konto hat keines mehr)
+
+## Passwort bei OIDC-Konten (23.08.2026)
+
+Wer sich über PocketID anmeldet, hat in Aether **kein** Passwort (`password`
+steht auf `''`). Das Formular konnte also nur fehlschlagen – und zwar mit
+„current password incorrect", was nach einem Tippfehler aussieht statt nach dem
+wahren Grund.
+
+- [ ] Als OIDC-Konto zeigt Settings → Account statt des Formulars den Hinweis
+      „You sign in through your identity provider…" 🔎
+- [ ] Als Konto **mit** Passwort ist das Formular unverändert da 🔎
+- [ ] `POST /auth/change-password` als OIDC-Konto → `400` mit klarer Meldung,
+      nicht `401` „current password incorrect" 🔎
+- [ ] Ein OIDC-Konto kann sich **nicht** über das Passwortfeld anmelden
+      (`''` ist kein gültiger Argon2-Hash – galt schon vorher, bitte
+      trotzdem einmal probieren)
+
+## Nutzerbereich oben rechts (23.08.2026)
+
+Der Block saß bis dahin unten links in der Seitenleiste – mit dem Abmelden-
+Symbol direkt neben dem Knopf, der zu den Einstellungen führt. Abmelden ist die
+einzige Handlung, die man nicht zurücknehmen kann, und war die am leichtesten
+erreichbare.
+
+- [ ] Oben rechts steht Avatar + **Anzeigename**, in **jeder** Ansicht an
+      derselben Stelle 🔎
+- [ ] Nur der Anzeigename, nicht zusätzlich die Kennung darunter 🔎
+- [ ] Klick öffnet das Menü: Name, Kennung (nur wenn sie sich unterscheidet),
+      „Administrator", dann Settings / Admin panel / Sign out
+- [ ] „Sign out" steht zuletzt, rot und durch eine Trennlinie abgesetzt
+- [ ] Klick daneben schließt, Esc schließt
+- [ ] Unten links steht **nur noch** der Speicherbalken – kein Nutzer, kein
+      Abmelden 🔎
+- [ ] „Admin panel" erscheint nur bei Administratoren
+- [ ] Die Kopfleiste bleibt in allen Ansichten gleich hoch (der Nutzerbereich
+      wächst sie nicht auf)
+
+## Dateien auf dem Wirt / SFTP (23.08.2026)
+
+Die Daten liegen seit dem 23.08.2026 in einem gewöhnlichen Verzeichnis
+(`DATA_PATH`), nicht mehr in einem Docker-Volume.
+
+- [ ] `ls -la $DATA_PATH/users/<name>/home/` zeigt echte Ordner und Namen, und
+      die Dateien gehören **dir** – kein `sudo` nötig 🔎
+- [ ] Eine hochgeladene Datei taucht dort sofort mit ihrem Namen auf 🔎
+- [ ] Gelöschte Datei liegt unter `.trash/`, wiederhergestellte wieder in
+      `home/`
+- [ ] Per SFTP von einem anderen Rechner: `get -r …/home` holt alles
+- [ ] Upload, Vorschau, WebDAV und OCR funktionieren wie vorher (der Container
+      läuft jetzt unter deiner Kennung) 🔎
+- [ ] Beim Umzug: Prüfsummen von Volume und Zielverzeichnis stimmen überein,
+      **bevor** umgeschaltet wird 🔎
+
+## Office – Collabora / OnlyOffice (24.08.2026)
+
+Aether ist WOPI-Host; der Office-Server holt die Datei selbst ab und schreibt
+sie zurück. Getestet mit Collabora im Compose-Profil `office`.
+
+### Öffnen
+- [ ] Rechtsklick auf .odt/.docx/.ods → „Edit in Office…" erscheint 🔎
+- [ ] Doppelklick öffnet den Editor statt der Vorschau 🔎
+- [ ] Der Inhalt ist da – nicht nur die Werkzeugleiste 🔎
+- [ ] Ohne Office-Server: Der Menüpunkt erscheint gar nicht erst 🔎
+- [ ] Bei einem PDF erscheint er ebenfalls nicht (eigener Betrachter)
+
+### Speichern
+- [ ] Text tippen, Strg+S → Fassung und Größe der Datei ändern sich 🔎
+      (gemessen: v1 → v3, 81 → 94 Zeichen im Dokument)
+- [ ] Der getippte Text steht wirklich in der heruntergeladenen Datei 🔎
+- [ ] Bei eingeschalteter Versionierung entsteht ein Eintrag im Verlauf
+- [ ] Kontingent voll → Office meldet einen Fehler, die alte Fassung bleibt
+- [ ] Schließen und neu öffnen zeigt den gespeicherten Stand
+
+### Rechte
+- [ ] Datei mit Leserecht geliehen → „read only" in der Kopfzeile, kein Speichern
+- [ ] Freigabe während der Bearbeitung zurückziehen → das nächste Speichern
+      scheitert (die Rechte werden bei **jedem** WOPI-Aufruf neu aufgelöst)
+- [ ] Token einer Datei an einer anderen Datei-ID → `404`
+- [ ] Abgelaufenes Token → `401`
+- [ ] `/wopi/files/<id>` ohne Token → `401` 🔎
+
+### Aufbau
+- [ ] Ohne `--profile office` startet der Container nicht 🔎
+- [ ] `OFFICE_ALLOWED_HOSTS` greift: eine fremde Adresse in `OFFICE_URL` wird
+      abgelehnt statt angefragt
+- [ ] Sicherheitsrichtlinie nennt den Office-Ursprung unter `frame-src` 🔎
+- [ ] Ohne Office-Server bleibt die Richtlinie so eng wie zuvor
+
+---
+
+## Absender / Korrespondent (23.08.2026)
+
+Das zweite Ordnungsmerkmal neben den Etiketten. Unterschied: genau **einer**
+je Dokument. Gesetzt im selben Dialog (Rechtsklick → „Organise…").
+
+### Setzen
+- [ ] Namen tippen und speichern → Absender erscheint an der Kachel, in der
+      Seitenleiste unter FROM, Zähler auf 1 🔎
+- [ ] Zweites Dokument, Vorschlagsliste zeigt den vorhandenen Namen 🔎
+- [ ] Gleicher Name in anderer Schreibweise („stadtwerke münchen") landet beim
+      vorhandenen Absender und legt **keinen** Zwilling an 🔎
+- [ ] Feld leeren und speichern → Absender weg, Etiketten und Belegdatum
+      bleiben stehen 🔎
+- [ ] Nur Leseberechtigung an einer geliehenen Datei → kein Speichern möglich
+
+### Liste und Ansicht
+- [ ] Klick auf einen Absender in der Seitenleiste → „alles von X",
+      absteigend nach Belegdatum sortiert 🔎
+- [ ] Adresse `/from/<id>` überlebt das Neuladen (Lesezeichen) 🔎
+- [ ] „Download all as ZIP" in dieser Ansicht
+- [ ] Zurück-Taste des Browsers führt aus der Absenderansicht heraus
+
+### Umbenennen und Löschen
+- [ ] Rechtsklick → „Rename…" → alle bisherigen Dokumente behalten ihn 🔎
+- [ ] Umbenennen auf einen schon vergebenen Namen → klare Meldung 🔎
+- [ ] Rechtsklick → „Delete" fragt nach und sagt dabei, dass die **Dokumente
+      bleiben** 🔎
+- [ ] Nach dem Löschen: Dokumente da, Belegdatum da, nur die Zuordnung weg 🔎
+
+### Fremdzugriff
+- [ ] Erratene Absender-ID an einer eigenen Datei → `400` 🔎
+- [ ] Fremden Absender umbenennen oder löschen → `404` (nicht `403`) 🔎
+
+### Gruppenordner
+- [ ] Ein Absender in einem Gruppenordner gehört der Gruppe, nicht dem
+      Anlegenden – alle Mitglieder sehen ihn
+- [ ] Die Vorschlagsliste zeigt in einem Gruppenordner nur Gruppen-Absender
+
+---
+
+## PDF-Betrachter (23.08.2026)
+
+Eigener Betrachter statt des eingebauten im `<iframe>`. Gründe: Chrome auf
+Android zeigte im `<iframe>` gar kein PDF an, und einem fremden Betrachter
+lässt sich kein Suchwort vorgeben.
+
+### Werkzeugleiste
+- [ ] Suchfeld sitzt **mittig** in der Leiste (gemessen: 0 Pixel Abweichung) 🔎
+- [ ] Beim ersten Treffer rutscht das Feld **nicht** zur Seite – der Platz für
+      die Sprungknöpfe steht immer bereit 🔎
+- [ ] Am Telefon zwei Zeilen: Steuerung oben, Suche darunter, beide
+      Sprungpfeile sichtbar 🔎
+- [ ] Zoomprozent stimmt beim Öffnen (nicht 10 %) – dreimal hintereinander
+      geprüft, war vorher vom Zufall abhängig 🔎
+
+### Grundlegend
+- [ ] PDF per Doppelklick öffnen → Seiten erscheinen, Seitenzahl stimmt 🔎
+- [ ] Blättern über die Pfeile der Werkzeugleiste 🔎
+- [ ] Zoom −/+ und der Umschalter „ganze Seite ↔ 100 %" 🔎
+- [ ] **Nach dem Zoomen bleibt man auf derselben Seite** – nicht am Anfang
+      eines fremden Blattes 🔎 (war ein Fehler: sprang zurück zur Fundstelle)
+- [ ] Text im PDF lässt sich markieren und kopieren 🔎
+- [ ] Drucken über den Browser (Strg+P) – der Betrachter bringt keinen
+      eigenen Druckknopf mit
+
+### Suche im Dokument
+- [ ] Aus der Volltextsuche geöffnet → Suchwort steht im Feld, der Betrachter
+      steht auf der Seite mit dem Treffer, das Wort ist orange 🔎
+- [ ] Weitere Treffer blass markiert, der aktuelle kräftiger und mit Kante 🔎
+- [ ] Das markierte Wort bleibt **lesbar** – der Streifen liegt darüber, nicht
+      darauf 🔎
+- [ ] Der Streifen sitzt **auf der Zeile**: nicht schief, oben nicht
+      angeschnitten 🔎 (kein Treffer ragt aus der Seite heraus)
+- [ ] Markiert wird das **ganze Wort**, nicht der Schnipsel: „la" färbt
+      `Display`, `last`, `labex` – nicht zwei Buchstaben mittendrin 🔎
+      (gemessen: unser Kasten und die Auswahl des Browsers liegen auf
+      demselben Pixel, 357,08 / 10,38 – der Versatz der Ersatzschrift ist
+      nicht wegzurechnen, wohl aber zu umgehen)
+- [ ] Sehr lange „Wörter" (Adresse, Prüfsumme) werden **nicht** ganz
+      eingefärbt – dort bleibt es beim Fundstück
+- [ ] **Suchfeld leeren → alle Markierungen verschwinden** 🔎 (war ein Fehler:
+      die Färbung blieb zu einem Wort stehen, das im Feld längst nicht mehr
+      stand)
+- [ ] Während Treffer markiert sind, lässt sich Text weiter mit der Maus
+      auswählen – die Markierungsebene fängt keine Klicks ab
+- [ ] „Nächster Treffer" / „Voriger Treffer" springt der Reihe nach 🔎
+- [ ] **Beim Tippen ruckt nichts.** Der Rand über der ersten Seite bleibt
+      stehen, das Blatt klebt nicht am Fensterrand 🔎 (gemessen: `scrollTop`
+      bleibt 0, Rand bleibt 16 px, **kein einziges** Roll-Ereignis)
+- [ ] Ist der Treffer schon zu sehen, wird gar nicht gerollt; erst ein
+      Treffer außerhalb holt die Anzeige nach 🔎 (gemessen: 6 × Enter →
+      Treffer 7 von 54, genau ein Roll-Ereignis)
+- [ ] Enter im Suchfeld = nächster Treffer, Umschalt+Enter = voriger
+- [ ] **Scan** (nur Bild, per OCR erkannt): Suche findet die *Seite*, springt
+      hin, markiert aber nichts – Anzeige „1 / 5 · page" 🔎
+- [ ] Ein Treffer nur im Dateinamen (nicht im Inhalt) füllt das Suchfeld
+      **nicht** vor – sonst meldete der Betrachter „No hits" ohne Grund
+- [ ] Fremde Datei: `GET /api/v1/files/<id>/text` → `404`
+
+### Test-PDF für die Suche
+
+`~/Dokumente/aether-suchtest.pdf` – zehn Seiten, jede eine eigene Falle.
+Suchwort ist überall **aether**; ein Durchlauf deckt alle Fälle ab.
+
+| Seite | Fall | Erwartung |
+|---|---|---|
+| 1 | Schriftgrößen 48 bis 4 pt | Kasten sitzt bei **jeder** Größe auf dem Wort |
+| 2 | Times / Helvetica / Courier, fett, kursiv | dito – hier fällt der Versatz der Ersatzschrift am ehesten auf |
+| 3 | Wortgrenzen: Bindestrich, Klammern, Umlaute, Ziffern, Unterstriche | ganzes Wort gefärbt; die 68-stellige Prüfsumme **nicht** |
+| 4 | Zwei Spalten, 8 pt, enge Zeilen | kein Überlappen zwischen den Zeilen |
+| 5 | Wort am Zeilenende getrennt (`Ae-` / `ther`) | wird **nicht** gefunden – bekannte Grenze |
+| 6 | gedreht: 90°, 45°, 180° | Kasten dreht mit |
+| 7 | Tabelle | Treffer in Zellen |
+| 8 | 66 Treffer auf einer Seite | Zähler stimmt, Weiterspringen läuft durch |
+| 9 | Querformat | Zoom stellt sich um |
+| 10 | **Scan** (nur Bild, leicht schief) | erst nach OCR, dann seitengenau: „· page", ohne Färbung |
+
+Gemessen beim Bauen: 390 Treffer über 10 Seiten, keine Fehler in der Konsole.
+
+### Randfälle
+- [ ] 60-seitiges PDF: höchstens 6 Seiten gleichzeitig gezeichnet, Suche über
+      alle 60 findet die richtige Seite 🔎
+- [ ] Passwortgeschütztes PDF → „This PDF is password protected." 🔎
+- [ ] Kaputte Datei mit Endung .pdf → „Could not open this PDF." 🔎
+- [ ] Andere Vorschauen unverändert (Bild, Text, Ton, Video) 🔎
+
+### Am Telefon
+- [ ] PDF wird **angezeigt** (mit dem `<iframe>` kam dort nur ein
+      Download-Hinweis) 🔎
+- [ ] Kein waagerechter Überlauf, Seite füllt die Breite 🔎
+- [ ] Die Pfeile zum Blättern zwischen Dateien sind bei einem PDF ausgeblendet
+      – sie lägen mitten auf dem Text 🔎
+- [ ] Zwei Finger zum Zoomen (das macht der Browser selbst)
+
+### Tastatur
+- [ ] Escape im Suchfeld des Betrachters leert das Feld, schließt **nicht**
+      die Vorschau
+- [ ] Pfeiltasten blättern nicht zur nächsten Datei, während man im Suchfeld
+      schreibt 🔎
+
+### Erkannter Text mit Seitenmarken
+- [ ] Nach dem Aktualisieren stehen Bestandsdateien auf `extract_version = 1`
+      und tragen Seitenmarken 🔎
+- [ ] Dateien im Papierkorb werden **nicht** neu erkannt 🔎
+
+---
+
+## Eigenschaften einer Datei (24.08.2026)
+
+Rechtsklick → **Properties…**. Das, was Dateimanager unter Windows und Linux
+anbieten. Anlass: Bei einem Bild stand nirgends, wie groß es in **Pixeln** ist.
+
+- [ ] Bild → Zeile „Dimensions" mit Breite × Höhe und Megapixeln 🔎
+      (gemessen: 2000 × 1851 px, 3.7 MP)
+- [ ] Nicht-Bild (Archiv, PDF, Office) → **keine** Zeile „Dimensions" 🔎
+- [ ] Größe steht zweimal: gerundet und auf das Byte genau 🔎
+- [ ] Belegdatum, Absender und Etiketten erscheinen nur, wenn gesetzt 🔎
+- [ ] „Version 2 (history kept)" bzw. „(history off)" passt zum Schalter
+      „Keep versions" im selben Menü 🔎
+- [ ] Klick auf die Prüfsumme kopiert sie („copied" erscheint kurz)
+- [ ] Ohne HTTPS (kein sicherer Kontext) bleibt der Wert stehen statt zu
+      kopieren – keine Fehlermeldung
+- [ ] Die Maße kommen aus dem Browser, nicht vom Server: Ein Bildformat, das
+      der Browser nicht kennt, lässt die Zeile bei „measuring…" – kein Fehler
+
+---
+
+## Kachelansicht: Absender statt Größe (24.08.2026)
+
+- [ ] Kachel **mit** Absender: links Symbol + Name, rechts das Etikett,
+      **keine** Dateigröße 🔎
+- [ ] Kachel **ohne** Absender: links die Größe wie bisher 🔎
+- [ ] Alle Kacheln einer Reihe sind gleich hoch, auch mit langem
+      Absendernamen (er wird abgeschnitten, nicht umgebrochen) 🔎
+- [ ] Die Größe steht weiterhin in der Listenansicht und unter „Properties…"
+
+---
+
+## Wurzelort heißt „Home"
+
+- [ ] Brotkrume ganz links zeigt ein Haus-Symbol und „Home", nicht „My Files"
+- [ ] Seitenleiste ebenso
+- [ ] Suchtreffer in der Wurzel stehen als „in Home"
+
+## Sortierung
+
+- [ ] Auswahlfeld in der Werkzeugleiste: Name, Größe, Datum – je auf- und
+      absteigend
+- [ ] Ordner stehen immer vor Dateien und folgen nur der Namensrichtung
+- [ ] Sortierung und Ansicht (Kacheln/Liste) überleben das Neuladen
+
+---
+
+## Downloads & Adressen (PWA-Fallen)
+- [ ] Rechtsklick → „Download" lädt die Datei – **ohne** dass ein leerer Tab aufgeht
+- [ ] Download aus dem Versionsverlauf funktioniert
+- [ ] Download aus „Shared with me" funktioniert
+- [ ] `/admin` oder `/profile` direkt in der Adresszeile eingeben → Anwendung
+      lädt, kein 404 🔎
+- [ ] Freigabelink `/s/<token>` in einem **frischen** Browser öffnen (privates
+      Fenster, kein Service Worker) → Seite lädt 🔎
+- [ ] Nach dem Update einmal hart neu laden (`Strg+Shift+R`), damit der alte
+      Service Worker ersetzt wird
+
+---
+
+## Automatisiert geprüft (22.08.2026)
+
+Diese Punkte hat Claude per API/`curl` gegen Wegwerf-Konten durchgespielt; sie
+brauchen keinen manuellen Durchgang mehr, stehen hier aber als Beleg:
+
+- **Prüfsummen** über 8 Größen (0 B, 1 B, 511/512/513 B, 64 KB, 1 MB+1, 20 MB):
+  WebDAV rein → WebDAV raus → REST raus, jedes Mal identisch. Gespeicherte
+  Prüfsumme = tatsächliche Prüfsumme auf der Platte, 0 Abweichungen.
+- **Pfad-Ausbruch:** 5 WebDAV-Varianten (`../`, URL-kodiert, absolut) und
+  5 REST-Dateinamen – nichts landet außerhalb des Nutzerbereichs.
+- **Kontingent:** `413` über REST, `507` über WebDAV, keine Datei-Torsos, kein
+  Rest im Staging-Verzeichnis.
+- **Soft-Delete:** gelöschte Datei liegt im Papierkorb, Download `404`,
+  nach Wiederherstellung Inhalt unverändert.
+- **Sperre:** 10 Fehlversuche → `429` mit `Retry-After: 900`; ein Erfolg
+  setzt den Zähler zurück.
+- **Passwort-Trennung:** Kontopasswort → WebDAV `401`, App-Passwort → Web-Login
+  `401`, App-Passwort eines fremden Kontos → `401`.
+- **Isolation:** fremdes Konto bekommt auf 9 Endpunkte plus WebDAV durchgängig
+  `404`, `shared-with-me` leer.
+- **Audit-Log:** jede sicherheitsrelevante Aktion erzeugt einen Eintrag;
+  zurückgesetztes Passwort, App-Passwort, Freigabe-Token und Share-Passwort
+  stehen **nicht** darin; Einträge überleben das Löschen des Kontos
+  (`actor_id` wird `NULL`, Name bleibt); Filter, Blättern und die Obergrenze
+  von 500 greifen; Nicht-Admin `403`, ohne Anmeldung `401`.
+- **Blob-Bereinigung:** DB-Referenzen und Platte stimmen exakt überein
+  (123 zu 123); ein künstlich gealtertes Waisen-Blob wird entfernt, das
+  eingetragene Logo nicht.
+
+## Regressionstest (sollte weiter funktionieren)
+- [ ] Normaler Datei-Upload (Web) mit Fortschrittsanzeige
+- [ ] Papierkorb: löschen → wiederherstellen
+- [ ] Share-Link erstellen (mit Passwort + Ablauf) und öffentlich öffnen
+- [ ] Favoriten in Sidebar: hinzufügen, umsortieren, navigieren
+- [ ] Ordner per Drag&Drop in anderen Ordner verschieben
+- [ ] „Verschieben nach…"-Dialog
+- [ ] Ordner-Upload per Drag & Drop (ganzer Ordner inkl. Unterordner wird angelegt)
diff --git a/backend/cmd/aether/main.go b/backend/cmd/aether/main.go
new file mode 100644
index 0000000..e9ed64f
--- /dev/null
+++ b/backend/cmd/aether/main.go
@@ -0,0 +1,622 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"path"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	chimiddleware "github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/httprate"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/acl"
+	"aether/internal/admin"
+	"aether/internal/audit"
+	"aether/internal/auth"
+	"aether/internal/documents"
+	"aether/internal/files"
+	"aether/internal/gc"
+	"aether/internal/office"
+	appoidc "aether/internal/oidc"
+	"aether/internal/sharing"
+	"aether/internal/storage"
+	"aether/internal/tags"
+	"aether/internal/thumbnails"
+	appwebdav "aether/internal/webdav"
+	"aether/pkg/config"
+	appdb "aether/pkg/db"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+// spaHandler liefert statische Dateien aus und fällt für alles andere auf
+// index.html zurück.
+//
+// Nötig, weil das Frontend seine Adressen selbst verwaltet: `/s/<token>`,
+// `/admin` und `/profile` existieren als Dateien nicht. Ohne Rückfalloption
+// beantwortet ein reiner FileServer sie mit 404 – ein frisch geteilter Link
+// landete beim Empfänger also auf einer Fehlerseite. Dass es bisher trotzdem
+// meist funktionierte, lag allein am Service Worker, der die Navigation
+// abfing; wer die Seite zum ersten Mal öffnet, hat den noch nicht.
+func spaHandler(root string) http.Handler {
+	fs := http.FileServer(http.Dir(root))
+	index := filepath.Join(root, "index.html")
+
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		upath := path.Clean("/" + r.URL.Path)
+
+		// Serverseitige Bereiche nie überdecken – dort ist ein 404 die richtige
+		// Antwort und kein Grund, die Anwendung auszuliefern.
+		for _, reserved := range []string{"/api/", "/dav/", "/share/", "/branding/", "/wopi/"} {
+			if strings.HasPrefix(upath+"/", reserved) {
+				http.NotFound(w, r)
+				return
+			}
+		}
+
+		if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(upath))); err == nil {
+			fs.ServeHTTP(w, r)
+			return
+		}
+
+		// Nur echte Seitenaufrufe bekommen die Anwendung. Eine fehlende
+		// JavaScript- oder Bilddatei soll als 404 sichtbar bleiben, statt
+		// stillschweigend HTML zu liefern – das erzeugt sonst rätselhafte
+		// Syntaxfehler in der Konsole statt einer klaren Meldung.
+		if r.Method != http.MethodGet || !strings.Contains(r.Header.Get("Accept"), "text/html") {
+			http.NotFound(w, r)
+			return
+		}
+		http.ServeFile(w, r, index)
+	})
+}
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "config error: %v\n", err)
+		os.Exit(1)
+	}
+
+	if cfg.IsDev() {
+		log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
+	}
+	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+
+	log.Info().Str("env", cfg.AppEnv).Str("addr", cfg.ListenAddr).Str("public_url", cfg.PublicURL).Msg("Aether starting")
+
+	ctx := context.Background()
+
+	if err := appdb.Migrate(cfg.DSN()); err != nil {
+		log.Fatal().Err(err).Msg("migrations failed")
+	}
+	log.Info().Msg("migrations up to date")
+
+	pool, err := appdb.Connect(ctx, cfg.DSN())
+	if err != nil {
+		log.Fatal().Err(err).Msg("database connection failed")
+	}
+	defer pool.Close()
+
+	// ── Storage ───────────────────────────────────────────────────────────────
+	// Thumbnails are stored in the main blob store under the "thumbs/" prefix.
+	blobStore, err := storage.NewLocalFS(cfg.StoragePath, cfg.TmpPath)
+	if err != nil {
+		log.Fatal().Err(err).Msg("blob storage init failed")
+	}
+
+	// ── Packages ──────────────────────────────────────────────────────────────
+	auditor := audit.NewLogger(pool)
+	aclStore := acl.NewStore(pool)
+	aclHandler := acl.NewHandler(aclStore, auditor)
+
+	authStore := auth.NewStore(pool)
+	sessions := auth.NewSessionStore(cfg.SessionSecret, cfg.SessionMaxAge)
+	fileStore := files.NewStore(pool)
+	authHandler := auth.NewHandler(authStore, sessions, fileStore, auditor)
+	tagStore := tags.NewStore(pool)
+	tagHandler := tags.NewHandler(tagStore, aclStore)
+	// ── Texterkennung ─────────────────────────────────────────────────────────
+	// Bleibt nil, wenn abgeschaltet oder die Programme fehlen. Alles, was
+	// docStore benutzt, prüft deshalb auf nil – eine Cloud ohne OCR ist eine
+	// vollständige Cloud, nur ohne Volltextsuche.
+	var docStore *documents.Store
+	if cfg.OCREnabled {
+		if ok, missing := documents.Available(); !ok {
+			log.Warn().Strs("missing", missing).
+				Msg("Texterkennung abgeschaltet: Programme fehlen im Image")
+		} else {
+			docStore = documents.NewStore(pool)
+			worker := documents.NewWorker(docStore, blobStore, &documents.Extractor{
+				Languages: cfg.OCRLanguages,
+				MaxPages:  cfg.OCRMaxPages,
+				Timeout:   cfg.OCRTimeout,
+				TmpDir:    cfg.TmpPath,
+			}, log.Logger)
+			go worker.Run(ctx)
+
+			// Bestand nachtragen: Beim ersten Start nach dem Einbau hat noch
+			// keine einzige Datei einen Auftrag. Ohne das bliebe alles
+			// unauffindbar, was vorher hochgeladen wurde – und das ist am
+			// Anfang der gesamte Bestand.
+			go func() {
+				n, err := docStore.EnqueueMissing(ctx, 5000)
+				if err != nil {
+					log.Warn().Err(err).Msg("Bestand nachtragen fehlgeschlagen")
+					return
+				}
+				if n > 0 {
+					log.Info().Int("files", n).Msg("Bestandsdateien zur Texterkennung eingeplant")
+				}
+
+				// Einträge nach älterer Regel erneut erkennen. Siehe
+				// documents.ExtractVersion – die Seitenmarke im Text kam
+				// nachträglich dazu, und ohne sie kann der Betrachter bei
+				// einem Scan die Fundstelle nicht auf einer Seite verorten.
+				m, err := docStore.EnqueueOutdated(ctx, 5000)
+				if err != nil {
+					log.Warn().Err(err).Msg("veraltete Texteintraege nachtragen fehlgeschlagen")
+					return
+				}
+				if m > 0 {
+					log.Info().Int("files", m).Int("version", documents.ExtractVersion).
+						Msg("veraltete Texteintraege zur erneuten Erkennung eingeplant")
+				}
+			}()
+		}
+	}
+
+	// fileHandler bekommt docStore mit: Der PDF-Betrachter holt sich darueber
+	// den erkannten Text eines Scans, in Seiten zerlegt.
+	fileHandler := files.NewHandler(fileStore, blobStore, auditor, aclStore, tagStore, docStore)
+
+	shareStore := sharing.NewStore(pool)
+	shareHandler := sharing.NewHandler(shareStore, fileStore, blobStore, auditor)
+
+	collector := gc.New(pool, blobStore)
+
+	adminStore := admin.NewStore(pool)
+	adminHandler := admin.NewHandler(adminStore, blobStore, auditor, collector, fileStore)
+
+	// docHandler ist auch bei abgeschaltetem OCR gültig – er meldet dann
+	// schlicht enabled:false. Eine Methode auf einem nil-Zeiger geht in Go
+	// gut, solange sie ihn nicht dereferenziert; Status prüft genau darauf.
+	docHandler := documents.NewHandler(docStore,
+		func(r *http.Request) bool {
+			u := auth.UserFromContext(r.Context())
+			return u != nil && u.IsAdmin
+		},
+		func(r *http.Request) uuid.UUID {
+			if u := auth.UserFromContext(r.Context()); u != nil {
+				return u.ID
+			}
+			return uuid.Nil
+		})
+
+	// ── Office ────────────────────────────────────────────────────────────────
+	// Bleibt nil, wenn OFFICE_PROVIDER leer ist. Ein nil-Handler meldet der
+	// Oberfläche schlicht „aus"; die Anwendung ist ohne Office vollständig.
+	var officeHandler *office.Handler
+	if cfg.OfficeEnabled() {
+		client, err := office.NewClient(cfg.OfficeProvider, cfg.OfficeURL, cfg.OfficePublicURL,
+			cfg.OfficeAllowedHosts, cfg.OfficeInsecureTLS)
+		if err != nil {
+			// Kein Fatal: Eine falsche Office-Adresse soll die Cloud nicht am
+			// Starten hindern. Dateien bleiben erreichbar, nur das Bearbeiten
+			// fehlt – und der Log sagt, warum.
+			log.Warn().Err(err).Msg("Office abgeschaltet: Konfiguration fehlerhaft")
+		} else {
+			officeHandler = office.NewHandler(client, office.NewSigner(cfg.SessionSecret),
+				fileStore, blobStore, aclStore, cfg.PublicURL, cfg.OfficeWopiURL)
+			log.Info().Str("provider", cfg.OfficeProvider).Str("url", cfg.OfficeURL).
+				Msg("Office-Bearbeitung aktiv")
+		}
+	}
+
+	// Der Ursprung, den die Sicherheitsrichtlinie als Rahmen zulassen muss.
+	// Leer, wenn kein Office-Server eingerichtet ist – dann bleibt die
+	// Richtlinie so eng wie zuvor.
+	officeFrameSrc := ""
+	if officeHandler.Enabled() {
+		officeFrameSrc = cfg.OfficePublicURL
+		if officeFrameSrc == "" {
+			officeFrameSrc = cfg.OfficeURL
+		}
+	}
+
+	// WebDAV
+	davHandler := appwebdav.NewHandler(authStore, fileStore, aclStore, blobStore)
+
+	// OIDC (optional – disabled if OIDC_ISSUER not set)
+	oidcHandler, err := appoidc.New(ctx, appoidc.Config{
+		Issuer:       cfg.OIDCIssuer,
+		ClientID:     cfg.OIDCClientID,
+		ClientSecret: cfg.OIDCClientSecret,
+		RedirectURL:  cfg.OIDCRedirectURL,
+
+		LinkByUsername: cfg.OIDCLinkByUsername,
+	}, authStore, sessions)
+	if err != nil {
+		log.Fatal().Err(err).Msg("OIDC init failed")
+	}
+
+	// ── Admin seed ────────────────────────────────────────────────────────────
+	if cfg.AdminUsername != "" && cfg.AdminPassword != "" {
+		if err := seedAdmin(ctx, authStore, cfg.AdminUsername, cfg.AdminPassword); err != nil {
+			log.Warn().Err(err).Msg("admin seed skipped")
+		} else {
+			log.Info().Str("username", cfg.AdminUsername).Msg("admin account ready")
+		}
+	}
+
+	// ── Blob-GC ───────────────────────────────────────────────────────────────
+	// Räumt Blobs weg, auf die keine Datenbankzeile mehr zeigt. Läuft im
+	// Hintergrund; jeder Lauf, der etwas entfernt, landet im Audit-Log.
+	collector.Start(ctx, func(res gc.Result) {
+		auditor.Log(ctx, audit.Event{
+			ActorName: "system",
+			Action:    audit.ActionGarbageCollect,
+			Detail: fmt.Sprintf("%d orphaned blobs removed, %d bytes freed",
+				res.Deleted, res.FreedBytes),
+		})
+	})
+
+	// ── Router ────────────────────────────────────────────────────────────────
+	// chi lehnt Methoden ab, die es nicht kennt – ohne diese Registrierung
+	// beantwortet der Router jedes PROPFIND & Co. mit 405, bevor der
+	// WebDAV-Handler (und damit dessen Auth) überhaupt erreicht wird.
+	for _, m := range []string{"PROPFIND", "PROPPATCH", "MKCOL", "COPY", "MOVE", "LOCK", "UNLOCK"} {
+		chi.RegisterMethod(m)
+	}
+
+	r := chi.NewRouter()
+	r.Use(chimiddleware.RequestID)
+	r.Use(middleware.TrustedProxy(cfg))
+	r.Use(middleware.Logger)
+	r.Use(middleware.SecurityHeaders(officeFrameSrc))
+	r.Use(chimiddleware.Recoverer)
+
+	r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
+		response.JSON(w, http.StatusOK, map[string]string{"status": "ok", "version": "0.2.0"})
+	})
+
+	// Logo ohne Anmeldung – die Login-Seite zeigt es, bevor jemand angemeldet ist.
+	r.Get("/branding/logo", adminHandler.ServeLogo)
+	r.Get("/branding/icon/{size}", adminHandler.ServeAppIcon)
+	// Das Manifest beschreibt die installierbare App. Es kommt aus der
+	// Datenbank, damit Name, Farbe und Symbol dem Admin-Bereich folgen.
+	r.Get("/manifest.webmanifest", adminHandler.ServeManifest)
+
+	// WOPI – **bewusst ausserhalb der Sitzungs- und CSRF-Kette.** Diese Aufrufe
+	// kommen vom Office-Server, nicht aus einem Browser; ihre Berechtigung ist
+	// allein das kurzlebige Token, das an genau eine Datei gebunden ist.
+	if officeHandler.Enabled() {
+		r.Get("/wopi/files/{id}", officeHandler.CheckFileInfo)
+		r.Get("/wopi/files/{id}/contents", officeHandler.GetFile)
+		r.Post("/wopi/files/{id}/contents", officeHandler.PutFile)
+	}
+
+	// Public share API – completely outside /api/v1 to avoid auth middleware conflict
+	r.Get("/share/{token}", shareHandler.GetPublicInfo)
+	r.Post("/share/{token}/download", shareHandler.Download)
+
+	// WebDAV endpoint – own auth (Basic Auth), outside /api/v1.
+	// Kein StripPrefix: der xwebdav.Handler entfernt "/dav" selbst über sein
+	// Prefix-Feld. Beides zusammen strippt doppelt und liefert nur noch 404.
+	r.Mount("/dav", davHandler)
+
+	// Public config (no auth) – used by login page to discover OIDC availability
+	r.Get("/api/v1/public/config", func(w http.ResponseWriter, r *http.Request) {
+		cloudName := "Aether"
+		// Farben gehören hierher (statt hinter die Auth), damit schon die
+		// Login-Seite im eingestellten Farbschema erscheint.
+		var primaryColor, accentColor, logoURL, faviconURL, appleTouchURL string
+		if s, err := adminStore.GetAllSettings(r.Context()); err == nil {
+			if n, ok := s["cloud_name"]; ok && n != "" {
+				cloudName = n
+			}
+			primaryColor = s["primary_color"]
+			accentColor = s["accent_color"]
+			logoURL = admin.LogoURL(s["logo_storage_key"])
+			// Dasselbe Symbol in zwei Größen: klein für den Tab, groß für den
+			// Startbildschirm von iOS.
+			faviconURL = admin.AppIconURL(s["app_icon_storage_key"], "64")
+			appleTouchURL = admin.AppIconURL(s["app_icon_storage_key"], "192")
+		}
+		apps := cfg.ExternalApps
+		if apps == nil {
+			apps = []config.ExternalApp{} // nie null – das Frontend erwartet eine Liste
+		}
+		response.JSON(w, http.StatusOK, map[string]any{
+			"oidc_enabled":         oidcHandler.IsEnabled(),
+			"cloud_name":           cloudName,
+			"primary_color":        primaryColor,
+			"accent_color":         accentColor,
+			"logo_url":             logoURL,
+			"favicon_url":          faviconURL,
+			"apple_touch_icon_url": appleTouchURL,
+			"external_apps":        apps,
+			// Damit die Oberflaeche den Menuepunkt „Edit in Office" gar nicht
+			// erst anbietet, wenn es keinen Office-Server gibt.
+			"office_enabled": officeHandler.Enabled(),
+		})
+	})
+
+	// Auth routes – login/logout strictly rate-limited, /me is lenient
+	r.Route("/api/v1/auth", func(r chi.Router) {
+		r.With(httprate.LimitByIP(20, time.Minute)).Post("/login", authHandler.Login)
+		r.With(httprate.LimitByIP(20, time.Minute)).Post("/logout", authHandler.Logout)
+		r.With(auth.RequireAuth(sessions, authStore)).Get("/me", authHandler.Me)
+		r.With(auth.RequireAuth(sessions, authStore), auth.CSRF).Patch("/profile", authHandler.UpdateProfile)
+		r.With(auth.RequireAuth(sessions, authStore), auth.CSRF).Post("/change-password", authHandler.ChangePassword)
+		// OIDC routes (only wired if oidcHandler != nil)
+		if oidcHandler != nil {
+			r.With(httprate.LimitByIP(20, time.Minute)).Get("/oidc/login", oidcHandler.Login)
+			r.Get("/oidc/callback", oidcHandler.Callback)
+		}
+	})
+
+	// Protected API
+	r.Route("/api/v1", func(r chi.Router) {
+		r.Use(auth.RequireAuth(sessions, authStore))
+		r.Use(auth.CSRF)
+		r.Use(httprate.LimitByIP(2000, time.Minute))
+
+		// Files
+		// Sammel-Download als Archiv. POST, weil eine Auswahl beliebig lang sein
+		// kann – als Adresse würde sie an der Längengrenze scheitern.
+		r.Post("/download/zip", fileHandler.DownloadZip)
+		r.Post("/files", afterUpload(fileHandler, fileStore, blobStore, docStore))
+		r.Get("/files", fileHandler.List)
+		// Suche über Namen von Ordnern und Dateien, begrenzt auf das, was der
+		// Anfragende erreichen darf.
+		r.Get("/search", fileHandler.Search)
+		r.Get("/files/{id}/download", fileHandler.Download)
+		r.Get("/files/{id}/thumbnail", fileHandler.GetThumbnail)
+		// Erkannter Text, in Seiten zerlegt – fuer die Suche im PDF-Betrachter.
+		r.Get("/files/{id}/text", fileHandler.TextPages)
+		// Sitzung fuer den Office-Rahmen: Hier entsteht das WOPI-Token, im
+		// angemeldeten Zusammenhang.
+		r.Get("/office/session/{id}", officeHandler.Session)
+		r.Patch("/files/{id}/versioning", fileHandler.SetVersioning)
+		r.Get("/files/{id}/versions", fileHandler.ListVersions)
+		r.Get("/files/{id}/versions/{versionId}/download", fileHandler.DownloadVersion)
+		r.Post("/files/{id}/versions/{versionId}/restore", fileHandler.RestoreVersion)
+		r.Delete("/files/{id}", fileHandler.Delete)
+		r.Patch("/files/{id}/rename", fileHandler.Rename)
+		r.Patch("/files/{id}/move", fileHandler.Move)
+		r.Post("/files/{id}/share", shareHandler.Create)
+
+		// Folders
+		r.Post("/folders", fileHandler.CreateFolder)
+		r.Patch("/folders/{id}/rename", fileHandler.RenameFolder)
+		r.Patch("/folders/{id}/move", fileHandler.MoveFolder)
+		r.Delete("/folders/{id}", fileHandler.DeleteFolder)
+
+		// Favorites
+		r.Get("/favorites", fileHandler.ListFavorites)
+		r.Post("/favorites", fileHandler.AddFavorite)
+		r.Delete("/favorites/{folderId}", fileHandler.RemoveFavorite)
+		r.Patch("/favorites/{folderId}/expand", fileHandler.SetFavoriteExpanded)
+		r.Patch("/favorites/reorder", fileHandler.ReorderFavorites)
+
+		// Trash
+		// Etiketten – siehe internal/tags. Die Rechteprüfung steckt in den
+		// Abfragen des Stores, nicht in einer Middleware davor.
+		r.Get("/tags", tagHandler.List)
+		r.Post("/tags", tagHandler.Create)
+		r.Patch("/tags/{id}", tagHandler.Update)
+		r.Delete("/tags/{id}", tagHandler.Delete)
+		r.Get("/tags/{id}/files", tagHandler.Files)
+		r.Put("/files/{id}/tags", tagHandler.SetForFile)
+
+		// Absender: dieselbe Form wie die Etiketten, aber genau einer je Datei.
+		// Gesetzt wird er ueber /files/{id}/tags mit – ein Dialog, ein Vorgang.
+		r.Get("/correspondents", tagHandler.ListCorrespondents)
+		r.Post("/correspondents", tagHandler.CreateCorrespondent)
+		r.Patch("/correspondents/{id}", tagHandler.UpdateCorrespondent)
+		r.Delete("/correspondents/{id}", tagHandler.DeleteCorrespondent)
+		r.Get("/correspondents/{id}/files", tagHandler.CorrespondentFiles)
+
+		r.Get("/trash", fileHandler.ListTrash)
+		r.Post("/trash/{id}/restore", fileHandler.RestoreFile)
+		r.Delete("/trash", fileHandler.EmptyTrash)
+		r.Delete("/trash/{id}", fileHandler.HardDelete)
+
+		// Shares
+		r.Get("/shares", shareHandler.List)
+		r.Delete("/shares/{id}", shareHandler.Delete)
+
+		// Interne Freigaben
+		r.Get("/shared-with-me", aclHandler.SharedWithMe)
+		r.Get("/share-recipients", aclHandler.Recipients)
+		r.Get("/folders/{id}/acl", aclHandler.ListFolderACL)
+		r.Post("/folders/{id}/acl", aclHandler.GrantFolderACL)
+		r.Get("/files/{id}/acl", aclHandler.ListFileACL)
+		r.Post("/files/{id}/acl", aclHandler.GrantFileACL)
+		r.Delete("/acl/{id}", aclHandler.RevokeACL)
+
+		// App passwords (WebDAV/sync clients)
+		r.Get("/app-passwords", authHandler.ListAppPasswords)
+		r.Post("/app-passwords", authHandler.CreateAppPassword)
+		r.Delete("/app-passwords/{id}", authHandler.DeleteAppPassword)
+
+		// Settings (readable by all authenticated users for theming)
+		r.Get("/admin/settings", adminHandler.GetSettings)
+
+		// Admin-only routes (server-side admin check inside each handler)
+		r.Patch("/admin/settings", adminHandler.UpdateSettings)
+		r.Get("/admin/users", adminHandler.ListUsers)
+		r.Post("/admin/users", adminHandler.CreateUser)
+		r.Patch("/admin/users/{id}", adminHandler.UpdateUser)
+		r.Post("/admin/users/{id}/reset-password", adminHandler.ResetPassword)
+		r.Delete("/admin/users/{id}", adminHandler.DeleteUser)
+		r.Get("/admin/audit", adminHandler.ListAudit)
+		r.Get("/admin/audit/actions", adminHandler.ListAuditActions)
+		r.Post("/admin/gc", adminHandler.RunGC)
+		// Immer erreichbar, auch wenn OCR aus ist – der Handler antwortet dann
+		// mit enabled:false. Eine Route, die je nach Konfiguration 404 liefert,
+		// wäre für die Oberfläche nicht von einem Fehler zu unterscheiden.
+		r.Get("/admin/ocr", docHandler.Status)
+		// Derselbe Stand, aber nur für die eigenen Dateien – ohne Adminrechte.
+		r.Get("/ocr", docHandler.MyStatus)
+		r.Post("/admin/branding/logo", adminHandler.UploadLogo)
+		r.Delete("/admin/branding/logo", adminHandler.DeleteLogo)
+		r.Post("/admin/branding/icon", adminHandler.UploadAppIcon)
+		r.Delete("/admin/branding/icon", adminHandler.DeleteAppIcon)
+		r.Get("/admin/group-folders", adminHandler.ListGroupFolders)
+		r.Post("/admin/group-folders", adminHandler.CreateGroupFolder)
+		r.Delete("/admin/group-folders/{id}", adminHandler.DeleteGroupFolder)
+		r.Get("/admin/groups", adminHandler.ListGroups)
+		r.Post("/admin/groups", adminHandler.CreateGroup)
+		r.Patch("/admin/groups/{id}", adminHandler.UpdateGroup)
+		r.Delete("/admin/groups/{id}", adminHandler.DeleteGroup)
+		r.Get("/admin/groups/{id}/members", adminHandler.ListGroupMembers)
+		r.Post("/admin/groups/{id}/members", adminHandler.AddGroupMember)
+		r.Delete("/admin/groups/{id}/members/{userId}", adminHandler.RemoveGroupMember)
+	})
+
+	// Serve built frontend
+	r.Handle("/*", spaHandler("./static"))
+
+	srv := &http.Server{
+		Addr:              cfg.ListenAddr,
+		Handler:           r,
+		ReadHeaderTimeout: 15 * time.Second,
+		WriteTimeout:      60 * time.Minute, // großzügig für Multi-GB Up-/Downloads
+		IdleTimeout:       60 * time.Second,
+	}
+
+	done := make(chan struct{})
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-quit
+		log.Info().Msg("shutting down...")
+		shutCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		_ = srv.Shutdown(shutCtx)
+		close(done)
+	}()
+
+	log.Info().Str("addr", srv.Addr).Msg("listening")
+	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		log.Fatal().Err(err).Msg("server error")
+	}
+	<-done
+	log.Info().Msg("stopped")
+}
+
+// afterUpload hängt sich hinter den Upload und stößt an, was danach im
+// Hintergrund passieren soll: das Vorschaubild und – bei Dokumenten – die
+// Texterkennung.
+//
+// Der Unterschied zwischen beiden ist Absicht: Das Vorschaubild entsteht hier
+// direkt in einer Goroutine, die Texterkennung wird nur in die Warteschlange
+// eingetragen. Ein verlorenes Vorschaubild fällt sofort auf und ist in
+// Millisekunden neu gemacht; verlorener Text fällt nie auf – man sucht später
+// vergeblich und weiß nicht, warum. Deshalb ist er die Datenbankzeile wert.
+//
+// docStore darf nil sein (OCR abgeschaltet oder Programme fehlen).
+func afterUpload(fh *files.Handler, fileStore *files.Store, st storage.Storage, docStore *documents.Store) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		crw := &captureWriter{ResponseWriter: w}
+		fh.Upload(crw, r)
+
+		if crw.status != http.StatusCreated {
+			return
+		}
+
+		// Parse file ID and MIME type from captured JSON response (wrapped in {"data":{...}}).
+		var wrapper struct {
+			Data struct {
+				ID       uuid.UUID `json:"id"`
+				Name     string    `json:"name"`
+				MimeType string    `json:"mime_type"`
+			} `json:"data"`
+		}
+		if err := json.Unmarshal(crw.body.Bytes(), &wrapper); err != nil || wrapper.Data.ID == uuid.Nil {
+			return
+		}
+		created := wrapper.Data
+
+		if docStore != nil && documents.Supported(created.MimeType, created.Name) {
+			// Eigener Kontext: Der Anfrage-Kontext endet, sobald die Antwort
+			// draußen ist – der Eintrag ginge dann ins Leere.
+			ctx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), 5*time.Second)
+			if err := docStore.Enqueue(ctx, created.ID); err != nil {
+				log.Warn().Err(err).Str("file_id", created.ID.String()).
+					Msg("Texterkennung konnte nicht eingeplant werden")
+			}
+			cancel()
+		}
+
+		if !thumbnails.SupportedMIME(created.MimeType) {
+			return
+		}
+
+		// Generate thumbnail in background – non-fatal if it fails.
+		go func() {
+			ctx := context.Background()
+			f, err := fileStore.GetFileByID(ctx, created.ID)
+			if err != nil {
+				return
+			}
+			rc, err := st.Get(ctx, f.StorageKey)
+			if err != nil {
+				return
+			}
+			defer rc.Close()
+			if err := thumbnails.Generate(ctx, st, created.ID.String(), created.MimeType, rc); err != nil {
+				log.Warn().Err(err).Str("file_id", created.ID.String()).Msg("thumbnail generation failed")
+				return
+			}
+			_ = fileStore.UpdateThumbnail(ctx, created.ID, true)
+		}()
+	}
+}
+
+func seedAdmin(ctx context.Context, store *auth.Store, username, password string) error {
+	exists, err := store.AdminExists(ctx)
+	if err != nil {
+		return fmt.Errorf("check admin: %w", err)
+	}
+	if exists {
+		return fmt.Errorf("admin already exists, skipping seed")
+	}
+	hash, err := auth.HashPassword(password)
+	if err != nil {
+		return fmt.Errorf("hash password: %w", err)
+	}
+	_, err = store.Create(ctx, username, hash, true)
+	return err
+}
+
+// captureWriter buffers the response body while forwarding to the real ResponseWriter.
+type captureWriter struct {
+	http.ResponseWriter
+	status int
+	body   bytes.Buffer
+}
+
+func (cw *captureWriter) WriteHeader(status int) {
+	cw.status = status
+	cw.ResponseWriter.WriteHeader(status)
+}
+
+func (cw *captureWriter) Write(b []byte) (int, error) {
+	cw.body.Write(b)
+	return cw.ResponseWriter.Write(b)
+}
diff --git a/backend/db/migrations/000001_init.down.sql b/backend/db/migrations/000001_init.down.sql
new file mode 100644
index 0000000..5a6277c
--- /dev/null
+++ b/backend/db/migrations/000001_init.down.sql
@@ -0,0 +1,12 @@
+DROP TRIGGER IF EXISTS trg_files_updated_at ON files;
+DROP TRIGGER IF EXISTS trg_folders_updated_at ON folders;
+DROP TRIGGER IF EXISTS trg_users_updated_at ON users;
+DROP FUNCTION IF EXISTS update_updated_at();
+
+DROP TABLE IF EXISTS file_versions;
+DROP TABLE IF EXISTS files;
+DROP TABLE IF EXISTS folders;
+DROP TABLE IF EXISTS sessions;
+DROP TABLE IF EXISTS users;
+
+DROP EXTENSION IF EXISTS "pgcrypto";
diff --git a/backend/db/migrations/000001_init.up.sql b/backend/db/migrations/000001_init.up.sql
new file mode 100644
index 0000000..c2ddeac
--- /dev/null
+++ b/backend/db/migrations/000001_init.up.sql
@@ -0,0 +1,103 @@
+-- Aether – Initial schema
+-- Phase 0: users, sessions, folders, files (no email)
+
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+-- ── Users ─────────────────────────────────────────────────────────────────────
+CREATE TABLE users (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    username    TEXT        NOT NULL UNIQUE,
+    password    TEXT        NOT NULL,       -- Argon2id hash
+    is_admin    BOOLEAN     NOT NULL DEFAULT FALSE,
+    quota_bytes BIGINT      NOT NULL DEFAULT 10737418240, -- 10 GB default
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- ── Sessions ──────────────────────────────────────────────────────────────────
+CREATE TABLE sessions (
+    id         TEXT        PRIMARY KEY,
+    user_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    data       BYTEA       NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    expires_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE INDEX idx_sessions_user_id  ON sessions(user_id);
+CREATE INDEX idx_sessions_expires  ON sessions(expires_at);
+
+-- ── Folders ───────────────────────────────────────────────────────────────────
+CREATE TABLE folders (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id   UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    parent_id  UUID        REFERENCES folders(id) ON DELETE CASCADE,
+    name       TEXT        NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (owner_id, parent_id, name)
+);
+
+CREATE INDEX idx_folders_owner   ON folders(owner_id);
+CREATE INDEX idx_folders_parent  ON folders(parent_id);
+
+-- ── Files ─────────────────────────────────────────────────────────────────────
+CREATE TABLE files (
+    id           UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id     UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    folder_id    UUID        REFERENCES folders(id) ON DELETE CASCADE,
+    name         TEXT        NOT NULL,
+    mime_type    TEXT        NOT NULL DEFAULT 'application/octet-stream',
+    size         BIGINT      NOT NULL DEFAULT 0,
+    checksum     TEXT        NOT NULL,   -- SHA-256 hex
+    storage_key  TEXT        NOT NULL,   -- path within blob storage
+    version      INTEGER     NOT NULL DEFAULT 1,
+    is_deleted   BOOLEAN     NOT NULL DEFAULT FALSE,
+    deleted_at   TIMESTAMPTZ,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_files_owner     ON files(owner_id);
+CREATE INDEX idx_files_folder    ON files(folder_id);
+CREATE INDEX idx_files_deleted   ON files(is_deleted);
+CREATE INDEX idx_files_storage   ON files(storage_key);
+
+-- Partial unique index: no two non-deleted files can share name+folder for the same owner.
+CREATE UNIQUE INDEX idx_files_unique_name
+    ON files(owner_id, folder_id, name)
+    WHERE NOT is_deleted;
+
+-- ── File versions ─────────────────────────────────────────────────────────────
+-- Previous versions of files (kept for Soft-Delete + versioning).
+CREATE TABLE file_versions (
+    id           UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_id      UUID        NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    version      INTEGER     NOT NULL,
+    size         BIGINT      NOT NULL,
+    checksum     TEXT        NOT NULL,
+    storage_key  TEXT        NOT NULL,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_file_versions_file ON file_versions(file_id);
+
+-- ── Updated_at trigger ────────────────────────────────────────────────────────
+CREATE OR REPLACE FUNCTION update_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER trg_users_updated_at
+    BEFORE UPDATE ON users
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER trg_folders_updated_at
+    BEFORE UPDATE ON folders
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER trg_files_updated_at
+    BEFORE UPDATE ON files
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
diff --git a/backend/db/migrations/000002_phase2.down.sql b/backend/db/migrations/000002_phase2.down.sql
new file mode 100644
index 0000000..33d013b
--- /dev/null
+++ b/backend/db/migrations/000002_phase2.down.sql
@@ -0,0 +1,3 @@
+DROP TABLE IF EXISTS uploads;
+DROP TABLE IF EXISTS share_links;
+ALTER TABLE files DROP COLUMN IF EXISTS has_thumbnail;
diff --git a/backend/db/migrations/000002_phase2.up.sql b/backend/db/migrations/000002_phase2.up.sql
new file mode 100644
index 0000000..36bd812
--- /dev/null
+++ b/backend/db/migrations/000002_phase2.up.sql
@@ -0,0 +1,35 @@
+-- Phase 2: share links, resumable uploads, thumbnails
+
+ALTER TABLE files ADD COLUMN has_thumbnail BOOLEAN NOT NULL DEFAULT FALSE;
+
+-- ── Share links ───────────────────────────────────────────────────────────────
+CREATE TABLE share_links (
+    id             UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_id        UUID        NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    owner_id       UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    token          TEXT        NOT NULL UNIQUE,
+    password_hash  TEXT,                   -- Argon2id, NULL = no password
+    expires_at     TIMESTAMPTZ,            -- NULL = never
+    download_count INTEGER     NOT NULL DEFAULT 0,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_share_links_token ON share_links(token);
+CREATE INDEX idx_share_links_owner ON share_links(owner_id);
+CREATE INDEX idx_share_links_file  ON share_links(file_id);
+
+-- ── Resumable uploads ────────────────────────────────────────────────────────
+CREATE TABLE uploads (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    folder_id   UUID        REFERENCES folders(id) ON DELETE SET NULL,
+    filename    TEXT        NOT NULL,
+    mime_type   TEXT        NOT NULL DEFAULT 'application/octet-stream',
+    total_size  BIGINT      NOT NULL,
+    uploaded    BIGINT      NOT NULL DEFAULT 0,
+    storage_key TEXT        NOT NULL UNIQUE,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    expires_at  TIMESTAMPTZ NOT NULL DEFAULT NOW() + INTERVAL '24 hours'
+);
+
+CREATE INDEX idx_uploads_owner ON uploads(owner_id);
diff --git a/backend/db/migrations/000003_favorites.down.sql b/backend/db/migrations/000003_favorites.down.sql
new file mode 100644
index 0000000..a006ce5
--- /dev/null
+++ b/backend/db/migrations/000003_favorites.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS favorites;
diff --git a/backend/db/migrations/000003_favorites.up.sql b/backend/db/migrations/000003_favorites.up.sql
new file mode 100644
index 0000000..e25437a
--- /dev/null
+++ b/backend/db/migrations/000003_favorites.up.sql
@@ -0,0 +1,11 @@
+CREATE TABLE favorites (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id     UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    folder_id   UUID        NOT NULL REFERENCES folders(id) ON DELETE CASCADE,
+    position    INTEGER     NOT NULL DEFAULT 0,
+    is_expanded BOOLEAN     NOT NULL DEFAULT false,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (user_id, folder_id)
+);
+
+CREATE INDEX idx_favorites_user ON favorites(user_id);
diff --git a/backend/db/migrations/000004_phase3_admin.down.sql b/backend/db/migrations/000004_phase3_admin.down.sql
new file mode 100644
index 0000000..21b32a1
--- /dev/null
+++ b/backend/db/migrations/000004_phase3_admin.down.sql
@@ -0,0 +1,4 @@
+DROP TABLE IF EXISTS group_members;
+DROP TABLE IF EXISTS groups;
+DELETE FROM settings WHERE key IN ('cloud_name','primary_color','accent_color','logo_storage_key');
+ALTER TABLE users DROP COLUMN IF EXISTS display_name;
diff --git a/backend/db/migrations/000004_phase3_admin.up.sql b/backend/db/migrations/000004_phase3_admin.up.sql
new file mode 100644
index 0000000..a58b97a
--- /dev/null
+++ b/backend/db/migrations/000004_phase3_admin.up.sql
@@ -0,0 +1,35 @@
+-- Phase 3: Admin panel – groups, settings, user display names
+
+-- ── Users: display name ───────────────────────────────────────────────────────
+ALTER TABLE users ADD COLUMN IF NOT EXISTS display_name TEXT NOT NULL DEFAULT '';
+
+-- ── Groups ───────────────────────────────────────────────────────────────────
+CREATE TABLE groups (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    name        TEXT        NOT NULL UNIQUE,
+    description TEXT        NOT NULL DEFAULT '',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE group_members (
+    group_id    UUID        NOT NULL REFERENCES groups(id)  ON DELETE CASCADE,
+    user_id     UUID        NOT NULL REFERENCES users(id)   ON DELETE CASCADE,
+    joined_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (group_id, user_id)
+);
+
+CREATE INDEX idx_group_members_user ON group_members(user_id);
+
+-- ── Settings (key-value, admin-managed) ───────────────────────────────────────
+CREATE TABLE settings (
+    key         TEXT        PRIMARY KEY,
+    value       TEXT        NOT NULL DEFAULT '',
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Default settings
+INSERT INTO settings (key, value) VALUES
+    ('cloud_name',     'Aether'),
+    ('primary_color',  '#6366f1'),
+    ('accent_color',   '#8b5cf6'),
+    ('logo_storage_key', '');
diff --git a/backend/db/migrations/000005_oidc.down.sql b/backend/db/migrations/000005_oidc.down.sql
new file mode 100644
index 0000000..90be798
--- /dev/null
+++ b/backend/db/migrations/000005_oidc.down.sql
@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS oidc_sub;
diff --git a/backend/db/migrations/000005_oidc.up.sql b/backend/db/migrations/000005_oidc.up.sql
new file mode 100644
index 0000000..f1c6078
--- /dev/null
+++ b/backend/db/migrations/000005_oidc.up.sql
@@ -0,0 +1,3 @@
+-- OIDC subject for linking OIDC provider accounts to local users.
+-- NULL means the user only has a local password login.
+ALTER TABLE users ADD COLUMN oidc_sub TEXT UNIQUE;
diff --git a/backend/db/migrations/000006_file_versioning.down.sql b/backend/db/migrations/000006_file_versioning.down.sql
new file mode 100644
index 0000000..901c13a
--- /dev/null
+++ b/backend/db/migrations/000006_file_versioning.down.sql
@@ -0,0 +1 @@
+ALTER TABLE files DROP COLUMN IF EXISTS versioning_enabled;
diff --git a/backend/db/migrations/000006_file_versioning.up.sql b/backend/db/migrations/000006_file_versioning.up.sql
new file mode 100644
index 0000000..0c8ead6
--- /dev/null
+++ b/backend/db/migrations/000006_file_versioning.up.sql
@@ -0,0 +1,11 @@
+-- Versionierung ist ab hier eine Opt-in-Einstellung pro Datei.
+-- Standard: aus. Ohne den Schalter würde jede Überschreibung eine weitere
+-- Fassung aufheben und den Speicher unbemerkt volllaufen lassen.
+ALTER TABLE files
+    ADD COLUMN versioning_enabled BOOLEAN NOT NULL DEFAULT false;
+
+-- Dateien, die bereits Fassungen haben, behalten ihr bisheriges Verhalten –
+-- sonst würde ein bestehender Verlauf stillschweigend eingefroren.
+UPDATE files f
+   SET versioning_enabled = true
+ WHERE EXISTS (SELECT 1 FROM file_versions v WHERE v.file_id = f.id);
diff --git a/backend/db/migrations/000007_user_colors.down.sql b/backend/db/migrations/000007_user_colors.down.sql
new file mode 100644
index 0000000..32bf3ac
--- /dev/null
+++ b/backend/db/migrations/000007_user_colors.down.sql
@@ -0,0 +1,3 @@
+ALTER TABLE users
+    DROP COLUMN IF EXISTS primary_color,
+    DROP COLUMN IF EXISTS accent_color;
diff --git a/backend/db/migrations/000007_user_colors.up.sql b/backend/db/migrations/000007_user_colors.up.sql
new file mode 100644
index 0000000..39dc829
--- /dev/null
+++ b/backend/db/migrations/000007_user_colors.up.sql
@@ -0,0 +1,9 @@
+-- Persönliche Farbpalette pro Nutzer. NULL bedeutet: es gilt die globale
+-- Einstellung des Administrators.
+--
+-- Bis hierher zeigte die Profilseite zwar Farbwähler, schrieb damit aber in die
+-- globalen Einstellungen – für normale Nutzer scheiterte das an der
+-- Admin-Prüfung, beim Administrator färbte es die ganze Cloud um.
+ALTER TABLE users
+    ADD COLUMN primary_color TEXT,
+    ADD COLUMN accent_color  TEXT;
diff --git a/backend/db/migrations/000008_use_custom_theme.down.sql b/backend/db/migrations/000008_use_custom_theme.down.sql
new file mode 100644
index 0000000..fd5dee9
--- /dev/null
+++ b/backend/db/migrations/000008_use_custom_theme.down.sql
@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS use_custom_theme;
diff --git a/backend/db/migrations/000008_use_custom_theme.up.sql b/backend/db/migrations/000008_use_custom_theme.up.sql
new file mode 100644
index 0000000..6c806a0
--- /dev/null
+++ b/backend/db/migrations/000008_use_custom_theme.up.sql
@@ -0,0 +1,13 @@
+-- Schalter zwischen persönlicher und globaler Palette.
+--
+-- Bisher bedeutete "keine eigene Farbe" = globale Einstellung. Zum Zurückschalten
+-- musste man die eigenen Werte löschen und war sie damit los. Der Schalter trennt
+-- beides: die Farben bleiben gespeichert, nur ihre Anwendung wird umgelegt.
+ALTER TABLE users
+    ADD COLUMN use_custom_theme BOOLEAN NOT NULL DEFAULT false;
+
+-- Wer bereits eine eigene Farbe gesetzt hat, hat sie sichtbar verwendet –
+-- das Verhalten soll durch die Migration nicht kippen.
+UPDATE users
+   SET use_custom_theme = true
+ WHERE primary_color IS NOT NULL OR accent_color IS NOT NULL;
diff --git a/backend/db/migrations/000009_app_passwords.down.sql b/backend/db/migrations/000009_app_passwords.down.sql
new file mode 100644
index 0000000..c4564ac
--- /dev/null
+++ b/backend/db/migrations/000009_app_passwords.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS app_passwords;
diff --git a/backend/db/migrations/000009_app_passwords.up.sql b/backend/db/migrations/000009_app_passwords.up.sql
new file mode 100644
index 0000000..f8fbc12
--- /dev/null
+++ b/backend/db/migrations/000009_app_passwords.up.sql
@@ -0,0 +1,15 @@
+-- App-Passwörter: widerrufbare Zugangsdaten für WebDAV-/Sync-Clients, damit das
+-- Hauptpasswort nicht auf Geräten liegt, die man verlieren kann.
+CREATE TABLE app_passwords (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id       UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    name          TEXT NOT NULL,
+    -- SHA-256 des Tokens. Kein Argon2: das Token ist serverseitig zufällig und
+    -- hochentropisch, also nicht ratbar – und WebDAV authentifiziert jeden
+    -- einzelnen Request, wo Argon2 pro Aufruf zu teuer wäre.
+    token_hash    TEXT NOT NULL UNIQUE,
+    last_used_at  TIMESTAMPTZ,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_app_passwords_user ON app_passwords(user_id);
diff --git a/backend/db/migrations/000010_audit_log.down.sql b/backend/db/migrations/000010_audit_log.down.sql
new file mode 100644
index 0000000..b750c3b
--- /dev/null
+++ b/backend/db/migrations/000010_audit_log.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS audit_log;
diff --git a/backend/db/migrations/000010_audit_log.up.sql b/backend/db/migrations/000010_audit_log.up.sql
new file mode 100644
index 0000000..cb4980f
--- /dev/null
+++ b/backend/db/migrations/000010_audit_log.up.sql
@@ -0,0 +1,27 @@
+-- Audit-Log: wer hat was wann getan. Zweck ist die Nachvollziehbarkeit nach
+-- einem Vorfall – deshalb muss ein Eintrag auch dann noch lesbar sein, wenn der
+-- handelnde oder betroffene Account längst gelöscht ist.
+CREATE TABLE audit_log (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    -- ON DELETE SET NULL statt CASCADE: sonst räumte das Löschen eines Users
+    -- genau die Spuren weg, die man danach untersuchen will.
+    actor_id     UUID REFERENCES users(id) ON DELETE SET NULL,
+    -- Denormalisiert, damit der Name den gelöschten Account überlebt.
+    actor_name   TEXT NOT NULL,
+
+    action       TEXT NOT NULL,
+    target_type  TEXT,
+    target_id    TEXT,
+    target_name  TEXT,
+
+    ip           TEXT,
+    detail       TEXT,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Die Admin-Ansicht liest immer neueste zuerst, oft gefiltert nach Aktion oder
+-- handelndem Konto.
+CREATE INDEX idx_audit_log_created  ON audit_log (created_at DESC);
+CREATE INDEX idx_audit_log_actor    ON audit_log (actor_id, created_at DESC);
+CREATE INDEX idx_audit_log_action   ON audit_log (action, created_at DESC);
diff --git a/backend/db/migrations/000011_acl_entries.down.sql b/backend/db/migrations/000011_acl_entries.down.sql
new file mode 100644
index 0000000..ad56c9d
--- /dev/null
+++ b/backend/db/migrations/000011_acl_entries.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS acl_entries;
diff --git a/backend/db/migrations/000011_acl_entries.up.sql b/backend/db/migrations/000011_acl_entries.up.sql
new file mode 100644
index 0000000..e91fd22
--- /dev/null
+++ b/backend/db/migrations/000011_acl_entries.up.sql
@@ -0,0 +1,51 @@
+-- Interne Freigaben: Ordner oder Datei an einen anderen Nutzer oder eine Gruppe
+-- geben, ohne dass die Bytes umziehen. Der Empfänger sieht sie virtuell unter
+-- „Geteilt mit mir"; auf der Platte bleibt alles beim Eigentümer.
+--
+-- Abweichung vom Projektplan: dort war eine polymorphe Tabelle skizziert
+-- (subject_type + subject_id als Text/UUID ohne Fremdschlüssel). Hier stattdessen
+-- vier nullbare Fremdschlüssel mit CHECK-Bedingung. Grund: polymorph kann die
+-- Datenbank nichts erzwingen – ein gelöschter Nutzer oder Ordner hinterließe
+-- Einträge, die auf nichts mehr zeigen, und aus so einer Leiche später eine
+-- Freigabe für einen neu vergebenen Namen zu machen wäre ein Sicherheitsloch.
+-- Mit echten Fremdschlüsseln räumt ON DELETE CASCADE das von selbst auf.
+CREATE TABLE acl_entries (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    -- Empfänger: genau eines von beiden.
+    subject_user_id  UUID REFERENCES users(id)  ON DELETE CASCADE,
+    subject_group_id UUID REFERENCES groups(id) ON DELETE CASCADE,
+
+    -- Freigegebene Ressource: genau eines von beiden.
+    resource_folder_id UUID REFERENCES folders(id) ON DELETE CASCADE,
+    resource_file_id   UUID REFERENCES files(id)   ON DELETE CASCADE,
+
+    permission TEXT NOT NULL CHECK (permission IN ('read', 'write')),
+
+    -- Wer die Freigabe erteilt hat. SET NULL statt CASCADE: die Freigabe soll
+    -- nicht verschwinden, nur weil das Konto des Erteilers gelöscht wurde.
+    granted_by UUID REFERENCES users(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    CONSTRAINT acl_one_subject  CHECK (num_nonnulls(subject_user_id, subject_group_id) = 1),
+    CONSTRAINT acl_one_resource CHECK (num_nonnulls(resource_folder_id, resource_file_id) = 1)
+);
+
+-- Zwei Freigaben derselben Ressource an denselben Empfänger wären mehrdeutig:
+-- welches Recht gilt dann? Partielle Unique-Indizes, weil NULL in einem
+-- gewöhnlichen UNIQUE nicht mit sich selbst kollidiert.
+CREATE UNIQUE INDEX idx_acl_user_folder  ON acl_entries (subject_user_id, resource_folder_id)
+    WHERE subject_user_id IS NOT NULL AND resource_folder_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_acl_user_file    ON acl_entries (subject_user_id, resource_file_id)
+    WHERE subject_user_id IS NOT NULL AND resource_file_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_acl_group_folder ON acl_entries (subject_group_id, resource_folder_id)
+    WHERE subject_group_id IS NOT NULL AND resource_folder_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_acl_group_file   ON acl_entries (subject_group_id, resource_file_id)
+    WHERE subject_group_id IS NOT NULL AND resource_file_id IS NOT NULL;
+
+-- Die Zugriffsprüfung läuft bei jedem Request; sie fragt nach Ressource.
+CREATE INDEX idx_acl_folder  ON acl_entries (resource_folder_id) WHERE resource_folder_id IS NOT NULL;
+CREATE INDEX idx_acl_file    ON acl_entries (resource_file_id)   WHERE resource_file_id IS NOT NULL;
+-- „Geteilt mit mir" fragt nach Empfänger.
+CREATE INDEX idx_acl_subject_user  ON acl_entries (subject_user_id)  WHERE subject_user_id IS NOT NULL;
+CREATE INDEX idx_acl_subject_group ON acl_entries (subject_group_id) WHERE subject_group_id IS NOT NULL;
diff --git a/backend/db/migrations/000012_group_folders.down.sql b/backend/db/migrations/000012_group_folders.down.sql
new file mode 100644
index 0000000..d82f56b
--- /dev/null
+++ b/backend/db/migrations/000012_group_folders.down.sql
@@ -0,0 +1,18 @@
+DROP INDEX IF EXISTS idx_files_group;
+DROP INDEX IF EXISTS idx_folders_group;
+DROP INDEX IF EXISTS idx_folders_group_root_name;
+DROP INDEX IF EXISTS idx_folders_group_name;
+
+ALTER TABLE groups  DROP COLUMN IF EXISTS quota_bytes;
+ALTER TABLE files   DROP CONSTRAINT IF EXISTS files_one_principal;
+ALTER TABLE folders DROP CONSTRAINT IF EXISTS folders_one_principal;
+
+-- Erst die Gruppendaten entfernen, sonst scheitert das NOT NULL unten.
+DELETE FROM files   WHERE group_id IS NOT NULL;
+DELETE FROM folders WHERE group_id IS NOT NULL;
+
+ALTER TABLE files   DROP COLUMN IF EXISTS group_id;
+ALTER TABLE folders DROP COLUMN IF EXISTS group_id;
+
+ALTER TABLE files   ALTER COLUMN owner_id SET NOT NULL;
+ALTER TABLE folders ALTER COLUMN owner_id SET NOT NULL;
diff --git a/backend/db/migrations/000012_group_folders.up.sql b/backend/db/migrations/000012_group_folders.up.sql
new file mode 100644
index 0000000..f683f70
--- /dev/null
+++ b/backend/db/migrations/000012_group_folders.up.sql
@@ -0,0 +1,35 @@
+-- Gruppenordner: ein Ordner, der keinem einzelnen Konto gehört, sondern einer
+-- Gruppe. Wer Mitglied ist, sieht ihn; wer die Gruppe verlässt, nicht mehr.
+--
+-- Ordner und Dateien gehören ab jetzt entweder einem Nutzer ODER einer Gruppe,
+-- nie beidem und nie keinem. Deshalb wird owner_id nullbar und bekommt eine
+-- CHECK-Bedingung als Gegengewicht – ohne die könnte ein Datensatz herrenlos
+-- werden und wäre über keine Abfrage mehr erreichbar.
+
+ALTER TABLE folders ALTER COLUMN owner_id DROP NOT NULL;
+ALTER TABLE files   ALTER COLUMN owner_id DROP NOT NULL;
+
+ALTER TABLE folders ADD COLUMN group_id UUID REFERENCES groups(id) ON DELETE CASCADE;
+ALTER TABLE files   ADD COLUMN group_id UUID REFERENCES groups(id) ON DELETE CASCADE;
+
+ALTER TABLE folders ADD CONSTRAINT folders_one_principal
+    CHECK (num_nonnulls(owner_id, group_id) = 1);
+ALTER TABLE files   ADD CONSTRAINT files_one_principal
+    CHECK (num_nonnulls(owner_id, group_id) = 1);
+
+-- Gruppen bekommen ein eigenes Kontingent. Die Alternative – „zählt beim
+-- Ersteller" – wäre für die Mitglieder nicht nachvollziehbar: Der Ordner wäre
+-- plötzlich voll, weil jemand anders privat etwas hochgeladen hat.
+ALTER TABLE groups ADD COLUMN quota_bytes BIGINT NOT NULL DEFAULT 10737418240;
+
+-- Die bestehende UNIQUE (owner_id, parent_id, name) greift für Gruppenordner
+-- nicht: In SQL kollidiert NULL nicht mit NULL, zwei Gruppenordner gleichen
+-- Namens rutschten also durch.
+CREATE UNIQUE INDEX idx_folders_group_name ON folders (group_id, parent_id, name)
+    WHERE group_id IS NOT NULL AND parent_id IS NOT NULL;
+-- Auf oberster Ebene ist parent_id NULL, das braucht einen eigenen Index.
+CREATE UNIQUE INDEX idx_folders_group_root_name ON folders (group_id, name)
+    WHERE group_id IS NOT NULL AND parent_id IS NULL;
+
+CREATE INDEX idx_folders_group ON folders (group_id) WHERE group_id IS NOT NULL;
+CREATE INDEX idx_files_group   ON files   (group_id) WHERE group_id IS NOT NULL;
diff --git a/backend/db/migrations/000013_search_indexes.down.sql b/backend/db/migrations/000013_search_indexes.down.sql
new file mode 100644
index 0000000..54e6ef3
--- /dev/null
+++ b/backend/db/migrations/000013_search_indexes.down.sql
@@ -0,0 +1,5 @@
+DROP INDEX IF EXISTS idx_folders_name_trgm;
+DROP INDEX IF EXISTS idx_files_name_trgm;
+
+-- Die Erweiterung bleibt bewusst stehen: Sie wieder zu entfernen würde alles
+-- mitreißen, was sonst noch auf ihr aufbaut, und sie kostet nichts.
diff --git a/backend/db/migrations/000013_search_indexes.up.sql b/backend/db/migrations/000013_search_indexes.up.sql
new file mode 100644
index 0000000..5ee3263
--- /dev/null
+++ b/backend/db/migrations/000013_search_indexes.up.sql
@@ -0,0 +1,12 @@
+-- Namenssuche über Dateien und Ordner.
+--
+-- pg_trgm statt einer Volltextsuche: Gesucht wird nach Namensteilen
+-- ("rechn" findet "Rechnung_2026.pdf"), und eine Volltextsuche zerlegt in
+-- Wörter, findet also gerade Teilwörter nicht. Volltext über den *Inhalt*
+-- kommt in Phase 6 dazu – das ist eine andere Aufgabe.
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+
+-- GIN mit Trigrammen macht ILIKE '%…%' indizierbar. Ohne den Index läuft jede
+-- Suche als vollständiger Tabellendurchlauf.
+CREATE INDEX idx_files_name_trgm ON files USING gin (name gin_trgm_ops);
+CREATE INDEX idx_folders_name_trgm ON folders USING gin (name gin_trgm_ops);
diff --git a/backend/db/migrations/000014_document_text.down.sql b/backend/db/migrations/000014_document_text.down.sql
new file mode 100644
index 0000000..12f1f5f
--- /dev/null
+++ b/backend/db/migrations/000014_document_text.down.sql
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS ocr_jobs;
+DROP TABLE IF EXISTS file_text;
diff --git a/backend/db/migrations/000014_document_text.up.sql b/backend/db/migrations/000014_document_text.up.sql
new file mode 100644
index 0000000..3806075
--- /dev/null
+++ b/backend/db/migrations/000014_document_text.up.sql
@@ -0,0 +1,63 @@
+-- Volltext über den *Inhalt* – die zweite Hälfte der Suche.
+--
+-- Migration 000013 machte Datei*namen* durchsuchbar. Das reicht, solange
+-- Dateien sprechende Namen haben. Ein Scanner nennt seine Ablage aber
+-- "scan_0042.pdf", und genau die Belege sollen auffindbar werden.
+
+-- ── Der erkannte Text ─────────────────────────────────────────────────────────
+-- Eigene Tabelle statt einer Spalte an files: Der Text ist um Größenordnungen
+-- länger als der Rest der Zeile, und files wird bei jedem Auflisten gelesen.
+-- Postgres lagert lange Werte zwar aus (TOAST), aber die tsvector-Spalte und
+-- ihr GIN-Index gehörten dann trotzdem an eine Tabelle, die ständig in
+-- Bewegung ist.
+CREATE TABLE file_text (
+    file_id    UUID        PRIMARY KEY REFERENCES files(id) ON DELETE CASCADE,
+    content    TEXT        NOT NULL,
+    -- Woher der Text stammt. 'layer' = das PDF hatte bereits eine Textebene
+    -- (pdftotext, verlustfrei); 'ocr' = aus dem Bild erkannt, kann Fehler
+    -- enthalten. Der Unterschied ist für die Fehlersuche wichtig: Findet die
+    -- Suche ein Wort nicht, sagt die Herkunft, ob OCR es verlesen hat.
+    source     TEXT        NOT NULL CHECK (source IN ('layer', 'ocr')),
+    -- Die Sprachen, mit denen erkannt wurde ("deu+eng"). Bei 'layer' leer.
+    lang       TEXT        NOT NULL DEFAULT '',
+    -- Zeichenzahl des Originals vor dem Kürzen – siehe maxTextBytes im Worker.
+    chars      INTEGER     NOT NULL DEFAULT 0,
+    pages      INTEGER     NOT NULL DEFAULT 0,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    -- Berechnete Spalte statt eines Triggers: Sie kann nie mit dem Inhalt
+    -- auseinanderlaufen, weil Postgres sie bei jedem Schreiben selbst füllt.
+    --
+    -- 'german' fest verdrahtet, nicht 'simple': Ohne Stammformen fände
+    -- "Rechnung" die "Rechnungen" nicht. Deutsch ist die Sprache der Belege,
+    -- um die es hier geht; englische Wörter darin verlieren nur ihre
+    -- Stammformbildung, sie bleiben wörtlich auffindbar. Eine Änderung wäre
+    -- eine Migration – der Preis dafür, dass der Ausdruck IMMUTABLE sein muss.
+    tsv tsvector GENERATED ALWAYS AS (to_tsvector('german', content)) STORED
+);
+
+CREATE INDEX idx_file_text_tsv ON file_text USING gin (tsv);
+
+-- ── Die Warteschlange ─────────────────────────────────────────────────────────
+-- Warum eine Tabelle und nicht einfach ein Goroutine-Aufruf wie bei den
+-- Vorschaubildern: OCR dauert Sekunden bis Minuten. Startet der Server in
+-- dieser Zeit neu – Update, Absturz, Neustart des Wirts –, ist ein Auftrag im
+-- Speicher verloren, und die Datei bleibt für immer unauffindbar, ohne dass es
+-- jemand merkt. Bei einem Vorschaubild fällt das auf; bei fehlendem Text nicht.
+CREATE TABLE ocr_jobs (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    -- Ein Auftrag je Datei. Wird dieselbe Datei erneut hochgeladen, ersetzt der
+    -- neue Auftrag den alten (ON CONFLICT), statt sich daneben zu stapeln.
+    file_id    UUID        NOT NULL UNIQUE REFERENCES files(id) ON DELETE CASCADE,
+    status     TEXT        NOT NULL DEFAULT 'pending'
+                           CHECK (status IN ('pending', 'running', 'done', 'failed')),
+    attempts   INTEGER     NOT NULL DEFAULT 0,
+    last_error TEXT        NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Der Arbeiter fragt nur nach offenen Aufträgen. Ein Teilindex bleibt klein,
+-- auch wenn sich zehntausend erledigte Zeilen ansammeln.
+CREATE INDEX idx_ocr_jobs_pending ON ocr_jobs(created_at)
+    WHERE status IN ('pending', 'running');
diff --git a/backend/db/migrations/000015_tags.down.sql b/backend/db/migrations/000015_tags.down.sql
new file mode 100644
index 0000000..812a011
--- /dev/null
+++ b/backend/db/migrations/000015_tags.down.sql
@@ -0,0 +1,4 @@
+DROP INDEX IF EXISTS idx_files_document_date;
+ALTER TABLE files DROP COLUMN IF EXISTS document_date;
+DROP TABLE IF EXISTS file_tags;
+DROP TABLE IF EXISTS tags;
diff --git a/backend/db/migrations/000015_tags.up.sql b/backend/db/migrations/000015_tags.up.sql
new file mode 100644
index 0000000..7c53d62
--- /dev/null
+++ b/backend/db/migrations/000015_tags.up.sql
@@ -0,0 +1,75 @@
+-- Etiketten für Dateien.
+--
+-- Warum neben Ordnern und Volltext noch ein drittes Ordnungsmittel: Ordner
+-- beantworten „wann" (Rechnungen/2026), der Volltext beantwortet „wo steht
+-- dieses Wort". Beides beantwortet **nicht**, wofür ein Beleg gebraucht wird –
+-- „absetzbar" steht in keiner Rechnung, das ist eine Einschätzung des Menschen.
+--
+-- Und der Fall, an dem Ordner scheitern: Der Kaufbeleg eines Notebooks ist
+-- zugleich Garantienachweis *und* absetzbar. In einen Ordner passt er nur
+-- einmal; Etiketten trägt dieselbe Datei beliebig viele.
+
+-- ── Die Etiketten selbst ─────────────────────────────────────────────────────
+-- Prinzipal-Modell wie bei files und folders: Ein Etikett gehört entweder einem
+-- Konto oder einer Gruppe, nie beidem und nie keinem.
+--
+-- Der Grund für die Gruppenvariante: In einem Gruppenordner arbeiten mehrere an
+-- denselben Dokumenten. Hätte dort jeder seine eigenen Etiketten, sortierte
+-- jeder dieselben Dateien für sich neu ein und niemand sähe die Arbeit des
+-- anderen – der Sinn eines geteilten Ordners wäre dahin.
+CREATE TABLE tags (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id   UUID        REFERENCES users(id)  ON DELETE CASCADE,
+    group_id   UUID        REFERENCES groups(id) ON DELETE CASCADE,
+    name       TEXT        NOT NULL,
+    -- Hex-Farbe für den Aufkleber. Leer heißt: die Oberfläche wählt eine aus
+    -- dem Namen, damit ein neues Etikett nicht erst eingefärbt werden muss.
+    color      TEXT        NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    CONSTRAINT tags_one_principal CHECK (
+        (owner_id IS NOT NULL AND group_id IS NULL) OR
+        (owner_id IS NULL AND group_id IS NOT NULL)
+    ),
+    CONSTRAINT tags_name_not_empty CHECK (length(btrim(name)) > 0)
+);
+
+-- Namen sind je Prinzipal eindeutig, und zwar **ohne Rücksicht auf
+-- Groß-/Kleinschreibung**. Sonst stehen nach drei Monaten "Stadtwerke",
+-- "stadtwerke" und "STADTWERKE" nebeneinander – genau der Zerfall, den
+-- Etiketten gegenüber freien Ordnernamen verhindern sollen.
+CREATE UNIQUE INDEX idx_tags_owner_name ON tags (owner_id, lower(btrim(name)))
+    WHERE owner_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_tags_group_name ON tags (group_id, lower(btrim(name)))
+    WHERE group_id IS NOT NULL;
+
+-- ── Die Zuordnung ────────────────────────────────────────────────────────────
+-- Eine reine Verknüpfungstabelle. Nichts davon wird in die Datei geschrieben:
+-- Das Dokument bleibt Byte für Byte, wie es hochgeladen wurde – dieselbe Regel
+-- wie beim erkannten Text (siehe internal/documents).
+CREATE TABLE file_tags (
+    file_id    UUID        NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    tag_id     UUID        NOT NULL REFERENCES tags(id)  ON DELETE CASCADE,
+    -- Wer es angehängt hat. In einem Gruppenordner sonst nicht nachvollziehbar.
+    tagged_by  UUID        REFERENCES users(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (file_id, tag_id)
+);
+
+-- Der Primärschlüssel deckt die Richtung Datei → Etiketten ab. Die andere
+-- Richtung – „zeig mir alles mit steuer-2026" – ist genau die Abfrage, für die
+-- Etiketten gebaut werden, und braucht ihren eigenen Index.
+CREATE INDEX idx_file_tags_tag ON file_tags (tag_id);
+
+-- ── Belegdatum ───────────────────────────────────────────────────────────────
+-- Das Datum, das auf dem Dokument steht – nicht das des Uploads.
+--
+-- Für beide Zwecke entscheidend: Die Garantiefrist läuft ab dem **Kauf**, und in
+-- die Steuererklärung 2026 gehört, was 2026 gekauft wurde – auch wenn der Beleg
+-- erst im März 2027 eingescannt wird. created_at wäre für beides das falsche
+-- Datum, und zwar unauffällig falsch.
+--
+-- NULL heißt schlicht „nicht gesetzt": Bei einem Urlaubsfoto gibt es kein
+-- Belegdatum, und ein Vorgabewert wäre eine Behauptung.
+ALTER TABLE files ADD COLUMN document_date DATE;
+CREATE INDEX idx_files_document_date ON files (document_date) WHERE document_date IS NOT NULL;
diff --git a/backend/db/migrations/000016_text_pages.down.sql b/backend/db/migrations/000016_text_pages.down.sql
new file mode 100644
index 0000000..dcb095f
--- /dev/null
+++ b/backend/db/migrations/000016_text_pages.down.sql
@@ -0,0 +1 @@
+ALTER TABLE file_text DROP COLUMN IF EXISTS extract_version;
diff --git a/backend/db/migrations/000016_text_pages.up.sql b/backend/db/migrations/000016_text_pages.up.sql
new file mode 100644
index 0000000..59db624
--- /dev/null
+++ b/backend/db/migrations/000016_text_pages.up.sql
@@ -0,0 +1,13 @@
+-- Seitengrenzen im erkannten Text.
+--
+-- Bis hierher ersetzte clean() den Seitenumbruch (\f) durch einen Zeilenumbruch:
+-- Für die Volltextsuche ist er bedeutungslos, ein tsvector kennt keine Seiten.
+-- Für den PDF-Betrachter ist er das Gegenteil von bedeutungslos – bei einem
+-- Scan steht der Text *nur* hier, im PDF selbst liegt bloß ein Bild. Ohne die
+-- Marke lässt sich nicht sagen, auf welcher Seite ein Suchwort steht, und der
+-- Betrachter beginnt bei einem Beleg-Scan wieder stumpf auf Seite 1.
+--
+-- extract_version sagt, nach welcher Regel ein Eintrag entstanden ist. Ältere
+-- Einträge werden beim Start erneut in die Warteschlange gelegt, statt still
+-- ohne Seitenmarken liegen zu bleiben.
+ALTER TABLE file_text ADD COLUMN IF NOT EXISTS extract_version smallint NOT NULL DEFAULT 0;
diff --git a/backend/db/migrations/000017_correspondents.down.sql b/backend/db/migrations/000017_correspondents.down.sql
new file mode 100644
index 0000000..af119fa
--- /dev/null
+++ b/backend/db/migrations/000017_correspondents.down.sql
@@ -0,0 +1,3 @@
+DROP INDEX IF EXISTS idx_files_correspondent;
+ALTER TABLE files DROP COLUMN IF EXISTS correspondent_id;
+DROP TABLE IF EXISTS correspondents;
diff --git a/backend/db/migrations/000017_correspondents.up.sql b/backend/db/migrations/000017_correspondents.up.sql
new file mode 100644
index 0000000..1580cda
--- /dev/null
+++ b/backend/db/migrations/000017_correspondents.up.sql
@@ -0,0 +1,52 @@
+-- Absender („Korrespondent") an Dateien.
+--
+-- Warum neben Etiketten noch ein Feld: Es sind **zwei verschiedene Fragen**.
+-- Ein Etikett sagt, *wofür* ein Dokument gebraucht wird („absetzbar",
+-- „garantie") – davon trägt eine Datei beliebig viele. Der Absender sagt, *von
+-- wem* es kommt („Stadtwerke", „Finanzamt") – davon hat eine Datei genau einen.
+--
+-- Als Etikett gelöst stünden beide in derselben Liste: „Stadtwerke" neben
+-- „absetzbar", Absender und Verwendungszweck durcheinander. Bei zwanzig
+-- Etiketten fällt das nicht auf, bei achtzig ist die Liste unbenutzbar. Und
+-- „alle Rechnungen von X" ließe sich nicht von „alles Absetzbare" trennen –
+-- genau die Verknüpfung, für die es gebaut wird.
+--
+-- Die Eins-Regel ist dabei kein Mangel, sondern der Zweck: Sie erzwingt eine
+-- Entscheidung und hält die Liste kurz.
+
+CREATE TABLE correspondents (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    -- Prinzipal-Modell wie bei tags: entweder ein Konto oder eine Gruppe.
+    -- In einem Gruppenordner müssen alle dieselben Absender sehen, sonst
+    -- sortiert jeder dieselben Dokumente für sich neu ein.
+    owner_id   UUID        REFERENCES users(id)  ON DELETE CASCADE,
+    group_id   UUID        REFERENCES groups(id) ON DELETE CASCADE,
+    name       TEXT        NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    CONSTRAINT correspondents_one_principal CHECK (
+        (owner_id IS NOT NULL AND group_id IS NULL) OR
+        (owner_id IS NULL AND group_id IS NOT NULL)
+    ),
+    CONSTRAINT correspondents_name_not_empty CHECK (length(btrim(name)) > 0)
+);
+
+-- Eindeutig je Prinzipal, ohne Rücksicht auf Groß-/Kleinschreibung – dieselbe
+-- Regel wie bei Etiketten. Hier wiegt sie schwerer: „Amazon" und „amazon"
+-- nebeneinander hieße, dass „alle Rechnungen von Amazon" nur die Hälfte
+-- findet, und zwar unauffällig.
+CREATE UNIQUE INDEX idx_correspondents_owner_name
+    ON correspondents (owner_id, lower(btrim(name))) WHERE owner_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_correspondents_group_name
+    ON correspondents (group_id, lower(btrim(name))) WHERE group_id IS NOT NULL;
+
+-- Am Datei-Datensatz, nicht in einer Verknüpfungstabelle: Genau einer je
+-- Datei – das steht damit im Schema und nicht bloß in einer Zusicherung des
+-- Codes.
+--
+-- ON DELETE SET NULL statt CASCADE: Wer einen Absender löscht, will ihn aus
+-- der Liste haben – nicht seine Rechnungen.
+ALTER TABLE files ADD COLUMN correspondent_id UUID REFERENCES correspondents(id) ON DELETE SET NULL;
+
+-- „Alles von Stadtwerke" ist die Abfrage, für die das Feld gebaut wird.
+CREATE INDEX idx_files_correspondent ON files (correspondent_id) WHERE correspondent_id IS NOT NULL;
diff --git a/backend/db/migrations/000018_tag_icons.down.sql b/backend/db/migrations/000018_tag_icons.down.sql
new file mode 100644
index 0000000..813c620
--- /dev/null
+++ b/backend/db/migrations/000018_tag_icons.down.sql
@@ -0,0 +1,2 @@
+ALTER TABLE tags           DROP COLUMN IF EXISTS icon;
+ALTER TABLE correspondents DROP COLUMN IF EXISTS icon;
diff --git a/backend/db/migrations/000018_tag_icons.up.sql b/backend/db/migrations/000018_tag_icons.up.sql
new file mode 100644
index 0000000..906936d
--- /dev/null
+++ b/backend/db/migrations/000018_tag_icons.up.sql
@@ -0,0 +1,15 @@
+-- Ein Symbol je Etikett und je Absender.
+--
+-- Die Farbe allein trägt nicht weit genug: Sie unterscheidet zuverlässig etwa
+-- fünf Einträge. Danach fragt man sich, ob Blau nun „Uni" oder „Versicherung"
+-- war. Ein Emoji ist sofort erkennbar, braucht keine Legende und ist in jeder
+-- Schrift schon da – kein Symbolsatz, keine Grafikdateien, keine zusätzliche
+-- Ladezeit.
+--
+-- Leer heißt „keins": Die Farbe bleibt der Rückfall, niemand muss ein Symbol
+-- wählen. Ein Vorgabe-Emoji wäre eine Behauptung über den Inhalt.
+--
+-- TEXT statt eines einzelnen Zeichens: Ein Emoji ist selten ein Codepunkt.
+-- 👨‍🎓 sind fünf, 🏳️‍🌈 vier – ein CHAR(1) hätte sie zerschnitten.
+ALTER TABLE tags           ADD COLUMN IF NOT EXISTS icon TEXT NOT NULL DEFAULT '';
+ALTER TABLE correspondents ADD COLUMN IF NOT EXISTS icon TEXT NOT NULL DEFAULT '';
diff --git a/backend/go.mod b/backend/go.mod
new file mode 100644
index 0000000..df2cf8a
--- /dev/null
+++ b/backend/go.mod
@@ -0,0 +1,34 @@
+module aether
+
+go 1.25.0
+
+require (
+	github.com/coreos/go-oidc/v3 v3.19.0
+	github.com/go-chi/chi/v5 v5.1.0
+	github.com/go-chi/httprate v0.15.0
+	github.com/golang-migrate/migrate/v4 v4.19.1
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/sessions v1.4.0
+	github.com/jackc/pgx/v5 v5.10.0
+	github.com/rs/zerolog v1.33.0
+	golang.org/x/crypto v0.53.0
+	golang.org/x/image v0.42.0
+	golang.org/x/net v0.56.0
+	golang.org/x/oauth2 v0.36.0
+)
+
+require (
+	github.com/go-jose/go-jose/v4 v4.1.4 // indirect
+	github.com/gorilla/securecookie v1.1.2 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/lib/pq v1.10.9 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/zeebo/xxh3 v1.0.2 // indirect
+	golang.org/x/sync v0.21.0 // indirect
+	golang.org/x/sys v0.46.0 // indirect
+	golang.org/x/text v0.38.0 // indirect
+)
diff --git a/backend/go.sum b/backend/go.sum
new file mode 100644
index 0000000..74c265b
--- /dev/null
+++ b/backend/go.sum
@@ -0,0 +1,124 @@
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI=
+github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
+github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
+github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
+github.com/coreos/go-oidc/v3 v3.19.0 h1:F/xyOi3x1UnG1U27YVnM1N6bHiL1K2upi6U/0qr8r+I=
+github.com/coreos/go-oidc/v3 v3.19.0/go.mod h1:DYCf24+ncYi+XkIH97GY1+dqoRlbaSI26KVTCI9SrY4=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dhui/dktest v0.4.6 h1:+DPKyScKSEp3VLtbMDHcUq6V5Lm5zfZZVb0Sk7Ahom4=
+github.com/dhui/dktest v0.4.6/go.mod h1:JHTSYDtKkvFNFHJKqCzVzqXecyv+tKt8EzceOmQOgbU=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/docker v28.3.3+incompatible h1:Dypm25kh4rmk49v1eiVbsAtpAsYURjYkaKubwuBdxEI=
+github.com/docker/docker v28.3.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
+github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw=
+github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
+github.com/go-chi/httprate v0.15.0 h1:j54xcWV9KGmPf/X4H32/aTH+wBlrvxL7P+SdnRqxh5g=
+github.com/go-chi/httprate v0.15.0/go.mod h1:rzGHhVrsBn3IMLYDOZQsSU4fJNWcjui4fWKJcCId1R4=
+github.com/go-jose/go-jose/v4 v4.1.4 h1:moDMcTHmvE6Groj34emNPLs/qtYXRVcd6S7NHbHz3kA=
+github.com/go-jose/go-jose/v4 v4.1.4/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang-migrate/migrate/v4 v4.19.1 h1:OCyb44lFuQfYXYLx1SCxPZQGU7mcaZ7gH9yH4jSFbBA=
+github.com/golang-migrate/migrate/v4 v4.19.1/go.mod h1:CTcgfjxhaUtsLipnLoQRWCrjYXycRz/g5+RWDuYgPrE=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/securecookie v1.1.2 h1:YCIWL56dvtr73r6715mJs5ZvhtnY73hBvEF8kXD8ePA=
+github.com/gorilla/securecookie v1.1.2/go.mod h1:NfCASbcHqRSY+3a8tlWJwsQap2VX5pwzwo4h3eOamfo=
+github.com/gorilla/sessions v1.4.0 h1:kpIYOp/oi6MG/p5PgxApU8srsSw9tuFbt46Lt7auzqQ=
+github.com/gorilla/sessions v1.4.0/go.mod h1:FLWm50oby91+hl7p/wRxDth9bWSuk0qVL2emc7lT5ik=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.10.0 h1:VhSvgU2jSli8o3AqIEOTJr7rZwAEUVo4E4XhR94Zfr0=
+github.com/jackc/pgx/v5 v5.10.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
+github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
+github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
+github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
+github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
+github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
+github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
+github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 h1:F7Jx+6hwnZ41NSFTO5q4LYDtJRXBf2PD0rNBkeB/lus=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0/go.mod h1:UHB22Z8QsdRDrnAtX4PntOl36ajSxcdUMt1sF7Y6E7Q=
+go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
+go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
+go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
+go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
+go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
+go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
+golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
+golang.org/x/image v0.42.0 h1:1gSs6ehNWXLbkHBIPcWztk3D/6aIA/8hauiAYtlodVY=
+golang.org/x/image v0.42.0/go.mod h1:rrpelvGFt+kLPAjPM4HeWPgrl0FtafueU//e5N0qk/Q=
+golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
+golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
+golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
+golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
+golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
+golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
+golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
+golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/backend/internal/acl/acl.go b/backend/internal/acl/acl.go
new file mode 100644
index 0000000..63c5ff2
--- /dev/null
+++ b/backend/internal/acl/acl.go
@@ -0,0 +1,351 @@
+// Package acl regelt interne Freigaben: Ordner und Dateien an andere Nutzer
+// oder Gruppen geben, ohne dass Daten umziehen.
+//
+// Das Zugriffsmodell in einem Satz: Zugriff hat, wem die Ressource gehört –
+// oder wer einen Freigabeeintrag darauf besitzt, direkt oder über eine Gruppe,
+// auf der Ressource selbst oder auf einem Ordner darüber.
+//
+// Die Vererbung nach unten ist der Grund, warum das nicht mit einer einfachen
+// Abfrage geht: Wer einen Ordner freigibt, meint dessen ganzen Inhalt – sonst
+// müsste man jede Datei einzeln freigeben, und jede neu hinzugefügte gleich
+// mit. Deshalb läuft die Prüfung den Ordnerbaum nach oben, bis sie einen
+// Eintrag findet.
+package acl
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	// ErrNoAccess: weder Eigentümer noch Freigabe. Handler antworten damit
+	// bewusst „nicht gefunden" statt „verboten" – sonst verriete die Antwort,
+	// dass die ID überhaupt existiert.
+	ErrNoAccess = errors.New("no access to this resource")
+	// ErrReadOnly: Zugriff ja, Schreiben nein.
+	ErrReadOnly = errors.New("read-only access")
+	ErrNotFound = errors.New("resource not found")
+)
+
+// Permission ist absichtlich klein gehalten. Feinere Rechte (löschen vs.
+// ändern) brächten Fragen mit sich, die für eine persönliche Cloud niemand
+// stellt.
+type Permission string
+
+const (
+	PermRead  Permission = "read"
+	PermWrite Permission = "write"
+)
+
+func (p Permission) valid() bool { return p == PermRead || p == PermWrite }
+
+// Access beschreibt das Ergebnis einer Zugriffsprüfung.
+type Access struct {
+	// OwnerID ist der *Prinzipal* der Ressource – ein Konto oder eine Gruppe,
+	// nicht zwingend der Anfragende. Alle Speicher- und Datenbankoperationen
+	// laufen weiter über ihn, denn dort liegen die Daten.
+	//
+	// Ein Prinzipal statt eines Eigentümers, weil Gruppenordner niemandem
+	// persönlich gehören. Die Abfragen prüfen deshalb `owner_id = $1 OR
+	// group_id = $1`; UUIDs sind global eindeutig, eine Gruppen-ID kann also
+	// nie versehentlich auf ein Konto passen.
+	OwnerID uuid.UUID
+	// IsGroup unterscheidet die beiden Fälle dort, wo es darauf ankommt:
+	// beim Anlegen (welche Spalte wird gesetzt) und beim Speicherpfad.
+	IsGroup bool
+	// OwnerUsername, weil Speicherpfade daraus gebaut werden
+	// (`users/{name}/home/…`). Wer in einem geliehenen Ordner arbeitet, schreibt
+	// in den Bereich des Eigentümers, nicht in seinen eigenen.
+	OwnerUsername string
+	// OwnerQuota ist das Kontingent des Eigentümers. Wer in einen geliehenen
+	// Ordner hochlädt, verbraucht dessen Platz – die Bytes liegen ja in dessen
+	// Bereich. Alles andere wäre ein Weg, fremde Kontingente zu umgehen.
+	OwnerQuota int64
+	// Permission ist das, was der Anfragende darf.
+	Permission Permission
+	// Shared unterscheidet eigenen Besitz von geliehenem Zugriff.
+	Shared bool
+}
+
+func (a Access) CanWrite() bool { return a.Permission == PermWrite }
+
+// OwnerRef und GroupRef liefern die Werte für die Spalten owner_id / group_id.
+// Genau einer ist gesetzt – so verlangt es die CHECK-Bedingung.
+func (a Access) OwnerRef() *uuid.UUID {
+	if a.IsGroup {
+		return nil
+	}
+	id := a.OwnerID
+	return &id
+}
+
+func (a Access) GroupRef() *uuid.UUID {
+	if !a.IsGroup {
+		return nil
+	}
+	id := a.OwnerID
+	return &id
+}
+
+// StorageRoot ist das Wurzelsegment für Speicherpfade. Gruppendaten liegen
+// bewusst nicht unter `users/…`: Auf der Platte soll man ansehen können, dass
+// ein Ordner keinem Konto gehört – sonst sucht man die Daten einer Gruppe im
+// Verzeichnis eines Nutzers, der zufällig ihr Ersteller war.
+func (a Access) StorageRoot() string {
+	if a.IsGroup {
+		return "groups/" + a.OwnerID.String()
+	}
+	return "users/" + a.OwnerUsername
+}
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store {
+	return &Store{db: db}
+}
+
+// ── Zugriffsauflösung ────────────────────────────────────────────────────────
+
+// ResolveFolder klärt, was userID mit diesem Ordner darf.
+func (s *Store) ResolveFolder(ctx context.Context, userID, folderID uuid.UUID) (Access, error) {
+	// Gruppenordner haben keinen Eigentümer, deshalb beide Fälle in einer
+	// Abfrage. COALESCE macht die Gruppen-ID zum Prinzipal, wenn owner_id leer
+	// ist – genau die ID, mit der die Store-Abfragen weiterarbeiten.
+	var principal uuid.UUID
+	var isGroup bool
+	var ownerName string
+	var quota int64
+	err := s.db.QueryRow(ctx,
+		`SELECT COALESCE(f.owner_id, f.group_id),
+		        f.group_id IS NOT NULL,
+		        COALESCE(u.username, ''),
+		        COALESCE(u.quota_bytes, g.quota_bytes, 0)
+		   FROM folders f
+		   LEFT JOIN users  u ON u.id = f.owner_id
+		   LEFT JOIN groups g ON g.id = f.group_id
+		  WHERE f.id = $1`, folderID).Scan(&principal, &isGroup, &ownerName, &quota)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Access{}, ErrNotFound
+	}
+	if err != nil {
+		return Access{}, fmt.Errorf("load folder principal: %w", err)
+	}
+
+	if isGroup {
+		// Mitgliedschaft ersetzt hier die Freigabe: Wer in der Gruppe ist, darf
+		// schreiben; wer sie verlässt, verliert den Zugriff im selben Moment.
+		member, err := s.isGroupMember(ctx, userID, principal)
+		if err != nil {
+			return Access{}, err
+		}
+		if !member {
+			return Access{}, ErrNoAccess
+		}
+		return Access{
+			OwnerID: principal, IsGroup: true, OwnerQuota: quota,
+			Permission: PermWrite, Shared: true,
+		}, nil
+	}
+
+	if principal == userID {
+		return Access{OwnerID: principal, OwnerUsername: ownerName, OwnerQuota: quota, Permission: PermWrite}, nil
+	}
+	ownerID, ownerQuota := principal, quota
+
+	perm, err := s.bestPermissionForFolder(ctx, userID, folderID)
+	if err != nil {
+		return Access{}, err
+	}
+	if perm == "" {
+		return Access{}, ErrNoAccess
+	}
+	return Access{OwnerID: ownerID, OwnerUsername: ownerName, OwnerQuota: ownerQuota, Permission: perm, Shared: true}, nil
+}
+
+// ResolveFile klärt, was userID mit dieser Datei darf. Geerbt wird über den
+// Ordner, in dem sie liegt.
+func (s *Store) ResolveFile(ctx context.Context, userID, fileID uuid.UUID) (Access, error) {
+	var principal uuid.UUID
+	var isGroup bool
+	var ownerName string
+	var quota int64
+	var folderID *uuid.UUID
+	err := s.db.QueryRow(ctx,
+		`SELECT COALESCE(x.owner_id, x.group_id),
+		        x.group_id IS NOT NULL,
+		        COALESCE(u.username, ''),
+		        COALESCE(u.quota_bytes, g.quota_bytes, 0),
+		        x.folder_id
+		   FROM files x
+		   LEFT JOIN users  u ON u.id = x.owner_id
+		   LEFT JOIN groups g ON g.id = x.group_id
+		  WHERE x.id = $1`, fileID).Scan(&principal, &isGroup, &ownerName, &quota, &folderID)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Access{}, ErrNotFound
+	}
+	if err != nil {
+		return Access{}, fmt.Errorf("load file principal: %w", err)
+	}
+
+	if isGroup {
+		member, err := s.isGroupMember(ctx, userID, principal)
+		if err != nil {
+			return Access{}, err
+		}
+		if !member {
+			return Access{}, ErrNoAccess
+		}
+		return Access{
+			OwnerID: principal, IsGroup: true, OwnerQuota: quota,
+			Permission: PermWrite, Shared: true,
+		}, nil
+	}
+
+	if principal == userID {
+		return Access{OwnerID: principal, OwnerUsername: ownerName, OwnerQuota: quota, Permission: PermWrite}, nil
+	}
+	ownerID, ownerQuota := principal, quota
+
+	// Direkte Freigabe auf der Datei.
+	perm, err := s.directFilePermission(ctx, userID, fileID)
+	if err != nil {
+		return Access{}, err
+	}
+	// Geerbt aus dem Ordner darüber. Das stärkere Recht gewinnt: eine
+	// Schreibfreigabe auf dem Ordner soll nicht dadurch entwertet werden, dass
+	// jemand zusätzlich eine Lesefreigabe auf einer einzelnen Datei erteilt hat.
+	if folderID != nil && perm != PermWrite {
+		inherited, err := s.bestPermissionForFolder(ctx, userID, *folderID)
+		if err != nil {
+			return Access{}, err
+		}
+		perm = stronger(perm, inherited)
+	}
+	if perm == "" {
+		return Access{}, ErrNoAccess
+	}
+	return Access{OwnerID: ownerID, OwnerUsername: ownerName, OwnerQuota: ownerQuota, Permission: perm, Shared: true}, nil
+}
+
+// RequireFolderWrite / RequireFileWrite sind die bequeme Form für Handler, die
+// ändern wollen.
+func (s *Store) RequireFolderWrite(ctx context.Context, userID, folderID uuid.UUID) (Access, error) {
+	a, err := s.ResolveFolder(ctx, userID, folderID)
+	if err != nil {
+		return a, err
+	}
+	if !a.CanWrite() {
+		return a, ErrReadOnly
+	}
+	return a, nil
+}
+
+func (s *Store) RequireFileWrite(ctx context.Context, userID, fileID uuid.UUID) (Access, error) {
+	a, err := s.ResolveFile(ctx, userID, fileID)
+	if err != nil {
+		return a, err
+	}
+	if !a.CanWrite() {
+		return a, ErrReadOnly
+	}
+	return a, nil
+}
+
+// IsGroupMember ist die öffentliche Fassung von isGroupMember – gebraucht von
+// internal/tags, um zu prüfen, ob jemand einer Gruppe ein Etikett anlegen darf.
+func (s *Store) IsGroupMember(ctx context.Context, userID, groupID uuid.UUID) (bool, error) {
+	return s.isGroupMember(ctx, userID, groupID)
+}
+
+func (s *Store) isGroupMember(ctx context.Context, userID, groupID uuid.UUID) (bool, error) {
+	var exists bool
+	err := s.db.QueryRow(ctx,
+		`SELECT EXISTS (SELECT 1 FROM group_members WHERE user_id = $1 AND group_id = $2)`,
+		userID, groupID).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("check group membership: %w", err)
+	}
+	return exists, nil
+}
+
+// bestPermissionForFolder läuft vom Ordner aus nach oben und liefert das
+// stärkste Recht, das userID auf dem Weg findet – direkt oder über eine Gruppe.
+// Leerer Rückgabewert heißt: keinerlei Zugriff.
+func (s *Store) bestPermissionForFolder(ctx context.Context, userID, folderID uuid.UUID) (Permission, error) {
+	// Rekursiv nach oben statt nach unten: Der Pfad zur Wurzel ist ein paar
+	// Ebenen lang, der Unterbaum kann Tausende Einträge haben.
+	const q = `
+		WITH RECURSIVE ancestry AS (
+		    SELECT id, parent_id FROM folders WHERE id = $1
+		    UNION ALL
+		    SELECT f.id, f.parent_id
+		      FROM folders f
+		      JOIN ancestry a ON f.id = a.parent_id
+		)
+		SELECT e.permission
+		  FROM acl_entries e
+		  JOIN ancestry a ON a.id = e.resource_folder_id
+		 WHERE e.subject_user_id = $2
+		    OR e.subject_group_id IN (
+		           SELECT group_id FROM group_members WHERE user_id = $2
+		       )`
+
+	rows, err := s.db.Query(ctx, q, folderID, userID)
+	if err != nil {
+		return "", fmt.Errorf("resolve folder permission: %w", err)
+	}
+	defer rows.Close()
+
+	var best Permission
+	for rows.Next() {
+		var p Permission
+		if err := rows.Scan(&p); err != nil {
+			return "", fmt.Errorf("scan permission: %w", err)
+		}
+		best = stronger(best, p)
+	}
+	return best, rows.Err()
+}
+
+func (s *Store) directFilePermission(ctx context.Context, userID, fileID uuid.UUID) (Permission, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT permission FROM acl_entries
+		  WHERE resource_file_id = $1
+		    AND (subject_user_id = $2
+		         OR subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $2))`,
+		fileID, userID)
+	if err != nil {
+		return "", fmt.Errorf("resolve file permission: %w", err)
+	}
+	defer rows.Close()
+
+	var best Permission
+	for rows.Next() {
+		var p Permission
+		if err := rows.Scan(&p); err != nil {
+			return "", fmt.Errorf("scan permission: %w", err)
+		}
+		best = stronger(best, p)
+	}
+	return best, rows.Err()
+}
+
+// stronger: Mehrere Wege zur selben Ressource (direkt und über zwei Gruppen)
+// sind normal. Das großzügigste Recht gilt – alles andere wäre für den Nutzer
+// nicht nachvollziehbar.
+func stronger(a, b Permission) Permission {
+	if a == PermWrite || b == PermWrite {
+		return PermWrite
+	}
+	if a == PermRead || b == PermRead {
+		return PermRead
+	}
+	return ""
+}
diff --git a/backend/internal/acl/acl_test.go b/backend/internal/acl/acl_test.go
new file mode 100644
index 0000000..71d398e
--- /dev/null
+++ b/backend/internal/acl/acl_test.go
@@ -0,0 +1,60 @@
+package acl
+
+import "testing"
+
+// stronger entscheidet, welches Recht gilt, wenn jemand eine Ressource über
+// mehrere Wege erreicht – direkt und zusätzlich über zwei Gruppen etwa. Kippt
+// diese Funktion, bekommt jemand entweder zu viel oder unerwartet zu wenig.
+func TestStrongerPermissionWins(t *testing.T) {
+	tests := []struct {
+		name string
+		a, b Permission
+		want Permission
+	}{
+		{"nichts und nichts", "", "", ""},
+		{"nur lesen", PermRead, "", PermRead},
+		{"lesen und schreiben", PermRead, PermWrite, PermWrite},
+		{"schreiben und lesen", PermWrite, PermRead, PermWrite},
+		{"zweimal schreiben", PermWrite, PermWrite, PermWrite},
+		{"zweimal lesen", PermRead, PermRead, PermRead},
+		{"schreiben aus dem Nichts", "", PermWrite, PermWrite},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := stronger(tt.a, tt.b); got != tt.want {
+				t.Errorf("stronger(%q, %q) = %q, want %q", tt.a, tt.b, got, tt.want)
+			}
+		})
+	}
+}
+
+// Ein unbekanntes Recht darf nicht durchrutschen: Die Datenbank hat zwar einen
+// CHECK, aber die Prüfung soll vorher greifen und eine klare Fehlermeldung
+// liefern statt eines Constraint-Fehlers.
+func TestPermissionValidation(t *testing.T) {
+	for _, p := range []Permission{PermRead, PermWrite} {
+		if !p.valid() {
+			t.Errorf("%q sollte gültig sein", p)
+		}
+	}
+	for _, p := range []Permission{"", "admin", "owner", "READ", "write "} {
+		if p.valid() {
+			t.Errorf("%q sollte ungültig sein", p)
+		}
+	}
+}
+
+// Access.CanWrite ist die Weiche vor jeder Änderung.
+func TestAccessCanWrite(t *testing.T) {
+	if (Access{Permission: PermRead}).CanWrite() {
+		t.Error("Lesezugriff darf nicht schreiben dürfen")
+	}
+	if !(Access{Permission: PermWrite}).CanWrite() {
+		t.Error("Schreibzugriff muss schreiben dürfen")
+	}
+	// Der Nullwert entsteht, wenn eine Auflösung fehlschlägt – der darf
+	// keinesfalls Schreibrechte bedeuten.
+	if (Access{}).CanWrite() {
+		t.Error("leerer Zugriff darf nicht schreiben dürfen")
+	}
+}
diff --git a/backend/internal/acl/handler.go b/backend/internal/acl/handler.go
new file mode 100644
index 0000000..2f9fdd7
--- /dev/null
+++ b/backend/internal/acl/handler.go
@@ -0,0 +1,263 @@
+package acl
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+
+	"aether/internal/audit"
+	"aether/internal/auth"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+// Handler bedient den Freigabedialog. Die Zugriffsprüfung selbst passiert im
+// files-Paket; hier geht es nur ums Erteilen, Ansehen und Widerrufen.
+//
+// Freigeben darf ausschließlich der Eigentümer. Wer selbst nur eine
+// Schreibfreigabe hat, kann sie nicht weiterreichen – sonst verlöre der
+// Eigentümer die Kontrolle darüber, wer seine Daten sieht.
+type Handler struct {
+	store   *Store
+	auditor *audit.Logger
+}
+
+func NewHandler(store *Store, auditor *audit.Logger) *Handler {
+	return &Handler{store: store, auditor: auditor}
+}
+
+// logShare hält fest, wer wem Zugriff auf was gegeben oder genommen hat. Bei
+// Freigaben ist das die interessanteste Spur überhaupt: Sie erklärt, wie jemand
+// an Daten kam, die ihm nicht gehören.
+func (h *Handler) logShare(r *http.Request, action, resourceType, resourceID, detail string) {
+	user := auth.UserFromContext(r.Context())
+	e := audit.Event{
+		Action:     action,
+		TargetType: resourceType,
+		TargetID:   resourceID,
+		Detail:     detail,
+		IP:         middleware.RealIP(r),
+	}
+	if user != nil {
+		e.ActorID = &user.ID
+		e.ActorName = user.Username
+	}
+	h.auditor.Log(r.Context(), e)
+}
+
+// ownedFolder / ownedFile liefern die Ressourcen-ID und den Anfragenden –
+// aber nur, wenn ihm die Ressource auch gehört. Alles andere ist bereits
+// beantwortet.
+func (h *Handler) ownedFolder(w http.ResponseWriter, r *http.Request) (uuid.UUID, uuid.UUID, bool) {
+	user := auth.UserFromContext(r.Context())
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return uuid.Nil, uuid.Nil, false
+	}
+	a, err := h.store.ResolveFolder(r.Context(), user.ID, id)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "folder not found")
+		return uuid.Nil, uuid.Nil, false
+	}
+	if a.OwnerID != user.ID {
+		response.Error(w, http.StatusForbidden, "only the owner can manage sharing")
+		return uuid.Nil, uuid.Nil, false
+	}
+	return id, user.ID, true
+}
+
+func (h *Handler) ownedFile(w http.ResponseWriter, r *http.Request) (uuid.UUID, uuid.UUID, bool) {
+	user := auth.UserFromContext(r.Context())
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return uuid.Nil, uuid.Nil, false
+	}
+	a, err := h.store.ResolveFile(r.Context(), user.ID, id)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return uuid.Nil, uuid.Nil, false
+	}
+	if a.OwnerID != user.ID {
+		response.Error(w, http.StatusForbidden, "only the owner can manage sharing")
+		return uuid.Nil, uuid.Nil, false
+	}
+	return id, user.ID, true
+}
+
+func userFrom(r *http.Request) uuid.UUID {
+	if u := auth.UserFromContext(r.Context()); u != nil {
+		return u.ID
+	}
+	return uuid.Nil
+}
+
+type grantRequest struct {
+	SubjectID   string     `json:"subject_id"`
+	SubjectType string     `json:"subject_type"` // "user" | "group"
+	Permission  Permission `json:"permission"`
+}
+
+// GET /api/v1/folders/{id}/acl
+func (h *Handler) ListFolderACL(w http.ResponseWriter, r *http.Request) {
+	id, _, ok := h.ownedFolder(w, r)
+	if !ok {
+		return
+	}
+	entries, err := h.store.ListForFolder(r.Context(), id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load shares")
+		return
+	}
+	response.JSON(w, http.StatusOK, entries)
+}
+
+// POST /api/v1/folders/{id}/acl
+func (h *Handler) GrantFolderACL(w http.ResponseWriter, r *http.Request) {
+	id, owner, ok := h.ownedFolder(w, r)
+	if !ok {
+		return
+	}
+	req, ok := decodeGrant(w, r)
+	if !ok {
+		return
+	}
+	entry, err := h.store.GrantFolder(r.Context(), id, req.subjectID, req.isGroup, req.perm, owner)
+	if err == nil {
+		h.logShare(r, audit.ActionShareGrant, "folder", id.String(),
+			string(req.perm)+" for "+req.subjectType()+" "+req.subjectID.String())
+	}
+	writeGrantResult(w, entry, err)
+}
+
+// GET /api/v1/files/{id}/acl
+func (h *Handler) ListFileACL(w http.ResponseWriter, r *http.Request) {
+	id, _, ok := h.ownedFile(w, r)
+	if !ok {
+		return
+	}
+	entries, err := h.store.ListForFile(r.Context(), id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load shares")
+		return
+	}
+	response.JSON(w, http.StatusOK, entries)
+}
+
+// POST /api/v1/files/{id}/acl
+func (h *Handler) GrantFileACL(w http.ResponseWriter, r *http.Request) {
+	id, owner, ok := h.ownedFile(w, r)
+	if !ok {
+		return
+	}
+	req, ok := decodeGrant(w, r)
+	if !ok {
+		return
+	}
+	entry, err := h.store.GrantFile(r.Context(), id, req.subjectID, req.isGroup, req.perm, owner)
+	if err == nil {
+		h.logShare(r, audit.ActionShareGrant, "file", id.String(),
+			string(req.perm)+" for "+req.subjectType()+" "+req.subjectID.String())
+	}
+	writeGrantResult(w, entry, err)
+}
+
+// DELETE /api/v1/acl/{id}
+func (h *Handler) RevokeACL(w http.ResponseWriter, r *http.Request) {
+	user := userFrom(r)
+	if user == uuid.Nil {
+		response.Error(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	entryID, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid id")
+		return
+	}
+	if err := h.store.Revoke(r.Context(), entryID, user); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "share not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not revoke share")
+		return
+	}
+	h.logShare(r, audit.ActionShareRevoke, "acl", entryID.String(), "")
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// GET /api/v1/shared-with-me
+func (h *Handler) SharedWithMe(w http.ResponseWriter, r *http.Request) {
+	user := userFrom(r)
+	if user == uuid.Nil {
+		response.Error(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	items, err := h.store.ListSharedWith(r.Context(), user)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load shared items")
+		return
+	}
+	response.JSON(w, http.StatusOK, items)
+}
+
+// GET /api/v1/share-recipients
+func (h *Handler) Recipients(w http.ResponseWriter, r *http.Request) {
+	user := userFrom(r)
+	if user == uuid.Nil {
+		response.Error(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	list, err := h.store.Recipients(r.Context(), user)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load recipients")
+		return
+	}
+	response.JSON(w, http.StatusOK, list)
+}
+
+// ── Hilfen ───────────────────────────────────────────────────────────────────
+
+type parsedGrant struct {
+	subjectID uuid.UUID
+	isGroup   bool
+	perm      Permission
+}
+
+func (g parsedGrant) subjectType() string { return subjectTypeName(g.isGroup) }
+
+func decodeGrant(w http.ResponseWriter, r *http.Request) (parsedGrant, bool) {
+	var body grantRequest
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid request body")
+		return parsedGrant{}, false
+	}
+	id, err := uuid.Parse(body.SubjectID)
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid subject_id")
+		return parsedGrant{}, false
+	}
+	if body.SubjectType != "user" && body.SubjectType != "group" {
+		response.Error(w, http.StatusBadRequest, `subject_type must be "user" or "group"`)
+		return parsedGrant{}, false
+	}
+	if !body.Permission.valid() {
+		response.Error(w, http.StatusBadRequest, `permission must be "read" or "write"`)
+		return parsedGrant{}, false
+	}
+	return parsedGrant{subjectID: id, isGroup: body.SubjectType == "group", perm: body.Permission}, true
+}
+
+func writeGrantResult(w http.ResponseWriter, entry *Entry, err error) {
+	switch {
+	case errors.Is(err, ErrSelfShare):
+		response.Error(w, http.StatusBadRequest, "you already have access to this")
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "could not share")
+	default:
+		response.JSON(w, http.StatusCreated, entry)
+	}
+}
diff --git a/backend/internal/acl/store.go b/backend/internal/acl/store.go
new file mode 100644
index 0000000..06574aa
--- /dev/null
+++ b/backend/internal/acl/store.go
@@ -0,0 +1,288 @@
+package acl
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+)
+
+var ErrSelfShare = errors.New("cannot share with yourself")
+
+// Entry ist eine Freigabe, wie sie der Eigentümer im Dialog sieht.
+type Entry struct {
+	ID          uuid.UUID  `json:"id"`
+	SubjectType string     `json:"subject_type"` // "user" | "group"
+	SubjectID   uuid.UUID  `json:"subject_id"`
+	SubjectName string     `json:"subject_name"`
+	Permission  Permission `json:"permission"`
+	CreatedAt   time.Time  `json:"created_at"`
+}
+
+// SharedResource ist ein Eintrag in „Geteilt mit mir".
+type SharedResource struct {
+	Type       string     `json:"type"` // "folder" | "file"
+	ID         uuid.UUID  `json:"id"`
+	Name       string     `json:"name"`
+	OwnerID    uuid.UUID  `json:"owner_id"`
+	OwnerName  string     `json:"owner_name"`
+	Permission Permission `json:"permission"`
+	Size       int64      `json:"size"`
+	MimeType   string     `json:"mime_type"`
+	SharedAt   time.Time  `json:"shared_at"`
+	// ViaGroup nennt die Gruppe, über die der Zugriff kommt – sonst wundert
+	// man sich, wo die Freigabe herkommt, die man nie persönlich bekommen hat.
+	ViaGroup string `json:"via_group"`
+}
+
+// ── Freigaben verwalten ──────────────────────────────────────────────────────
+
+// GrantFolder gibt einen Ordner frei. subjectIsGroup entscheidet, ob subjectID
+// ein Nutzer oder eine Gruppe ist.
+func (s *Store) GrantFolder(ctx context.Context, folderID, subjectID uuid.UUID, subjectIsGroup bool, perm Permission, grantedBy uuid.UUID) (*Entry, error) {
+	return s.grant(ctx, &folderID, nil, subjectID, subjectIsGroup, perm, grantedBy)
+}
+
+func (s *Store) GrantFile(ctx context.Context, fileID, subjectID uuid.UUID, subjectIsGroup bool, perm Permission, grantedBy uuid.UUID) (*Entry, error) {
+	return s.grant(ctx, nil, &fileID, subjectID, subjectIsGroup, perm, grantedBy)
+}
+
+func (s *Store) grant(ctx context.Context, folderID, fileID *uuid.UUID, subjectID uuid.UUID, subjectIsGroup bool, perm Permission, grantedBy uuid.UUID) (*Entry, error) {
+	if !perm.valid() {
+		return nil, fmt.Errorf("invalid permission %q", perm)
+	}
+	// Sich selbst freigeben ist sinnlos und würde in „Geteilt mit mir" die
+	// eigenen Ordner doppelt anzeigen.
+	if !subjectIsGroup && subjectID == grantedBy {
+		return nil, ErrSelfShare
+	}
+
+	var subjUser, subjGroup *uuid.UUID
+	if subjectIsGroup {
+		subjGroup = &subjectID
+	} else {
+		subjUser = &subjectID
+	}
+
+	var e Entry
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO acl_entries
+		   (subject_user_id, subject_group_id, resource_folder_id, resource_file_id, permission, granted_by)
+		 VALUES ($1, $2, $3, $4, $5, $6)
+		 RETURNING id, permission, created_at`,
+		subjUser, subjGroup, folderID, fileID, perm, grantedBy,
+	).Scan(&e.ID, &e.Permission, &e.CreatedAt)
+
+	// Eine zweite Freigabe an denselben Empfänger ist keine neue, sondern eine
+	// Änderung des Rechts – sonst müsste man erst widerrufen, um von „lesen"
+	// auf „schreiben" zu wechseln. Die vier partiellen Unique-Indizes lassen
+	// sich nicht in einer einzigen ON-CONFLICT-Klausel abdecken, deshalb hier
+	// über den Fehlercode.
+	var pgErr *pgconn.PgError
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
+		return s.updateExisting(ctx, folderID, fileID, subjUser, subjGroup, perm)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("grant access: %w", err)
+	}
+
+	e.SubjectID = subjectID
+	e.SubjectType = subjectTypeName(subjectIsGroup)
+	return &e, nil
+}
+
+func (s *Store) updateExisting(ctx context.Context, folderID, fileID, subjUser, subjGroup *uuid.UUID, perm Permission) (*Entry, error) {
+	var e Entry
+	err := s.db.QueryRow(ctx,
+		`UPDATE acl_entries SET permission = $1
+		  WHERE resource_folder_id IS NOT DISTINCT FROM $2
+		    AND resource_file_id   IS NOT DISTINCT FROM $3
+		    AND subject_user_id    IS NOT DISTINCT FROM $4
+		    AND subject_group_id   IS NOT DISTINCT FROM $5
+		 RETURNING id, permission, created_at`,
+		perm, folderID, fileID, subjUser, subjGroup,
+	).Scan(&e.ID, &e.Permission, &e.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("update access: %w", err)
+	}
+	if subjGroup != nil {
+		e.SubjectID, e.SubjectType = *subjGroup, "group"
+	} else if subjUser != nil {
+		e.SubjectID, e.SubjectType = *subjUser, "user"
+	}
+	return &e, nil
+}
+
+// Revoke entfernt eine Freigabe. ownerID stellt sicher, dass nur der
+// Eigentümer der Ressource widerrufen kann.
+func (s *Store) Revoke(ctx context.Context, entryID, ownerID uuid.UUID) error {
+	tag, err := s.db.Exec(ctx,
+		`DELETE FROM acl_entries e
+		  WHERE e.id = $1
+		    AND ( EXISTS (SELECT 1 FROM folders f WHERE f.id = e.resource_folder_id AND f.owner_id = $2)
+		       OR EXISTS (SELECT 1 FROM files   x WHERE x.id = e.resource_file_id   AND x.owner_id = $2) )`,
+		entryID, ownerID)
+	if err != nil {
+		return fmt.Errorf("revoke access: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// ListForFolder / ListForFile zeigen dem Eigentümer, wer aktuell Zugriff hat.
+func (s *Store) ListForFolder(ctx context.Context, folderID uuid.UUID) ([]Entry, error) {
+	return s.list(ctx, `e.resource_folder_id = $1`, folderID)
+}
+
+func (s *Store) ListForFile(ctx context.Context, fileID uuid.UUID) ([]Entry, error) {
+	return s.list(ctx, `e.resource_file_id = $1`, fileID)
+}
+
+func (s *Store) list(ctx context.Context, where string, resourceID uuid.UUID) ([]Entry, error) {
+	rows, err := s.db.Query(ctx, `
+		SELECT e.id,
+		       CASE WHEN e.subject_group_id IS NOT NULL THEN 'group' ELSE 'user' END,
+		       COALESCE(e.subject_group_id, e.subject_user_id),
+		       COALESCE(g.name, NULLIF(u.display_name, ''), u.username, ''),
+		       e.permission, e.created_at
+		  FROM acl_entries e
+		  LEFT JOIN users  u ON u.id = e.subject_user_id
+		  LEFT JOIN groups g ON g.id = e.subject_group_id
+		 WHERE `+where+`
+		 ORDER BY e.created_at`, resourceID)
+	if err != nil {
+		return nil, fmt.Errorf("list access entries: %w", err)
+	}
+	defer rows.Close()
+
+	out := []Entry{}
+	for rows.Next() {
+		var e Entry
+		if err := rows.Scan(&e.ID, &e.SubjectType, &e.SubjectID, &e.SubjectName,
+			&e.Permission, &e.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan access entry: %w", err)
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// ListSharedWith liefert alles, was userID freigegeben bekommen hat – direkt
+// oder über eine Gruppe. Das ist der Inhalt von „Geteilt mit mir".
+//
+// Nur die obersten freigegebenen Knoten erscheinen: Wer einen Ordner und darin
+// eine Datei freigegeben bekommt, soll den Ordner sehen und die Datei darin,
+// nicht beides nebeneinander.
+func (s *Store) ListSharedWith(ctx context.Context, userID uuid.UUID) ([]SharedResource, error) {
+	const q = `
+		SELECT 'folder', f.id, f.name, f.owner_id,
+		       COALESCE(NULLIF(o.display_name, ''), o.username),
+		       e.permission, 0::bigint, '', e.created_at,
+		       COALESCE(g.name, '')
+		  FROM acl_entries e
+		  JOIN folders f ON f.id = e.resource_folder_id
+		  JOIN users   o ON o.id = f.owner_id
+		  LEFT JOIN groups g ON g.id = e.subject_group_id
+		 WHERE (e.subject_user_id = $1
+		        OR e.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))
+		   -- Ordner weglassen, deren Elternteil ohnehin schon freigegeben ist.
+		   AND NOT EXISTS (
+		       SELECT 1
+		         FROM acl_entries pe
+		         JOIN folders pf ON pf.id = pe.resource_folder_id
+		        WHERE pf.id = f.parent_id
+		          AND (pe.subject_user_id = $1
+		               OR pe.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))
+		   )
+
+		UNION ALL
+
+		SELECT 'file', x.id, x.name, x.owner_id,
+		       COALESCE(NULLIF(o.display_name, ''), o.username),
+		       e.permission, x.size, x.mime_type, e.created_at,
+		       COALESCE(g.name, '')
+		  FROM acl_entries e
+		  JOIN files x ON x.id = e.resource_file_id
+		  JOIN users o ON o.id = x.owner_id
+		  LEFT JOIN groups g ON g.id = e.subject_group_id
+		 WHERE x.is_deleted = false
+		   AND (e.subject_user_id = $1
+		        OR e.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))
+		   -- Datei weglassen, wenn ihr Ordner bereits freigegeben ist.
+		   AND NOT EXISTS (
+		       SELECT 1
+		         FROM acl_entries fe
+		        WHERE fe.resource_folder_id = x.folder_id
+		          AND (fe.subject_user_id = $1
+		               OR fe.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))
+		   )
+
+		ORDER BY 1, 3`
+
+	rows, err := s.db.Query(ctx, q, userID)
+	if err != nil {
+		return nil, fmt.Errorf("list shared resources: %w", err)
+	}
+	defer rows.Close()
+
+	out := []SharedResource{}
+	for rows.Next() {
+		var r SharedResource
+		if err := rows.Scan(&r.Type, &r.ID, &r.Name, &r.OwnerID, &r.OwnerName,
+			&r.Permission, &r.Size, &r.MimeType, &r.SharedAt, &r.ViaGroup); err != nil {
+			return nil, fmt.Errorf("scan shared resource: %w", err)
+		}
+		out = append(out, r)
+	}
+	return out, rows.Err()
+}
+
+// ── Verzeichnis für den Freigabedialog ───────────────────────────────────────
+
+type Recipient struct {
+	ID   uuid.UUID `json:"id"`
+	Name string    `json:"name"`
+	Type string    `json:"type"` // "user" | "group"
+}
+
+// Recipients listet mögliche Empfänger. Bewusst nur ID, Anzeigename und Art –
+// Quota, Admin-Status und E-Mail gehen einen normalen Nutzer nichts an, auch
+// wenn er teilen darf.
+func (s *Store) Recipients(ctx context.Context, exclude uuid.UUID) ([]Recipient, error) {
+	rows, err := s.db.Query(ctx, `
+		SELECT id, COALESCE(NULLIF(display_name, ''), username), 'user'
+		  FROM users WHERE id <> $1
+		UNION ALL
+		SELECT id, name, 'group' FROM groups
+		 ORDER BY 3 DESC, 2`, exclude)
+	if err != nil {
+		return nil, fmt.Errorf("list recipients: %w", err)
+	}
+	defer rows.Close()
+
+	out := []Recipient{}
+	for rows.Next() {
+		var r Recipient
+		if err := rows.Scan(&r.ID, &r.Name, &r.Type); err != nil {
+			return nil, fmt.Errorf("scan recipient: %w", err)
+		}
+		out = append(out, r)
+	}
+	return out, rows.Err()
+}
+
+func subjectTypeName(isGroup bool) string {
+	if isGroup {
+		return "group"
+	}
+	return "user"
+}
diff --git a/backend/internal/admin/appicon.go b/backend/internal/admin/appicon.go
new file mode 100644
index 0000000..3922ff1
--- /dev/null
+++ b/backend/internal/admin/appicon.go
@@ -0,0 +1,142 @@
+package admin
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"image/color"
+	_ "image/gif"
+	_ "image/jpeg"
+	"image/png"
+	"io"
+
+	"golang.org/x/image/draw"
+	_ "golang.org/x/image/webp" // nur der Dekodierer – x/image ist schon da
+)
+
+// Aus einem einzigen hochgeladenen Bild entstehen alle Größen, die Browser und
+// Android brauchen. Zwei Bilder zu pflegen (Tab-Symbol und App-Symbol) war der
+// Grund, es zusammenzulegen.
+
+const (
+	// Chrome verweigert die Installation, wenn im Manifest kein Symbol von
+	// mindestens dieser Kantenlänge steht.
+	minIconSide = 192
+	// Der maskable-Bereich, den Android garantiert nicht wegschneidet: 80 % in
+	// der Mitte. Der Rest verschwindet je nach Gerät im Kreis oder Squircle.
+	maskableSafeZone = 0.8
+)
+
+// iconVariant beschreibt eine der erzeugten Dateien.
+type iconVariant struct {
+	// name ist der Dateiname im Symbol-Verzeichnis, ohne Endung.
+	name string
+	side int
+	// maskable legt das Motiv verkleinert auf einen farbigen Grund.
+	maskable bool
+}
+
+// renderAppIcon erzeugt aus der Vorlage die PNG-Dateien des Symbol-Satzes.
+// Der Schlüssel der Rückgabe ist der Dateiname inklusive Endung.
+//
+// Hochskaliert wird nie: Aus einer 256er-Vorlage ein 512er zu rechnen ergibt
+// ein matschiges Symbol, das schlechter aussieht als gar keins. Fehlt eine
+// Größe, nennt das Manifest sie einfach nicht.
+func renderAppIcon(src io.Reader, bg color.Color) (map[string][]byte, error) {
+	img, _, err := image.Decode(src)
+	if err != nil {
+		return nil, fmt.Errorf("decode image: %w", err)
+	}
+
+	// Nicht quadratische Vorlagen werden gerahmt, nicht beschnitten – ein
+	// Zuschnitt würde ein Logo anschneiden, und das fällt erst auf, wenn das
+	// Symbol schon überall klebt.
+	square := squareCanvas(img)
+	side := square.Bounds().Dx()
+	if side < minIconSide {
+		return nil, fmt.Errorf("image must be at least %dx%d pixels, got %dx%d",
+			minIconSide, minIconSide, img.Bounds().Dx(), img.Bounds().Dy())
+	}
+
+	variants := []iconVariant{
+		// 64 statt 32 fürs Tab: Auf feinen Bildschirmen wird das Symbol mit
+		// doppelter Pixeldichte gezeichnet.
+		{name: "64", side: 64},
+		{name: "192", side: 192},
+	}
+	if side >= 512 {
+		variants = append(variants, iconVariant{name: "512", side: 512})
+	}
+	maskSide := 192
+	if side >= 512 {
+		maskSide = 512
+	}
+	variants = append(variants, iconVariant{name: "maskable", side: maskSide, maskable: true})
+
+	out := make(map[string][]byte, len(variants))
+	for _, v := range variants {
+		buf, err := encodeVariant(square, v, bg)
+		if err != nil {
+			return nil, fmt.Errorf("render %s: %w", v.name, err)
+		}
+		out[v.name+".png"] = buf
+	}
+	return out, nil
+}
+
+func encodeVariant(square image.Image, v iconVariant, bg color.Color) ([]byte, error) {
+	dst := image.NewRGBA(image.Rect(0, 0, v.side, v.side))
+	target := dst.Bounds()
+
+	if v.maskable {
+		// Durchsichtig geht hier nicht: Android legt sonst eine weiße Kachel
+		// unter das Symbol, die im dunklen App-Menü leuchtet.
+		draw.Draw(dst, dst.Bounds(), image.NewUniform(bg), image.Point{}, draw.Src)
+		inset := int(float64(v.side) * (1 - maskableSafeZone) / 2)
+		target = image.Rect(inset, inset, v.side-inset, v.side-inset)
+	}
+
+	// CatmullRom statt des BiLinear aus internal/thumbnails: Vorschaubilder
+	// dürfen weich sein, ein Symbol soll scharfe Kanten behalten.
+	draw.CatmullRom.Scale(dst, target, square, square.Bounds(), draw.Over, nil)
+
+	var buf bytes.Buffer
+	// PNG, damit Transparenz erhalten bleibt – ein Symbol mit weißem Kasten
+	// drumherum sieht auf jedem farbigen Hintergrund falsch aus.
+	if err := png.Encode(&buf, dst); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// squareCanvas legt das Bild mittig auf eine quadratische, durchsichtige
+// Fläche. Ist es schon quadratisch, bleibt es unverändert.
+func squareCanvas(img image.Image) image.Image {
+	b := img.Bounds()
+	if b.Dx() == b.Dy() {
+		return img
+	}
+	side := b.Dx()
+	if b.Dy() > side {
+		side = b.Dy()
+	}
+	dst := image.NewRGBA(image.Rect(0, 0, side, side))
+	draw.Draw(dst, image.Rect(
+		(side-b.Dx())/2, (side-b.Dy())/2,
+		(side-b.Dx())/2+b.Dx(), (side-b.Dy())/2+b.Dy(),
+	), img, b.Min, draw.Src)
+	return dst
+}
+
+// parseHexColor liest "#rrggbb". Bei allem anderen kommt die Ersatzfarbe
+// zurück – eine kaputte Einstellung soll keinen Upload scheitern lassen.
+func parseHexColor(s string, fallback color.RGBA) color.RGBA {
+	if len(s) != 7 || s[0] != '#' {
+		return fallback
+	}
+	var r, g, b uint8
+	if _, err := fmt.Sscanf(s[1:], "%02x%02x%02x", &r, &g, &b); err != nil {
+		return fallback
+	}
+	return color.RGBA{R: r, G: g, B: b, A: 255}
+}
diff --git a/backend/internal/admin/appicon_test.go b/backend/internal/admin/appicon_test.go
new file mode 100644
index 0000000..14f9b61
--- /dev/null
+++ b/backend/internal/admin/appicon_test.go
@@ -0,0 +1,122 @@
+package admin
+
+import (
+	"bytes"
+	"image"
+	"image/color"
+	"image/png"
+	"testing"
+)
+
+func testImage(w, h int) []byte {
+	img := image.NewRGBA(image.Rect(0, 0, w, h))
+	for y := range h {
+		for x := range w {
+			img.Set(x, y, color.RGBA{R: 20, G: 180, B: 120, A: 255})
+		}
+	}
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, img); err != nil {
+		panic(err)
+	}
+	return buf.Bytes()
+}
+
+func decodeSize(t *testing.T, blob []byte) (int, int) {
+	t.Helper()
+	img, err := png.Decode(bytes.NewReader(blob))
+	if err != nil {
+		t.Fatalf("decode result: %v", err)
+	}
+	return img.Bounds().Dx(), img.Bounds().Dy()
+}
+
+var testBG = color.RGBA{R: 31, G: 107, B: 92, A: 255}
+
+func TestRenderAppIconSizes(t *testing.T) {
+	out, err := renderAppIcon(bytes.NewReader(testImage(1000, 1000)), testBG)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	for name, want := range map[string]int{
+		"64.png": 64, "192.png": 192, "512.png": 512, "maskable.png": 512,
+	} {
+		blob, ok := out[name]
+		if !ok {
+			t.Fatalf("%s missing", name)
+		}
+		if w, h := decodeSize(t, blob); w != want || h != want {
+			t.Errorf("%s: got %dx%d, want %dx%d", name, w, h, want, want)
+		}
+	}
+}
+
+// Aus einer kleinen Vorlage darf kein 512er entstehen – hochskaliert sähe es
+// schlechter aus als gar keins, und das Manifest nennt dann nur, was es gibt.
+func TestRenderAppIconNeverUpscales(t *testing.T) {
+	out, err := renderAppIcon(bytes.NewReader(testImage(256, 256)), testBG)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	if _, ok := out["512.png"]; ok {
+		t.Error("512.png was generated from a 256px source")
+	}
+	if w, _ := decodeSize(t, out["maskable.png"]); w != 192 {
+		t.Errorf("maskable: got %d, want 192", w)
+	}
+}
+
+func TestRenderAppIconRejectsSmall(t *testing.T) {
+	if _, err := renderAppIcon(bytes.NewReader(testImage(100, 100)), testBG); err == nil {
+		t.Fatal("expected an error for a 100px source")
+	}
+}
+
+// Nicht quadratische Vorlagen werden gerahmt, nicht beschnitten: Ein Zuschnitt
+// würde ein Logo anschneiden, und das fällt erst auf, wenn das Symbol klebt.
+func TestRenderAppIconFramesInsteadOfCropping(t *testing.T) {
+	out, err := renderAppIcon(bytes.NewReader(testImage(400, 150)), testBG)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	img, err := png.Decode(bytes.NewReader(out["192.png"]))
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	if _, _, _, a := img.At(96, 2).RGBA(); a != 0 {
+		t.Error("top edge should be transparent padding, not image content")
+	}
+	if _, g, _, a := img.At(96, 96).RGBA(); a == 0 || g>>8 < 150 {
+		t.Error("centre should carry the motif")
+	}
+}
+
+// Der maskable-Grund ist die Primärfarbe: Durchsichtig füllt Android mit Weiß,
+// und Weiß leuchtet im dunklen App-Menü.
+func TestRenderAppIconMaskableHasBackground(t *testing.T) {
+	out, err := renderAppIcon(bytes.NewReader(testImage(512, 512)), testBG)
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	img, err := png.Decode(bytes.NewReader(out["maskable.png"]))
+	if err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	r, g, b, a := img.At(2, 2).RGBA()
+	if a>>8 != 255 || r>>8 != 31 || g>>8 != 107 || b>>8 != 92 {
+		t.Errorf("corner: got %d,%d,%d,%d – want the background colour", r>>8, g>>8, b>>8, a>>8)
+	}
+}
+
+func TestParseHexColor(t *testing.T) {
+	fallback := color.RGBA{R: 1, G: 2, B: 3, A: 255}
+	if got := parseHexColor("#1f6b5c", fallback); got != (color.RGBA{R: 31, G: 107, B: 92, A: 255}) {
+		t.Errorf("valid colour: got %v", got)
+	}
+	// Eine kaputte Einstellung darf keinen Upload scheitern lassen.
+	for _, bad := range []string{"", "1f6b5c", "#xyz", "#1f6b5cff"} {
+		if got := parseHexColor(bad, fallback); got != fallback {
+			t.Errorf("%q: got %v, want the fallback", bad, got)
+		}
+	}
+}
diff --git a/backend/internal/admin/audit_handler.go b/backend/internal/admin/audit_handler.go
new file mode 100644
index 0000000..5b2a8ec
--- /dev/null
+++ b/backend/internal/admin/audit_handler.go
@@ -0,0 +1,99 @@
+package admin
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/google/uuid"
+
+	"aether/internal/audit"
+	"aether/pkg/response"
+)
+
+// Die Audit-Endpunkte liegen im admin-Paket, nicht in audit: `auth` schreibt
+// selbst Einträge und importiert deshalb `audit` – läge der Handler dort und
+// bräuchte `auth` für die Admin-Prüfung, wäre der Import-Zyklus fertig.
+
+// GET /api/v1/admin/audit?action=&actor_id=&limit=&offset=
+func (h *Handler) ListAudit(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+
+	f := audit.Filter{Action: r.URL.Query().Get("action")}
+
+	if raw := r.URL.Query().Get("actor_id"); raw != "" {
+		id, err := uuid.Parse(raw)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid actor_id")
+			return
+		}
+		f.ActorID = &id
+	}
+	if raw := r.URL.Query().Get("limit"); raw != "" {
+		f.Limit, _ = strconv.Atoi(raw)
+	}
+	if raw := r.URL.Query().Get("offset"); raw != "" {
+		f.Offset, _ = strconv.Atoi(raw)
+	}
+
+	entries, total, err := h.auditor.List(r.Context(), f)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load audit log")
+		return
+	}
+	response.JSON(w, http.StatusOK, map[string]any{
+		"entries": entries,
+		"total":   total,
+	})
+}
+
+// GET /api/v1/admin/audit/actions – füttert das Filter-Dropdown.
+func (h *Handler) ListAuditActions(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	actions, err := h.auditor.Actions(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load actions")
+		return
+	}
+	response.JSON(w, http.StatusOK, actions)
+}
+
+// POST /api/v1/admin/gc – Bereinigung von Hand anstoßen.
+//
+// Der GC läuft ohnehin im Hintergrund; dieser Endpunkt macht ihn beobachtbar.
+// Ein Aufräumjob, dessen Wirkung man nicht nachsehen kann, ist schwer zu
+// vertrauen – und genau darum geht es hier, weil er Dateien löscht.
+func (h *Handler) RunGC(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	if h.gc == nil {
+		response.Error(w, http.StatusServiceUnavailable, "cleanup not available")
+		return
+	}
+
+	res, err := h.gc.Run(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "cleanup failed")
+		return
+	}
+
+	h.logAdmin(r, audit.ActionGarbageCollect, "storage", "", "",
+		fmt.Sprintf("manual run: %d blobs scanned, %d removed, %d bytes freed",
+			res.Scanned, res.Deleted, res.FreedBytes))
+
+	response.JSON(w, http.StatusOK, map[string]any{
+		"scanned":       res.Scanned,
+		"orphans":       res.Orphans,
+		"deleted":       res.Deleted,
+		"freed_bytes":   res.FreedBytes,
+		"skipped_young": res.SkippedYoung,
+	})
+}
diff --git a/backend/internal/admin/branding_handler.go b/backend/internal/admin/branding_handler.go
new file mode 100644
index 0000000..f7b0981
--- /dev/null
+++ b/backend/internal/admin/branding_handler.go
@@ -0,0 +1,416 @@
+package admin
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"image/color"
+	"io"
+	"net/http"
+	"path"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/audit"
+	"aether/internal/storage"
+	"aether/pkg/response"
+)
+
+// Bild-Upload für den Admin-Bereich: Logo und App-Symbol.
+//
+// Das Logo ist ein einzelnes Blob. Das App-Symbol ist ein Verzeichnis mit
+// mehreren Größen, die beim Hochladen aus einer Vorlage entstehen – ein Upload
+// deckt damit Tab-Symbol und installierte App zugleich ab.
+
+const (
+	logoSettingKey    = "logo_storage_key"
+	appIconSettingKey = "app_icon_storage_key"
+	// Genug Bytes, damit http.DetectContentType sicher entscheidet.
+	sniffLen = 512
+	// 2 MiB – ein Logo, das größer ist, ist kein Logo. Fürs App-Symbol gilt
+	// dieselbe Grenze: Die Vorlage darf großzügig sein, ausgeliefert werden
+	// ohnehin nur die gerechneten Größen.
+	maxBrandingBytes = 2 << 20
+	humanMaxSize     = "2 MB"
+	humanTypes       = "a PNG, JPEG, WebP or GIF image"
+)
+
+// Erlaubte Bildformate. SVG fehlt bewusst: Eine SVG-Datei darf Skripte
+// enthalten, und beide Bilder werden ohne Anmeldung ausgeliefert – also genau
+// dort, wo noch niemand angemeldet ist. Ein Rasterbild kann das nicht.
+//
+// ICO fehlt ebenfalls: Go bringt keinen Dekodierer mit, und ohne Dekodieren
+// lassen sich keine Größen rechnen.
+var allowedImageTypes = map[string]string{
+	"image/png":  ".png",
+	"image/jpeg": ".jpg",
+	"image/webp": ".webp",
+	"image/gif":  ".gif",
+}
+
+// Die Dateien, aus denen ein Symbol-Satz besteht. renderAppIcon legt sie an –
+// welche davon wirklich entstehen, hängt von der Größe der Vorlage ab.
+var iconSizes = []string{"64", "192", "512", "maskable"}
+
+// ── Logo ─────────────────────────────────────────────────────────────────────
+
+// POST /api/v1/admin/branding/logo  (multipart, Feld "file")
+func (h *Handler) UploadLogo(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	data, ext, ok := readUpload(w, r, "logo")
+	if !ok {
+		return
+	}
+
+	suffix := randomSuffix()
+	if suffix == "" {
+		response.Error(w, http.StatusInternalServerError, "could not store the logo")
+		return
+	}
+	newKey := "branding/logo-" + suffix + ext
+
+	settings, _ := h.store.GetAllSettings(r.Context())
+	oldKey := settings[logoSettingKey]
+
+	if _, _, err := h.storage.Put(r.Context(), newKey, bytes.NewReader(data)); err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not store the logo")
+		return
+	}
+	if err := h.store.SetSetting(r.Context(), logoSettingKey, newKey); err != nil {
+		// Ohne Eintrag zeigt niemand auf das Blob – wieder wegräumen.
+		_ = h.storage.Delete(r.Context(), newKey)
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Erst jetzt das alte Logo entfernen: Wäre es vorher weg und der neue
+	// Eintrag scheiterte, stünde man ganz ohne da.
+	if oldKey != "" && oldKey != newKey {
+		if err := h.storage.Delete(r.Context(), oldKey); err != nil {
+			log.Ctx(r.Context()).Warn().Err(err).Str("key", oldKey).
+				Msg("previous logo could not be removed")
+		}
+	}
+
+	h.logAdmin(r, audit.ActionSettingsUpdate, "settings", "", "", "logo uploaded")
+	response.JSON(w, http.StatusOK, map[string]string{"url": LogoURL(newKey)})
+}
+
+// DELETE /api/v1/admin/branding/logo
+func (h *Handler) DeleteLogo(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	settings, _ := h.store.GetAllSettings(r.Context())
+	key := settings[logoSettingKey]
+	if key == "" {
+		w.WriteHeader(http.StatusNoContent)
+		return
+	}
+	if err := h.store.SetSetting(r.Context(), logoSettingKey, ""); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if err := h.storage.Delete(r.Context(), key); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Str("key", key).Msg("logo blob not removed")
+	}
+	h.logAdmin(r, audit.ActionSettingsUpdate, "settings", "", "", "logo removed")
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// ServeLogo liefert das Logo ohne Anmeldung aus – die Anmeldeseite braucht es,
+// und dort ist noch niemand angemeldet.
+func (h *Handler) ServeLogo(w http.ResponseWriter, r *http.Request) {
+	settings, err := h.store.GetAllSettings(r.Context())
+	if err != nil {
+		http.NotFound(w, r)
+		return
+	}
+	key := settings[logoSettingKey]
+	if key == "" {
+		http.NotFound(w, r)
+		return
+	}
+	mime := "application/octet-stream"
+	for m, ext := range allowedImageTypes {
+		if path.Ext(key) == ext {
+			mime = m
+			break
+		}
+	}
+	h.serveBlob(w, r, key, mime)
+}
+
+// ── App-Symbol ───────────────────────────────────────────────────────────────
+
+// POST /api/v1/admin/branding/icon  (multipart, Feld "file")
+//
+// Aus der Vorlage entstehen alle Größen auf einmal. Ein zweites Feld für das
+// Tab-Symbol gibt es bewusst nicht – zwei Bilder zu pflegen, die dasselbe
+// zeigen sollen, laufen mit der Zeit auseinander.
+func (h *Handler) UploadAppIcon(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	data, _, ok := readUpload(w, r, "app icon")
+	if !ok {
+		return
+	}
+
+	settings, _ := h.store.GetAllSettings(r.Context())
+	// Der maskable-Grund nimmt die eingestellte Primärfarbe: Weiß leuchtet im
+	// dunklen App-Menü, und durchsichtig füllt Android selbst mit Weiß.
+	bg := parseHexColor(settings["primary_color"], color.RGBA{R: 0x63, G: 0x66, B: 0xf1, A: 255})
+
+	variants, err := renderAppIcon(bytes.NewReader(data), bg)
+	if err != nil {
+		// Zu klein oder unlesbar – beides ist eine Sache des Absenders, keine
+		// des Servers, und die Meldung sagt welche.
+		response.Error(w, http.StatusUnprocessableEntity, err.Error())
+		return
+	}
+
+	suffix := randomSuffix()
+	if suffix == "" {
+		response.Error(w, http.StatusInternalServerError, "could not store the app icon")
+		return
+	}
+	newDir := "branding/icon-" + suffix + "/"
+	oldDir := settings[appIconSettingKey]
+
+	for name, blob := range variants {
+		if _, _, err := h.storage.Put(r.Context(), newDir+name, bytes.NewReader(blob)); err != nil {
+			// Halbe Sätze sind wertlos: was schon liegt, wieder wegräumen.
+			h.removeIconDir(r, newDir)
+			response.Error(w, http.StatusInternalServerError, "could not store the app icon")
+			return
+		}
+	}
+
+	if err := h.store.SetSetting(r.Context(), appIconSettingKey, newDir); err != nil {
+		h.removeIconDir(r, newDir)
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	if oldDir != "" && oldDir != newDir {
+		h.removeIconDir(r, oldDir)
+	}
+
+	h.logAdmin(r, audit.ActionSettingsUpdate, "settings", "", "",
+		fmt.Sprintf("app icon uploaded (%d sizes)", len(variants)))
+	response.JSON(w, http.StatusOK, map[string]string{"url": AppIconURL(newDir, "192")})
+}
+
+// DELETE /api/v1/admin/branding/icon
+func (h *Handler) DeleteAppIcon(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	settings, _ := h.store.GetAllSettings(r.Context())
+	dir := settings[appIconSettingKey]
+	if dir == "" {
+		w.WriteHeader(http.StatusNoContent)
+		return
+	}
+	if err := h.store.SetSetting(r.Context(), appIconSettingKey, ""); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.removeIconDir(r, dir)
+	h.logAdmin(r, audit.ActionSettingsUpdate, "settings", "", "", "app icon removed")
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// ServeAppIcon liefert eine Größe des Symbol-Satzes aus – ohne Anmeldung, der
+// Browser fragt das Tab-Symbol vor dem Anmelden ab.
+func (h *Handler) ServeAppIcon(w http.ResponseWriter, r *http.Request) {
+	size := chi.URLParam(r, "size")
+	if !validIconSize(size) {
+		http.NotFound(w, r)
+		return
+	}
+	settings, err := h.store.GetAllSettings(r.Context())
+	if err != nil {
+		http.NotFound(w, r)
+		return
+	}
+	dir := settings[appIconSettingKey]
+	if dir == "" {
+		http.NotFound(w, r)
+		return
+	}
+	h.serveBlob(w, r, dir+size+".png", "image/png")
+}
+
+// removeIconDir räumt ein Symbol-Verzeichnis samt Verzeichnis selbst weg.
+// Einzelne Dateien zu löschen reichte nicht: Der leere Ordner bliebe stehen,
+// bei jedem Austausch einer mehr – und der GC sähe ihn nie, weil er nur
+// Dateien betrachtet.
+//
+// Fehler werden nur vermerkt: Ein Rest auf der Platte ist unschön, aber kein
+// Grund, dem Admin einen erfolgreichen Upload als fehlgeschlagen zu melden.
+func (h *Handler) removeIconDir(r *http.Request, dir string) {
+	if dir == "" || !strings.HasPrefix(dir, "branding/icon-") {
+		// Ein Präfix, das nicht danach aussieht, wird nicht angefasst –
+		// DeletePrefix löscht rekursiv, da will man sich nicht vertippen.
+		log.Ctx(r.Context()).Warn().Str("dir", dir).Msg("refusing to remove unexpected icon dir")
+		return
+	}
+	if err := h.storage.DeletePrefix(r.Context(), dir); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Str("dir", dir).Msg("app icon dir not removed")
+	}
+}
+
+// ── Gemeinsames ──────────────────────────────────────────────────────────────
+
+// readUpload liest das hochgeladene Bild vollständig ein und prüft Größe und
+// Format. Vollständig deshalb, weil das App-Symbol ohnehin dekodiert werden
+// muss – bei höchstens 2 MiB ist das unproblematisch.
+func readUpload(w http.ResponseWriter, r *http.Request, what string) ([]byte, string, bool) {
+	r.Body = http.MaxBytesReader(w, r.Body, maxBrandingBytes+1024)
+	file, _, err := r.FormFile("file")
+	if err != nil {
+		// MaxBytesReader schlägt schon beim Zerlegen des Formulars zu. Ohne
+		// diese Unterscheidung bekäme man bei einer zu großen Datei die Meldung
+		// „kein Bild gefunden" und suchte den Fehler an der falschen Stelle.
+		var tooLarge *http.MaxBytesError
+		if errors.As(err, &tooLarge) {
+			response.Error(w, http.StatusRequestEntityTooLarge,
+				fmt.Sprintf("%s must be %s or smaller", what, humanMaxSize))
+			return nil, "", false
+		}
+		response.Error(w, http.StatusBadRequest, "expected an image in the 'file' field")
+		return nil, "", false
+	}
+	defer file.Close()
+
+	data, err := io.ReadAll(io.LimitReader(file, maxBrandingBytes+1))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "could not read the image")
+		return nil, "", false
+	}
+	if int64(len(data)) > maxBrandingBytes {
+		response.Error(w, http.StatusRequestEntityTooLarge,
+			fmt.Sprintf("%s must be %s or smaller", what, humanMaxSize))
+		return nil, "", false
+	}
+
+	// Den Typ aus dem Inhalt bestimmen, nicht aus dem Dateinamen oder dem
+	// mitgeschickten Content-Type – beides kann der Client frei behaupten.
+	head := data
+	if len(head) > sniffLen {
+		head = head[:sniffLen]
+	}
+	mime := strings.Split(http.DetectContentType(head), ";")[0]
+	ext, ok := allowedImageTypes[mime]
+	if !ok {
+		response.Error(w, http.StatusUnsupportedMediaType,
+			fmt.Sprintf("%s must be %s", what, humanTypes))
+		return nil, "", false
+	}
+	return data, ext, true
+}
+
+// serveBlob liefert ein Branding-Blob aus.
+func (h *Handler) serveBlob(w http.ResponseWriter, r *http.Request, key, mime string) {
+	// Nur unterhalb von branding/ – der Schlüssel kommt zwar aus den
+	// Einstellungen, aber die Prüfung kostet nichts und schließt aus, dass eine
+	// verbogene Zeile eine fremde Datei ausliefert.
+	if !strings.HasPrefix(key, "branding/") {
+		http.NotFound(w, r)
+		return
+	}
+	rc, err := h.storage.Get(r.Context(), key)
+	if err != nil {
+		http.NotFound(w, r)
+		return
+	}
+	defer rc.Close()
+
+	w.Header().Set("Content-Type", mime)
+	// Kein Erraten des Typs im Browser – zusammen mit dem SVG-Verbot schließt
+	// das aus, dass ein hochgeladenes Bild als etwas Ausführbares gedeutet wird.
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	// Der Pfad enthält einen Zufallsanteil, der sich bei jedem Austausch
+	// ändert – deshalb darf lange zwischengespeichert werden.
+	w.Header().Set("Cache-Control", "public, max-age=604800")
+	_, _ = io.Copy(w, rc)
+}
+
+func randomSuffix() string {
+	b := make([]byte, 6)
+	if _, err := rand.Read(b); err != nil {
+		return ""
+	}
+	return hex.EncodeToString(b)
+}
+
+func validIconSize(size string) bool {
+	for _, s := range iconSizes {
+		if s == size {
+			return true
+		}
+	}
+	return false
+}
+
+// AvailableIconSizes nennt die Größen, die für den hinterlegten Symbol-Satz
+// wirklich auf der Platte liegen. Aus einer kleinen Vorlage entsteht kein
+// 512er, und das Manifest darf nichts nennen, was es nicht gibt.
+func (h *Handler) AvailableIconSizes(r *http.Request, dir string) []string {
+	if dir == "" {
+		return nil
+	}
+	found := map[string]bool{}
+	err := h.storage.Walk(r.Context(), dir, func(key string, _ storage.FileInfo) error {
+		found[strings.TrimSuffix(path.Base(key), ".png")] = true
+		return nil
+	})
+	if err != nil {
+		return nil
+	}
+	// Reihenfolge aus iconSizes, nicht die der Platte – im Manifest sollen die
+	// Größen aufsteigend stehen.
+	var sizes []string
+	for _, s := range iconSizes {
+		if found[s] {
+			sizes = append(sizes, s)
+		}
+	}
+	return sizes
+}
+
+// LogoURL baut die öffentliche Adresse des Logos.
+func LogoURL(storageKey string) string {
+	if storageKey == "" {
+		return ""
+	}
+	return "/branding/logo?v=" + version(storageKey)
+}
+
+// AppIconURL baut die öffentliche Adresse einer Symbol-Größe.
+func AppIconURL(dir, size string) string {
+	if dir == "" {
+		return ""
+	}
+	return "/branding/icon/" + size + "?v=" + version(dir)
+}
+
+// version ist der Zufallsanteil aus dem Speicherschlüssel. Er hängt an jeder
+// Adresse, damit ein Austausch sofort sichtbar wird – Browser halten gerade
+// Tab-Symbole sonst hartnäckig fest.
+func version(storageKey string) string {
+	base := path.Base(strings.TrimSuffix(storageKey, "/"))
+	return strings.TrimSuffix(base, path.Ext(base))
+}
diff --git a/backend/internal/admin/groupfolder_handler.go b/backend/internal/admin/groupfolder_handler.go
new file mode 100644
index 0000000..8ce8f73
--- /dev/null
+++ b/backend/internal/admin/groupfolder_handler.go
@@ -0,0 +1,115 @@
+package admin
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/audit"
+	"aether/internal/files"
+	"aether/pkg/response"
+)
+
+// Gruppenordner werden ausschließlich hier verwaltet. Bewusst nicht in der
+// Dateiansicht: Ein Gruppenordner gehört keinem der Mitglieder, also soll ihn
+// auch keines von ihnen entfernen können.
+
+// GET /api/v1/admin/group-folders
+func (h *Handler) ListGroupFolders(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	list, err := h.files.ListGroupFolders(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load group folders")
+		return
+	}
+	response.JSON(w, http.StatusOK, list)
+}
+
+// POST /api/v1/admin/group-folders
+func (h *Handler) CreateGroupFolder(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	var body struct {
+		GroupID string `json:"group_id"`
+		Name    string `json:"name"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	groupID, err := uuid.Parse(body.GroupID)
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid group_id")
+		return
+	}
+	// Gleiche Namensregeln wie überall – der Name wird Teil des Ablagepfads.
+	name := files.SanitizeFilename(strings.TrimSpace(body.Name))
+	if name == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+
+	folder, err := h.files.CreateGroupFolder(r.Context(), groupID, name)
+	if errors.Is(err, files.ErrGroupFolderExists) {
+		response.Error(w, http.StatusConflict, "this group already has a folder")
+		return
+	}
+	if errors.Is(err, files.ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "a folder with that name already exists")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not create group folder")
+		return
+	}
+
+	h.logAdmin(r, audit.ActionGroupFolderCreate, "folder", folder.ID.String(), folder.Name,
+		"group "+groupID.String())
+	response.JSON(w, http.StatusCreated, folder)
+}
+
+// DELETE /api/v1/admin/group-folders/{id}
+func (h *Handler) DeleteGroupFolder(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return
+	}
+
+	groupID, err := h.files.DeleteGroupFolderTree(r.Context(), id)
+	if errors.Is(err, files.ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "group folder not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not delete group folder")
+		return
+	}
+
+	// Speicher erst nach dem Datenbank-Commit, und am Stück statt Blob für
+	// Blob: Da eine Gruppe genau einen Ordner hat, ist `groups/<id>` exakt ihr
+	// Bereich – inklusive Papierkorb und Versionen. Einzeln gelöscht blieben
+	// leere Verzeichnisse zurück.
+	if err := h.storage.DeletePrefix(r.Context(), "groups/"+groupID.String()); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Str("group_id", groupID.String()).
+			Msg("group folder deleted but storage remains")
+	}
+
+	h.logAdmin(r, audit.ActionGroupFolderDelete, "folder", id.String(), "",
+		"group "+groupID.String()+" and all its files")
+	w.WriteHeader(http.StatusNoContent)
+}
diff --git a/backend/internal/admin/handler.go b/backend/internal/admin/handler.go
new file mode 100644
index 0000000..a076154
--- /dev/null
+++ b/backend/internal/admin/handler.go
@@ -0,0 +1,490 @@
+package admin
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/audit"
+	"aether/internal/auth"
+	"aether/internal/files"
+	"aether/internal/gc"
+	"aether/internal/storage"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+type Handler struct {
+	store   *Store
+	storage storage.Storage
+	auditor *audit.Logger
+	gc      *gc.Collector
+	files   *files.Store
+}
+
+func NewHandler(store *Store, st storage.Storage, auditor *audit.Logger, collector *gc.Collector, fileStore *files.Store) *Handler {
+	return &Handler{store: store, storage: st, auditor: auditor, gc: collector, files: fileStore}
+}
+
+// logAdmin schreibt einen Audit-Eintrag für eine Admin-Aktion. Bündelt das
+// Wiederkehrende (Handelnder, IP), damit die Aufrufstellen kurz bleiben.
+func (h *Handler) logAdmin(r *http.Request, action, targetType, targetID, targetName, detail string) {
+	actor := auth.UserFromContext(r.Context())
+	e := audit.Event{
+		Action:     action,
+		TargetType: targetType,
+		TargetID:   targetID,
+		TargetName: targetName,
+		Detail:     detail,
+		IP:         middleware.RealIP(r),
+	}
+	if actor != nil {
+		e.ActorID = &actor.ID
+		e.ActorName = actor.Username
+	}
+	h.auditor.Log(r.Context(), e)
+}
+
+// requireAdmin is called at the start of every handler — server-side check.
+func requireAdmin(r *http.Request) (*auth.User, bool) {
+	user := auth.UserFromContext(r.Context())
+	return user, user != nil && user.IsAdmin
+}
+
+// ── Users ─────────────────────────────────────────────────────────────────────
+
+// GET /api/v1/admin/users
+func (h *Handler) ListUsers(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	users, err := h.store.ListUsers(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, users)
+}
+
+// POST /api/v1/admin/users
+func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	var body struct {
+		Username    string `json:"username"`
+		DisplayName string `json:"display_name"`
+		Password    string `json:"password"`
+		IsAdmin     bool   `json:"is_admin"`
+		QuotaBytes  int64  `json:"quota_bytes"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	if strings.TrimSpace(body.Username) == "" || strings.TrimSpace(body.Password) == "" {
+		response.Error(w, http.StatusBadRequest, "username and password required")
+		return
+	}
+	if body.QuotaBytes <= 0 {
+		body.QuotaBytes = 10 << 30 // 10 GB default
+	}
+	hash, err := auth.HashPassword(body.Password)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "hash error")
+		return
+	}
+	user, err := h.store.CreateUser(r.Context(), strings.TrimSpace(body.Username), body.DisplayName, hash, body.IsAdmin, body.QuotaBytes)
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "username already taken")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionUserCreate, "user", user.ID.String(), user.Username,
+		fmt.Sprintf("admin=%t, quota=%d", body.IsAdmin, body.QuotaBytes))
+	response.JSON(w, http.StatusCreated, user)
+}
+
+// PATCH /api/v1/admin/users/{id}
+func (h *Handler) UpdateUser(w http.ResponseWriter, r *http.Request) {
+	caller, ok := requireAdmin(r)
+	if !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid user id")
+		return
+	}
+	var body struct {
+		DisplayName string `json:"display_name"`
+		IsAdmin     bool   `json:"is_admin"`
+		QuotaBytes  int64  `json:"quota_bytes"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	if body.QuotaBytes <= 0 {
+		body.QuotaBytes = 10 << 30
+	}
+	user, err := h.store.UpdateUser(r.Context(), id, body.DisplayName, body.IsAdmin, body.QuotaBytes, caller.ID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "user not found")
+		return
+	}
+	if errors.Is(err, ErrSelfDemote) {
+		response.Error(w, http.StatusBadRequest, "cannot remove your own admin status")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionUserUpdate, "user", user.ID.String(), user.Username,
+		fmt.Sprintf("admin=%t, quota=%d", body.IsAdmin, body.QuotaBytes))
+	response.JSON(w, http.StatusOK, user)
+}
+
+// POST /api/v1/admin/users/{id}/reset-password
+func (h *Handler) ResetPassword(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid user id")
+		return
+	}
+
+	// Accept explicit password or generate a random one.
+	var body struct {
+		Password string `json:"password"`
+	}
+	_ = json.NewDecoder(r.Body).Decode(&body)
+
+	newPassword := strings.TrimSpace(body.Password)
+	if newPassword == "" {
+		newPassword = randomPassword()
+	}
+
+	hash, err := auth.HashPassword(newPassword)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "hash error")
+		return
+	}
+	if err := h.store.ResetPassword(r.Context(), id, hash); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "user not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Protokolliert wird, DASS zurückgesetzt wurde – niemals das Passwort selbst.
+	h.logAdmin(r, audit.ActionUserPasswordReset, "user", id.String(), "", "")
+
+	// Return the new plain-text password to the admin (no email in this system).
+	response.JSON(w, http.StatusOK, map[string]string{"new_password": newPassword})
+}
+
+// DELETE /api/v1/admin/users/{id}
+func (h *Handler) DeleteUser(w http.ResponseWriter, r *http.Request) {
+	caller, ok := requireAdmin(r)
+	if !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid user id")
+		return
+	}
+	// Den Namen vor dem Löschen holen: danach lässt sich der Speicherbereich
+	// des Kontos nicht mehr ermitteln.
+	victim, err := h.store.GetUser(r.Context(), id)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "user not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	if err := h.store.DeleteUser(r.Context(), id, caller.ID); errors.Is(err, ErrSelfDemote) {
+		response.Error(w, http.StatusBadRequest, "cannot delete your own account")
+		return
+	} else if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "user not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Erst die Datenbank, dann die Dateien: Schlägt das Aufräumen fehl, bleiben
+	// höchstens Dateileichen zurück – umgekehrt hätte ein Konto ohne seine
+	// Dateien überlebt. Die Datenbankzeilen sind per Fremdschlüssel-Kaskade weg,
+	// es gibt also keinen Verweis mehr auf diese Blobs.
+	if victim.Username != "" {
+		if err := h.storage.DeletePrefix(r.Context(), "users/"+victim.Username); err != nil {
+			log.Ctx(r.Context()).Error().Err(err).
+				Str("username", victim.Username).
+				Msg("user deleted but their files could not be removed")
+		}
+	}
+
+	h.logAdmin(r, audit.ActionUserDelete, "user", id.String(), victim.Username,
+		"account and all files removed")
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// ── Groups ────────────────────────────────────────────────────────────────────
+
+// GET /api/v1/admin/groups
+func (h *Handler) ListGroups(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	groups, err := h.store.ListGroups(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, groups)
+}
+
+// POST /api/v1/admin/groups
+func (h *Handler) CreateGroup(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	var body struct {
+		Name        string `json:"name"`
+		Description string `json:"description"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Name) == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+	group, err := h.store.CreateGroup(r.Context(), strings.TrimSpace(body.Name), body.Description)
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "group name already taken")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionGroupCreate, "group", group.ID.String(), group.Name, "")
+	response.JSON(w, http.StatusCreated, group)
+}
+
+// PATCH /api/v1/admin/groups/{id}
+func (h *Handler) UpdateGroup(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid group id")
+		return
+	}
+	var body struct {
+		Name        string `json:"name"`
+		Description string `json:"description"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Name) == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+	group, err := h.store.UpdateGroup(r.Context(), id, strings.TrimSpace(body.Name), body.Description)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "group not found")
+		return
+	}
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "group name already taken")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionGroupUpdate, "group", group.ID.String(), group.Name, "")
+	response.JSON(w, http.StatusOK, group)
+}
+
+// DELETE /api/v1/admin/groups/{id}
+func (h *Handler) DeleteGroup(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid group id")
+		return
+	}
+	if err := h.store.DeleteGroup(r.Context(), id); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "group not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionGroupDelete, "group", id.String(), "", "")
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// GET /api/v1/admin/groups/{id}/members
+func (h *Handler) ListGroupMembers(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid group id")
+		return
+	}
+	members, err := h.store.ListGroupMembers(r.Context(), id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, members)
+}
+
+// POST /api/v1/admin/groups/{id}/members
+func (h *Handler) AddGroupMember(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	groupID, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid group id")
+		return
+	}
+	var body struct {
+		UserID uuid.UUID `json:"user_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.UserID == uuid.Nil {
+		response.Error(w, http.StatusBadRequest, "user_id required")
+		return
+	}
+	if err := h.store.AddGroupMember(r.Context(), groupID, body.UserID); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionGroupMemberAdd, "group", groupID.String(), "",
+		"user "+body.UserID.String())
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// DELETE /api/v1/admin/groups/{id}/members/{userId}
+func (h *Handler) RemoveGroupMember(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	groupID, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid group id")
+		return
+	}
+	userID, err := uuid.Parse(chi.URLParam(r, "userId"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid user id")
+		return
+	}
+	if err := h.store.RemoveGroupMember(r.Context(), groupID, userID); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logAdmin(r, audit.ActionGroupMemberRemove, "group", groupID.String(), "",
+		"user "+userID.String())
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// ── Settings ──────────────────────────────────────────────────────────────────
+
+// GET /api/v1/admin/settings
+func (h *Handler) GetSettings(w http.ResponseWriter, r *http.Request) {
+	// Settings are readable by all authenticated users (needed for theming).
+	if auth.UserFromContext(r.Context()) == nil {
+		response.Error(w, http.StatusUnauthorized, "unauthorized")
+		return
+	}
+	settings, err := h.store.GetAllSettings(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, settings)
+}
+
+// PATCH /api/v1/admin/settings
+func (h *Handler) UpdateSettings(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireAdmin(r); !ok {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	var body map[string]string
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+
+	allowed := map[string]bool{
+		"cloud_name": true, "primary_color": true, "accent_color": true,
+	}
+	changed := []string{}
+	for k, v := range body {
+		if !allowed[k] {
+			continue
+		}
+		if err := h.store.SetSetting(r.Context(), k, v); err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+		changed = append(changed, k+"="+v)
+	}
+	if len(changed) > 0 {
+		sort.Strings(changed) // Map-Reihenfolge ist zufällig – sonst wäre das Protokoll unruhig.
+		h.logAdmin(r, audit.ActionSettingsUpdate, "settings", "", "", strings.Join(changed, ", "))
+	}
+	settings, _ := h.store.GetAllSettings(r.Context())
+	response.JSON(w, http.StatusOK, settings)
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+func randomPassword() string {
+	b := make([]byte, 12)
+	_, _ = rand.Read(b)
+	return hex.EncodeToString(b)
+}
diff --git a/backend/internal/admin/manifest_handler.go b/backend/internal/admin/manifest_handler.go
new file mode 100644
index 0000000..8bd4125
--- /dev/null
+++ b/backend/internal/admin/manifest_handler.go
@@ -0,0 +1,95 @@
+package admin
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// Das Web-App-Manifest kommt aus der Datenbank statt aus dem Build. Vorher
+// stand es fest in vite.config.ts und zeigte auf drei mitgelieferte Dateien –
+// ein hochgeladenes Symbol konnte die installierte App also nie erreichen.
+
+// Die mitgelieferten Symbole aus frontend/public/, wenn keins hinterlegt ist.
+var builtinIcons = []manifestIcon{
+	{Src: "/icon-192.png", Sizes: "192x192", Type: "image/png"},
+	{Src: "/icon-512.png", Sizes: "512x512", Type: "image/png"},
+	{Src: "/icon-maskable-512.png", Sizes: "512x512", Type: "image/png", Purpose: "maskable"},
+}
+
+type manifestIcon struct {
+	Src   string `json:"src"`
+	Sizes string `json:"sizes"`
+	Type  string `json:"type"`
+	// Purpose bleibt bei "any" leer – das ist die Vorgabe, und ein leeres Feld
+	// ist im Manifest weniger missverständlich als ein ausgeschriebenes "any".
+	Purpose string `json:"purpose,omitempty"`
+}
+
+// ServeManifest liefert /manifest.webmanifest. Ohne Anmeldung: Der Browser
+// holt es, bevor irgendjemand angemeldet ist.
+func (h *Handler) ServeManifest(w http.ResponseWriter, r *http.Request) {
+	name := "Aether"
+	themeColor := "#6366f1"
+	var iconDir string
+
+	if s, err := h.store.GetAllSettings(r.Context()); err == nil {
+		if n := s["cloud_name"]; n != "" {
+			name = n
+		}
+		if c := s["primary_color"]; c != "" {
+			themeColor = c
+		}
+		iconDir = s[appIconSettingKey]
+	}
+
+	icons := builtinIcons
+	if sizes := h.AvailableIconSizes(r, iconDir); len(sizes) > 0 {
+		icons = nil
+		for _, size := range sizes {
+			// Das 64er ist das Tab-Symbol. Android will mindestens 192 und
+			// wertet kleinere Einträge nur als Ballast.
+			if size == "64" {
+				continue
+			}
+			icon := manifestIcon{Src: AppIconURL(iconDir, size), Type: "image/png"}
+			if size == "maskable" {
+				icon.Purpose = "maskable"
+				icon.Sizes = maskableSizeOf(sizes)
+			} else {
+				icon.Sizes = size + "x" + size
+			}
+			icons = append(icons, icon)
+		}
+	}
+
+	manifest := map[string]any{
+		"name":             name,
+		"short_name":       name,
+		"description":      "Your self-hosted cloud",
+		"theme_color":      themeColor,
+		"background_color": "#0f172a",
+		"display":          "standalone",
+		"start_url":        "/",
+		"scope":            "/",
+		"lang":             "de",
+		"icons":            icons,
+	}
+
+	w.Header().Set("Content-Type", "application/manifest+json")
+	// Die Symbole darin dürfen lange zwischengespeichert werden, die Liste
+	// selbst nicht: Sonst bekäme der Browser einen Symbolwechsel tagelang nicht
+	// mit, und genau darauf wartet die installierte App.
+	w.Header().Set("Cache-Control", "no-cache")
+	_ = json.NewEncoder(w).Encode(manifest)
+}
+
+// maskableSizeOf nennt die Kantenlänge der maskable-Fassung. Sie entsteht in
+// 512, sobald die Vorlage das hergibt – sonst in 192.
+func maskableSizeOf(sizes []string) string {
+	for _, s := range sizes {
+		if s == "512" {
+			return "512x512"
+		}
+	}
+	return "192x192"
+}
diff --git a/backend/internal/admin/model.go b/backend/internal/admin/model.go
new file mode 100644
index 0000000..250ed5b
--- /dev/null
+++ b/backend/internal/admin/model.go
@@ -0,0 +1,41 @@
+package admin
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type User struct {
+	ID          uuid.UUID `json:"id"`
+	Username    string    `json:"username"`
+	DisplayName string    `json:"display_name"`
+	IsAdmin     bool      `json:"is_admin"`
+	QuotaBytes  int64     `json:"quota_bytes"`
+	UsedBytes   int64     `json:"used_bytes"`
+	// Groups sind die Namen der Gruppen, in denen der Nutzer Mitglied ist –
+	// damit die Benutzerliste die Zugehörigkeit zeigt, ohne pro Zeile
+	// nachladen zu müssen.
+	Groups    []string  `json:"groups"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+type Group struct {
+	ID          uuid.UUID `json:"id"`
+	Name        string    `json:"name"`
+	Description string    `json:"description"`
+	MemberCount int       `json:"member_count"`
+	CreatedAt   time.Time `json:"created_at"`
+}
+
+type GroupMember struct {
+	UserID      uuid.UUID `json:"user_id"`
+	Username    string    `json:"username"`
+	DisplayName string    `json:"display_name"`
+	JoinedAt    time.Time `json:"joined_at"`
+}
+
+type Setting struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
diff --git a/backend/internal/admin/store.go b/backend/internal/admin/store.go
new file mode 100644
index 0000000..26d1897
--- /dev/null
+++ b/backend/internal/admin/store.go
@@ -0,0 +1,297 @@
+package admin
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("not found")
+var ErrNameTaken = errors.New("name already taken")
+var ErrSelfDemote = errors.New("cannot remove own admin status")
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store {
+	return &Store{db: db}
+}
+
+// ── Users ─────────────────────────────────────────────────────────────────────
+
+func (s *Store) ListUsers(ctx context.Context) ([]*User, error) {
+	rows, err := s.db.Query(ctx,
+		// Die Gruppen kommen als Unterabfrage, nicht als weiterer JOIN: ein JOIN
+		// würde die Zeilen vervielfachen und damit die Summe der Dateigrößen
+		// verfälschen.
+		`SELECT u.id, u.username, u.display_name, u.is_admin, u.quota_bytes,
+		        COALESCE(SUM(f.size) FILTER (WHERE f.is_deleted = false), 0) AS used_bytes,
+		        COALESCE((SELECT array_agg(g.name ORDER BY g.name)
+		                    FROM group_members gm
+		                    JOIN groups g ON g.id = gm.group_id
+		                   WHERE gm.user_id = u.id), '{}') AS groups,
+		        u.created_at
+		 FROM users u
+		 LEFT JOIN files f ON f.owner_id = u.id
+		 GROUP BY u.id
+		 ORDER BY u.created_at ASC`,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list users: %w", err)
+	}
+	defer rows.Close()
+	users := make([]*User, 0)
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes, &u.UsedBytes, &u.Groups, &u.CreatedAt); err != nil {
+			return nil, err
+		}
+		users = append(users, &u)
+	}
+	return users, rows.Err()
+}
+
+func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (*User, error) {
+	var u User
+	err := s.db.QueryRow(ctx,
+		`SELECT u.id, u.username, u.display_name, u.is_admin, u.quota_bytes,
+		        COALESCE(SUM(f.size) FILTER (WHERE f.is_deleted = false), 0) AS used_bytes,
+		        u.created_at
+		 FROM users u
+		 LEFT JOIN files f ON f.owner_id = u.id
+		 WHERE u.id = $1
+		 GROUP BY u.id`,
+		id,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes, &u.UsedBytes, &u.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &u, err
+}
+
+func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string, isAdmin bool, quotaBytes int64) (*User, error) {
+	var u User
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO users (username, display_name, password, is_admin, quota_bytes)
+		 VALUES ($1, $2, $3, $4, $5)
+		 RETURNING id, username, display_name, is_admin, quota_bytes, 0, created_at`,
+		username, displayName, passwordHash, isAdmin, quotaBytes,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes, &u.UsedBytes, &u.CreatedAt)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("create user: %w", err)
+	}
+	return &u, nil
+}
+
+func (s *Store) UpdateUser(ctx context.Context, id uuid.UUID, displayName string, isAdmin bool, quotaBytes int64, callerID uuid.UUID) (*User, error) {
+	// Prevent admin from removing their own admin flag.
+	if id == callerID && !isAdmin {
+		return nil, ErrSelfDemote
+	}
+	var u User
+	err := s.db.QueryRow(ctx,
+		`UPDATE users SET display_name=$2, is_admin=$3, quota_bytes=$4
+		 WHERE id=$1
+		 RETURNING id, username, display_name, is_admin, quota_bytes, created_at`,
+		id, displayName, isAdmin, quotaBytes,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes, &u.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &u, err
+}
+
+func (s *Store) ResetPassword(ctx context.Context, id uuid.UUID, newHash string) error {
+	tag, err := s.db.Exec(ctx,
+		`UPDATE users SET password=$2 WHERE id=$1`, id, newHash)
+	if err != nil {
+		return fmt.Errorf("reset password: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+func (s *Store) DeleteUser(ctx context.Context, id, callerID uuid.UUID) error {
+	if id == callerID {
+		return ErrSelfDemote
+	}
+	tag, err := s.db.Exec(ctx, `DELETE FROM users WHERE id=$1`, id)
+	if err != nil {
+		return fmt.Errorf("delete user: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// ── Groups ────────────────────────────────────────────────────────────────────
+
+func (s *Store) ListGroups(ctx context.Context) ([]*Group, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT g.id, g.name, g.description,
+		        COUNT(gm.user_id) AS member_count,
+		        g.created_at
+		 FROM groups g
+		 LEFT JOIN group_members gm ON gm.group_id = g.id
+		 GROUP BY g.id
+		 ORDER BY g.name`,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list groups: %w", err)
+	}
+	defer rows.Close()
+	groups := make([]*Group, 0)
+	for rows.Next() {
+		var g Group
+		if err := rows.Scan(&g.ID, &g.Name, &g.Description, &g.MemberCount, &g.CreatedAt); err != nil {
+			return nil, err
+		}
+		groups = append(groups, &g)
+	}
+	return groups, rows.Err()
+}
+
+func (s *Store) CreateGroup(ctx context.Context, name, description string) (*Group, error) {
+	var g Group
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO groups (name, description)
+		 VALUES ($1, $2)
+		 RETURNING id, name, description, 0, created_at`,
+		name, description,
+	).Scan(&g.ID, &g.Name, &g.Description, &g.MemberCount, &g.CreatedAt)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("create group: %w", err)
+	}
+	return &g, nil
+}
+
+// UpdateGroup ändert Name und Beschreibung einer Gruppe.
+func (s *Store) UpdateGroup(ctx context.Context, id uuid.UUID, name, description string) (*Group, error) {
+	var g Group
+	err := s.db.QueryRow(ctx,
+		`UPDATE groups SET name=$2, description=$3
+		 WHERE id=$1
+		 RETURNING id, name, description,
+		           (SELECT COUNT(*) FROM group_members WHERE group_id = groups.id),
+		           created_at`,
+		id, name, description,
+	).Scan(&g.ID, &g.Name, &g.Description, &g.MemberCount, &g.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("update group: %w", err)
+	}
+	return &g, nil
+}
+
+func (s *Store) DeleteGroup(ctx context.Context, id uuid.UUID) error {
+	tag, err := s.db.Exec(ctx, `DELETE FROM groups WHERE id=$1`, id)
+	if err != nil {
+		return err
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+func (s *Store) ListGroupMembers(ctx context.Context, groupID uuid.UUID) ([]*GroupMember, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT u.id, u.username, u.display_name, gm.joined_at
+		 FROM group_members gm
+		 JOIN users u ON u.id = gm.user_id
+		 WHERE gm.group_id = $1
+		 ORDER BY u.username`,
+		groupID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list members: %w", err)
+	}
+	defer rows.Close()
+	members := make([]*GroupMember, 0)
+	for rows.Next() {
+		var m GroupMember
+		if err := rows.Scan(&m.UserID, &m.Username, &m.DisplayName, &m.JoinedAt); err != nil {
+			return nil, err
+		}
+		members = append(members, &m)
+	}
+	return members, rows.Err()
+}
+
+func (s *Store) AddGroupMember(ctx context.Context, groupID, userID uuid.UUID) error {
+	_, err := s.db.Exec(ctx,
+		`INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
+		 ON CONFLICT DO NOTHING`,
+		groupID, userID,
+	)
+	return err
+}
+
+func (s *Store) RemoveGroupMember(ctx context.Context, groupID, userID uuid.UUID) error {
+	_, err := s.db.Exec(ctx,
+		`DELETE FROM group_members WHERE group_id=$1 AND user_id=$2`,
+		groupID, userID,
+	)
+	return err
+}
+
+// ── Settings ──────────────────────────────────────────────────────────────────
+
+func (s *Store) GetAllSettings(ctx context.Context) (map[string]string, error) {
+	rows, err := s.db.Query(ctx, `SELECT key, value FROM settings`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	result := make(map[string]string)
+	for rows.Next() {
+		var k, v string
+		if err := rows.Scan(&k, &v); err != nil {
+			return nil, err
+		}
+		result[k] = v
+	}
+	return result, rows.Err()
+}
+
+func (s *Store) SetSetting(ctx context.Context, key, value string) error {
+	_, err := s.db.Exec(ctx,
+		`INSERT INTO settings (key, value) VALUES ($1, $2)
+		 ON CONFLICT (key) DO UPDATE SET value=EXCLUDED.value, updated_at=NOW()`,
+		key, value,
+	)
+	return err
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+func isUniqueViolation(err error) bool {
+	if err == nil {
+		return false
+	}
+	type sqlStater interface{ SQLState() string }
+	var se sqlStater
+	if errors.As(err, &se) {
+		return se.SQLState() == "23505"
+	}
+	return false
+}
diff --git a/backend/internal/audit/audit.go b/backend/internal/audit/audit.go
new file mode 100644
index 0000000..2cec0cc
--- /dev/null
+++ b/backend/internal/audit/audit.go
@@ -0,0 +1,207 @@
+// Package audit protokolliert sicherheitsrelevante Vorgänge.
+//
+// Leitgedanke: Ein Audit-Eintrag ist nur so viel wert, wie er nach einem
+// Vorfall noch aussagt. Deshalb werden Namen mitgeschrieben statt nur IDs, und
+// das Protokollieren darf die eigentliche Aktion niemals scheitern lassen –
+// ein kaputtes Log ist ärgerlich, eine deswegen abgebrochene Anmeldung wäre
+// schlimmer.
+package audit
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/rs/zerolog/log"
+)
+
+// Actions – als Konstanten, damit Filter und Schreiber nicht auseinanderlaufen.
+const (
+	ActionLogin          = "auth.login"
+	ActionLoginFailed    = "auth.login_failed"
+	ActionLogout         = "auth.logout"
+	ActionPasswordChange = "auth.password_change"
+
+	ActionAppPasswordCreate = "app_password.create"
+	ActionAppPasswordRevoke = "app_password.revoke"
+
+	ActionUserCreate        = "admin.user_create"
+	ActionUserUpdate        = "admin.user_update"
+	ActionUserDelete        = "admin.user_delete"
+	ActionUserPasswordReset = "admin.user_password_reset"
+
+	ActionGroupCreate       = "admin.group_create"
+	ActionGroupUpdate       = "admin.group_update"
+	ActionGroupDelete       = "admin.group_delete"
+	ActionGroupMemberAdd    = "admin.group_member_add"
+	ActionGroupMemberRemove = "admin.group_member_remove"
+
+	ActionSettingsUpdate = "admin.settings_update"
+
+	ActionGroupFolderCreate = "admin.group_folder_create"
+	ActionGroupFolderDelete = "admin.group_folder_delete"
+
+	ActionShareCreate = "share.create"
+	ActionShareDelete = "share.delete"
+	ActionShareGrant  = "share.grant"
+	ActionShareRevoke = "share.revoke"
+
+	ActionFileDelete  = "file.delete"
+	ActionTrashEmpty  = "file.trash_empty"
+	ActionHardDelete  = "file.hard_delete"
+	ActionFileRestore = "file.restore"
+
+	ActionGarbageCollect = "system.gc"
+)
+
+// Entry ist ein Eintrag, wie ihn die Admin-Ansicht liest.
+type Entry struct {
+	ID         uuid.UUID  `json:"id"`
+	ActorID    *uuid.UUID `json:"actor_id"`
+	ActorName  string     `json:"actor_name"`
+	Action     string     `json:"action"`
+	TargetType *string    `json:"target_type"`
+	TargetID   *string    `json:"target_id"`
+	TargetName *string    `json:"target_name"`
+	IP         *string    `json:"ip"`
+	Detail     *string    `json:"detail"`
+	CreatedAt  time.Time  `json:"created_at"`
+}
+
+// Event beschreibt einen zu protokollierenden Vorgang.
+type Event struct {
+	ActorID    *uuid.UUID
+	ActorName  string
+	Action     string
+	TargetType string
+	TargetID   string
+	TargetName string
+	IP         string
+	Detail     string
+}
+
+type Logger struct {
+	db *pgxpool.Pool
+}
+
+func NewLogger(db *pgxpool.Pool) *Logger {
+	return &Logger{db: db}
+}
+
+// Log schreibt einen Eintrag. Fehler werden geloggt, nicht zurückgegeben: der
+// Aufrufer soll seine Aktion nicht abbrechen, nur weil das Protokoll klemmt.
+//
+// Bewusst mit eigenem Kontext: bei einem abgebrochenen Request (Client weg,
+// Timeout) ist der Vorgang trotzdem passiert und gehört ins Protokoll.
+func (l *Logger) Log(ctx context.Context, e Event) {
+	if l == nil || l.db == nil {
+		return
+	}
+
+	writeCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
+	defer cancel()
+
+	_, err := l.db.Exec(writeCtx,
+		`INSERT INTO audit_log
+		   (actor_id, actor_name, action, target_type, target_id, target_name, ip, detail)
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+		e.ActorID, e.ActorName, e.Action,
+		nullIfEmpty(e.TargetType), nullIfEmpty(e.TargetID), nullIfEmpty(e.TargetName),
+		nullIfEmpty(e.IP), nullIfEmpty(e.Detail),
+	)
+	if err != nil {
+		log.Ctx(ctx).Error().Err(err).
+			Str("action", e.Action).
+			Str("actor", e.ActorName).
+			Msg("audit: could not write entry")
+	}
+}
+
+// Filter für die Admin-Ansicht.
+type Filter struct {
+	Action  string
+	ActorID *uuid.UUID
+	Limit   int
+	Offset  int
+}
+
+const (
+	defaultLimit = 100
+	maxLimit     = 500
+)
+
+// List liefert Einträge, neueste zuerst, plus die Gesamtzahl für die
+// Blätterfunktion.
+func (l *Logger) List(ctx context.Context, f Filter) ([]Entry, int, error) {
+	limit := f.Limit
+	if limit <= 0 {
+		limit = defaultLimit
+	}
+	if limit > maxLimit {
+		limit = maxLimit
+	}
+
+	var total int
+	if err := l.db.QueryRow(ctx,
+		`SELECT count(*) FROM audit_log
+		  WHERE ($1 = '' OR action = $1)
+		    AND ($2::uuid IS NULL OR actor_id = $2)`,
+		f.Action, f.ActorID,
+	).Scan(&total); err != nil {
+		return nil, 0, fmt.Errorf("count audit entries: %w", err)
+	}
+
+	rows, err := l.db.Query(ctx,
+		`SELECT id, actor_id, actor_name, action, target_type, target_id,
+		        target_name, ip, detail, created_at
+		   FROM audit_log
+		  WHERE ($1 = '' OR action = $1)
+		    AND ($2::uuid IS NULL OR actor_id = $2)
+		  ORDER BY created_at DESC
+		  LIMIT $3 OFFSET $4`,
+		f.Action, f.ActorID, limit, f.Offset)
+	if err != nil {
+		return nil, 0, fmt.Errorf("query audit entries: %w", err)
+	}
+	defer rows.Close()
+
+	entries := []Entry{}
+	for rows.Next() {
+		var e Entry
+		if err := rows.Scan(&e.ID, &e.ActorID, &e.ActorName, &e.Action,
+			&e.TargetType, &e.TargetID, &e.TargetName, &e.IP, &e.Detail, &e.CreatedAt); err != nil {
+			return nil, 0, fmt.Errorf("scan audit entry: %w", err)
+		}
+		entries = append(entries, e)
+	}
+	return entries, total, rows.Err()
+}
+
+// Actions listet die tatsächlich vorkommenden Aktionen – füttert das
+// Filter-Dropdown, damit dort nichts steht, was es im Protokoll gar nicht gibt.
+func (l *Logger) Actions(ctx context.Context) ([]string, error) {
+	rows, err := l.db.Query(ctx, `SELECT DISTINCT action FROM audit_log ORDER BY action`)
+	if err != nil {
+		return nil, fmt.Errorf("query audit actions: %w", err)
+	}
+	defer rows.Close()
+
+	out := []string{}
+	for rows.Next() {
+		var a string
+		if err := rows.Scan(&a); err != nil {
+			return nil, fmt.Errorf("scan audit action: %w", err)
+		}
+		out = append(out, a)
+	}
+	return out, rows.Err()
+}
+
+func nullIfEmpty(s string) *string {
+	if s == "" {
+		return nil
+	}
+	return &s
+}
diff --git a/backend/internal/auth/apppassword.go b/backend/internal/auth/apppassword.go
new file mode 100644
index 0000000..3a57360
--- /dev/null
+++ b/backend/internal/auth/apppassword.go
@@ -0,0 +1,264 @@
+package auth
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/subtle"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+
+	"aether/internal/audit"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+// App-Passwörter ersetzen das Hauptpasswort in WebDAV-Clients. Ein verlorenes
+// Handy kostet dann ein Token, nicht das Konto – und der Widerruf trifft nur
+// dieses eine Gerät.
+
+const (
+	appPasswordGroups   = 5
+	appPasswordGroupLen = 5
+	// Ohne 0/1/l/o/i – auf einem Handy-Keyboard abgetippt sind die zu leicht
+	// zu verwechseln.
+	appPasswordAlphabet = "abcdefghjkmnpqrstuvwxyz23456789"
+	maxAppPasswords     = 20
+	// Schreiblast bremsen: WebDAV authentifiziert jeden Request einzeln, ein
+	// UPDATE pro Aufruf wäre reine Verschwendung.
+	lastUsedResolution = 5 * time.Minute
+)
+
+var ErrTooManyAppPasswords = errors.New("too many app passwords")
+
+type AppPassword struct {
+	ID         uuid.UUID  `json:"id"`
+	Name       string     `json:"name"`
+	LastUsedAt *time.Time `json:"last_used_at"`
+	CreatedAt  time.Time  `json:"created_at"`
+}
+
+// GenerateAppPassword liefert ein Token in Fünfergruppen (aaaaa-bbbbb-…),
+// damit es sich am Handy noch abtippen lässt.
+func GenerateAppPassword() (string, error) {
+	buf := make([]byte, appPasswordGroups*appPasswordGroupLen)
+	if _, err := rand.Read(buf); err != nil {
+		return "", fmt.Errorf("read random: %w", err)
+	}
+	var sb strings.Builder
+	for i, b := range buf {
+		if i > 0 && i%appPasswordGroupLen == 0 {
+			sb.WriteByte('-')
+		}
+		sb.WriteByte(appPasswordAlphabet[int(b)%len(appPasswordAlphabet)])
+	}
+	return sb.String(), nil
+}
+
+// HashAppPassword: SHA-256 genügt, weil das Token zufällig und hochentropisch
+// ist. Argon2 wäre hier nur langsam, nicht sicherer – und liefe bei WebDAV bei
+// jedem einzelnen Request.
+func HashAppPassword(token string) string {
+	sum := sha256.Sum256([]byte(strings.TrimSpace(token)))
+	return hex.EncodeToString(sum[:])
+}
+
+// ── Store ────────────────────────────────────────────────────────────────────
+
+func (s *Store) ListAppPasswords(ctx context.Context, userID uuid.UUID) ([]AppPassword, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT id, name, last_used_at, created_at
+		   FROM app_passwords WHERE user_id = $1 ORDER BY created_at DESC`,
+		userID)
+	if err != nil {
+		return nil, fmt.Errorf("query app passwords: %w", err)
+	}
+	defer rows.Close()
+
+	out := []AppPassword{}
+	for rows.Next() {
+		var a AppPassword
+		if err := rows.Scan(&a.ID, &a.Name, &a.LastUsedAt, &a.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan app password: %w", err)
+		}
+		out = append(out, a)
+	}
+	return out, rows.Err()
+}
+
+func (s *Store) CreateAppPassword(ctx context.Context, userID uuid.UUID, name, token string) (*AppPassword, error) {
+	var count int
+	if err := s.db.QueryRow(ctx,
+		`SELECT count(*) FROM app_passwords WHERE user_id = $1`, userID).Scan(&count); err != nil {
+		return nil, fmt.Errorf("count app passwords: %w", err)
+	}
+	if count >= maxAppPasswords {
+		return nil, ErrTooManyAppPasswords
+	}
+
+	var a AppPassword
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO app_passwords (user_id, name, token_hash)
+		 VALUES ($1, $2, $3)
+		 RETURNING id, name, last_used_at, created_at`,
+		userID, name, HashAppPassword(token),
+	).Scan(&a.ID, &a.Name, &a.LastUsedAt, &a.CreatedAt)
+	if err != nil {
+		return nil, fmt.Errorf("insert app password: %w", err)
+	}
+	return &a, nil
+}
+
+func (s *Store) DeleteAppPassword(ctx context.Context, userID, id uuid.UUID) error {
+	tag, err := s.db.Exec(ctx,
+		`DELETE FROM app_passwords WHERE id = $1 AND user_id = $2`, id, userID)
+	if err != nil {
+		return fmt.Errorf("delete app password: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// VerifyAppPassword sucht das Token über seinen Hash und gibt den zugehörigen
+// User zurück. Der Username muss passen, damit ein Token nicht für ein fremdes
+// Konto gilt.
+func (s *Store) VerifyAppPassword(ctx context.Context, username, token string) (*User, error) {
+	hash := HashAppPassword(token)
+
+	var u User
+	var storedHash string
+	var pwID uuid.UUID
+	var lastUsed *time.Time
+	err := s.db.QueryRow(ctx,
+		`SELECT ap.id, ap.token_hash, ap.last_used_at,
+		        u.id, u.username, u.display_name, u.is_admin, u.quota_bytes, u.created_at
+		   FROM app_passwords ap
+		   JOIN users u ON u.id = ap.user_id
+		  WHERE ap.token_hash = $1 AND u.username = $2`,
+		hash, username,
+	).Scan(&pwID, &storedHash, &lastUsed,
+		&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes, &u.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("query app password: %w", err)
+	}
+	// Gürtel und Hosenträger – der Vergleich lief schon in der Datenbank.
+	if subtle.ConstantTimeCompare([]byte(storedHash), []byte(hash)) != 1 {
+		return nil, ErrNotFound
+	}
+
+	if lastUsed == nil || time.Since(*lastUsed) > lastUsedResolution {
+		if _, err := s.db.Exec(ctx,
+			`UPDATE app_passwords SET last_used_at = now() WHERE id = $1`, pwID); err != nil {
+			return nil, fmt.Errorf("touch app password: %w", err)
+		}
+	}
+	return &u, nil
+}
+
+// ── Handlers ─────────────────────────────────────────────────────────────────
+
+// GET /api/v1/app-passwords
+func (h *Handler) ListAppPasswords(w http.ResponseWriter, r *http.Request) {
+	user := UserFromContext(r.Context())
+	list, err := h.store.ListAppPasswords(r.Context(), user.ID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load app passwords")
+		return
+	}
+	response.JSON(w, http.StatusOK, list)
+}
+
+// POST /api/v1/app-passwords
+func (h *Handler) CreateAppPassword(w http.ResponseWriter, r *http.Request) {
+	user := UserFromContext(r.Context())
+
+	var body struct {
+		Name string `json:"name"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	name := strings.TrimSpace(body.Name)
+	if name == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+	if len(name) > 60 {
+		name = name[:60]
+	}
+
+	token, err := GenerateAppPassword()
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not generate app password")
+		return
+	}
+
+	created, err := h.store.CreateAppPassword(r.Context(), user.ID, name, token)
+	if errors.Is(err, ErrTooManyAppPasswords) {
+		response.Error(w, http.StatusConflict, "app password limit reached")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not create app password")
+		return
+	}
+
+	h.auditor.Log(r.Context(), audit.Event{
+		ActorID:    &user.ID,
+		ActorName:  user.Username,
+		Action:     audit.ActionAppPasswordCreate,
+		TargetType: "app_password",
+		TargetID:   created.ID.String(),
+		TargetName: created.Name,
+		IP:         middleware.RealIP(r),
+	})
+
+	// Einziger Moment, in dem das Klartext-Token existiert – danach steht nur
+	// noch der Hash in der Datenbank.
+	response.JSON(w, http.StatusCreated, struct {
+		AppPassword
+		Password string `json:"password"`
+	}{AppPassword: *created, Password: token})
+}
+
+// DELETE /api/v1/app-passwords/{id}
+func (h *Handler) DeleteAppPassword(w http.ResponseWriter, r *http.Request) {
+	user := UserFromContext(r.Context())
+
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid id")
+		return
+	}
+	if err := h.store.DeleteAppPassword(r.Context(), user.ID, id); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "app password not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not revoke app password")
+		return
+	}
+	h.auditor.Log(r.Context(), audit.Event{
+		ActorID:    &user.ID,
+		ActorName:  user.Username,
+		Action:     audit.ActionAppPasswordRevoke,
+		TargetType: "app_password",
+		TargetID:   id.String(),
+		IP:         middleware.RealIP(r),
+	})
+	w.WriteHeader(http.StatusNoContent)
+}
diff --git a/backend/internal/auth/apppassword_test.go b/backend/internal/auth/apppassword_test.go
new file mode 100644
index 0000000..a424b26
--- /dev/null
+++ b/backend/internal/auth/apppassword_test.go
@@ -0,0 +1,66 @@
+package auth
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestGenerateAppPasswordFormat(t *testing.T) {
+	token, err := GenerateAppPassword()
+	if err != nil {
+		t.Fatalf("GenerateAppPassword: %v", err)
+	}
+
+	groups := strings.Split(token, "-")
+	if len(groups) != appPasswordGroups {
+		t.Fatalf("got %d groups, want %d (%q)", len(groups), appPasswordGroups, token)
+	}
+	for _, g := range groups {
+		if len(g) != appPasswordGroupLen {
+			t.Fatalf("group %q has length %d, want %d", g, len(g), appPasswordGroupLen)
+		}
+		for _, c := range g {
+			if !strings.ContainsRune(appPasswordAlphabet, c) {
+				t.Fatalf("character %q is outside the alphabet – hard to type on a phone", c)
+			}
+		}
+	}
+}
+
+func TestGenerateAppPasswordIsRandom(t *testing.T) {
+	seen := make(map[string]bool, 100)
+	for i := 0; i < 100; i++ {
+		token, err := GenerateAppPassword()
+		if err != nil {
+			t.Fatalf("GenerateAppPassword: %v", err)
+		}
+		if seen[token] {
+			t.Fatalf("duplicate token after %d draws: %q", i, token)
+		}
+		seen[token] = true
+	}
+}
+
+// Der Klartext darf nie gespeichert werden – gehasht wird deterministisch,
+// damit der Login ein reiner Index-Lookup bleibt.
+func TestHashAppPassword(t *testing.T) {
+	const token = "abcde-fghij-klmno-pqrst-uvwxy"
+
+	h := HashAppPassword(token)
+	if h == token || strings.Contains(h, token) {
+		t.Fatal("hash leaks the plaintext token")
+	}
+	if len(h) != 64 {
+		t.Fatalf("hash length = %d, want 64 hex chars", len(h))
+	}
+	if h != HashAppPassword(token) {
+		t.Fatal("hash is not deterministic")
+	}
+	if h == HashAppPassword("abcde-fghij-klmno-pqrst-uvwxz") {
+		t.Fatal("different tokens hash to the same value")
+	}
+	// Clients hängen beim Kopieren gern Whitespace an.
+	if h != HashAppPassword("  "+token+"\n") {
+		t.Fatal("surrounding whitespace changes the hash")
+	}
+}
diff --git a/backend/internal/auth/handler.go b/backend/internal/auth/handler.go
new file mode 100644
index 0000000..a122c38
--- /dev/null
+++ b/backend/internal/auth/handler.go
@@ -0,0 +1,266 @@
+package auth
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"aether/internal/audit"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+type Handler struct {
+	store    *Store
+	sessions *SessionStore
+	usage    UsageQuerier
+	auditor  *audit.Logger
+}
+
+func NewHandler(store *Store, sessions *SessionStore, usage UsageQuerier, auditor *audit.Logger) *Handler {
+	return &Handler{store: store, sessions: sessions, usage: usage, auditor: auditor}
+}
+
+type loginRequest struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// POST /api/v1/auth/login
+func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
+	var req loginRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	if req.Username == "" || req.Password == "" {
+		response.Error(w, http.StatusBadRequest, "username and password required")
+		return
+	}
+
+	user, hash, err := h.store.GetByUsername(r.Context(), req.Username)
+	if err != nil {
+		// constant-time: always hash even if user not found to prevent timing attacks
+		_, _ = VerifyPassword(req.Password, "$argon2id$v=19$m=65536,t=1,p=4$AAAAAAAAAAAAAAAAAAAAAA$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
+		h.auditor.Log(r.Context(), audit.Event{
+			ActorName: req.Username,
+			Action:    audit.ActionLoginFailed,
+			IP:        middleware.RealIP(r),
+			Detail:    "unknown account",
+		})
+		response.Error(w, http.StatusUnauthorized, "invalid credentials")
+		return
+	}
+
+	ok, err := VerifyPassword(req.Password, hash)
+	if err != nil || !ok {
+		h.auditor.Log(r.Context(), audit.Event{
+			ActorID:   &user.ID,
+			ActorName: user.Username,
+			Action:    audit.ActionLoginFailed,
+			IP:        middleware.RealIP(r),
+			Detail:    "wrong password",
+		})
+		response.Error(w, http.StatusUnauthorized, "invalid credentials")
+		return
+	}
+
+	if err := h.sessions.SetUser(w, r, user.ID); err != nil {
+		response.Error(w, http.StatusInternalServerError, "session error")
+		return
+	}
+
+	csrfToken, err := SetCSRFCookie(w, r)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "csrf error")
+		return
+	}
+
+	h.auditor.Log(r.Context(), audit.Event{
+		ActorID:   &user.ID,
+		ActorName: user.Username,
+		Action:    audit.ActionLogin,
+		IP:        middleware.RealIP(r),
+	})
+
+	// Denselben Wert wie /me mitgeben: Ohne ihn stand der Speicherbalken
+	// direkt nach der Anmeldung auf 0 B und sprang erst beim nächsten
+	// Nutzer-Abgleich auf den echten Stand.
+	if used, err := h.usage.UsedBytes(r.Context(), user.ID); err == nil {
+		user.UsedBytes = used
+	}
+
+	response.JSON(w, http.StatusOK, map[string]any{
+		"user":       user,
+		"csrf_token": csrfToken,
+	})
+}
+
+// POST /api/v1/auth/logout
+func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
+	// Die Route liegt bewusst nicht hinter RequireAuth – abmelden soll auch
+	// mit abgelaufener Sitzung klappen und nie mit 401 scheitern. Dadurch
+	// steht aber kein Nutzer im Kontext, und der Eintrag im Protokoll blieb
+	// bisher aus. Also hier selbst aus der Sitzung nachschlagen.
+	if userID, ok := h.sessions.GetUserID(r); ok {
+		name := ""
+		if u, err := h.store.GetByID(r.Context(), userID); err == nil {
+			name = u.Username
+		}
+		h.auditor.Log(r.Context(), audit.Event{
+			ActorID:   &userID,
+			ActorName: name,
+			Action:    audit.ActionLogout,
+			IP:        middleware.RealIP(r),
+		})
+	}
+	_ = h.sessions.Clear(w, r)
+	// clear CSRF cookie
+	http.SetCookie(w, &http.Cookie{
+		Name:   csrfCookieName,
+		Value:  "",
+		Path:   "/",
+		MaxAge: -1,
+	})
+	response.NoContent(w)
+}
+
+// PATCH /api/v1/auth/profile  – update own display_name
+// isHexColor lässt leere Werte zu – leer bedeutet "globale Farbe verwenden".
+func isHexColor(v string) bool {
+	if v == "" {
+		return true
+	}
+	if len(v) != 7 || v[0] != '#' {
+		return false
+	}
+	for _, c := range v[1:] {
+		if !strings.ContainsRune("0123456789abcdefABCDEF", c) {
+			return false
+		}
+	}
+	return true
+}
+
+func (h *Handler) UpdateProfile(w http.ResponseWriter, r *http.Request) {
+	user := UserFromContext(r.Context())
+	// Zeiger, damit sich "Feld nicht mitgeschickt" von "auf leer setzen"
+	// unterscheiden lässt: Der Profilname und die Farben werden getrennt
+	// gespeichert, sollen sich aber nicht gegenseitig überschreiben.
+	var body struct {
+		DisplayName    *string `json:"display_name"`
+		PrimaryColor   *string `json:"primary_color"`
+		AccentColor    *string `json:"accent_color"`
+		UseCustomTheme *bool   `json:"use_custom_theme"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+
+	if body.DisplayName != nil {
+		name := strings.TrimSpace(*body.DisplayName)
+		if err := h.store.UpdateDisplayName(r.Context(), user.ID, name); err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+		user.DisplayName = name
+	}
+
+	if body.PrimaryColor != nil || body.AccentColor != nil {
+		primary, accent := user.PrimaryColor, user.AccentColor
+		if body.PrimaryColor != nil {
+			primary = strings.TrimSpace(*body.PrimaryColor)
+		}
+		if body.AccentColor != nil {
+			accent = strings.TrimSpace(*body.AccentColor)
+		}
+		if !isHexColor(primary) || !isHexColor(accent) {
+			response.Error(w, http.StatusBadRequest, "colors must be hex values like #4f46e5")
+			return
+		}
+		if err := h.store.UpdateColors(r.Context(), user.ID, primary, accent); err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+		user.PrimaryColor, user.AccentColor = primary, accent
+	}
+
+	if body.UseCustomTheme != nil {
+		if err := h.store.SetUseCustomTheme(r.Context(), user.ID, *body.UseCustomTheme); err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+		user.UseCustomTheme = *body.UseCustomTheme
+	}
+
+	response.JSON(w, http.StatusOK, user)
+}
+
+// POST /api/v1/auth/change-password
+func (h *Handler) ChangePassword(w http.ResponseWriter, r *http.Request) {
+	user := UserFromContext(r.Context())
+	var body struct {
+		CurrentPassword string `json:"current_password"`
+		NewPassword     string `json:"new_password"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.CurrentPassword == "" || body.NewPassword == "" {
+		response.Error(w, http.StatusBadRequest, "current_password and new_password required")
+		return
+	}
+	// Konten, die über den Identitätsanbieter kommen, haben hier kein Passwort.
+	// Der Aufruf scheitert ohnehin – '' ist kein gültiger Argon2-Hash –, aber
+	// mit „current password incorrect" statt mit dem wahren Grund. Diese
+	// Prüfung sagt, was los ist; die Oberfläche blendet das Formular
+	// zusätzlich aus.
+	if user.IsOIDC {
+		response.Error(w, http.StatusBadRequest,
+			"this account signs in through your identity provider — change the password there")
+		return
+	}
+
+	_, hash, err := h.store.GetByUsername(r.Context(), user.Username)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	ok, err := VerifyPassword(body.CurrentPassword, hash)
+	if err != nil || !ok {
+		response.Error(w, http.StatusUnauthorized, "current password incorrect")
+		return
+	}
+	newHash, err := HashPassword(body.NewPassword)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "hash error")
+		return
+	}
+	if err := h.store.UpdatePassword(r.Context(), user.ID, newHash); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.auditor.Log(r.Context(), audit.Event{
+		ActorID:   &user.ID,
+		ActorName: user.Username,
+		Action:    audit.ActionPasswordChange,
+		IP:        middleware.RealIP(r),
+	})
+	response.NoContent(w)
+}
+
+// GET /api/v1/auth/me
+func (h *Handler) Me(w http.ResponseWriter, r *http.Request) {
+	user := UserFromContext(r.Context())
+	if used, err := h.usage.UsedBytes(r.Context(), user.ID); err == nil {
+		user.UsedBytes = used
+	}
+	// Refresh CSRF token on each /me call so frontend always has a valid one.
+	csrfToken, err := SetCSRFCookie(w, r)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "csrf error")
+		return
+	}
+	response.JSON(w, http.StatusOK, map[string]any{
+		"user":       user,
+		"csrf_token": csrfToken,
+	})
+}
diff --git a/backend/internal/auth/middleware.go b/backend/internal/auth/middleware.go
new file mode 100644
index 0000000..7669887
--- /dev/null
+++ b/backend/internal/auth/middleware.go
@@ -0,0 +1,67 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+
+	"aether/pkg/response"
+)
+
+type contextKey int
+
+const keyUser contextKey = iota
+
+// RequireAuth loads the session user and injects it into context.
+// Returns 401 if not authenticated.
+func RequireAuth(ss *SessionStore, store *Store) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			id, ok := ss.GetUserID(r)
+			if !ok {
+				response.Error(w, http.StatusUnauthorized, "authentication required")
+				return
+			}
+			user, err := store.GetByID(r.Context(), id)
+			if err != nil {
+				response.Error(w, http.StatusUnauthorized, "authentication required")
+				return
+			}
+			ctx := context.WithValue(r.Context(), keyUser, user)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
+
+// RequireAdmin additionally checks that the user is an admin.
+func RequireAdmin(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		user := UserFromContext(r.Context())
+		if user == nil || !user.IsAdmin {
+			response.Error(w, http.StatusForbidden, "admin access required")
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// CSRF validates the double-submit CSRF token for state-changing requests.
+func CSRF(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodGet, http.MethodHead, http.MethodOptions:
+			next.ServeHTTP(w, r)
+			return
+		}
+		if !ValidateCSRF(r) {
+			response.Error(w, http.StatusForbidden, "invalid CSRF token")
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// UserFromContext retrieves the authenticated user from context (may be nil).
+func UserFromContext(ctx context.Context) *User {
+	u, _ := ctx.Value(keyUser).(*User)
+	return u
+}
diff --git a/backend/internal/auth/model.go b/backend/internal/auth/model.go
new file mode 100644
index 0000000..f0b2aac
--- /dev/null
+++ b/backend/internal/auth/model.go
@@ -0,0 +1,37 @@
+package auth
+
+import (
+	"context"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type User struct {
+	ID          uuid.UUID `json:"id"`
+	Username    string    `json:"username"`
+	DisplayName string    `json:"display_name"`
+	IsAdmin     bool      `json:"is_admin"`
+	QuotaBytes  int64     `json:"quota_bytes"`
+	UsedBytes   int64     `json:"used_bytes"`
+	// Persönliche Palette. Sie bleibt gespeichert, auch wenn UseCustomTheme
+	// aus ist – so kann man jederzeit umschalten, ohne sie neu zu wählen.
+	PrimaryColor   string `json:"primary_color"`
+	AccentColor    string `json:"accent_color"`
+	UseCustomTheme bool   `json:"use_custom_theme"`
+	// IsOIDC heißt: Dieses Konto meldet sich über den Identitätsanbieter an
+	// und hat hier gar kein Passwort (`password` steht auf ''). Die Oberfläche
+	// blendet die Passwortänderung dann aus – ein Formular, das nur
+	// fehlschlagen kann, ist schlimmer als keines.
+	//
+	// Nicht sicherheitsrelevant, sondern eine Auskunft: Anmeldung und
+	// Passwortänderung scheitern für solche Konten ohnehin schon daran, dass
+	// '' kein gültiger Argon2-Hash ist.
+	IsOIDC    bool      `json:"is_oidc"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// UsageQuerier is satisfied by files.Store – keeps auth ↔ files decoupled.
+type UsageQuerier interface {
+	UsedBytes(ctx context.Context, userID uuid.UUID) (int64, error)
+}
diff --git a/backend/internal/auth/oidclink_test.go b/backend/internal/auth/oidclink_test.go
new file mode 100644
index 0000000..67a3ad3
--- /dev/null
+++ b/backend/internal/auth/oidclink_test.go
@@ -0,0 +1,90 @@
+package auth
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Prüft den Fall, der beim Einschalten von OIDC über eine bestehende
+// Installation entscheidet: Wird das vorhandene Konto verbunden – oder entsteht
+// daneben ein zweites, leeres?
+//
+// Läuft nur mit TEST_DSN gegen eine echte Datenbank; ohne wird übersprungen,
+// damit `go test ./...` überall grün bleibt.
+func TestGetOrCreateByOIDC_Linking(t *testing.T) {
+	dsn := os.Getenv("TEST_DSN")
+	if dsn == "" {
+		t.Skip("TEST_DSN nicht gesetzt")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("verbinden: %v", err)
+	}
+	defer pool.Close()
+	s := NewStore(pool)
+
+	// Aufräumen, auch wenn der Test scheitert.
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE username LIKE 'linkprobe%'`)
+	}
+	cleanup()
+	defer cleanup()
+
+	hash, _ := HashPassword("irrelevant-aber-gueltig")
+	if _, err := pool.Exec(ctx,
+		`INSERT INTO users (username, display_name, password, is_admin)
+		 VALUES ('linkprobe', 'Link Probe', $1, true)`, hash); err != nil {
+		t.Fatalf("konto anlegen: %v", err)
+	}
+
+	t.Run("ohne Verknüpfung entsteht ein zweites Konto", func(t *testing.T) {
+		u, err := s.GetOrCreateByOIDC(ctx, "sub-A", "linkprobe", "Link Probe", false)
+		if err != nil {
+			t.Fatalf("aufruf: %v", err)
+		}
+		if u.Username == "linkprobe" {
+			t.Fatal("erwartet: ein neues Konto mit abgewandeltem Namen")
+		}
+		if u.IsAdmin {
+			t.Error("ein neu angelegtes Konto darf keine Adminrechte erben")
+		}
+		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE oidc_sub = 'sub-A'`)
+	})
+
+	t.Run("mit Verknüpfung bleibt das bestehende Konto", func(t *testing.T) {
+		u, err := s.GetOrCreateByOIDC(ctx, "sub-B", "linkprobe", "Link Probe", true)
+		if err != nil {
+			t.Fatalf("aufruf: %v", err)
+		}
+		if u.Username != "linkprobe" {
+			t.Fatalf("erwartet linkprobe, bekam %q", u.Username)
+		}
+		if !u.IsAdmin {
+			t.Error("Adminrecht des bestehenden Kontos ging verloren")
+		}
+		if !u.IsOIDC {
+			t.Error("Konto sollte jetzt als OIDC-Konto gelten")
+		}
+	})
+
+	t.Run("erneutes Anmelden findet dasselbe Konto", func(t *testing.T) {
+		u, err := s.GetOrCreateByOIDC(ctx, "sub-B", "linkprobe", "Link Probe", true)
+		if err != nil || u.Username != "linkprobe" {
+			t.Fatalf("wiederholte Anmeldung: %v / %+v", err, u)
+		}
+	})
+
+	t.Run("fremde Identität übernimmt ein gebundenes Konto nicht", func(t *testing.T) {
+		u, err := s.GetOrCreateByOIDC(ctx, "sub-FREMD", "linkprobe", "Angreifer", true)
+		if err != nil {
+			t.Fatalf("aufruf: %v", err)
+		}
+		if u.Username == "linkprobe" {
+			t.Fatal("ein bereits gebundenes Konto wurde übernommen – das darf nie passieren")
+		}
+	})
+}
diff --git a/backend/internal/auth/password.go b/backend/internal/auth/password.go
new file mode 100644
index 0000000..df8ebdd
--- /dev/null
+++ b/backend/internal/auth/password.go
@@ -0,0 +1,49 @@
+package auth
+
+import (
+	"crypto/rand"
+	"crypto/subtle"
+	"encoding/base64"
+	"fmt"
+	"strings"
+
+	"golang.org/x/crypto/argon2"
+)
+
+const (
+	argonTime    = 1
+	argonMemory  = 64 * 1024
+	argonThreads = 4
+	argonKeyLen  = 32
+	saltLen      = 16
+)
+
+func HashPassword(password string) (string, error) {
+	salt := make([]byte, saltLen)
+	if _, err := rand.Read(salt); err != nil {
+		return "", fmt.Errorf("generate salt: %w", err)
+	}
+	hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
+	return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
+		argonMemory, argonTime, argonThreads,
+		base64.RawStdEncoding.EncodeToString(salt),
+		base64.RawStdEncoding.EncodeToString(hash),
+	), nil
+}
+
+func VerifyPassword(password, encoded string) (bool, error) {
+	parts := strings.Split(encoded, "$")
+	if len(parts) != 6 || parts[1] != "argon2id" {
+		return false, fmt.Errorf("invalid hash format")
+	}
+	salt, err := base64.RawStdEncoding.DecodeString(parts[4])
+	if err != nil {
+		return false, fmt.Errorf("decode salt: %w", err)
+	}
+	expected, err := base64.RawStdEncoding.DecodeString(parts[5])
+	if err != nil {
+		return false, fmt.Errorf("decode hash: %w", err)
+	}
+	check := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, uint32(len(expected)))
+	return subtle.ConstantTimeCompare(expected, check) == 1, nil
+}
diff --git a/backend/internal/auth/password_test.go b/backend/internal/auth/password_test.go
new file mode 100644
index 0000000..a7a6ad7
--- /dev/null
+++ b/backend/internal/auth/password_test.go
@@ -0,0 +1,39 @@
+package auth
+
+import (
+	"testing"
+)
+
+func TestHashAndVerify(t *testing.T) {
+	hash, err := HashPassword("correct-horse-battery-staple")
+	if err != nil {
+		t.Fatalf("HashPassword: %v", err)
+	}
+	if hash == "" {
+		t.Fatal("expected non-empty hash")
+	}
+
+	ok, err := VerifyPassword("correct-horse-battery-staple", hash)
+	if err != nil {
+		t.Fatalf("VerifyPassword: %v", err)
+	}
+	if !ok {
+		t.Error("expected password to match")
+	}
+
+	ok, err = VerifyPassword("wrong-password", hash)
+	if err != nil {
+		t.Fatalf("VerifyPassword wrong: %v", err)
+	}
+	if ok {
+		t.Error("expected wrong password to not match")
+	}
+}
+
+func TestHashUniqueness(t *testing.T) {
+	h1, _ := HashPassword("same-password")
+	h2, _ := HashPassword("same-password")
+	if h1 == h2 {
+		t.Error("two hashes of the same password should differ (different salts)")
+	}
+}
diff --git a/backend/internal/auth/session.go b/backend/internal/auth/session.go
new file mode 100644
index 0000000..76d84f2
--- /dev/null
+++ b/backend/internal/auth/session.go
@@ -0,0 +1,118 @@
+package auth
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"net/http"
+	"strings"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/sessions"
+
+	"aether/pkg/middleware"
+)
+
+const (
+	sessionName    = "aether_session"
+	sessionKeyUser = "user_id"
+	csrfCookieName = "aether_csrf"
+	csrfHeaderName = "X-CSRF-Token"
+)
+
+type SessionStore struct {
+	store  *sessions.CookieStore
+	maxAge int
+}
+
+func NewSessionStore(secret string, maxAge int) *SessionStore {
+	store := sessions.NewCookieStore([]byte(secret))
+	store.Options = &sessions.Options{
+		Path:     "/",
+		MaxAge:   maxAge,
+		HttpOnly: true,
+		SameSite: http.SameSiteLaxMode,
+	}
+	return &SessionStore{store: store, maxAge: maxAge}
+}
+
+func (ss *SessionStore) SetUser(w http.ResponseWriter, r *http.Request, userID uuid.UUID) error {
+	sess, err := ss.store.Get(r, sessionName)
+	if err != nil {
+		sess, _ = ss.store.New(r, sessionName)
+	}
+	sess.Values[sessionKeyUser] = userID.String()
+	sess.Options.Secure = middleware.IsHTTPS(r)
+	return ss.store.Save(r, w, sess)
+}
+
+func (ss *SessionStore) GetUserID(r *http.Request) (uuid.UUID, bool) {
+	sess, err := ss.store.Get(r, sessionName)
+	if err != nil {
+		return uuid.Nil, false
+	}
+	raw, ok := sess.Values[sessionKeyUser].(string)
+	if !ok {
+		return uuid.Nil, false
+	}
+	id, err := uuid.Parse(raw)
+	if err != nil {
+		return uuid.Nil, false
+	}
+	return id, true
+}
+
+func (ss *SessionStore) Clear(w http.ResponseWriter, r *http.Request) error {
+	sess, err := ss.store.Get(r, sessionName)
+	if err != nil {
+		return nil
+	}
+	sess.Options.MaxAge = -1
+	return ss.store.Save(r, w, sess)
+}
+
+// SetCSRFCookie sets a CSRF token as a readable (non-httpOnly) cookie.
+func SetCSRFCookie(w http.ResponseWriter, r *http.Request) (string, error) {
+	token := make([]byte, 32)
+	if _, err := rand.Read(token); err != nil {
+		return "", err
+	}
+	encoded := base64.RawURLEncoding.EncodeToString(token)
+	http.SetCookie(w, &http.Cookie{
+		Name:     csrfCookieName,
+		Value:    encoded,
+		Path:     "/",
+		HttpOnly: false, // must be readable by JS
+		Secure:   middleware.IsHTTPS(r),
+		SameSite: http.SameSiteStrictMode,
+	})
+	return encoded, nil
+}
+
+// ValidateCSRF prüft, dass das mitgeschickte Token zum CSRF-Cookie passt
+// (Double-Submit).
+//
+// Neben dem Header wird auch ein Formularfeld akzeptiert. Grund: Ein Download
+// muss aus einer **Navigation** kommen, damit der Browser ihn als Datei
+// behandelt statt ihn in den Speicher zu laden – und ein abgeschicktes
+// Formular kann keine Header setzen. Am Schutz ändert das nichts: Verglichen
+// wird weiterhin gegen das Cookie, an das eine fremde Seite nicht herankommt.
+func ValidateCSRF(r *http.Request) bool {
+	cookie, err := r.Cookie(csrfCookieName)
+	if err != nil || cookie.Value == "" {
+		return false
+	}
+	if token := r.Header.Get(csrfHeaderName); token != "" {
+		return token == cookie.Value
+	}
+	// Nur bei Formularen nachsehen: Bei anderen Inhaltstypen würde ParseForm
+	// den Rumpf lesen, den der eigentliche Handler danach noch braucht.
+	ct := r.Header.Get("Content-Type")
+	if strings.HasPrefix(ct, "application/x-www-form-urlencoded") {
+		if err := r.ParseForm(); err != nil {
+			return false
+		}
+		token := r.PostFormValue("csrf_token")
+		return token != "" && token == cookie.Value
+	}
+	return false
+}
diff --git a/backend/internal/auth/store.go b/backend/internal/auth/store.go
new file mode 100644
index 0000000..182c91a
--- /dev/null
+++ b/backend/internal/auth/store.go
@@ -0,0 +1,211 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// userCols ist die Spaltenliste jeder Nutzerabfrage – einmal, weil vier
+// Abfragen mit derselben Reihenfolge scannen und eine übersehene Ergänzung
+// sonst erst zur Laufzeit auffällt.
+const userCols = `id, username, display_name, is_admin, quota_bytes,
+	COALESCE(primary_color,''), COALESCE(accent_color,''), use_custom_theme,
+	oidc_sub IS NOT NULL AND oidc_sub <> '' AS is_oidc, created_at`
+
+var ErrNotFound = errors.New("user not found")
+var ErrUsernameTaken = errors.New("username already taken")
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store {
+	return &Store{db: db}
+}
+
+func (s *Store) GetByUsername(ctx context.Context, username string) (*User, string, error) {
+	var u User
+	var passwordHash string
+	err := s.db.QueryRow(ctx,
+		`SELECT id, username, display_name, password, is_admin, quota_bytes, created_at
+		 FROM users WHERE username = $1`,
+		username,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &passwordHash, &u.IsAdmin, &u.QuotaBytes, &u.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, "", ErrNotFound
+	}
+	if err != nil {
+		return nil, "", fmt.Errorf("query user: %w", err)
+	}
+	return &u, passwordHash, nil
+}
+
+func (s *Store) GetByID(ctx context.Context, id uuid.UUID) (*User, error) {
+	var u User
+	err := s.db.QueryRow(ctx,
+		`SELECT id, username, display_name, is_admin, quota_bytes,
+		        COALESCE(primary_color,''), COALESCE(accent_color,''), use_custom_theme, oidc_sub IS NOT NULL AND oidc_sub <> '' AS is_oidc, created_at
+		 FROM users WHERE id = $1`,
+		id,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes,
+		&u.PrimaryColor, &u.AccentColor, &u.UseCustomTheme, &u.IsOIDC, &u.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("query user: %w", err)
+	}
+	return &u, nil
+}
+
+func (s *Store) Create(ctx context.Context, username, passwordHash string, isAdmin bool) (*User, error) {
+	var u User
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO users (username, password, is_admin)
+		 VALUES ($1, $2, $3)
+		 RETURNING id, username, display_name, is_admin, quota_bytes,
+		           COALESCE(primary_color,''), COALESCE(accent_color,''), use_custom_theme, oidc_sub IS NOT NULL AND oidc_sub <> '' AS is_oidc, created_at`,
+		username, passwordHash, isAdmin,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes,
+		&u.PrimaryColor, &u.AccentColor, &u.UseCustomTheme, &u.IsOIDC, &u.CreatedAt)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrUsernameTaken
+		}
+		return nil, fmt.Errorf("create user: %w", err)
+	}
+	return &u, nil
+}
+
+// GetOrCreateByOIDC findet den Nutzer über sein OIDC-Subject – oder legt ihn an.
+//
+// linkByUsername entscheidet über den heiklen Fall: Es gibt bereits ein Konto
+// mit diesem Benutzernamen, aber ohne Bindung an eine OIDC-Identität.
+//
+//   - **aus (Voreinstellung):** Es entsteht ein *zweites* Konto. Da der Name
+//     schon vergeben ist, heißt es „name2" – leer, ohne Adminrechte, ohne die
+//     bisherigen Dateien. Wer seine Cloud bisher mit Passwort benutzt hat und
+//     dann OIDC einschaltet, landet also in einer fremden, leeren Cloud.
+//   - **an:** Das bestehende Konto wird mit der Identität verbunden. Dateien,
+//     Adminrecht und Freigaben bleiben, künftig meldet man sich darüber an.
+//
+// **Warum das nicht die Voreinstellung ist:** Verbinden heißt, dem
+// Identitätsanbieter zu glauben, dass „marc" bei ihm derselbe „marc" ist wie
+// hier. Bei einem eigenen Anbieter, dessen Konten man selbst anlegt, stimmt
+// das. Bei einem Anbieter, bei dem sich Fremde registrieren und ihren
+// Benutzernamen frei wählen können, wäre es die Übernahme fremder Konten.
+// Deshalb eine bewusste Entscheidung in der .env statt einer stillen Annahme.
+//
+// Verbunden wird nur, was **noch keine** Bindung hat: Ein Konto, das bereits zu
+// einer anderen Identität gehört, wird nie überschrieben.
+func (s *Store) GetOrCreateByOIDC(ctx context.Context, sub, username, displayName string, linkByUsername bool) (*User, error) {
+	// First: try to find by oidc_sub.
+	var u User
+	err := s.db.QueryRow(ctx,
+		`SELECT id, username, display_name, is_admin, quota_bytes,
+		        COALESCE(primary_color,''), COALESCE(accent_color,''), use_custom_theme, oidc_sub IS NOT NULL AND oidc_sub <> '' AS is_oidc, created_at
+		 FROM users WHERE oidc_sub=$1`,
+		sub,
+	).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes,
+		&u.PrimaryColor, &u.AccentColor, &u.UseCustomTheme, &u.IsOIDC, &u.CreatedAt)
+	if err == nil {
+		return &u, nil
+	}
+
+	// Bestehendes Konto übernehmen, falls gewünscht und noch ungebunden.
+	if linkByUsername {
+		err = s.db.QueryRow(ctx,
+			`UPDATE users SET oidc_sub = $1
+			  WHERE username = $2 AND (oidc_sub IS NULL OR oidc_sub = '')
+			 RETURNING `+userCols,
+			sub, username,
+		).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes,
+			&u.PrimaryColor, &u.AccentColor, &u.UseCustomTheme, &u.IsOIDC, &u.CreatedAt)
+		if err == nil {
+			return &u, nil
+		}
+		// Kein Treffer heißt: kein solches Konto oder schon anderweitig
+		// gebunden. Beides führt weiter unten zum Anlegen eines neuen.
+	}
+
+	// Not found: create a new user. Ensure username uniqueness.
+	candidate := username
+	for i := 2; i <= 99; i++ {
+		err = s.db.QueryRow(ctx,
+			`INSERT INTO users (username, display_name, password, oidc_sub)
+			 VALUES ($1, $2, '', $3)
+			 RETURNING id, username, display_name, is_admin, quota_bytes,
+		           COALESCE(primary_color,''), COALESCE(accent_color,''), use_custom_theme, oidc_sub IS NOT NULL AND oidc_sub <> '' AS is_oidc, created_at`,
+			candidate, displayName, sub,
+		).Scan(&u.ID, &u.Username, &u.DisplayName, &u.IsAdmin, &u.QuotaBytes,
+			&u.PrimaryColor, &u.AccentColor, &u.UseCustomTheme, &u.IsOIDC, &u.CreatedAt)
+		if err == nil {
+			return &u, nil
+		}
+		if isUniqueViolation(err) {
+			candidate = fmt.Sprintf("%s%d", username, i)
+			continue
+		}
+		return nil, fmt.Errorf("create oidc user: %w", err)
+	}
+	return nil, fmt.Errorf("could not find unique username for %q", username)
+}
+
+func (s *Store) UpdateDisplayName(ctx context.Context, id uuid.UUID, displayName string) error {
+	_, err := s.db.Exec(ctx, `UPDATE users SET display_name=$2 WHERE id=$1`, id, displayName)
+	return err
+}
+
+// SetUseCustomTheme legt um, ob die persönliche Palette angewendet wird.
+// Die gespeicherten Farben bleiben dabei unangetastet.
+func (s *Store) SetUseCustomTheme(ctx context.Context, id uuid.UUID, enabled bool) error {
+	_, err := s.db.Exec(ctx, `UPDATE users SET use_custom_theme=$2 WHERE id=$1`, id, enabled)
+	return err
+}
+
+// UpdateColors setzt die persönliche Palette. Leere Werte werden als NULL
+// gespeichert – dann gilt wieder die globale Einstellung des Administrators.
+func (s *Store) UpdateColors(ctx context.Context, id uuid.UUID, primary, accent string) error {
+	var p, a *string
+	if primary != "" {
+		p = &primary
+	}
+	if accent != "" {
+		a = &accent
+	}
+	_, err := s.db.Exec(ctx,
+		`UPDATE users SET primary_color=$2, accent_color=$3 WHERE id=$1`, id, p, a)
+	return err
+}
+
+func (s *Store) UpdatePassword(ctx context.Context, id uuid.UUID, newHash string) error {
+	_, err := s.db.Exec(ctx, `UPDATE users SET password=$2 WHERE id=$1`, id, newHash)
+	return err
+}
+
+func (s *Store) AdminExists(ctx context.Context) (bool, error) {
+	var count int
+	err := s.db.QueryRow(ctx, `SELECT COUNT(*) FROM users WHERE is_admin = true`).Scan(&count)
+	return count > 0, err
+}
+
+func isUniqueViolation(err error) bool {
+	return err != nil && (containsCode(err, "23505"))
+}
+
+func containsCode(err error, code string) bool {
+	return err != nil && len(err.Error()) > 0 &&
+		(func() bool {
+			type pgErr interface{ SQLState() string }
+			var pe pgErr
+			if errors.As(err, &pe) {
+				return pe.SQLState() == code
+			}
+			return false
+		}())
+}
diff --git a/backend/internal/documents/diskspace.go b/backend/internal/documents/diskspace.go
new file mode 100644
index 0000000..7ac74e9
--- /dev/null
+++ b/backend/internal/documents/diskspace.go
@@ -0,0 +1,66 @@
+package documents
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+)
+
+// minFreeBytes ist die Untergrenze, unter der die Texterkennung pausiert.
+//
+// OCR ist das einzige Stück dieser Anwendung, das von sich aus und ohne
+// Zutun eines Menschen Platz verbraucht: Es arbeitet eine Warteschlange ab,
+// solange etwas darin liegt. Eine Cloud, die ihre eigene Platte vollschreibt,
+// nimmt Uploads nicht mehr an – und das wäre dann kein OCR-Problem mehr,
+// sondern ein Ausfall.
+//
+// 2 GiB ist mit Absicht großzügig: Der Sidecar einer Erkennung ist kaum größer
+// als ein Megabyte, tesseract und ghostscript brauchen währenddessen aber
+// Arbeitsdateien, deren Größe von der Auflösung der Vorlage abhängt. Lieber
+// eine Weile nichts erkennen als eine volle Platte.
+const minFreeBytes = 2 << 30 // 2 GiB
+
+// freeBytes meldet den freien Platz auf dem Dateisystem, auf dem path liegt.
+func freeBytes(path string) (uint64, error) {
+	var st syscall.Statfs_t
+	if err := syscall.Statfs(path, &st); err != nil {
+		return 0, fmt.Errorf("statfs %s: %w", path, err)
+	}
+	// Bavail, nicht Bfree: Bfree zählt auch die Reserve mit, die nur root
+	// benutzen darf – der Server läuft aber als unprivilegierter Nutzer und
+	// käme daran nie heran.
+	return st.Bavail * uint64(st.Bsize), nil
+}
+
+// sweepTemp räumt Zwischendateien früherer Läufe weg.
+//
+// Im Normalfall räumt der Arbeiter selbst auf. Wird der Container aber hart
+// beendet – `docker kill`, ein Absturz, Stromausfall –, läuft kein defer mehr,
+// und die angefangene Datei bleibt liegen. Ohne diesen Durchgang sammelt sich
+// das über Monate an, ausgerechnet auf der Platte, die auch die Dateien trägt.
+//
+// Es wird nur weggeräumt, was diese Anwendung selbst angelegt hat: das Präfix
+// "ocr-" im Zwischenverzeichnis. Fremde Dateien bleiben unangetastet.
+func sweepTemp(dir string) (int, int64) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return 0, 0
+	}
+	var count int
+	var bytes int64
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasPrefix(e.Name(), "ocr-") {
+			continue
+		}
+		full := filepath.Join(dir, e.Name())
+		if info, err := e.Info(); err == nil {
+			bytes += info.Size()
+		}
+		if err := os.Remove(full); err == nil {
+			count++
+		}
+	}
+	return count, bytes
+}
diff --git a/backend/internal/documents/extract.go b/backend/internal/documents/extract.go
new file mode 100644
index 0000000..6258de5
--- /dev/null
+++ b/backend/internal/documents/extract.go
@@ -0,0 +1,302 @@
+// Package documents macht den Inhalt von Dokumenten durchsuchbar.
+//
+// Die Namenssuche (internal/files/search.go) findet "Rechnung_Stadtwerke.pdf".
+// Ein Scanner nennt seine Ablage aber "scan_0042.pdf" – der Name sagt dann
+// nichts, und der Beleg ist praktisch verloren. Dieses Paket holt den Text aus
+// der Datei und legt ihn nach file_text, wo die Suche ihn findet.
+package documents
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// Herkunft des Textes. Der Unterschied zählt bei der Fehlersuche: Findet die
+// Suche ein Wort nicht, sagt die Herkunft, ob OCR es verlesen haben kann.
+const (
+	SourceLayer = "layer" // aus der Textebene des PDFs – verlustfrei
+	SourceOCR   = "ocr"   // aus dem Bild erkannt – kann Fehler enthalten
+)
+
+// minCharsPerPage entscheidet, ob ein PDF schon Text mitbringt.
+//
+// Nicht "> 0 Zeichen": Fast jeder Scan trägt eine Kopfzeile, eine Seitenzahl
+// oder ein Wasserzeichen als echten Text – oft nur zehn Zeichen. Ohne diese
+// Schwelle gälte er als lesbar, und die eigentliche Rechnung bliebe
+// unauffindbar. Eine getippte Seite hat mehrere tausend Zeichen; 120 trennt die
+// beiden Fälle mit reichlich Abstand in beide Richtungen.
+const minCharsPerPage = 120
+
+// maxTextBytes deckelt, was in die Datenbank geht. Ein 400-seitiges Handbuch
+// erzeugt sonst mehrere Megabyte Text pro Datei, und der GIN-Index wächst mit.
+// Für einen Beleg ist das weit jenseits von allem; abgeschnitten wird am Ende,
+// wo der Inhalt ohnehin am wenigsten aussagt.
+const maxTextBytes = 1 << 20 // 1 MiB
+
+// Extractor holt Text aus einer Datei. Er ruft externe Programme auf –
+// pdftotext, ocrmypdf, tesseract –, die im Container mitgeliefert werden.
+type Extractor struct {
+	// Languages sind die Sprachmodelle für tesseract, z. B. "deu+eng".
+	Languages string
+	// MaxPages begrenzt, wie viele Seiten erkannt werden. OCR kostet Sekunden
+	// je Seite; ohne Grenze blockiert ein einzelnes dickes PDF die
+	// Warteschlange für alle anderen.
+	MaxPages int
+	// Timeout je Datei. Greift zusätzlich zu MaxPages, weil auch eine einzelne
+	// Seite entgleisen kann.
+	Timeout time.Duration
+	// TmpDir nimmt die Zwischendateien auf. Leer heißt: das System entscheidet.
+	TmpDir string
+}
+
+// Result ist der gefundene Text mitsamt seiner Herkunft.
+type Result struct {
+	Text   string
+	Source string
+	// Lang sind die verwendeten Sprachmodelle – bei SourceLayer leer, weil
+	// dort nichts erkannt, sondern nur ausgelesen wurde.
+	Lang  string
+	Pages int
+	// Chars ist die Länge *vor* dem Kürzen auf maxTextBytes.
+	Chars int
+}
+
+// Supported sagt, ob aus dieser Datei überhaupt Text zu holen ist.
+//
+// Bewusst eng: PDFs und Bilder. Word- und Excel-Dateien bräuchten je einen
+// eigenen Umwandler; sie tragen ihren Text ohnehin meist schon im Namen und
+// sind selten das, was eingescannt wird.
+func Supported(mime, name string) bool {
+	m := strings.ToLower(mime)
+	if strings.Contains(m, "pdf") {
+		return true
+	}
+	if strings.HasPrefix(m, "image/") {
+		// SVG ist Text, kein Bild – tesseract kann damit nichts anfangen.
+		return !strings.Contains(m, "svg")
+	}
+	switch strings.ToLower(filepath.Ext(name)) {
+	case ".pdf", ".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp":
+		return true
+	}
+	return false
+}
+
+// Available prüft, ob die Programme da sind. Fehlen sie, läuft die Cloud
+// weiter – nur ohne Volltext. Ein fehlendes Paket soll den Start nicht
+// verhindern.
+func Available() (bool, []string) {
+	var missing []string
+	for _, bin := range []string{"pdftotext", "ocrmypdf", "tesseract"} {
+		if _, err := exec.LookPath(bin); err != nil {
+			missing = append(missing, bin)
+		}
+	}
+	return len(missing) == 0, missing
+}
+
+// Extract liest die Datei unter path. Das Original wird dabei **nicht**
+// angefasst.
+//
+// Das ist die wichtigste Eigenschaft hier: ocrmypdf schreibt normalerweise ein
+// neues PDF mit eingebetteter Textebene. Täten wir das, änderten sich Größe und
+// Prüfsumme der Datei – die gespeicherte Prüfsumme passte nicht mehr, die
+// Versionshistorie bekäme einen Eintrag, den niemand ausgelöst hat, und
+// WebDAV-Clients hielten die Datei für fremdverändert und lüden sie erneut. Für
+// ein Archiv ist eine unangetastete Datei mehr wert als ein durchsuchbares PDF.
+// Der Text landet deshalb daneben in der Datenbank, das PDF bleibt Byte für
+// Byte, wie es hochgeladen wurde.
+func (e *Extractor) Extract(ctx context.Context, path, mime, name string) (Result, error) {
+	if e.Timeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, e.Timeout)
+		defer cancel()
+	}
+
+	isPDF := strings.Contains(strings.ToLower(mime), "pdf") ||
+		strings.EqualFold(filepath.Ext(name), ".pdf")
+	if isPDF {
+		return e.extractPDF(ctx, path)
+	}
+	return e.extractImage(ctx, path)
+}
+
+func (e *Extractor) extractPDF(ctx context.Context, path string) (Result, error) {
+	pages := e.pageCount(ctx, path)
+
+	// Erst der billige Weg: Hat das PDF eine Textebene, ist pdftotext in
+	// Millisekunden fertig und liefert den Text exakt so, wie er gesetzt wurde.
+	// OCR wäre hier nicht nur langsamer, sondern schlechter – es würde
+	// fehlerfreien Text durch geratenen ersetzen.
+	limit := pages
+	if e.MaxPages > 0 && (limit == 0 || limit > e.MaxPages) {
+		limit = e.MaxPages
+	}
+	args := []string{"-q"}
+	if limit > 0 {
+		args = append(args, "-l", fmt.Sprint(limit))
+	}
+	args = append(args, path, "-")
+
+	layer, err := e.run(ctx, "pdftotext", args...)
+	if err == nil {
+		text := clean(layer)
+		perPage := len(text)
+		if pages > 1 {
+			perPage = len(text) / pages
+		}
+		if perPage >= minCharsPerPage {
+			return finish(text, SourceLayer, "", pages), nil
+		}
+	}
+
+	// Zu wenig Text – also ein Scan. Jetzt OCR.
+	sidecar, err := os.CreateTemp(e.TmpDir, "ocr-*.txt")
+	if err != nil {
+		return Result{}, fmt.Errorf("sidecar anlegen: %w", err)
+	}
+	sidecarPath := sidecar.Name()
+	sidecar.Close()
+	defer os.Remove(sidecarPath)
+
+	ocrArgs := []string{
+		"--quiet",
+		"-l", e.Languages,
+		// Der eigentliche Zweck des Aufrufs: --sidecar schreibt den erkannten
+		// Text als reine Textdatei daneben.
+		"--sidecar", sidecarPath,
+		// Wir landen hier nur, wenn kaum Text da ist. --force-ocr rastert die
+		// Seite und erkennt sie neu, statt an den paar vorhandenen Zeichen zu
+		// scheitern (ocrmypdf bricht sonst mit PriorOcrFoundError ab).
+		"--force-ocr",
+		// Kein Ergebnis-PDF erzeugen. Uns interessiert allein der Sidecar; das
+		// Schreiben (und Optimieren) einer Datei, die sofort wieder
+		// verschwindet, wäre reine Rechenzeit und reiner Plattenplatz.
+		"--output-type", "none",
+		"--optimize", "0",
+	}
+	if e.MaxPages > 0 && pages > e.MaxPages {
+		ocrArgs = append(ocrArgs, "--pages", fmt.Sprintf("1-%d", e.MaxPages))
+	}
+	// Ausgabe nach stdout, und dank --output-type none kommt dort nichts an:
+	// gemessen 0 Bytes, Sidecar trotzdem vollständig. Damit entsteht gar kein
+	// Ergebnis-PDF – wichtig auf einer Platte, die knapp werden kann, denn ein
+	// force-OCR rastert jede Seite und das Ergebnis kann ein Vielfaches der
+	// Vorlage wiegen.
+	//
+	// /dev/null als Ausgabe geht übrigens **nicht** – ocrmypdf bricht damit
+	// mit Exit 3 ab. Der Bindestrich ist der Weg.
+	ocrArgs = append(ocrArgs, path, "-")
+
+	if _, err := e.run(ctx, "ocrmypdf", ocrArgs...); err != nil {
+		return Result{}, fmt.Errorf("ocrmypdf: %w", err)
+	}
+	raw, err := os.ReadFile(sidecarPath)
+	if err != nil {
+		return Result{}, fmt.Errorf("sidecar lesen: %w", err)
+	}
+	return finish(clean(string(raw)), SourceOCR, e.Languages, pages), nil
+}
+
+func (e *Extractor) extractImage(ctx context.Context, path string) (Result, error) {
+	out, err := e.run(ctx, "tesseract", path, "stdout", "-l", e.Languages)
+	if err != nil {
+		return Result{}, fmt.Errorf("tesseract: %w", err)
+	}
+	return finish(clean(out), SourceOCR, e.Languages, 1), nil
+}
+
+// pageCount fragt pdfinfo nach der Seitenzahl. Schlägt das fehl, arbeiten wir
+// mit 0 weiter – die Seitenzahl steuert nur Grenzen, sie ist nicht kritisch.
+func (e *Extractor) pageCount(ctx context.Context, path string) int {
+	out, err := e.run(ctx, "pdfinfo", path)
+	if err != nil {
+		return 0
+	}
+	for _, line := range strings.Split(out, "\n") {
+		if !strings.HasPrefix(line, "Pages:") {
+			continue
+		}
+		var n int
+		if _, err := fmt.Sscanf(strings.TrimSpace(line), "Pages: %d", &n); err == nil {
+			return n
+		}
+	}
+	return 0
+}
+
+func (e *Extractor) run(ctx context.Context, name string, args ...string) (string, error) {
+	cmd := exec.CommandContext(ctx, name, args...)
+	var out, errOut bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &errOut
+	if err := cmd.Run(); err != nil {
+		msg := strings.TrimSpace(errOut.String())
+		if len(msg) > 300 {
+			msg = msg[:300] + "…"
+		}
+		if msg != "" {
+			return "", fmt.Errorf("%s: %w (%s)", name, err, msg)
+		}
+		return "", fmt.Errorf("%s: %w", name, err)
+	}
+	return out.String(), nil
+}
+
+// clean räumt auf, was aus den Werkzeugen kommt.
+//
+// **Der Seitenumbruch (\f) bleibt stehen.** Für die Suche ist er bedeutungslos
+// – ein tsvector kennt keine Seiten –, für den Betrachter ist er das Einzige,
+// woran sich ablesen lässt, *wo* ein Wort steht. Bei einem Scan liegt im PDF
+// nur ein Bild; der erkannte Text steht ausschließlich hier. Ohne die Marke
+// beginnt der Betrachter bei einem zwölfseitigen Beleg wieder auf Seite 1.
+//
+// Ein Wust aus Leerzeilen bläht den Text dagegen nur auf. Ungültiges UTF-8
+// muss raus, weil Postgres es sonst zurückweist und der ganze Auftrag
+// scheitert; OCR liefert es bei verrauschten Vorlagen durchaus.
+func clean(s string) string {
+	s = strings.ReplaceAll(s, "\x00", "")
+	if !utf8.ValidString(s) {
+		s = strings.ToValidUTF8(s, "")
+	}
+	var b strings.Builder
+	b.Grow(len(s))
+	blank := 0
+	for _, line := range strings.Split(s, "\n") {
+		line = strings.TrimRight(line, " \t\r")
+		// Die Seitenmarke steht bei pdftotext am Ende der letzten Zeile einer
+		// Seite. Sie überlebt das Trimmen und zählt nicht als leer.
+		if strings.TrimSpace(strings.ReplaceAll(line, "\f", "")) == "" && !strings.Contains(line, "\f") {
+			blank++
+			if blank > 1 {
+				continue
+			}
+		} else {
+			blank = 0
+		}
+		b.WriteString(line)
+		b.WriteByte('\n')
+	}
+	return strings.TrimSpace(b.String())
+}
+
+// finish kürzt auf maxTextBytes und merkt sich die ursprüngliche Länge.
+func finish(text, source, lang string, pages int) Result {
+	chars := utf8.RuneCountInString(text)
+	if len(text) > maxTextBytes {
+		text = text[:maxTextBytes]
+		// Nicht mitten in einem Zeichen abschneiden – das ergäbe ungültiges
+		// UTF-8, und Postgres lehnte den ganzen Text ab.
+		for len(text) > 0 && !utf8.ValidString(text) {
+			text = text[:len(text)-1]
+		}
+	}
+	return Result{Text: text, Source: source, Lang: lang, Pages: pages, Chars: chars}
+}
diff --git a/backend/internal/documents/handler.go b/backend/internal/documents/handler.go
new file mode 100644
index 0000000..1c39182
--- /dev/null
+++ b/backend/internal/documents/handler.go
@@ -0,0 +1,86 @@
+package documents
+
+import (
+	"net/http"
+
+	"github.com/google/uuid"
+
+	"aether/pkg/response"
+)
+
+// Handler zeigt den Stand der Texterkennung.
+//
+// Ohne diese Auskunft ist nicht zu erkennen, ob der Volltext funktioniert:
+// Eine Suche, die nichts findet, sieht genauso aus wie eine Suche in einem
+// Bestand, der noch gar nicht erkannt wurde. Nach dem ersten Start läuft der
+// Arbeiter je nach Menge Stunden – ohne Zähler weiß niemand, ob er
+// vorankommt.
+type Handler struct {
+	store *Store
+	// isAdmin und userID trennen die Rechteprüfung von diesem Paket.
+	// documents kennt weder Sessions noch Rollen, und soll es auch nicht.
+	isAdmin func(r *http.Request) bool
+	userID  func(r *http.Request) uuid.UUID
+}
+
+func NewHandler(store *Store, isAdmin func(r *http.Request) bool, userID func(r *http.Request) uuid.UUID) *Handler {
+	return &Handler{store: store, isAdmin: isAdmin, userID: userID}
+}
+
+// Status beantwortet GET /api/v1/admin/ocr – der Gesamtstand des Servers.
+func (h *Handler) Status(w http.ResponseWriter, r *http.Request) {
+	if !h.isAdmin(r) {
+		response.Error(w, http.StatusForbidden, "admin required")
+		return
+	}
+	// h.store nil heißt: OCR ist abgeschaltet oder die Programme fehlen. Das
+	// ist eine Auskunft, kein Fehler – die Oberfläche soll „aus" anzeigen
+	// können, statt in einen Fehlerzustand zu laufen.
+	if h == nil || h.store == nil {
+		response.JSON(w, http.StatusOK, map[string]any{"enabled": false})
+		return
+	}
+	stats, err := h.store.Stats(r.Context())
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "ocr status failed")
+		return
+	}
+	response.JSON(w, http.StatusOK, map[string]any{
+		"enabled": true,
+		"pending": stats.Pending,
+		"running": stats.Running,
+		"done":    stats.Done,
+		"failed":  stats.Failed,
+		"indexed": stats.Indexed,
+	})
+}
+
+// MyStatus beantwortet GET /api/v1/ocr – der Stand der **eigenen** Dateien.
+//
+// Ohne diesen Endpunkt wüsste nur der Administrator, ob ein Dokument schon
+// gelesen wurde. Das ist die falsche Person: Wissen muss es, wer die Rechnung
+// hochgeladen hat und sie gerade nicht findet.
+func (h *Handler) MyStatus(w http.ResponseWriter, r *http.Request) {
+	uid := h.userID(r)
+	if uid == uuid.Nil {
+		response.Error(w, http.StatusUnauthorized, "not signed in")
+		return
+	}
+	if h == nil || h.store == nil {
+		response.JSON(w, http.StatusOK, map[string]any{"enabled": false})
+		return
+	}
+	stats, err := h.store.StatsForUser(r.Context(), uid)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "ocr status failed")
+		return
+	}
+	response.JSON(w, http.StatusOK, map[string]any{
+		"enabled": true,
+		"pending": stats.Pending,
+		"running": stats.Running,
+		"done":    stats.Done,
+		"failed":  stats.Failed,
+		"indexed": stats.Indexed,
+	})
+}
diff --git a/backend/internal/documents/store.go b/backend/internal/documents/store.go
new file mode 100644
index 0000000..522413d
--- /dev/null
+++ b/backend/internal/documents/store.go
@@ -0,0 +1,315 @@
+package documents
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// ExtractVersion ist die Fassung der Textaufbereitung.
+//
+// Sie steht an jedem Eintrag in file_text. Wird die Aufbereitung geändert, so
+// dass alte Einträge nicht mehr taugen, wird die Zahl erhöht – beim Start
+// werden sie dann erneut erkannt, statt still nach der alten Regel liegen zu
+// bleiben. Ohne so eine Marke fällt der Unterschied nie auf: Der Text ist ja
+// da, er kann nur weniger.
+//
+//	1 – Seitenumbruch (\f) bleibt im Text stehen (23.08.2026)
+const ExtractVersion = 1
+
+// ErrNoJob heißt: gerade nichts zu tun. Kein Fehler, sondern der Normalfall.
+var ErrNoJob = errors.New("no pending job")
+
+// maxAttempts begrenzt, wie oft ein Auftrag wiederholt wird.
+//
+// Zwei Wiederholungen fangen das ab, was vorübergehend war – ein Neustart
+// mitten im Lauf, kurzzeitig fehlender Speicherplatz. Was dreimal scheitert,
+// scheitert an der Datei selbst (kaputtes PDF, passwortgeschützt), und ein
+// vierter Versuch verbrennt nur Rechenzeit. Der Auftrag bleibt dann als
+// 'failed' mit Fehlertext stehen, statt still zu verschwinden.
+const maxAttempts = 3
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store {
+	return &Store{db: db}
+}
+
+// Job ist ein Auftrag samt allem, was der Arbeiter über die Datei braucht.
+type Job struct {
+	ID         uuid.UUID
+	FileID     uuid.UUID
+	Attempts   int
+	Name       string
+	MimeType   string
+	StorageKey string
+	Size       int64
+}
+
+// Enqueue trägt eine Datei zur Texterkennung ein.
+//
+// ON CONFLICT statt eines zweiten Eintrags: Wird dieselbe Datei erneut
+// hochgeladen, ist der alte Text hinfällig – der Auftrag wird auf 'pending'
+// zurückgesetzt, statt sich daneben zu stapeln. Der Zähler geht dabei auf 0,
+// weil eine neue Fassung eine neue Chance verdient: Vielleicht war es genau
+// der kaputte Scan, der ersetzt wurde.
+func (s *Store) Enqueue(ctx context.Context, fileID uuid.UUID) error {
+	_, err := s.db.Exec(ctx, `
+		INSERT INTO ocr_jobs (file_id, status)
+		VALUES ($1, 'pending')
+		ON CONFLICT (file_id) DO UPDATE
+		   SET status = 'pending', attempts = 0, last_error = '', updated_at = NOW()`,
+		fileID)
+	if err != nil {
+		return fmt.Errorf("enqueue ocr job: %w", err)
+	}
+	return nil
+}
+
+// Claim holt den ältesten offenen Auftrag und markiert ihn als laufend.
+//
+// FOR UPDATE SKIP LOCKED ist der Kern: Zwei Arbeiter greifen damit nie
+// denselben Auftrag – der zweite überspringt die gesperrte Zeile, statt darauf
+// zu warten. Heute läuft nur einer, aber die Sperre kostet nichts und erspart
+// die Suche nach doppelt erkannten Dateien, sobald es zwei werden.
+//
+// 'running' wird mit übernommen, nicht nur 'pending': Ein Auftrag, der beim
+// Neustart mittendrin war, steht sonst für immer auf 'running' und wird nie
+// wieder angefasst. Der Zähler sorgt dafür, dass daraus keine Endlosschleife
+// wird, falls die Datei den Server reproduzierbar umbringt.
+func (s *Store) Claim(ctx context.Context) (*Job, error) {
+	var j Job
+	err := s.db.QueryRow(ctx, `
+		UPDATE ocr_jobs
+		   SET status = 'running', attempts = attempts + 1, updated_at = NOW()
+		 WHERE id = (
+		       SELECT j.id
+		         FROM ocr_jobs j
+		         JOIN files f ON f.id = j.file_id AND f.is_deleted = false
+		        WHERE j.status IN ('pending', 'running')
+		          AND j.attempts < $1
+		        ORDER BY j.created_at
+		        FOR UPDATE SKIP LOCKED
+		        LIMIT 1)
+		RETURNING id, file_id, attempts,
+		          (SELECT name        FROM files WHERE id = file_id),
+		          (SELECT mime_type   FROM files WHERE id = file_id),
+		          (SELECT storage_key FROM files WHERE id = file_id),
+		          (SELECT size        FROM files WHERE id = file_id)`,
+		maxAttempts,
+	).Scan(&j.ID, &j.FileID, &j.Attempts, &j.Name, &j.MimeType, &j.StorageKey, &j.Size)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNoJob
+	}
+	if err != nil {
+		return nil, fmt.Errorf("claim ocr job: %w", err)
+	}
+	return &j, nil
+}
+
+// Complete speichert den Text und schließt den Auftrag ab. Beides in einer
+// Transaktion: Ein gespeicherter Text ohne erledigten Auftrag würde beim
+// nächsten Durchgang erneut erkannt, ein erledigter Auftrag ohne Text ließe die
+// Datei unauffindbar zurück.
+func (s *Store) Complete(ctx context.Context, job *Job, res Result) error {
+	tx, err := s.db.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("begin: %w", err)
+	}
+	defer tx.Rollback(ctx)
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO file_text (file_id, content, source, lang, chars, pages, extract_version)
+		VALUES ($1, $2, $3, $4, $5, $6, $7)
+		ON CONFLICT (file_id) DO UPDATE
+		   SET content = EXCLUDED.content, source = EXCLUDED.source,
+		       lang = EXCLUDED.lang, chars = EXCLUDED.chars,
+		       pages = EXCLUDED.pages, extract_version = EXCLUDED.extract_version,
+		       created_at = NOW()`,
+		job.FileID, res.Text, res.Source, res.Lang, res.Chars, res.Pages, ExtractVersion,
+	); err != nil {
+		return fmt.Errorf("save text: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx,
+		`UPDATE ocr_jobs SET status = 'done', last_error = '', updated_at = NOW() WHERE id = $1`,
+		job.ID,
+	); err != nil {
+		return fmt.Errorf("finish job: %w", err)
+	}
+	return tx.Commit(ctx)
+}
+
+// Fail vermerkt den Fehler. Ist der Zähler ausgeschöpft, bleibt der Auftrag als
+// 'failed' liegen; sonst geht er zurück in die Schlange.
+func (s *Store) Fail(ctx context.Context, job *Job, cause error) error {
+	msg := cause.Error()
+	if len(msg) > 500 {
+		msg = msg[:500] + "…"
+	}
+	status := "pending"
+	if job.Attempts >= maxAttempts {
+		status = "failed"
+	}
+	_, err := s.db.Exec(ctx,
+		`UPDATE ocr_jobs SET status = $2, last_error = $3, updated_at = NOW() WHERE id = $1`,
+		job.ID, status, msg)
+	return err
+}
+
+// Skip schließt einen Auftrag ohne Text ab – etwa wenn die Datei inzwischen
+// gelöscht wurde. 'done' statt 'failed': Es ist nichts schiefgegangen.
+func (s *Store) Skip(ctx context.Context, jobID uuid.UUID, reason string) error {
+	_, err := s.db.Exec(ctx,
+		`UPDATE ocr_jobs SET status = 'done', last_error = $2, updated_at = NOW() WHERE id = $1`,
+		jobID, reason)
+	return err
+}
+
+// Stats zählt die Aufträge je Zustand – für die Anzeige im Admin-Bereich und
+// für die Prüfung, ob der Arbeiter überhaupt vorankommt.
+type Stats struct {
+	Pending int `json:"pending"`
+	Running int `json:"running"`
+	Done    int `json:"done"`
+	Failed  int `json:"failed"`
+	// Indexed ist die Zahl der Dateien mit gespeichertem Text.
+	Indexed int `json:"indexed"`
+}
+
+func (s *Store) Stats(ctx context.Context) (Stats, error) {
+	var st Stats
+	err := s.db.QueryRow(ctx, `
+		SELECT COUNT(*) FILTER (WHERE status = 'pending'),
+		       COUNT(*) FILTER (WHERE status = 'running'),
+		       COUNT(*) FILTER (WHERE status = 'done'),
+		       COUNT(*) FILTER (WHERE status = 'failed'),
+		       (SELECT COUNT(*) FROM file_text)
+		  FROM ocr_jobs`,
+	).Scan(&st.Pending, &st.Running, &st.Done, &st.Failed, &st.Indexed)
+	if err != nil {
+		return st, fmt.Errorf("ocr stats: %w", err)
+	}
+	return st, nil
+}
+
+// StatsForUser zählt nur, was diesem Nutzer gehört.
+//
+// Warum es das getrennt von Stats gibt: Den Gesamtstand darf nur der
+// Administrator sehen – die Zahl aller Dokumente auf dem Server verrät etwas
+// über fremde Bestände. Wissen muss es aber genau der, der die Rechnung
+// hochgeladen hat: Findet seine Suche sie nicht, ist die Frage „ist sie schon
+// gelesen?" die erste, die er stellt.
+//
+// Gezählt wird über owner_id, also die eigenen Dateien. Dateien in
+// Gruppenordnern bleiben außen vor – sie gehören der Gruppe, und ihr Stand
+// wäre für den Einzelnen keine Auskunft über den eigenen Bestand.
+func (s *Store) StatsForUser(ctx context.Context, userID uuid.UUID) (Stats, error) {
+	var st Stats
+	err := s.db.QueryRow(ctx, `
+		SELECT COUNT(*) FILTER (WHERE j.status = 'pending'),
+		       COUNT(*) FILTER (WHERE j.status = 'running'),
+		       COUNT(*) FILTER (WHERE j.status = 'done'),
+		       COUNT(*) FILTER (WHERE j.status = 'failed'),
+		       COUNT(*) FILTER (WHERE t.file_id IS NOT NULL)
+		  FROM files f
+		  JOIN ocr_jobs j ON j.file_id = f.id
+		  LEFT JOIN file_text t ON t.file_id = f.id
+		 WHERE f.owner_id = $1 AND f.is_deleted = false`,
+		userID,
+	).Scan(&st.Pending, &st.Running, &st.Done, &st.Failed, &st.Indexed)
+	if err != nil {
+		return st, fmt.Errorf("ocr stats for user: %w", err)
+	}
+	return st, nil
+}
+
+// EnqueueMissing trägt alle Bestandsdateien nach, die noch keinen Auftrag
+// haben. Ohne das bliebe alles unauffindbar, was vor dem Einbau hochgeladen
+// wurde – und das ist beim ersten Start genau der gesamte Bestand.
+//
+// Die Auswahl der Typen passiert hier in SQL statt über Supported(): Bei
+// zehntausend Dateien wäre es Unfug, jede einzelne nach Go zu holen, nur um
+// ihren MIME-Typ anzusehen.
+func (s *Store) EnqueueMissing(ctx context.Context, limit int) (int, error) {
+	tag, err := s.db.Exec(ctx, `
+		INSERT INTO ocr_jobs (file_id, status)
+		SELECT f.id, 'pending'
+		  FROM files f
+		 WHERE f.is_deleted = false
+		   AND (f.mime_type ILIKE '%pdf%'
+		        OR (f.mime_type ILIKE 'image/%' AND f.mime_type NOT ILIKE '%svg%')
+		        OR f.name ~* '\.(pdf|png|jpe?g|tiff?|bmp|webp)$')
+		   AND NOT EXISTS (SELECT 1 FROM ocr_jobs j WHERE j.file_id = f.id)
+		 ORDER BY f.created_at DESC
+		 LIMIT $1
+		ON CONFLICT (file_id) DO NOTHING`, limit)
+	if err != nil {
+		return 0, fmt.Errorf("enqueue missing: %w", err)
+	}
+	return int(tag.RowsAffected()), nil
+}
+
+// EnqueueOutdated legt Einträge erneut in die Warteschlange, die nach einer
+// älteren Regel entstanden sind.
+//
+// Anlass war die Seitenmarke: Bis Fassung 1 wurde der Seitenumbruch aus dem
+// Text entfernt. Wer damit indiziert wurde, ist zwar auffindbar – aber der
+// Betrachter kann bei einem Scan nicht sagen, auf welcher Seite das Wort
+// steht. Ein stiller Rest, der sich nur durch erneutes Erkennen auflöst.
+//
+// Bewusst mit derselben Obergrenze wie EnqueueMissing: Bei einem großen
+// Bestand soll ein Neustart nicht die ganze Platte an OCR verheizen, sondern
+// den Rückstand über mehrere Starte abtragen.
+func (s *Store) EnqueueOutdated(ctx context.Context, limit int) (int, error) {
+	tag, err := s.db.Exec(ctx, `
+		INSERT INTO ocr_jobs (file_id, status)
+		SELECT t.file_id, 'pending'
+		  FROM file_text t
+		  JOIN files f ON f.id = t.file_id AND f.is_deleted = false
+		 WHERE t.extract_version < $2
+		 LIMIT $1
+		ON CONFLICT (file_id) DO UPDATE
+		   SET status = 'pending', attempts = 0, last_error = '', updated_at = NOW()`,
+		limit, ExtractVersion)
+	if err != nil {
+		return 0, fmt.Errorf("enqueue outdated: %w", err)
+	}
+	return int(tag.RowsAffected()), nil
+}
+
+// TextPages liefert den erkannten Text einer Datei, in Seiten zerlegt.
+//
+// Für den PDF-Betrachter: Bei einem Scan steht im PDF selbst kein Wort, nur
+// ein Bild. Ohne diesen Weg fände die Suche im Dokument nichts – ausgerechnet
+// bei dem Dateityp, für den der erkannte Text überhaupt gebaut wurde.
+//
+// Die Zugriffsprüfung passiert im Aufrufer; hier liegt nur die Abfrage.
+func (s *Store) TextPages(ctx context.Context, fileID uuid.UUID) ([]string, string, error) {
+	var content, source string
+	err := s.db.QueryRow(ctx,
+		`SELECT content, source FROM file_text WHERE file_id = $1`, fileID,
+	).Scan(&content, &source)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, "", nil
+	}
+	if err != nil {
+		return nil, "", fmt.Errorf("text pages: %w", err)
+	}
+	return strings.Split(content, "\f"), source, nil
+}
+
+// DeleteText entfernt den Text einer Datei. Wird beim endgültigen Löschen
+// gebraucht; solange die Datei nur im Papierkorb liegt, bleibt er stehen –
+// beim Wiederherstellen wäre er sonst weg.
+func (s *Store) DeleteText(ctx context.Context, fileID uuid.UUID) error {
+	_, err := s.db.Exec(ctx, `DELETE FROM file_text WHERE file_id = $1`, fileID)
+	return err
+}
diff --git a/backend/internal/documents/worker.go b/backend/internal/documents/worker.go
new file mode 100644
index 0000000..d183baf
--- /dev/null
+++ b/backend/internal/documents/worker.go
@@ -0,0 +1,239 @@
+package documents
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"github.com/rs/zerolog"
+
+	"aether/internal/storage"
+)
+
+// idleInterval ist die Pause, wenn nichts zu tun ist.
+//
+// Abfragen statt Benachrichtigen (LISTEN/NOTIFY) ist hier die richtige Wahl:
+// Eine Abfrage auf einen Teilindex kostet nichts, und der Arbeiter muss ohnehin
+// regelmäßig nachsehen – ein Auftrag kann auch dadurch entstehen, dass der
+// Server beim letzten Mal mittendrin ausgefallen ist. Fünf Sekunden Verzug
+// spielen bei einer Aufgabe, die selbst Sekunden bis Minuten dauert, keine
+// Rolle.
+const idleInterval = 5 * time.Second
+
+// busyInterval: Wurde gerade etwas erledigt, sofort weitermachen. Eine kurze
+// Pause bleibt trotzdem, damit ein Stapel von hundert Scans nicht die ganze
+// Maschine belegt und die Cloud daneben zäh wird.
+const busyInterval = 200 * time.Millisecond
+
+// maxFileBytes: Größeres wird übersprungen. Der Arbeiter muss die Datei in eine
+// temporäre Kopie schreiben, bevor die Werkzeuge sie lesen können; ein
+// 4-GB-Video würde dabei die Platte füllen – und Text ist darin ohnehin keiner.
+const maxFileBytes = 512 << 20 // 512 MiB
+
+// Worker arbeitet die Warteschlange ab. Einer genügt: OCR lastet einen Kern
+// voll aus, und mehrere parallel machen auf einem Heimserver die Oberfläche
+// zäh, ohne insgesamt schneller fertig zu sein.
+type Worker struct {
+	store   *Store
+	blobs   storage.Storage
+	extract *Extractor
+	log     zerolog.Logger
+	// paused merkt sich, ob wegen Platzmangels gerade nichts läuft – nur damit
+	// die Warnung einmal im Log steht und nicht alle fünf Sekunden.
+	paused bool
+}
+
+func NewWorker(store *Store, blobs storage.Storage, ex *Extractor, log zerolog.Logger) *Worker {
+	return &Worker{store: store, blobs: blobs, extract: ex, log: log.With().Str("component", "ocr").Logger()}
+}
+
+// Run läuft, bis der Kontext endet. Gedacht für `go worker.Run(ctx)` beim Start.
+func (w *Worker) Run(ctx context.Context) {
+	w.log.Info().
+		Str("languages", w.extract.Languages).
+		Int("max_pages", w.extract.MaxPages).
+		Msg("OCR-Arbeiter gestartet")
+
+	// Angefangene Dateien eines hart beendeten Laufs wegräumen (siehe
+	// sweepTemp). Einmal beim Start genügt: Während des Betriebs räumt der
+	// Arbeiter selbst auf.
+	if n, freed := sweepTemp(w.extract.TmpDir); n > 0 {
+		w.log.Info().Int("files", n).Int64("bytes", freed).
+			Msg("Zwischendateien eines früheren Laufs entfernt")
+	}
+
+	for {
+		wait := idleInterval
+		if w.step(ctx) {
+			wait = busyInterval
+		}
+		select {
+		case <-ctx.Done():
+			w.log.Info().Msg("OCR-Arbeiter beendet")
+			return
+		case <-time.After(wait):
+		}
+	}
+}
+
+// step erledigt höchstens einen Auftrag. Rückgabe: ob etwas zu tun war.
+func (w *Worker) step(ctx context.Context) bool {
+	// Vor dem Zugreifen nachsehen, nicht danach: Ein Auftrag, den wir schon
+	// auf 'running' gesetzt haben, hätte einen Versuch verbraucht, obwohl es
+	// gar nicht an ihm lag.
+	if free, err := freeBytes(w.extract.TmpDir); err == nil && free < minFreeBytes {
+		// Nur einmal je Zustandswechsel melden – sonst füllt die Warnung im
+		// Fünf-Sekunden-Takt den Log, und das ausgerechnet, wenn der Platz
+		// knapp ist.
+		if !w.paused {
+			w.paused = true
+			w.log.Warn().
+				Uint64("free_mb", free/(1<<20)).
+				Uint64("needed_mb", uint64(minFreeBytes)/(1<<20)).
+				Msg("Texterkennung pausiert: zu wenig Platz auf der Platte")
+		}
+		return false
+	} else if w.paused {
+		w.paused = false
+		w.log.Info().Msg("Texterkennung fortgesetzt: wieder genug Platz")
+	}
+
+	job, err := w.store.Claim(ctx)
+	if errors.Is(err, ErrNoJob) {
+		return false
+	}
+	if err != nil {
+		// Datenbank weg oder Kontext beendet – nicht in einer engen Schleife
+		// weiterprobieren.
+		if ctx.Err() == nil {
+			w.log.Warn().Err(err).Msg("Auftrag holen fehlgeschlagen")
+		}
+		return false
+	}
+
+	start := time.Now()
+	res, err := w.process(ctx, job)
+	if err != nil {
+		if ctx.Err() != nil {
+			// Herunterfahren mitten im Lauf ist kein Fehler der Datei. Der
+			// Auftrag steht auf 'running' und wird beim nächsten Start wieder
+			// aufgegriffen – genau dafür nimmt Claim auch 'running' mit.
+			return false
+		}
+		w.log.Warn().Err(err).
+			Str("file", job.Name).Int("attempt", job.Attempts).
+			Msg("Texterkennung fehlgeschlagen")
+		if err := w.store.Fail(context.WithoutCancel(ctx), job, err); err != nil {
+			w.log.Error().Err(err).Msg("Fehlschlag konnte nicht vermerkt werden")
+		}
+		return true
+	}
+
+	if err := w.store.Complete(ctx, job, res); err != nil {
+		w.log.Error().Err(err).Str("file", job.Name).Msg("Text konnte nicht gespeichert werden")
+		return true
+	}
+	w.log.Info().
+		Str("file", job.Name).
+		Str("source", res.Source).
+		Int("chars", res.Chars).
+		Int("pages", res.Pages).
+		Dur("took", time.Since(start)).
+		Msg("Text erkannt")
+	return true
+}
+
+func (w *Worker) process(ctx context.Context, job *Job) (Result, error) {
+	if job.Size > maxFileBytes {
+		return Result{}, fmt.Errorf("Datei zu groß für die Texterkennung (%d Bytes)", job.Size)
+	}
+	if !Supported(job.MimeType, job.Name) {
+		// Kann vorkommen, wenn der MIME-Typ nachträglich korrigiert wurde.
+		// Kein Fehler – nur nichts zu tun.
+		return Result{}, w.store.Skip(ctx, job.ID, "Dateityp trägt keinen Text")
+	}
+
+	// Die Werkzeuge sind externe Programme und brauchen einen Pfad; die
+	// Ablageschicht gibt grundsätzlich nur einen Datenstrom heraus, weil sie
+	// später auch S3 bedienen soll.
+	//
+	// Bei der lokalen Ablage gibt es den Pfad aber wirklich – dann wird
+	// **nicht** kopiert. Das ist kein Feinschliff: Eine Kopie bedeutet, dass
+	// neben jedem Dokument kurzzeitig noch einmal dieselbe Menge auf der
+	// Platte liegt, und die Erkennung läuft ausgerechnet auf einer Maschine,
+	// die auch alle Dateien beherbergt.
+	path, cleanup, err := w.materialize(ctx, job)
+	if err != nil {
+		return Result{}, err
+	}
+	defer cleanup()
+
+	return w.extract.Extract(ctx, path, job.MimeType, job.Name)
+}
+
+// materialize besorgt einen Pfad zur Datei – ohne Kopie, wo es geht.
+//
+// Der zurückgegebene cleanup räumt nur auf, wenn tatsächlich kopiert wurde. Er
+// darf das Original niemals löschen; deshalb die klare Trennung der beiden
+// Zweige statt eines gemeinsamen Pfads mit einem Merker.
+func (w *Worker) materialize(ctx context.Context, job *Job) (string, func(), error) {
+	if lp, ok := w.blobs.(storage.LocalPather); ok {
+		path, err := lp.LocalPath(job.StorageKey)
+		if err == nil {
+			// Nichts zu räumen: Das ist die Datei selbst. Gelesen wird sie nur.
+			return path, func() {}, nil
+		}
+		// Kein Abbruch – der Weg über die Kopie funktioniert weiterhin.
+		w.log.Debug().Err(err).Str("key", job.StorageKey).
+			Msg("kein lokaler Pfad, weiche auf Kopie aus")
+	}
+
+	rc, err := w.blobs.Get(ctx, job.StorageKey)
+	if err != nil {
+		return "", nil, fmt.Errorf("Datei lesen: %w", err)
+	}
+	defer rc.Close()
+
+	// Die Endung mitnehmen: ocrmypdf und tesseract entscheiden auch danach,
+	// was sie vor sich haben.
+	pattern := "ocr-*" + extOf(job.Name)
+	var tmp *os.File
+	if tf, ok := w.blobs.(storage.TempFiler); ok {
+		// Über die Ablageschicht, damit die Kopie auf derselben Platte landet
+		// wie die Daten – nicht in einem knappen /tmp im Container.
+		tmp, err = tf.CreateTemp(pattern)
+	} else {
+		tmp, err = os.CreateTemp("", pattern)
+	}
+	if err != nil {
+		return "", nil, fmt.Errorf("Zwischendatei anlegen: %w", err)
+	}
+	name := tmp.Name()
+	cleanup := func() { os.Remove(name) }
+
+	if _, err := io.Copy(tmp, rc); err != nil {
+		tmp.Close()
+		cleanup()
+		return "", nil, fmt.Errorf("Zwischendatei schreiben: %w", err)
+	}
+	if err := tmp.Close(); err != nil {
+		cleanup()
+		return "", nil, fmt.Errorf("Zwischendatei schließen: %w", err)
+	}
+	return name, cleanup, nil
+}
+
+func extOf(name string) string {
+	for i := len(name) - 1; i >= 0 && len(name)-i <= 6; i-- {
+		if name[i] == '.' {
+			return name[i:]
+		}
+		if name[i] == '/' {
+			break
+		}
+	}
+	return ""
+}
diff --git a/backend/internal/files/access.go b/backend/internal/files/access.go
new file mode 100644
index 0000000..6f00f87
--- /dev/null
+++ b/backend/internal/files/access.go
@@ -0,0 +1,63 @@
+package files
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/google/uuid"
+
+	"aether/internal/acl"
+	"aether/internal/auth"
+	"aether/pkg/response"
+)
+
+// Zugriffsprüfung für Dateien und Ordner, die dem Anfragenden nicht selbst
+// gehören müssen.
+//
+// Die Datenbankschicht arbeitet durchgehend eigentümerbezogen (`WHERE owner_id
+// = $x`) – daran ändert sich nichts. Stattdessen klären diese Helfer vorab, in
+// wessen Namen die Operation läuft: bei eigenen Daten der Anfragende selbst,
+// bei geliehenen der Eigentümer. Danach sieht der Rest des Handlers aus wie
+// vorher.
+
+// resolveFile liefert den Zugriffskontext für eine Datei. Ist der Zugriff nicht
+// erlaubt, ist die Antwort bereits geschrieben und der zweite Rückgabewert
+// false – der Handler bricht dann einfach ab.
+func (h *Handler) resolveFile(w http.ResponseWriter, r *http.Request, id uuid.UUID, needWrite bool) (acl.Access, bool) {
+	user := auth.UserFromContext(r.Context())
+	if h.acl == nil {
+		return acl.Access{OwnerID: user.ID, OwnerUsername: user.Username, OwnerQuota: user.QuotaBytes, Permission: acl.PermWrite}, true
+	}
+	a, err := h.acl.ResolveFile(r.Context(), user.ID, id)
+	return finish(w, a, err, needWrite, "file")
+}
+
+// resolveFolder ist dasselbe für Ordner. folderID darf nil sein – das ist die
+// eigene Wurzel, die niemandem sonst gehört.
+func (h *Handler) resolveFolder(w http.ResponseWriter, r *http.Request, id *uuid.UUID, needWrite bool) (acl.Access, bool) {
+	user := auth.UserFromContext(r.Context())
+	own := acl.Access{OwnerID: user.ID, OwnerUsername: user.Username, OwnerQuota: user.QuotaBytes, Permission: acl.PermWrite}
+	if h.acl == nil || id == nil {
+		return own, true
+	}
+	a, err := h.acl.ResolveFolder(r.Context(), user.ID, *id)
+	return finish(w, a, err, needWrite, "folder")
+}
+
+func finish(w http.ResponseWriter, a acl.Access, err error, needWrite bool, kind string) (acl.Access, bool) {
+	switch {
+	case errors.Is(err, acl.ErrNotFound), errors.Is(err, acl.ErrNoAccess):
+		// Absichtlich 404 statt 403: Ein „verboten" verriete, dass es die ID
+		// gibt. Wer keinen Zugriff hat, soll nicht einmal das erfahren.
+		response.Error(w, http.StatusNotFound, kind+" not found")
+		return acl.Access{}, false
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return acl.Access{}, false
+	}
+	if needWrite && !a.CanWrite() {
+		response.Error(w, http.StatusForbidden, "you only have read access to this "+kind)
+		return acl.Access{}, false
+	}
+	return a, true
+}
diff --git a/backend/internal/files/groupfolder.go b/backend/internal/files/groupfolder.go
new file mode 100644
index 0000000..9105697
--- /dev/null
+++ b/backend/internal/files/groupfolder.go
@@ -0,0 +1,165 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+)
+
+// Gruppenordner: Ordner, die keinem Konto gehören, sondern einer Gruppe.
+// Sichtbar für jedes Mitglied, angelegt und entfernt ausschließlich vom Admin.
+
+// ErrGroupRootProtected: Der Wurzelordner einer Gruppe lässt sich nicht aus der
+// Dateiansicht heraus löschen oder umbenennen. Er ist kein gewöhnlicher Ordner,
+// sondern der Zugang der Gruppe – wenn ein beliebiges Mitglied ihn entfernen
+// könnte, wären die Daten aller anderen mit weg. Verwaltet wird er im
+// Admin-Bereich; alles *innerhalb* bleibt normal löschbar.
+var ErrGroupRootProtected = errors.New("group folder can only be removed by an administrator")
+
+// ErrGroupFolderExists: Eine Gruppe hat genau einen Ordner, nicht mehrere.
+// Das hält das Modell verständlich („der Ordner der Gruppe") und erlaubt es,
+// beim Löschen den gesamten Speicherbereich der Gruppe in einem Zug zu
+// entfernen, statt Blob für Blob – wodurch keine leeren Verzeichnisse
+// zurückbleiben. Wer mehr Struktur braucht, legt Unterordner an.
+var ErrGroupFolderExists = errors.New("this group already has a folder")
+
+// GroupFolder ist ein Gruppenordner samt Gruppe – für die Admin-Übersicht.
+type GroupFolder struct {
+	ID        uuid.UUID `json:"id"`
+	Name      string    `json:"name"`
+	GroupID   uuid.UUID `json:"group_id"`
+	GroupName string    `json:"group_name"`
+	Members   int       `json:"members"`
+	UsedBytes int64     `json:"used_bytes"`
+	QuotaByte int64     `json:"quota_bytes"`
+}
+
+// IsGroupRoot sagt, ob ein Ordner der Wurzelordner einer Gruppe ist.
+func (s *Store) IsGroupRoot(ctx context.Context, folderID uuid.UUID) (bool, error) {
+	var isRoot bool
+	err := s.db.QueryRow(ctx,
+		`SELECT group_id IS NOT NULL AND parent_id IS NULL FROM folders WHERE id = $1`,
+		folderID).Scan(&isRoot)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return false, ErrNotFound
+	}
+	if err != nil {
+		return false, fmt.Errorf("check group root: %w", err)
+	}
+	return isRoot, nil
+}
+
+// GroupName liefert den Namen einer Gruppe – für die Beschriftung des
+// Gruppenordners in WebDAV.
+func (s *Store) GroupName(ctx context.Context, groupID uuid.UUID) (string, error) {
+	var name string
+	err := s.db.QueryRow(ctx, `SELECT name FROM groups WHERE id = $1`, groupID).Scan(&name)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return "", ErrNotFound
+	}
+	if err != nil {
+		return "", fmt.Errorf("group name: %w", err)
+	}
+	return name, nil
+}
+
+// ListGroupFoldersForUser liefert die Gruppenordner, die dem Nutzer über seine
+// Mitgliedschaften zustehen. Sie erscheinen in seiner Wurzel neben den eigenen
+// Ordnern – ohne dass er etwas dafür tun muss.
+func (s *Store) ListGroupFoldersForUser(ctx context.Context, userID uuid.UUID) ([]*Folder, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT f.id, f.owner_id, f.group_id, f.parent_id, f.name, f.created_at
+		   FROM folders f
+		   JOIN group_members m ON m.group_id = f.group_id
+		  WHERE m.user_id = $1 AND f.parent_id IS NULL
+		  ORDER BY f.name`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("list group folders: %w", err)
+	}
+	defer rows.Close()
+
+	out := []*Folder{}
+	for rows.Next() {
+		var f Folder
+		if err := rows.Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan group folder: %w", err)
+		}
+		out = append(out, &f)
+	}
+	return out, rows.Err()
+}
+
+// ListGroupFolders liefert alle Gruppenordner für den Admin-Bereich.
+func (s *Store) ListGroupFolders(ctx context.Context) ([]*GroupFolder, error) {
+	rows, err := s.db.Query(ctx, `
+		SELECT f.id, f.name, g.id, g.name, g.quota_bytes,
+		       (SELECT count(*) FROM group_members m WHERE m.group_id = g.id),
+		       COALESCE((SELECT SUM(x.size) FROM files x
+		                  WHERE x.group_id = g.id AND x.is_deleted = false), 0)
+		  FROM folders f
+		  JOIN groups g ON g.id = f.group_id
+		 WHERE f.parent_id IS NULL
+		 ORDER BY g.name, f.name`)
+	if err != nil {
+		return nil, fmt.Errorf("list group folders: %w", err)
+	}
+	defer rows.Close()
+
+	out := []*GroupFolder{}
+	for rows.Next() {
+		var gf GroupFolder
+		if err := rows.Scan(&gf.ID, &gf.Name, &gf.GroupID, &gf.GroupName,
+			&gf.QuotaByte, &gf.Members, &gf.UsedBytes); err != nil {
+			return nil, fmt.Errorf("scan group folder: %w", err)
+		}
+		out = append(out, &gf)
+	}
+	return out, rows.Err()
+}
+
+// CreateGroupFolder legt den Wurzelordner einer Gruppe an.
+func (s *Store) CreateGroupFolder(ctx context.Context, groupID uuid.UUID, name string) (*Folder, error) {
+	var exists bool
+	if err := s.db.QueryRow(ctx,
+		`SELECT EXISTS (SELECT 1 FROM folders WHERE group_id = $1 AND parent_id IS NULL)`,
+		groupID).Scan(&exists); err != nil {
+		return nil, fmt.Errorf("check existing group folder: %w", err)
+	}
+	if exists {
+		return nil, ErrGroupFolderExists
+	}
+	return s.CreateFolder(ctx, &Folder{GroupID: &groupID, Name: name})
+}
+
+// DeleteGroupFolderTree entfernt einen Gruppenordner mit allem darin und gibt
+// die Gruppen-ID zurück, damit der Aufrufer deren Speicherbereich am Stück
+// entfernen kann. Nur für den Admin-Bereich gedacht.
+func (s *Store) DeleteGroupFolderTree(ctx context.Context, folderID uuid.UUID) (uuid.UUID, error) {
+	var groupID *uuid.UUID
+	var parentID *uuid.UUID
+	err := s.db.QueryRow(ctx,
+		`SELECT group_id, parent_id FROM folders WHERE id = $1`, folderID).Scan(&groupID, &parentID)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return uuid.Nil, ErrNotFound
+	}
+	if err != nil {
+		return uuid.Nil, fmt.Errorf("load group folder: %w", err)
+	}
+	if groupID == nil || parentID != nil {
+		return uuid.Nil, ErrNotFound
+	}
+
+	// Dateien zuerst: Die Kaskade über folders nimmt nur mit, was unter dem
+	// Ordner hängt. Dateien direkt in der Wurzel hätten sonst keinen
+	// Elternteil mehr, der sie entfernt.
+	if _, err := s.db.Exec(ctx, `DELETE FROM files WHERE group_id = $1`, *groupID); err != nil {
+		return uuid.Nil, fmt.Errorf("delete group files: %w", err)
+	}
+	if _, err := s.db.Exec(ctx, `DELETE FROM folders WHERE group_id = $1`, *groupID); err != nil {
+		return uuid.Nil, fmt.Errorf("delete group folders: %w", err)
+	}
+	return *groupID, nil
+}
diff --git a/backend/internal/files/handler.go b/backend/internal/files/handler.go
new file mode 100644
index 0000000..7f3dced
--- /dev/null
+++ b/backend/internal/files/handler.go
@@ -0,0 +1,781 @@
+package files
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"io"
+	"mime"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/acl"
+	"aether/internal/audit"
+	"aether/internal/auth"
+	"aether/internal/documents"
+	"aether/internal/storage"
+	"aether/internal/tags"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+const maxUploadSize = 5 << 30 // 5 GB
+
+// maxVersionsKept begrenzt den Verlauf einer Datei mit aktivierter
+// Versionierung. Ältere Fassungen werden samt Blob entfernt.
+const maxVersionsKept = 5
+
+type Handler struct {
+	store   *Store
+	storage storage.Storage
+	auditor *audit.Logger
+	acl     *acl.Store
+	// tags darf nil sein – die Dateiliste funktioniert dann ohne Aufkleber.
+	tags *tags.Store
+	// docs darf nil sein – dann ist die Texterkennung abgeschaltet und der
+	// PDF-Betrachter sucht nur in dem Text, den das PDF selbst mitbringt.
+	docs *documents.Store
+}
+
+func NewHandler(store *Store, st storage.Storage, auditor *audit.Logger, aclStore *acl.Store, tagStore *tags.Store, docStore *documents.Store) *Handler {
+	return &Handler{store: store, storage: st, auditor: auditor, acl: aclStore, tags: tagStore, docs: docStore}
+}
+
+// logFile protokolliert Löschvorgänge. Normale Uploads und Downloads bleiben
+// bewusst draußen: bei Dutzenden Dateien am Tag ersäuft sonst das, worauf es
+// ankommt – nämlich was verschwunden ist.
+func (h *Handler) logFile(r *http.Request, action, targetID, targetName, detail string) {
+	user := auth.UserFromContext(r.Context())
+	e := audit.Event{
+		Action:     action,
+		TargetType: "file",
+		TargetID:   targetID,
+		TargetName: targetName,
+		Detail:     detail,
+		IP:         middleware.RealIP(r),
+	}
+	if user != nil {
+		e.ActorID = &user.ID
+		e.ActorName = user.Username
+	}
+	h.auditor.Log(r.Context(), e)
+}
+
+// POST /api/v1/files
+func (h *Handler) Upload(w http.ResponseWriter, r *http.Request) {
+	r.Body = http.MaxBytesReader(w, r.Body, maxUploadSize)
+	mr, err := r.MultipartReader()
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "expected multipart upload")
+		return
+	}
+
+	// The frontend sends folder_id BEFORE the file part, so we know the target
+	// folder by the time we reach the streamed file content.
+	var folderID *uuid.UUID
+
+	for {
+		part, err := mr.NextPart()
+		if errors.Is(err, io.EOF) {
+			break
+		}
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "failed to read upload")
+			return
+		}
+
+		switch part.FormName() {
+		case "folder_id":
+			buf, _ := io.ReadAll(io.LimitReader(part, 256))
+			part.Close()
+			fid := strings.TrimSpace(string(buf))
+			if fid == "" {
+				continue
+			}
+			id, err := uuid.Parse(fid)
+			if err != nil {
+				response.Error(w, http.StatusBadRequest, "invalid folder_id")
+				return
+			}
+			folderID = &id
+
+		case "file":
+			// Erst hier steht der Zielordner fest – das Frontend schickt
+			// folder_id vor dem Dateiteil. Zugriff und Eigentümer werden
+			// deshalb an dieser Stelle geklärt, nicht früher.
+			owner, ok := h.resolveFolder(w, r, folderID, true)
+			if !ok {
+				part.Close()
+				return
+			}
+
+			filename := SanitizeFilename(part.FileName())
+			if filename == "" {
+				part.Close()
+				response.Error(w, http.StatusBadRequest, "file field required")
+				return
+			}
+			mimeType := detectMIME(filename, part.Header.Get("Content-Type"))
+			// Stream the part body straight into storage – no full-file buffering.
+			h.storeUploadedFile(w, r, owner, folderID, filename, mimeType, part)
+			part.Close()
+			return
+
+		default:
+			part.Close()
+		}
+	}
+
+	response.Error(w, http.StatusBadRequest, "file field required")
+}
+
+// storeUploadedFile streams content into storage and writes the file metadata.
+// Handles versioning when a file of the same name already exists. It writes the
+// HTTP response itself (success or error).
+// storeUploadedFile schreibt im Namen von owner. Bei eigenen Uploads ist das
+// der Anfragende selbst; in einem geliehenen Ordner der Eigentümer – die Datei
+// landet in dessen Bereich und zählt gegen dessen Kontingent.
+func (h *Handler) storeUploadedFile(w http.ResponseWriter, r *http.Request, owner acl.Access, folderID *uuid.UUID, filename, mimeType string, content io.Reader) {
+	// Build human-readable storage key mirroring the app folder structure.
+	folderPath, err := h.store.GetFolderPath(r.Context(), folderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	storageKey := BuildStorageKey(owner.StorageRoot(), folderPath, filename)
+
+	// Versioning: if a file with the same name already exists, preserve old content.
+	existing, err := h.store.GetFileByName(r.Context(), owner.OwnerID, folderID, filename)
+	if err != nil && !errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	if existing != nil {
+		// Die alte Fassung zählt nach dem Überschreiben nicht mehr zum Verbrauch.
+		remaining, unlimited, err := h.store.RemainingQuota(r.Context(), owner.OwnerID, owner.OwnerQuota, existing.Size)
+		if err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+
+		// Nur bei aktivierter Versionierung wird die alte Fassung aufgehoben.
+		// Sonst ersetzt Put sie atomar (Temp + Rename) und der Platz bleibt frei.
+		var versionKey string
+		if existing.VersioningEnabled {
+			versionKey = fmt.Sprintf("%s/.versions/%s", owner.StorageRoot(), uuid.New().String())
+			if err := h.storage.Move(r.Context(), existing.StorageKey, versionKey); err != nil {
+				response.Error(w, http.StatusInternalServerError, "storage error")
+				return
+			}
+		}
+
+		if !unlimited {
+			content = newQuotaReader(content, remaining)
+		}
+		checksum, size, err := h.storage.Put(r.Context(), storageKey, content)
+		if err != nil {
+			// Der Blob ist bereits verschoben – zurückrollen, sonst verliert der
+			// Nutzer die bestehende Datei an einen Upload, der nie ankam.
+			if versionKey != "" {
+				if mvErr := h.storage.Move(r.Context(), versionKey, existing.StorageKey); mvErr != nil {
+					log.Ctx(r.Context()).Error().Err(mvErr).
+						Str("file_id", existing.ID.String()).
+						Msg("rollback of version move failed – blob orphaned")
+				}
+			}
+			if errors.Is(err, ErrQuotaExceeded) {
+				response.Error(w, http.StatusRequestEntityTooLarge, "storage quota exceeded")
+				return
+			}
+			response.Error(w, http.StatusInternalServerError, "storage error")
+			return
+		}
+
+		if versionKey != "" {
+			if err := h.store.CreateVersion(r.Context(), existing.ID, existing.Version, existing.Size, existing.Checksum, versionKey); err != nil {
+				response.Error(w, http.StatusInternalServerError, "database error")
+				return
+			}
+		} else if existing.StorageKey != storageKey {
+			// Altbestand unter abweichendem Pfad (z.B. früherer WebDAV-Upload):
+			// Put hat ihn nicht ersetzt, er wäre sonst verwaist.
+			_ = h.storage.Delete(r.Context(), existing.StorageKey)
+		}
+
+		updated, err := h.store.UpdateFileContent(r.Context(), existing.ID, size, checksum, storageKey)
+		if err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+		if oldKeys, err := h.store.PruneVersions(r.Context(), existing.ID, maxVersionsKept); err == nil {
+			for _, key := range oldKeys {
+				_ = h.storage.Delete(r.Context(), key)
+			}
+		}
+		_ = h.storage.Delete(r.Context(), "thumbs/"+existing.ID.String()+".jpg")
+		response.JSON(w, http.StatusCreated, updated)
+		return
+	}
+
+	remaining, unlimited, err := h.store.RemainingQuota(r.Context(), owner.OwnerID, owner.OwnerQuota, 0)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if !unlimited {
+		content = newQuotaReader(content, remaining)
+	}
+
+	checksum, size, err := h.storage.Put(r.Context(), storageKey, content)
+	if err != nil {
+		if errors.Is(err, ErrQuotaExceeded) {
+			response.Error(w, http.StatusRequestEntityTooLarge, "storage quota exceeded")
+			return
+		}
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+	created, err := h.store.CreateFile(r.Context(), &File{
+		OwnerID:    owner.OwnerRef(),
+		GroupID:    owner.GroupRef(),
+		FolderID:   folderID,
+		Name:       filename,
+		MimeType:   mimeType,
+		Size:       size,
+		Checksum:   checksum,
+		StorageKey: storageKey,
+	})
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusCreated, created)
+}
+
+// GET /api/v1/files
+// Search GET /api/v1/search?q=…
+//
+// Der Umfang steckt in der Abfrage, nicht hier: Store.Search liefert nur, was
+// der Anfragende ohnehin erreichen darf. Ein nachgelagerter Filter wäre die
+// Variante, bei der man einen Fall vergisst.
+func (h *Handler) Search(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	query := strings.TrimSpace(r.URL.Query().Get("q"))
+	// Ein einzelnes Zeichen trifft fast alles und kostet nur – die Oberfläche
+	// fragt deshalb erst ab zwei Zeichen, und der Server hält sich daran.
+	if len([]rune(query)) < 2 {
+		response.JSON(w, http.StatusOK, map[string]any{"hits": []any{}, "query": query})
+		return
+	}
+
+	hits, err := h.store.Search(r.Context(), user.ID, query)
+	if err != nil {
+		log.Ctx(r.Context()).Error().Err(err).Msg("search failed")
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, map[string]any{
+		"hits":  hits,
+		"query": query,
+		// truncated sagt der Oberfläche, dass sie „mehr als 100" anzeigen soll –
+		// sonst sieht eine abgeschnittene Liste wie eine vollständige aus.
+		"truncated": len(hits) >= SearchLimit,
+	})
+}
+
+func (h *Handler) List(w http.ResponseWriter, r *http.Request) {
+	var folderID *uuid.UUID
+	if fid := r.URL.Query().Get("folder_id"); fid != "" {
+		id, err := uuid.Parse(fid)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid folder_id")
+			return
+		}
+		folderID = &id
+	}
+
+	owner, ok := h.resolveFolder(w, r, folderID, false)
+	if !ok {
+		return
+	}
+
+	files, err := h.store.ListFiles(r.Context(), owner.OwnerID, folderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	folders, err := h.store.ListFolders(r.Context(), owner.OwnerID, folderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// In der Wurzel kommen die Gruppenordner dazu, in denen der Anfragende
+	// Mitglied ist. Sie gehören ihm nicht, erscheinen aber neben seinen eigenen
+	// Ordnern – das ist der Punkt an einem Gruppenordner.
+	if folderID == nil {
+		user := auth.UserFromContext(r.Context())
+		groupFolders, err := h.store.ListGroupFoldersForUser(r.Context(), user.ID)
+		if err != nil {
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+		folders = append(folders, groupFolders...)
+	}
+
+	if files == nil {
+		files = []*File{}
+	}
+	if folders == nil {
+		folders = []*Folder{}
+	}
+
+	// Etiketten zu allen Dateien in *einer* Abfrage nachladen, nicht je Datei.
+	// Bei fünfzig Kacheln wären das sonst fünfzig Rundreisen zur Datenbank, nur
+	// um ein paar Aufkleber zu zeichnen.
+	fileTags := map[string]any{}
+	fileCorrespondents := map[string]any{}
+	if h.tags != nil && len(files) > 0 {
+		ids := make([]uuid.UUID, 0, len(files))
+		for _, f := range files {
+			ids = append(ids, f.ID)
+		}
+		if m, err := h.tags.ForFiles(r.Context(), ids); err == nil {
+			for id, list := range m {
+				fileTags[id.String()] = list
+			}
+		}
+		// Der Absender kommt auf demselben Weg: eine Abfrage für alle Kacheln.
+		if m, err := h.tags.CorrespondentsForFiles(r.Context(), ids); err == nil {
+			for id, c := range m {
+				fileCorrespondents[id.String()] = c
+			}
+		}
+		// Ein Fehler hier ist kein Grund, die Dateiliste zu verweigern – dann
+		// fehlen eben die Aufkleber.
+	}
+
+	response.JSON(w, http.StatusOK, map[string]any{
+		"files":   files,
+		"folders": folders,
+		// Nicht an der Datei selbst, damit File weiterhin genau das ist, was in
+		// der Tabelle steht – und damit jede andere Stelle, die Dateien
+		// ausliefert, nicht plötzlich leere Etikettenlisten mitschickt.
+		"tags":           fileTags,
+		"correspondents": fileCorrespondents,
+	})
+}
+
+// GET /api/v1/files/{id}/download
+func (h *Handler) Download(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, false)
+	if !ok {
+		return
+	}
+
+	f, err := h.store.GetFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	rc, err := h.storage.Get(r.Context(), f.StorageKey)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+	defer rc.Close()
+
+	// Für ältere Dateien steht in der Datenbank oft application/octet-stream:
+	// Bis zum 23.08.2026 kannte der Server die Endungen .mp3, .mp4 und .zip
+	// nicht (siehe extraMIMETypes). Statt 94 Zeilen nachträglich umzuschreiben,
+	// wird der Typ beim Ausliefern neu bestimmt, wenn der gespeicherte nichts
+	// aussagt – das wirkt sofort und rührt die Daten nicht an.
+	serveType := f.MimeType
+	if serveType == "" || serveType == "application/octet-stream" {
+		serveType = detectMIME(f.Name, "")
+	}
+
+	w.Header().Set("Content-Type", serveType)
+	w.Header().Set("X-Checksum-SHA256", f.Checksum)
+	// Ohne diesen Kopf hält der Browser die Antwort für unteilbar und gibt in
+	// der Abspielleiste von Video und Ton kein Springen frei – man kann dann
+	// nur von vorn bis hinten hören.
+	w.Header().Set("Accept-Ranges", "bytes")
+
+	// Die Vorschau braucht die Datei *im* Browser statt im Download-Ordner.
+	// Das ist die gefährliche Richtung: Eine hochgeladene HTML- oder SVG-Datei
+	// liefe im selben Ursprung wie die Anwendung und käme damit an die
+	// Sitzung. Deshalb inline nur für eine feste Liste harmloser Typen, und
+	// alles andere fällt still auf den Anhang zurück.
+	if r.URL.Query().Get("inline") == "1" && inlineSafe(serveType) {
+		w.Header().Set("Content-Disposition", fmt.Sprintf(`inline; filename=%q`, f.Name))
+		// Kein Typ-Raten: Sonst könnte eine als Bild deklarierte Datei doch als
+		// HTML gedeutet werden.
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+		// sandbox nimmt der Antwort ihren Ursprung – selbst wenn doch etwas
+		// Ausführbares durchkäme, hätte es keinen Zugriff auf Cookies.
+		// allow-scripts nur für PDF: Der eingebaute Betrachter von Chrome ist
+		// selbst ein Skript und zeigt sonst nichts an. Ohne allow-same-origin
+		// bleibt der Ursprung trotzdem fremd, die Sitzung also unerreichbar.
+		sandbox := "sandbox"
+		if strings.HasPrefix(serveType, "application/pdf") {
+			sandbox = "sandbox allow-scripts"
+		}
+		w.Header().Set("Content-Security-Policy",
+			sandbox+"; default-src 'none'; img-src 'self' data:; media-src 'self'; style-src 'unsafe-inline'; frame-ancestors 'self'")
+		// Die Vorschau zeigt die Datei in einem Rahmen der eigenen Anwendung.
+		// Die allgemeine Kopfzeile setzt DENY und verbietet damit auch das –
+		// hier also gezielt auf den eigenen Ursprung heruntergestuft. Fremde
+		// Seiten können die Datei weiterhin nicht einbetten.
+		w.Header().Set("X-Frame-Options", "SAMEORIGIN")
+	} else {
+		w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename=%q`, f.Name))
+	}
+
+	// Springt der Abspieler mitten hinein, übernimmt ServeContent: Es
+	// beantwortet den Range-Kopf mit 206 und dem passenden Ausschnitt.
+	//
+	// Die Prüfsumme bleibt dabei außen vor – sie deckt die ganze Datei ab, und
+	// ein Ausschnitt lässt sich nicht dagegen halten. Beim vollständigen
+	// Abruf, also bei jedem echten Download, wird weiter geprüft.
+	if seeker, ok := rc.(io.ReadSeeker); ok && r.Header.Get("Range") != "" {
+		http.ServeContent(w, r, f.Name, f.UpdatedAt, seeker)
+		return
+	}
+
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", f.Size))
+
+	// Verify checksum while streaming.
+	h256 := sha256.New()
+	reader := io.TeeReader(rc, h256)
+
+	if _, err := io.Copy(w, reader); err != nil {
+		return // client disconnected
+	}
+
+	actual := hex.EncodeToString(h256.Sum(nil))
+	if actual != f.Checksum {
+		// Log corruption; headers already sent, can't change status.
+		// TODO: alert / observability hook
+		_ = actual
+	}
+}
+
+// inlineSafeTypes sind die Typen, die im Browser angezeigt werden dürfen.
+// Bewusst eine Positivliste: Was nicht daraufsteht, wird heruntergeladen.
+// Nicht drauf steht insbesondere SVG – eine SVG-Datei darf Skripte enthalten –
+// und alles, was nach HTML aussieht.
+var inlineSafeTypes = map[string]bool{
+	"image/png":       true,
+	"image/jpeg":      true,
+	"image/gif":       true,
+	"image/webp":      true,
+	"image/bmp":       true,
+	"application/pdf": true,
+	"text/plain":      true,
+	"video/mp4":       true,
+	"video/webm":      true,
+	"audio/mpeg":      true,
+	"audio/ogg":       true,
+	"audio/wav":       true,
+}
+
+func inlineSafe(mimeType string) bool {
+	// Der gespeicherte Typ kann Parameter tragen ("text/plain; charset=utf-8").
+	base := strings.TrimSpace(strings.Split(mimeType, ";")[0])
+	return inlineSafeTypes[strings.ToLower(base)]
+}
+
+// DELETE /api/v1/files/{id}
+func (h *Handler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, true)
+	if !ok {
+		return
+	}
+
+	current, err := h.store.GetFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	trashKey := fmt.Sprintf("%s/.trash/%s_%s", owner.StorageRoot(), id.String()[:8], current.Name)
+	if err := h.storage.Move(r.Context(), current.StorageKey, trashKey); err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+
+	if err := h.store.SoftDeleteFile(r.Context(), id, owner.OwnerID, trashKey); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logFile(r, audit.ActionFileDelete, id.String(), current.Name, "moved to trash")
+	response.NoContent(w)
+}
+
+// PATCH /api/v1/files/{id}/rename
+func (h *Handler) Rename(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, true)
+	if !ok {
+		return
+	}
+
+	var body struct {
+		Name string `json:"name"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Name) == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+
+	newName := SanitizeFilename(body.Name)
+	if newName == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+
+	current, err := h.store.GetFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	folderPath, err := h.store.GetFolderPath(r.Context(), current.FolderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	newStorageKey := BuildStorageKey(owner.StorageRoot(), folderPath, newName)
+
+	if err := h.storage.Move(r.Context(), current.StorageKey, newStorageKey); err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+
+	f, err := h.store.RenameFile(r.Context(), id, owner.OwnerID, newName, newStorageKey)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "name already exists")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, f)
+}
+
+// PATCH /api/v1/files/{id}/move
+func (h *Handler) Move(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, true)
+	if !ok {
+		return
+	}
+
+	var body struct {
+		FolderID *string `json:"folder_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+
+	var folderID *uuid.UUID
+	if body.FolderID != nil && *body.FolderID != "" {
+		fid, err := uuid.Parse(*body.FolderID)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid folder_id")
+			return
+		}
+		// Ziel muss demselben Eigentümer gehören. Ein Verschieben über
+		// Eigentumsgrenzen hinweg würde Bytes zwischen Kontingenten umbuchen
+		// und Freigaben unter der Hand umhängen – bewusst nicht erlaubt.
+		// Zum Übertragen kopiert man herunter und lädt wieder hoch.
+		if _, err := h.store.GetFolder(r.Context(), fid, owner.OwnerID); err != nil {
+			response.Error(w, http.StatusNotFound, "target folder not found in the same account")
+			return
+		}
+		folderID = &fid
+	}
+
+	current, err := h.store.GetFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	newFolderPath, err := h.store.GetFolderPath(r.Context(), folderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	newStorageKey := BuildStorageKey(owner.StorageRoot(), newFolderPath, current.Name)
+
+	if err := h.storage.Move(r.Context(), current.StorageKey, newStorageKey); err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+
+	f, err := h.store.MoveFile(r.Context(), id, owner.OwnerID, folderID, newStorageKey)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, f)
+}
+
+// GET /api/v1/files/{id}/thumbnail
+func (h *Handler) GetThumbnail(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, false)
+	if !ok {
+		return
+	}
+	f, err := h.store.GetFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	thumbKey := "thumbs/" + f.ID.String() + ".jpg"
+	rc, err := h.storage.Get(r.Context(), thumbKey)
+	if err != nil {
+		http.NotFound(w, r)
+		return
+	}
+	defer rc.Close()
+	w.Header().Set("Content-Type", "image/jpeg")
+	w.Header().Set("Cache-Control", "public, max-age=86400")
+	_, _ = io.Copy(w, rc)
+}
+
+// ── Favorites ─────────────────────────────────────────────────────────────────
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+func parseID(r *http.Request, param string) (uuid.UUID, error) {
+	return uuid.Parse(chi.URLParam(r, param))
+}
+
+// extraMIMETypes füllt eine Lücke des Alpine-Images: Go liest die
+// Typtabelle aus /etc/mime.types, und die Datei existiert dort nicht. Die
+// eingebaute Ersatztabelle kennt nur eine Handvoll Web-Typen – .mp3, .mp4 und
+// .zip gehören nicht dazu.
+//
+// Sichtbare Folge vor dieser Ergänzung: Eine hochgeladene MP3 lag als
+// application/octet-stream in der Datenbank, ließ sich deshalb nicht abspielen
+// (die Vorschau entscheidet am Typ) und bekam das Symbol für „unbekannt".
+//
+// Eine Tabelle im Code statt eines Pakets im Image: Sie gilt überall gleich,
+// auch wenn das Grundbild wechselt, und lässt sich testen.
+var extraMIMETypes = map[string]string{
+	".mp3": "audio/mpeg", ".m4a": "audio/mp4", ".aac": "audio/aac",
+	".ogg": "audio/ogg", ".oga": "audio/ogg", ".opus": "audio/ogg",
+	".wav": "audio/wav", ".flac": "audio/flac",
+
+	".mp4": "video/mp4", ".m4v": "video/mp4", ".webm": "video/webm",
+	".mkv": "video/x-matroska", ".mov": "video/quicktime", ".avi": "video/x-msvideo",
+
+	".zip": "application/zip", ".tar": "application/x-tar",
+	".gz": "application/gzip", ".tgz": "application/gzip",
+	".bz2": "application/x-bzip2", ".xz": "application/x-xz",
+	".7z": "application/x-7z-compressed", ".rar": "application/vnd.rar",
+	".zst": "application/zstd", ".deb": "application/vnd.debian.binary-package",
+
+	".csv": "text/csv", ".md": "text/markdown", ".txt": "text/plain",
+	".log": "text/plain", ".yaml": "text/yaml", ".yml": "text/yaml",
+	".toml": "text/plain", ".ini": "text/plain", ".conf": "text/plain",
+
+	".doc":  "application/msword",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".xls":  "application/vnd.ms-excel",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	".odt":  "application/vnd.oasis.opendocument.text",
+	".ods":  "application/vnd.oasis.opendocument.spreadsheet",
+	".ppt":  "application/vnd.ms-powerpoint",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	".odp":  "application/vnd.oasis.opendocument.presentation",
+	".rtf":  "application/rtf",
+}
+
+func detectMIME(filename, contentType string) string {
+	if ext := strings.ToLower(filepath.Ext(filename)); ext != "" {
+		if t := mime.TypeByExtension(ext); t != "" {
+			return t
+		}
+		if t, ok := extraMIMETypes[ext]; ok {
+			return t
+		}
+	}
+	if contentType != "" && contentType != "application/octet-stream" {
+		return contentType
+	}
+	return "application/octet-stream"
+}
diff --git a/backend/internal/files/handler_favorites.go b/backend/internal/files/handler_favorites.go
new file mode 100644
index 0000000..2504230
--- /dev/null
+++ b/backend/internal/files/handler_favorites.go
@@ -0,0 +1,131 @@
+package files
+
+import (
+	"encoding/json"
+	"errors"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"net/http"
+
+	"github.com/google/uuid"
+
+	"aether/internal/auth"
+	"aether/pkg/response"
+)
+
+// Favoriten der Seitenleiste: anlegen, entfernen, sortieren, auf- und
+// zuklappen. Der Zustand liegt serverseitig, damit er auf jedem Gerät gleich ist.
+
+// GET /api/v1/favorites
+func (h *Handler) ListFavorites(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	favs, err := h.store.ListFavorites(r.Context(), user.ID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if favs == nil {
+		favs = []*Favorite{}
+	}
+	response.JSON(w, http.StatusOK, favs)
+}
+
+// POST /api/v1/favorites
+func (h *Handler) AddFavorite(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	var body struct {
+		FolderID string `json:"folder_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.FolderID == "" {
+		response.Error(w, http.StatusBadRequest, "folder_id required")
+		return
+	}
+	folderID, err := uuid.Parse(body.FolderID)
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder_id")
+		return
+	}
+	// Lesezugriff genügt: Ein Favorit ist ein Lesezeichen, keine Änderung.
+	// Die frühere Besitzprüfung schloss Gruppenordner und geteilte Ordner aus –
+	// sie gehören dem Anfragenden nicht, sind aber genau die, die man sich
+	// merken will.
+	if _, ok := h.resolveFolder(w, r, &folderID, false); !ok {
+		return
+	}
+	fav, err := h.store.AddFavorite(r.Context(), user.ID, folderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusCreated, fav)
+}
+
+// DELETE /api/v1/favorites/{folderId}
+func (h *Handler) RemoveFavorite(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	folderID, err := parseID(r, "folderId")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return
+	}
+	if err := h.store.RemoveFavorite(r.Context(), user.ID, folderID); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "favorite not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.NoContent(w)
+}
+
+// PATCH /api/v1/favorites/{folderId}/expand
+func (h *Handler) SetFavoriteExpanded(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	folderID, err := parseID(r, "folderId")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return
+	}
+	var body struct {
+		Expanded bool `json:"expanded"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	if err := h.store.SetFavoriteExpanded(r.Context(), user.ID, folderID, body.Expanded); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "favorite not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.NoContent(w)
+}
+
+// PATCH /api/v1/favorites/reorder
+func (h *Handler) ReorderFavorites(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	var body struct {
+		FolderIDs []string `json:"folder_ids"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	ids := make([]uuid.UUID, 0, len(body.FolderIDs))
+	for _, s := range body.FolderIDs {
+		id, err := uuid.Parse(s)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid folder_id: "+s)
+			return
+		}
+		ids = append(ids, id)
+	}
+	if err := h.store.ReorderFavorites(r.Context(), user.ID, ids); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.NoContent(w)
+}
diff --git a/backend/internal/files/handler_folders.go b/backend/internal/files/handler_folders.go
new file mode 100644
index 0000000..8891219
--- /dev/null
+++ b/backend/internal/files/handler_folders.go
@@ -0,0 +1,273 @@
+package files
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"net/http"
+	"strings"
+
+	"github.com/google/uuid"
+
+	"aether/pkg/response"
+)
+
+// Ordner anlegen, umbenennen, verschieben und löschen.
+//
+// Umbenennen und Verschieben ziehen die Blobs auf der Platte mit – der
+// Speicherpfad soll lesbar bleiben und dem Ordnerbaum entsprechen.
+
+// POST /api/v1/folders
+func (h *Handler) CreateFolder(w http.ResponseWriter, r *http.Request) {
+
+	var body struct {
+		Name     string  `json:"name"`
+		ParentID *string `json:"parent_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Name) == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+
+	// Ordnernamen werden Teil des Storage-Pfads – gleiche Regeln wie für Dateien.
+	folderName := SanitizeFilename(body.Name)
+	if folderName == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+
+	// Ein Unterordner in einem geliehenen Ordner gehört dem Eigentümer des
+	// Elternordners, nicht dem, der ihn anlegt: Die Bytes liegen in dessen
+	// Bereich, und beim Entzug der Freigabe soll er nicht plötzlich fremde
+	// Ordner in seinem Baum haben.
+	var parentID *uuid.UUID
+	if body.ParentID != nil && *body.ParentID != "" {
+		pid, err := uuid.Parse(*body.ParentID)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid parent_id")
+			return
+		}
+		parentID = &pid
+	}
+
+	owner, ok := h.resolveFolder(w, r, parentID, true)
+	if !ok {
+		return
+	}
+
+	f := &Folder{
+		OwnerID:  owner.OwnerRef(),
+		GroupID:  owner.GroupRef(),
+		Name:     folderName,
+		ParentID: parentID,
+	}
+
+	created, err := h.store.CreateFolder(r.Context(), f)
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "folder name already exists")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusCreated, created)
+}
+
+// PATCH /api/v1/folders/{id}/rename
+func (h *Handler) RenameFolder(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return
+	}
+
+	owner, ok := h.resolveFolder(w, r, &id, true)
+	if !ok {
+		return
+	}
+
+	// Der Wurzelordner einer Gruppe ist kein gewöhnlicher Ordner, sondern der
+	// Zugang der Gruppe. Verwaltet wird er im Admin-Bereich.
+	if isRoot, err := h.store.IsGroupRoot(r.Context(), id); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	} else if isRoot {
+		response.Error(w, http.StatusForbidden, ErrGroupRootProtected.Error())
+		return
+	}
+
+	var body struct {
+		Name string `json:"name"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Name) == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+	newName := SanitizeFilename(body.Name)
+	if newName == "" {
+		response.Error(w, http.StatusBadRequest, "name required")
+		return
+	}
+
+	// Collect files before renaming so we have the old storage keys.
+	filesToMove, err := h.store.ListFilesInSubtree(r.Context(), owner.OwnerID, id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Rename the folder in DB first — GetFolderPath will now return the new path.
+	folder, err := h.store.RenameFolder(r.Context(), id, owner.OwnerID, newName)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "folder not found")
+		return
+	}
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "name already exists")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Cascade: move each blob to the updated path.
+	ResyncBlobPaths(r.Context(), h.store, h.storage, owner.StorageRoot(), filesToMove)
+
+	response.JSON(w, http.StatusOK, folder)
+}
+
+// DELETE /api/v1/folders/{id}
+func (h *Handler) DeleteFolder(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return
+	}
+
+	owner, ok := h.resolveFolder(w, r, &id, true)
+	if !ok {
+		return
+	}
+
+	// Der Wurzelordner einer Gruppe ist kein gewöhnlicher Ordner, sondern der
+	// Zugang der Gruppe. Verwaltet wird er im Admin-Bereich.
+	if isRoot, err := h.store.IsGroupRoot(r.Context(), id); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	} else if isRoot {
+		response.Error(w, http.StatusForbidden, ErrGroupRootProtected.Error())
+		return
+	}
+
+	_, err = h.store.GetFolder(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "folder not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Move blobs to .trash/ before soft-deleting so the file system stays consistent.
+	filesToTrash, err := h.store.ListFilesInSubtree(r.Context(), owner.OwnerID, id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	for _, f := range filesToTrash {
+		trashKey := fmt.Sprintf("%s/.trash/%s_%s", owner.StorageRoot(), f.ID.String()[:8], f.Name)
+		if err := h.storage.Move(r.Context(), f.StorageKey, trashKey); err != nil {
+			continue
+		}
+		_ = h.store.UpdateFileStorageKey(r.Context(), f.ID, trashKey)
+	}
+
+	if err := h.store.DeleteFolder(r.Context(), id, owner.OwnerID); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// PATCH /api/v1/folders/{id}/move
+func (h *Handler) MoveFolder(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid folder id")
+		return
+	}
+
+	owner, ok := h.resolveFolder(w, r, &id, true)
+	if !ok {
+		return
+	}
+
+	// Der Wurzelordner einer Gruppe ist kein gewöhnlicher Ordner, sondern der
+	// Zugang der Gruppe. Verwaltet wird er im Admin-Bereich.
+	if isRoot, err := h.store.IsGroupRoot(r.Context(), id); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	} else if isRoot {
+		response.Error(w, http.StatusForbidden, ErrGroupRootProtected.Error())
+		return
+	}
+
+	var body struct {
+		ParentID *uuid.UUID `json:"parent_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+
+	// Reject self-move.
+	if body.ParentID != nil && *body.ParentID == id {
+		response.Error(w, http.StatusBadRequest, "cannot move folder into itself")
+		return
+	}
+
+	// Verify target folder exists and is owned by user.
+	if body.ParentID != nil {
+		if _, err := h.store.GetFolder(r.Context(), *body.ParentID, owner.OwnerID); err != nil {
+			response.Error(w, http.StatusNotFound, "target folder not found")
+			return
+		}
+	}
+
+	// Collect files before moving so we have the old storage keys.
+	filesToMove, err := h.store.ListFilesInSubtree(r.Context(), owner.OwnerID, id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	folder, err := h.store.MoveFolder(r.Context(), id, owner.OwnerID, body.ParentID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "folder not found")
+		return
+	}
+	if errors.Is(err, ErrCycle) {
+		response.Error(w, http.StatusBadRequest, "cannot move folder into its own subtree")
+		return
+	}
+	if errors.Is(err, ErrNameTaken) {
+		response.Error(w, http.StatusConflict, "name already exists in target folder")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Cascade blob moves to updated paths.
+	ResyncBlobPaths(r.Context(), h.store, h.storage, owner.StorageRoot(), filesToMove)
+
+	response.JSON(w, http.StatusOK, folder)
+}
diff --git a/backend/internal/files/handler_text.go b/backend/internal/files/handler_text.go
new file mode 100644
index 0000000..91303fc
--- /dev/null
+++ b/backend/internal/files/handler_text.go
@@ -0,0 +1,50 @@
+package files
+
+import (
+	"net/http"
+
+	"aether/pkg/response"
+)
+
+// TextPages beantwortet GET /api/v1/files/{id}/text.
+//
+// **Wofür das da ist:** Der PDF-Betrachter im Browser sucht im Dokument – aber
+// bei einem *Scan* steht im PDF kein einziges Wort, nur ein Bild. Der erkannte
+// Text liegt daneben in der Datenbank. Ohne diesen Endpunkt fände die Suche im
+// Dokument ausgerechnet bei dem Dateityp nichts, für den die Texterkennung
+// überhaupt gebaut wurde.
+//
+// Geliefert wird der Text **in Seiten zerlegt**. Mehr geht nicht: Wo genau auf
+// dem Bild ein Wort steht, weiß nur die Erkennung selbst, und wir bewahren
+// ihre Koordinaten nicht auf. Die Seite ist aber der Sprung, auf den es
+// ankommt – bei einem zwölfseitigen Beleg ist das der Unterschied zwischen
+// „gefunden" und „such weiter".
+//
+// Die Prüfung ist dieselbe wie beim Herunterladen: Wer die Datei nicht lesen
+// darf, bekommt hier auch ihren Text nicht. Das ist keine Kleinigkeit – der
+// Text *ist* der Inhalt der Rechnung.
+func (h *Handler) TextPages(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+	if _, ok := h.resolveFile(w, r, id, false); !ok {
+		return
+	}
+	// Ohne Texterkennung gibt es keinen Text – das ist eine Auskunft, kein
+	// Fehler. Der Betrachter zeigt dann schlicht keine Fundstellen an.
+	if h.docs == nil {
+		response.JSON(w, http.StatusOK, map[string]any{"pages": []string{}, "source": ""})
+		return
+	}
+	pages, source, err := h.docs.TextPages(r.Context(), id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if pages == nil {
+		pages = []string{}
+	}
+	response.JSON(w, http.StatusOK, map[string]any{"pages": pages, "source": source})
+}
diff --git a/backend/internal/files/handler_trash.go b/backend/internal/files/handler_trash.go
new file mode 100644
index 0000000..7ecc0e4
--- /dev/null
+++ b/backend/internal/files/handler_trash.go
@@ -0,0 +1,144 @@
+package files
+
+import (
+	"errors"
+	"fmt"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"net/http"
+
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/audit"
+	"aether/internal/auth"
+	"aether/pkg/response"
+)
+
+// Papierkorb: auflisten, wiederherstellen, endgültig entfernen.
+//
+// Gelöscht wird nie hart, sondern weich – erst von hier aus verschwinden die
+// Bytes wirklich.
+
+// GET /api/v1/trash
+func (h *Handler) ListTrash(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	items, err := h.store.ListTrash(r.Context(), user.ID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if items == nil {
+		items = []*TrashFile{}
+	}
+	response.JSON(w, http.StatusOK, items)
+}
+
+// POST /api/v1/trash/{id}/restore
+func (h *Handler) RestoreFile(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, true)
+	if !ok {
+		return
+	}
+
+	trashed, err := h.store.GetTrashedFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found in trash")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	folderPath, err := h.store.GetFolderPath(r.Context(), trashed.FolderID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	newStorageKey := BuildStorageKey(owner.StorageRoot(), folderPath, trashed.Name)
+
+	if err := h.storage.Move(r.Context(), trashed.StorageKey, newStorageKey); err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+
+	f, err := h.store.RestoreFile(r.Context(), id, owner.OwnerID, newStorageKey)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found in trash")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.logFile(r, audit.ActionFileRestore, id.String(), trashed.Name, "restored from trash")
+	response.JSON(w, http.StatusOK, f)
+}
+
+// DELETE /api/v1/trash/{id} – permanent delete
+// DELETE /api/v1/trash – leert den Papierkorb vollständig.
+func (h *Handler) EmptyTrash(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+
+	fileIDs, keys, err := h.store.EmptyTrash(r.Context(), user.ID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	// Blobs erst nach dem Datenbank-Commit entfernen. Scheitert eine Löschung,
+	// bleibt höchstens eine Dateileiche zurück – das ist harmloser als ein
+	// Eintrag ohne Inhalt.
+	for _, key := range keys {
+		if err := h.storage.Delete(r.Context(), key); err != nil {
+			log.Ctx(r.Context()).Warn().Err(err).Str("key", key).
+				Msg("empty trash: blob not removed")
+		}
+	}
+	for _, id := range fileIDs {
+		_ = h.storage.Delete(r.Context(), "thumbs/"+id.String()+".jpg")
+	}
+
+	log.Ctx(r.Context()).Info().
+		Int("files", len(fileIDs)).Int("blobs", len(keys)).
+		Msg("trash emptied")
+	h.logFile(r, audit.ActionTrashEmpty, "", "",
+		fmt.Sprintf("%d files permanently deleted", len(fileIDs)))
+	response.NoContent(w)
+}
+
+func (h *Handler) HardDelete(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, true)
+	if !ok {
+		return
+	}
+	storageKey, versionKeys, err := h.store.HardDeleteFile(r.Context(), id, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found in trash")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	_ = h.storage.Delete(r.Context(), storageKey)
+	for _, key := range versionKeys {
+		_ = h.storage.Delete(r.Context(), key)
+	}
+	_ = h.storage.Delete(r.Context(), "thumbs/"+id.String()+".jpg")
+	h.logFile(r, audit.ActionHardDelete, id.String(), "", "permanently deleted from trash")
+	response.NoContent(w)
+}
diff --git a/backend/internal/files/handler_versions.go b/backend/internal/files/handler_versions.go
new file mode 100644
index 0000000..923a4b7
--- /dev/null
+++ b/backend/internal/files/handler_versions.go
@@ -0,0 +1,202 @@
+package files
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+	"io"
+	"net/http"
+
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"aether/pkg/response"
+)
+
+// Versionen einer Datei: an- und abschalten, auflisten, herunterladen,
+// wiederherstellen.
+//
+// Versionierung ist bewusst pro Datei opt-in.
+
+// GET /api/v1/files/{id}/versions
+// PATCH /api/v1/files/{id}/versioning
+func (h *Handler) SetVersioning(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, true)
+	if !ok {
+		return
+	}
+
+	var body struct {
+		Enabled *bool `json:"enabled"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.Enabled == nil {
+		response.Error(w, http.StatusBadRequest, "enabled required")
+		return
+	}
+
+	f, err := h.store.SetVersioning(r.Context(), id, owner.OwnerID, *body.Enabled)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	response.JSON(w, http.StatusOK, f)
+}
+
+func (h *Handler) ListVersions(w http.ResponseWriter, r *http.Request) {
+	id, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, id, false)
+	if !ok {
+		return
+	}
+	versions, err := h.store.ListVersions(r.Context(), id, owner.OwnerID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if versions == nil {
+		versions = []*FileVersion{}
+	}
+	response.JSON(w, http.StatusOK, versions)
+}
+
+// GET /api/v1/files/{id}/versions/{versionId}/download
+func (h *Handler) DownloadVersion(w http.ResponseWriter, r *http.Request) {
+	fileID, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+	versionID, err := parseID(r, "versionId")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid version id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, fileID, false)
+	if !ok {
+		return
+	}
+	f, err := h.store.GetFile(r.Context(), fileID, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	v, err := h.store.GetVersion(r.Context(), versionID, fileID, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "version not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	rc, err := h.storage.Get(r.Context(), v.StorageKey)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+	defer rc.Close()
+	w.Header().Set("Content-Type", f.MimeType)
+	w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename=%q`, f.Name))
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", v.Size))
+	_, _ = io.Copy(w, rc)
+}
+
+// POST /api/v1/files/{id}/versions/{versionId}/restore
+func (h *Handler) RestoreVersion(w http.ResponseWriter, r *http.Request) {
+	fileID, err := parseID(r, "id")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+	versionID, err := parseID(r, "versionId")
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid version id")
+		return
+	}
+
+	owner, ok := h.resolveFile(w, r, fileID, true)
+	if !ok {
+		return
+	}
+	current, err := h.store.GetFile(r.Context(), fileID, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	v, err := h.store.GetVersion(r.Context(), versionID, fileID, owner.OwnerID)
+	if errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "version not found")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	// Die wiederhergestellte Fassung muss auf den lesbaren Pfad der Datei
+	// wandern – bliebe sie unter .versions/<uuid>, läge die aktive Datei
+	// plötzlich im Versionsarchiv.
+	activeKey := current.StorageKey
+
+	if current.VersioningEnabled {
+		// Bisherige Fassung sichern, damit der Weg zurück offen bleibt.
+		versionKey := fmt.Sprintf("%s/.versions/%s", owner.StorageRoot(), uuid.New().String())
+		if err := h.storage.Move(r.Context(), activeKey, versionKey); err != nil {
+			response.Error(w, http.StatusInternalServerError, "storage error")
+			return
+		}
+		if err := h.store.CreateVersion(r.Context(), current.ID, current.Version, current.Size, current.Checksum, versionKey); err != nil {
+			if mvErr := h.storage.Move(r.Context(), versionKey, activeKey); mvErr != nil {
+				log.Ctx(r.Context()).Error().Err(mvErr).Str("file_id", current.ID.String()).
+					Msg("restore: rollback of current-version move failed – blob orphaned")
+			}
+			response.Error(w, http.StatusInternalServerError, "database error")
+			return
+		}
+	} else if err := h.storage.Delete(r.Context(), activeKey); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Str("file_id", current.ID.String()).
+			Msg("restore: could not remove replaced blob")
+	}
+
+	// Versionsblob an den Platz der aktiven Datei holen.
+	if err := h.storage.Move(r.Context(), v.StorageKey, activeKey); err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+	// Der Versionseintrag ist damit gegenstandslos – sein Inhalt ist jetzt aktiv.
+	if err := h.store.DeleteVersion(r.Context(), v.ID, fileID); err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+
+	updated, err := h.store.UpdateFileContent(r.Context(), fileID, v.Size, v.Checksum, activeKey)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if oldKeys, err := h.store.PruneVersions(r.Context(), fileID, maxVersionsKept); err == nil {
+		for _, key := range oldKeys {
+			_ = h.storage.Delete(r.Context(), key)
+		}
+	}
+	_ = h.storage.Delete(r.Context(), "thumbs/"+fileID.String()+".jpg")
+	response.JSON(w, http.StatusOK, updated)
+}
diff --git a/backend/internal/files/handler_zip.go b/backend/internal/files/handler_zip.go
new file mode 100644
index 0000000..e3811bb
--- /dev/null
+++ b/backend/internal/files/handler_zip.go
@@ -0,0 +1,210 @@
+package files
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"net/http"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+
+	"aether/internal/auth"
+	"aether/pkg/response"
+)
+
+// Bereits komprimierte Formate werden nur *gelagert*, nicht noch einmal
+// gepackt. Ein 116-MB-Paket durch Deflate zu schicken kostet Sekunden CPU und
+// spart nichts – die Bytes sind schon dicht.
+var storeOnlyExt = map[string]bool{
+	".zip": true, ".gz": true, ".tgz": true, ".bz2": true, ".xz": true, ".7z": true,
+	".rar": true, ".zst": true, ".deb": true, ".rpm": true,
+	".jpg": true, ".jpeg": true, ".png": true, ".gif": true, ".webp": true,
+	".mp3": true, ".mp4": true, ".m4a": true, ".mkv": true, ".webm": true, ".avi": true,
+	".pdf": true,
+}
+
+// DownloadZip packt eine Auswahl in ein Archiv – POST /api/v1/download/zip.
+//
+// **Gestreamt, nicht gesammelt.** Das Archiv entsteht direkt in der Antwort;
+// es liegt zu keinem Zeitpunkt ganz auf der Platte oder im Speicher. Bei einem
+// 5-GB-Ordner wäre das andernfalls 5 GB Bedarf auf einem Speicher, der ohnehin
+// knapp ist – und der Nutzer sähe minutenlang nichts.
+//
+// Der Preis: Ist das Archiv einmal angefangen, steht der Statuscode schon auf
+// 200. Ein Fehler danach kann nur noch dazu führen, dass das Archiv unvollständig
+// endet. Deshalb wird alles, was scheitern kann – Rechte, Auswahl, Grenzen –
+// **vor** dem ersten geschriebenen Byte geprüft.
+func (h *Handler) DownloadZip(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	if user == nil {
+		response.Error(w, http.StatusUnauthorized, "not signed in")
+		return
+	}
+
+	// Formular *und* JSON: Der Browser lädt eine Antwort nur dann als Datei
+	// herunter, wenn sie aus einer Navigation stammt – also aus einem
+	// abgeschickten Formular. Ein fetch() müsste das ganze Archiv erst in den
+	// Speicher holen, und genau das soll hier nicht passieren.
+	if err := r.ParseForm(); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid form")
+		return
+	}
+	name := strings.TrimSpace(r.FormValue("name"))
+	folderID := strings.TrimSpace(r.FormValue("folder_id"))
+	rawIDs := r.Form["file_ids"]
+	if len(rawIDs) == 1 && strings.Contains(rawIDs[0], ",") {
+		rawIDs = strings.Split(rawIDs[0], ",")
+	}
+
+	var entries []ZipEntry
+	var err error
+
+	switch {
+	case folderID != "":
+		id, perr := uuid.Parse(folderID)
+		if perr != nil {
+			response.Error(w, http.StatusBadRequest, "invalid folder_id")
+			return
+		}
+		// Rechteprüfung über dieselbe Stelle wie überall: Wer den Ordner nicht
+		// lesen darf, bekommt 404 – nicht 403, sonst verrät die Antwort, dass
+		// es ihn gibt.
+		access, aerr := h.acl.ResolveFolder(r.Context(), user.ID, id)
+		if aerr != nil {
+			response.Error(w, http.StatusNotFound, "not found")
+			return
+		}
+		entries, err = h.store.FilesInFolderTree(r.Context(), access.OwnerID, id)
+		if name == "" {
+			if folder, ferr := h.store.GetFolder(r.Context(), id, access.OwnerID); ferr == nil {
+				name = folder.Name
+			}
+		}
+
+	default:
+		ids := make([]uuid.UUID, 0, len(rawIDs))
+		for _, raw := range rawIDs {
+			id, perr := uuid.Parse(strings.TrimSpace(raw))
+			if perr != nil {
+				response.Error(w, http.StatusBadRequest, "invalid file id")
+				return
+			}
+			ids = append(ids, id)
+		}
+		if len(ids) == 0 {
+			response.Error(w, http.StatusBadRequest, "nothing selected")
+			return
+		}
+		entries, err = h.store.FilesForZipByIDs(r.Context(), user.ID, ids)
+	}
+
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if len(entries) == 0 {
+		// Auch der Fall „alles herausgefiltert, weil nichts erreichbar war".
+		response.Error(w, http.StatusNotFound, "nothing to download")
+		return
+	}
+	if len(entries) > MaxZipEntries {
+		response.Error(w, http.StatusRequestEntityTooLarge,
+			fmt.Sprintf("too many files (limit %d) — narrow the selection", MaxZipEntries))
+		return
+	}
+
+	// Ab hier ist die Antwort unterwegs.
+	filename := zipFilename(name)
+	w.Header().Set("Content-Type", "application/zip")
+	w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename=%q`, filename))
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	// Keine Länge im Voraus: Sie stünde erst fest, wenn alles gepackt ist – und
+	// dann wäre das Streamen sinnlos gewesen. Der Browser zeigt deshalb keinen
+	// Fortschrittsbalken, dafür beginnt der Download sofort.
+	w.WriteHeader(http.StatusOK)
+
+	zw := zip.NewWriter(w)
+	used := map[string]int{}
+
+	for _, e := range entries {
+		if r.Context().Err() != nil {
+			// Abgebrochen (Fenster zu, Verbindung weg). Nicht weiterpacken.
+			break
+		}
+		entryPath := uniquePath(used, e.Path)
+
+		method := zip.Deflate
+		if storeOnlyExt[strings.ToLower(path.Ext(e.Name))] {
+			method = zip.Store
+		}
+		hdr := &zip.FileHeader{Name: entryPath, Method: method, Modified: time.Now()}
+		// Ohne dieses Bit deuten manche Entpacker (Windows-Explorer) den Namen
+		// in einer alten Codepage – aus „Rechnung Müller.pdf" wird dann
+		// „Rechnung Müller.pdf".
+		hdr.Flags |= 0x800
+
+		fw, werr := zw.CreateHeader(hdr)
+		if werr != nil {
+			break
+		}
+		rc, gerr := h.storage.Get(r.Context(), e.StorageKey)
+		if gerr != nil {
+			// Eine fehlende Datei darf das ganze Archiv nicht kippen – der Rest
+			// ist ja in Ordnung. Sie fehlt darin, das ist die ehrlichste
+			// Auskunft, die zu diesem Zeitpunkt noch möglich ist.
+			continue
+		}
+		_, cerr := io.Copy(fw, rc)
+		rc.Close()
+		if cerr != nil {
+			break
+		}
+	}
+	_ = zw.Close()
+}
+
+// zipFilename baut einen Dateinamen, der auf jedem System durchgeht.
+func zipFilename(name string) string {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		name = "download-" + time.Now().Format("2006-01-02")
+	}
+	// Zeichen, die Windows in Dateinamen verbietet, dazu Pfadtrenner.
+	name = strings.Map(func(r rune) rune {
+		if strings.ContainsRune(`/\:*?"<>|`, r) || r < 32 {
+			return '-'
+		}
+		return r
+	}, name)
+	return name + ".zip"
+}
+
+// uniquePath verhindert doppelte Einträge im Archiv.
+//
+// Bei einer Auswahl aus mehreren Ordnern – oder bei allem mit einem Etikett –
+// können zwei Dateien denselben Namen tragen. Ein Archiv mit zwei gleichen
+// Einträgen entpacken manche Programme kommentarlos zu einer Datei; die zweite
+// wäre still verloren.
+func uniquePath(used map[string]int, p string) string {
+	used[p]++
+	if used[p] == 1 {
+		return p
+	}
+	ext := doubleExt(p)
+	return fmt.Sprintf("%s (%d)%s", strings.TrimSuffix(p, ext), used[p], ext)
+}
+
+// doubleExt erkennt zweiteilige Endungen wie .tar.gz.
+//
+// path.Ext sieht nur ".gz", und die Zahl landete dann mittendrin:
+// „paket.tar (2).gz". Gemessen beim Prüfen, nicht vermutet.
+func doubleExt(p string) string {
+	ext := path.Ext(p)
+	if rest := strings.TrimSuffix(p, ext); strings.HasSuffix(strings.ToLower(rest), ".tar") {
+		return path.Ext(rest) + ext
+	}
+	return ext
+}
diff --git a/backend/internal/files/mime_test.go b/backend/internal/files/mime_test.go
new file mode 100644
index 0000000..7e3ded4
--- /dev/null
+++ b/backend/internal/files/mime_test.go
@@ -0,0 +1,37 @@
+package files
+
+import "testing"
+
+// Das Alpine-Image bringt keine /etc/mime.types mit, und Gos eingebaute
+// Ersatztabelle kennt nur Web-Typen. Ohne die eigene Tabelle landete eine MP3
+// als application/octet-stream in der Datenbank – nicht abspielbar, falsches
+// Symbol.
+func TestDetectMIMEKennteMedienTypen(t *testing.T) {
+	cases := map[string]string{
+		"lied.mp3":     "audio/mpeg",
+		"clip.mp4":     "video/mp4",
+		"paket.zip":    "application/zip",
+		"paket.tar.gz": "application/gzip",
+		"tabelle.csv":  "text/csv",
+		"BILD.PNG":     "image/png", // Endung ohne Rücksicht auf Groß/Klein
+		"folien.pptx":  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		"brief.docx":   "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		"budget.xlsx":  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	}
+	for name, want := range cases {
+		if got := detectMIME(name, ""); got != want {
+			t.Errorf("detectMIME(%q) = %q, want %q", name, got, want)
+		}
+	}
+}
+
+// Behauptet der Client etwas Sinnvolles und die Endung sagt nichts, gilt der
+// Client. Behauptet er octet-stream, ist das keine Aussage.
+func TestDetectMIMEFallback(t *testing.T) {
+	if got := detectMIME("datei.unbekannt", "image/png"); got != "image/png" {
+		t.Errorf("got %q, want the client type", got)
+	}
+	if got := detectMIME("datei.unbekannt", "application/octet-stream"); got != "application/octet-stream" {
+		t.Errorf("got %q", got)
+	}
+}
diff --git a/backend/internal/files/model.go b/backend/internal/files/model.go
new file mode 100644
index 0000000..051c1d7
--- /dev/null
+++ b/backend/internal/files/model.go
@@ -0,0 +1,64 @@
+package files
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type File struct {
+	ID uuid.UUID `json:"id"`
+	// Entweder OwnerID oder GroupID ist gesetzt, nie beides: Eine Datei gehört
+	// einem Konto oder einer Gruppe. Die Datenbank erzwingt das per CHECK.
+	OwnerID      *uuid.UUID `json:"owner_id"`
+	GroupID      *uuid.UUID `json:"group_id"`
+	FolderID     *uuid.UUID `json:"folder_id"`
+	Name         string     `json:"name"`
+	MimeType     string     `json:"mime_type"`
+	Size         int64      `json:"size"`
+	Checksum     string     `json:"checksum"`
+	StorageKey   string     `json:"-"`
+	HasThumbnail bool       `json:"has_thumbnail"`
+	Version      int        `json:"version"`
+	// VersioningEnabled ist Opt-in: nur dann hebt eine Überschreibung die
+	// vorige Fassung auf. Sonst wird sie ersetzt und der Platz freigegeben.
+	VersioningEnabled bool `json:"versioning_enabled"`
+	// DocumentDate ist das Datum, das auf dem Dokument steht – Kaufdatum,
+	// Rechnungsdatum. Nicht zu verwechseln mit CreatedAt (dem Upload): Ein
+	// Beleg von Dezember, im Januar eingescannt, gehört ins alte Jahr.
+	// NULL heißt „nicht gesetzt"; bei einem Urlaubsfoto gibt es keins.
+	DocumentDate *time.Time `json:"document_date,omitempty"`
+	CreatedAt    time.Time  `json:"created_at"`
+	UpdatedAt    time.Time  `json:"updated_at"`
+}
+
+type FileVersion struct {
+	ID         uuid.UUID `json:"id"`
+	FileID     uuid.UUID `json:"file_id"`
+	Version    int       `json:"version"`
+	Size       int64     `json:"size"`
+	Checksum   string    `json:"checksum"`
+	StorageKey string    `json:"-"`
+	CreatedAt  time.Time `json:"created_at"`
+}
+
+type Folder struct {
+	ID uuid.UUID `json:"id"`
+	// Siehe File: entweder Konto oder Gruppe.
+	OwnerID   *uuid.UUID `json:"owner_id"`
+	GroupID   *uuid.UUID `json:"group_id"`
+	ParentID  *uuid.UUID `json:"parent_id"`
+	Name      string     `json:"name"`
+	CreatedAt time.Time  `json:"created_at"`
+}
+
+type Favorite struct {
+	ID             uuid.UUID  `json:"id"`
+	UserID         uuid.UUID  `json:"user_id"`
+	FolderID       uuid.UUID  `json:"folder_id"`
+	Position       int        `json:"position"`
+	IsExpanded     bool       `json:"is_expanded"`
+	CreatedAt      time.Time  `json:"created_at"`
+	FolderName     string     `json:"folder_name"`
+	FolderParentID *uuid.UUID `json:"folder_parent_id"`
+}
diff --git a/backend/internal/files/naming.go b/backend/internal/files/naming.go
new file mode 100644
index 0000000..68d42f1
--- /dev/null
+++ b/backend/internal/files/naming.go
@@ -0,0 +1,108 @@
+package files
+
+import (
+	"context"
+	"strings"
+	"unicode"
+
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/storage"
+)
+
+// maxFilenameLen begrenzt den Dateinamen so, dass der zusammengesetzte Pfad
+// auf gängigen Dateisystemen (255 Bytes pro Segment) sicher passt.
+const maxFilenameLen = 200
+
+// BuildStorageKey erzeugt einen menschenlesbaren Pfad, der die Struktur der
+// App spiegelt:
+//
+//	users/{username}/home/{folderPath}/{filename}
+//
+// Bewusst lesbar statt UUID-basiert: fällt die Datenbank aus, sollen die
+// Dateien per SFTP weiterhin auffindbar sein. Versionen (.versions/) und
+// Papierkorb (.trash/) sind davon ausgenommen – das sind interne Artefakte.
+// BuildStorageKey setzt den lesbaren Ablagepfad zusammen. root ist das
+// Wurzelsegment – `users/<name>` für persönliche Daten, `groups/<id>` für
+// Gruppenordner (siehe acl.Access.StorageRoot).
+func BuildStorageKey(root, folderPath, filename string) string {
+	if folderPath == "" {
+		return root + "/home/" + filename
+	}
+	return root + "/home/" + folderPath + "/" + filename
+}
+
+// SanitizeFilename macht einen vom Client gelieferten Namen als einzelnes
+// Pfadsegment sicher.
+//
+// Der Traversal-Schutz sitzt in storage.safePath; hier geht es darum, dass
+// Name in der Datenbank und Pfad im Storage nicht auseinanderlaufen: Ein Name
+// wie "a/b.txt" würde sonst still eine Ordnerebene im Storage erzeugen, die
+// die Datenbank nicht kennt.
+//
+// Gibt "" zurück, wenn nichts Brauchbares übrig bleibt – Aufrufer müssen das
+// als ungültige Eingabe behandeln.
+func SanitizeFilename(name string) string {
+	// Nur das letzte Segment übernehmen – Clients schicken teils ganze Pfade.
+	if i := strings.LastIndexAny(name, `/\`); i >= 0 {
+		name = name[i+1:]
+	}
+
+	// Steuerzeichen entfernen (inkl. NUL und Zeilenumbrüche in Namen).
+	name = strings.Map(func(r rune) rune {
+		if r == unicode.ReplacementChar || unicode.IsControl(r) {
+			return -1
+		}
+		return r
+	}, name)
+
+	// Führende/abschließende Punkte und Leerraum: "." und ".." wären sonst
+	// Verzeichnisverweise, abschließende Punkte stören unter Windows.
+	name = strings.Trim(strings.TrimSpace(name), ".")
+	name = strings.TrimSpace(name)
+
+	if len(name) > maxFilenameLen {
+		// Auf Rune-Grenze kürzen, damit kein kaputtes UTF-8 entsteht.
+		runes := []rune(name)
+		for len(string(runes)) > maxFilenameLen {
+			runes = runes[:len(runes)-1]
+		}
+		name = strings.TrimSpace(string(runes))
+	}
+
+	return name
+}
+
+// ResyncBlobPaths bringt die Blobs der übergebenen Dateien auf die Pfade, die
+// sich aus dem aktuellen Datenbankstand ergeben.
+//
+// Wird ein Ordner umbenannt oder verschoben, ändert sich der Pfad aller
+// Dateien darunter. Weil die Storage-Schlüssel lesbar sind (und nicht bloß
+// UUIDs), müssen die Blobs mitwandern. Aufrufen, *nachdem* die Umbenennung in
+// der Datenbank committet ist – erst dann liefert GetFolderPath den neuen Pfad.
+//
+// Die Dateiliste muss *vorher* eingesammelt werden, damit die alten
+// Storage-Schlüssel noch bekannt sind.
+func ResyncBlobPaths(ctx context.Context, store *Store, st storage.Storage, root string, moved []*File) {
+	for _, f := range moved {
+		newFolderPath, err := store.GetFolderPath(ctx, f.FolderID)
+		if err != nil {
+			log.Ctx(ctx).Warn().Err(err).Str("file_id", f.ID.String()).
+				Msg("resync: folder path lookup failed – blob keeps old path")
+			continue
+		}
+		newKey := BuildStorageKey(root, newFolderPath, f.Name)
+		if newKey == f.StorageKey {
+			continue
+		}
+		if err := st.Move(ctx, f.StorageKey, newKey); err != nil {
+			log.Ctx(ctx).Warn().Err(err).Str("file_id", f.ID.String()).
+				Msg("resync: blob move failed – storage key now stale")
+			continue
+		}
+		if err := store.UpdateFileStorageKey(ctx, f.ID, newKey); err != nil {
+			log.Ctx(ctx).Error().Err(err).Str("file_id", f.ID.String()).
+				Msg("resync: blob moved but storage key not updated")
+		}
+	}
+}
diff --git a/backend/internal/files/quota.go b/backend/internal/files/quota.go
new file mode 100644
index 0000000..47e4bdd
--- /dev/null
+++ b/backend/internal/files/quota.go
@@ -0,0 +1,63 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/google/uuid"
+)
+
+// ErrQuotaExceeded wird gemeldet, sobald ein Upload das Speicherkontingent des
+// Nutzers überschreitet.
+var ErrQuotaExceeded = errors.New("storage quota exceeded")
+
+// quotaReader reicht Daten durch und bricht ab, sobald mehr als `remaining`
+// Bytes gelesen wurden. Nötig, weil Uploads gestreamt werden: die tatsächliche
+// Größe steht erst am Ende fest, und bis dahin wären die Bytes längst auf der
+// Platte. So bricht der Schreibvorgang bereits beim Überschreiten ab statt
+// erst hinterher zu prüfen.
+type quotaReader struct {
+	r         io.Reader
+	remaining int64
+}
+
+func newQuotaReader(r io.Reader, remaining int64) *quotaReader {
+	if remaining < 0 {
+		remaining = 0
+	}
+	return &quotaReader{r: r, remaining: remaining}
+}
+
+func (q *quotaReader) Read(p []byte) (int, error) {
+	n, err := q.r.Read(p)
+	q.remaining -= int64(n)
+	if q.remaining < 0 {
+		return n, ErrQuotaExceeded
+	}
+	return n, err
+}
+
+// RemainingQuota liefert, wie viele Bytes der Nutzer noch schreiben darf, und
+// ob sein Kontingent unbegrenzt ist.
+//
+// `allowance` sind Bytes, die durch diesen Vorgang frei werden – beim
+// Überschreiben einer Datei zählt die alte Fassung nicht mehr zum Verbrauch,
+// sonst schlüge das Ersetzen einer Datei durch eine gleich große fehl.
+//
+// Ein Kontingent <= 0 gilt als unbegrenzt.
+func (s *Store) RemainingQuota(ctx context.Context, userID uuid.UUID, quotaBytes, allowance int64) (int64, bool, error) {
+	if quotaBytes <= 0 {
+		return 0, true, nil
+	}
+	used, err := s.UsedBytes(ctx, userID)
+	if err != nil {
+		return 0, false, fmt.Errorf("read used bytes: %w", err)
+	}
+	remaining := quotaBytes - used + allowance
+	if remaining < 0 {
+		remaining = 0
+	}
+	return remaining, false, nil
+}
diff --git a/backend/internal/files/replace.go b/backend/internal/files/replace.go
new file mode 100644
index 0000000..cb7861c
--- /dev/null
+++ b/backend/internal/files/replace.go
@@ -0,0 +1,93 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/acl"
+	"aether/internal/storage"
+)
+
+// ReplaceContent ersetzt den Inhalt einer bestehenden Datei.
+//
+// Gebraucht von der Office-Anbindung: Der Office-Server schickt beim Speichern
+// den neuen Inhalt, aber keinen Ordner, keinen Namen und keine Sitzung. Der
+// Weg über den Upload-Handler geht deshalb nicht – der liest ein Formular und
+// schreibt selbst die HTTP-Antwort.
+//
+// **Ein Office-Server ist kein Sonderweg an der Datenintegrität vorbei.** Es
+// gelten dieselben vier Regeln wie bei jedem Upload: atomar schreiben, Prüfsumme
+// neu berechnen, das Kontingent beachten, und bei eingeschalteter Versionierung
+// die alte Fassung aufheben.
+func ReplaceContent(
+	ctx context.Context,
+	store *Store,
+	blobs storage.Storage,
+	f *File,
+	owner acl.Access,
+	content io.Reader,
+) (*File, error) {
+	// Die alte Fassung zählt nach dem Überschreiben nicht mehr zum Verbrauch –
+	// deshalb ihre Größe als Freibetrag.
+	remaining, unlimited, err := store.RemainingQuota(ctx, owner.OwnerID, owner.OwnerQuota, f.Size)
+	if err != nil {
+		return nil, fmt.Errorf("quota: %w", err)
+	}
+
+	// Nur bei eingeschalteter Versionierung wird die alte Fassung beiseite
+	// geschoben. Sonst ersetzt Put sie atomar und der Platz bleibt frei.
+	var versionKey string
+	if f.VersioningEnabled {
+		versionKey = fmt.Sprintf("%s/.versions/%s", owner.StorageRoot(), uuid.New().String())
+		if err := blobs.Move(ctx, f.StorageKey, versionKey); err != nil {
+			return nil, fmt.Errorf("keep previous version: %w", err)
+		}
+	}
+
+	if !unlimited {
+		content = newQuotaReader(content, remaining)
+	}
+	checksum, size, err := blobs.Put(ctx, f.StorageKey, content)
+	if err != nil {
+		// Die alte Fassung ist schon verschoben – zurückrollen, sonst
+		// verliert man die bestehende Datei an ein Speichern, das nie ankam.
+		if versionKey != "" {
+			if mvErr := blobs.Move(ctx, versionKey, f.StorageKey); mvErr != nil {
+				log.Ctx(ctx).Error().Err(mvErr).Str("file_id", f.ID.String()).
+					Msg("rollback of version move failed – blob orphaned")
+			}
+		}
+		if errors.Is(err, ErrQuotaExceeded) {
+			return nil, ErrQuotaExceeded
+		}
+		return nil, fmt.Errorf("write: %w", err)
+	}
+
+	if versionKey != "" {
+		if err := store.CreateVersion(ctx, f.ID, f.Version, f.Size, f.Checksum, versionKey); err != nil {
+			return nil, fmt.Errorf("record version: %w", err)
+		}
+	}
+
+	updated, err := store.UpdateFileContent(ctx, f.ID, size, checksum, f.StorageKey)
+	if err != nil {
+		return nil, fmt.Errorf("update file: %w", err)
+	}
+
+	if versionKey != "" {
+		// Alte Fassungen über der Grenze wegräumen – sonst wächst der Verlauf
+		// eines oft gespeicherten Dokuments unbegrenzt. Ein Fehler hier ist
+		// kein Grund, das Speichern scheitern zu lassen.
+		if oldKeys, err := store.PruneVersions(ctx, f.ID, maxVersionsKept); err == nil {
+			for _, k := range oldKeys {
+				_ = blobs.Delete(ctx, k)
+			}
+		}
+	}
+	return updated, nil
+}
diff --git a/backend/internal/files/search.go b/backend/internal/files/search.go
new file mode 100644
index 0000000..96cbce0
--- /dev/null
+++ b/backend/internal/files/search.go
@@ -0,0 +1,199 @@
+package files
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// Namenssuche über alles, was der Anfragende erreichen darf.
+//
+// Der heikle Teil ist nicht die Abfrage, sondern der Umfang: Eine Suche, die
+// die Zugriffsregeln nicht mitdenkt, ist ein Leck – sie zeigte Namen aus
+// Ordnern, die man nicht betreten darf. Deshalb schneidet die Abfrage den
+// erreichbaren Bereich selbst zu, statt Treffer nachträglich zu filtern.
+// Nachträglich zu filtern wäre die Variante, bei der man einen Fall vergisst.
+//
+// Erreichbar ist:
+//   - was dem Anfragenden gehört
+//   - was einer seiner Gruppen gehört (Gruppenordner)
+//   - was ihm freigegeben wurde – direkt oder über eine Gruppe
+//   - alles *unterhalb* eines freigegebenen Ordners (Vererbung nach unten)
+//
+// Papierkorb bleibt außen vor: Gelöschtes taucht dort auf, nicht in der Suche.
+
+// SearchLimit begrenzt die Trefferzahl. Wer mehr als 100 Treffer bekommt, hat
+// zu ungenau gesucht – eine längere Liste hilft niemandem und kostet nur.
+const SearchLimit = 100
+
+// SearchHit ist ein Treffer. Ordner und Dateien kommen in derselben Liste,
+// damit die Oberfläche sie in einer Trefferliste zeigen kann.
+type SearchHit struct {
+	Kind string    `json:"kind"` // "folder" oder "file"
+	ID   uuid.UUID `json:"id"`
+	Name string    `json:"name"`
+	// FolderID ist der Ordner, in dem der Treffer liegt – bei einem Ordner der
+	// übergeordnete. Leer heißt Wurzel. Die Oberfläche springt damit dorthin.
+	FolderID *uuid.UUID `json:"folder_id"`
+	// FolderName benennt denselben Ordner, damit ein Treffer einordbar ist:
+	// Drei Dateien namens „Rechnung.pdf" unterscheiden sich sonst nicht.
+	FolderName   string    `json:"folder_name"`
+	MimeType     string    `json:"mime_type,omitempty"`
+	Size         int64     `json:"size"`
+	HasThumbnail bool      `json:"has_thumbnail"`
+	UpdatedAt    time.Time `json:"updated_at"`
+
+	// MatchedContent heißt: Nicht der Name passte, sondern der erkannte Text
+	// im Dokument. Für die Oberfläche ein wichtiger Unterschied – sonst wirkt
+	// ein Treffer namens "scan_0042.pdf" wie ein Fehler der Suche.
+	MatchedContent bool `json:"matched_content,omitempty"`
+	// Snippet ist die Fundstelle im Text, Treffer hervorgehoben (<b>…</b>).
+	// Nur gesetzt, wenn MatchedContent gilt.
+	Snippet string `json:"snippet,omitempty"`
+}
+
+// Search findet Ordner und Dateien – nach Name und, bei Dokumenten mit
+// erkanntem Text, auch nach Inhalt.
+//
+// Beides in *einer* Abfrage und in *einem* Zweig des UNION, nicht in zweien:
+// Eine Datei, deren Name und Inhalt beide passen, käme sonst doppelt in der
+// Liste an. Welche Hälfte den Treffer verursacht hat, sagt matched_content.
+func (s *Store) Search(ctx context.Context, userID uuid.UUID, query string) ([]SearchHit, error) {
+	query = strings.TrimSpace(query)
+	if query == "" {
+		return []SearchHit{}, nil
+	}
+	// Die Platzhalter von LIKE gehören nicht dem Nutzer: Ein "%" im Suchwort
+	// soll ein Prozentzeichen suchen, keine beliebige Zeichenfolge.
+	pattern := "%" + escapeLike(query) + "%"
+
+	// Für den Volltext wird das Suchwort unverändert weitergereicht:
+	// websearch_to_tsquery versteht das, was Menschen ohnehin eintippen –
+	// Anführungszeichen für Wortgruppen, "or", ein Minus zum Ausschließen –
+	// und wirft bei krummer Eingabe keinen Fehler, sondern liefert eine leere
+	// Abfrage. Eine Suche darf an einem Sonderzeichen nicht scheitern.
+
+	const q = `
+WITH RECURSIVE my_groups AS (
+    SELECT group_id FROM group_members WHERE user_id = $1
+),
+-- Ordner, die dem Anfragenden freigegeben wurden – persönlich oder über eine
+-- seiner Gruppen.
+granted_roots AS (
+    SELECT resource_folder_id AS id
+      FROM acl_entries
+     WHERE resource_folder_id IS NOT NULL
+       AND (subject_user_id = $1
+            OR subject_group_id IN (SELECT group_id FROM my_groups))
+),
+-- Freigaben vererben sich nach unten: Wer einen Ordner freigibt, meint dessen
+-- ganzen Inhalt. Hier deshalb ausnahmsweise nach unten statt nach oben – die
+-- Einzelprüfung in internal/acl läuft andersherum, weil sie nur einen Pfad
+-- zur Wurzel braucht.
+shared_tree AS (
+    SELECT id FROM granted_roots
+    UNION
+    SELECT f.id FROM folders f JOIN shared_tree s ON f.parent_id = s.id
+),
+-- Einmal berechnet statt in jeder Zeile. NULLIF fängt den Fall ab, dass die
+-- Eingabe nur aus Füllwörtern besteht ("und der"): Daraus entsteht eine leere
+-- tsquery, und die passt auf nichts – ohne NULLIF stünde stattdessen eine
+-- Bedingung da, die nie erfüllt ist, aber trotzdem jede Zeile prüft.
+q AS (
+    SELECT NULLIF(websearch_to_tsquery('german', $4)::text, '')::tsquery AS tsq
+),
+granted_files AS (
+    SELECT resource_file_id AS id
+      FROM acl_entries
+     WHERE resource_file_id IS NOT NULL
+       AND (subject_user_id = $1
+            OR subject_group_id IN (SELECT group_id FROM my_groups))
+)
+SELECT * FROM (
+SELECT 'folder' AS kind, fo.id, fo.name, fo.parent_id AS folder_id,
+       COALESCE(p.name, '') AS folder_name,
+       '' AS mime_type, 0::bigint AS size, false AS has_thumbnail, fo.updated_at,
+       false AS matched_content, '' AS snippet
+  FROM folders fo
+  LEFT JOIN folders p ON p.id = fo.parent_id
+ WHERE fo.name ILIKE $2 ESCAPE '\'
+   AND (fo.owner_id = $1
+        OR fo.group_id IN (SELECT group_id FROM my_groups)
+        OR fo.id IN (SELECT id FROM shared_tree))
+
+UNION ALL
+
+SELECT 'file' AS kind, fi.id, fi.name, fi.folder_id,
+       COALESCE(p.name, '') AS folder_name,
+       fi.mime_type, fi.size, fi.has_thumbnail, fi.updated_at,
+       -- Nur als Inhaltstreffer zählen, was der Name nicht schon hergibt:
+       -- Passt beides, ist der Name die bessere Erklärung.
+       (fi.name NOT ILIKE $2 ESCAPE '\') AS matched_content,
+       CASE WHEN fi.name NOT ILIKE $2 ESCAPE '\' AND ft.file_id IS NOT NULL
+            -- Eigene Markierungen statt der voreingestellten <b>…</b>: Der
+            -- Text stammt aus einem fremden Dokument und darf im Frontend
+            -- niemals als HTML eingesetzt werden. Die Oberfläche zerlegt die
+            -- Zeichenkette an diesen Marken und baut daraus Textknoten – ein
+            -- <script> im Dokument bleibt damit sichtbarer Text.
+            -- MaxWords/MinWords passen zu zwei Zeilen in der Trefferliste.
+            -- Bei 18 Wörtern brach die Fundstelle mitten im Satz ab, ohne dass
+            -- die zweite Zeile voll war; 30 füllt sie und wird darunter von
+            -- der Oberfläche sauber gekappt statt vom Textende.
+            THEN ts_headline('german', ft.content, q.tsq,
+                             'StartSel=[[hl]], StopSel=[[/hl]], MaxWords=30, MinWords=12, MaxFragments=1')
+            ELSE '' END AS snippet
+  FROM files fi
+  LEFT JOIN folders p ON p.id = fi.folder_id
+  -- LEFT JOIN, nicht JOIN: Dateien ohne erkannten Text – alles außer PDFs und
+  -- Bildern – müssen weiterhin über ihren Namen gefunden werden.
+  LEFT JOIN file_text ft ON ft.file_id = fi.id
+ CROSS JOIN q
+ WHERE fi.is_deleted = false
+   AND (fi.name ILIKE $2 ESCAPE '\' OR (q.tsq IS NOT NULL AND ft.tsv @@ q.tsq))
+   AND (fi.owner_id = $1
+        OR fi.group_id IN (SELECT group_id FROM my_groups)
+        OR fi.folder_id IN (SELECT id FROM shared_tree)
+        OR fi.id IN (SELECT id FROM granted_files))
+) hits
+
+-- Ordner zuerst: Wer einen Ordner sucht, will nicht erst an dreißig Dateien
+-- vorbeiscrollen. (Nicht nach kind sortieren – alphabetisch käme "file" vor
+-- "folder", also genau andersherum. Und die Sortierung braucht die Klammer
+-- drumherum: Über einem UNION erlaubt Postgres nur Spaltennamen, keine
+-- Ausdrücke.)
+-- Ordner zuerst, dann Namenstreffer, dann Inhaltstreffer. Wer "Stadtwerke"
+-- sucht und eine so benannte Datei hat, will die oben sehen – nicht die
+-- dreißig Rechnungen, in denen das Wort nur vorkommt.
+ORDER BY (kind = 'folder') DESC, matched_content ASC, name ASC
+LIMIT $3`
+
+	rows, err := s.db.Query(ctx, q, userID, pattern, SearchLimit, query)
+	if err != nil {
+		return nil, fmt.Errorf("search: %w", err)
+	}
+	defer rows.Close()
+
+	hits := []SearchHit{}
+	for rows.Next() {
+		var h SearchHit
+		if err := rows.Scan(&h.Kind, &h.ID, &h.Name, &h.FolderID, &h.FolderName,
+			&h.MimeType, &h.Size, &h.HasThumbnail, &h.UpdatedAt,
+			&h.MatchedContent, &h.Snippet); err != nil {
+			return nil, fmt.Errorf("scan search hit: %w", err)
+		}
+		hits = append(hits, h)
+	}
+	return hits, rows.Err()
+}
+
+// escapeLike entschärft die Platzhalter von LIKE. Der Backslash ist dabei
+// zuerst dran, sonst verdoppelt der Ersatz die eigenen Fluchtzeichen wieder.
+func escapeLike(s string) string {
+	s = strings.ReplaceAll(s, `\`, `\\`)
+	s = strings.ReplaceAll(s, "%", `\%`)
+	s = strings.ReplaceAll(s, "_", `\_`)
+	return s
+}
diff --git a/backend/internal/files/search_test.go b/backend/internal/files/search_test.go
new file mode 100644
index 0000000..1d89bf3
--- /dev/null
+++ b/backend/internal/files/search_test.go
@@ -0,0 +1,22 @@
+package files
+
+import "testing"
+
+// Die Platzhalter von LIKE gehören nicht dem Nutzer: Wer nach "%" sucht, meint
+// ein Prozentzeichen. Ohne Entschärfung fände "%e" alles mit einem "e" darin.
+func TestEscapeLike(t *testing.T) {
+	cases := map[string]string{
+		"rechnung": `rechnung`,
+		"100%":     `100\%`,
+		"a_b":      `a\_b`,
+		`c:\pfad`:  `c:\\pfad`,
+		// Der Backslash muss zuerst ersetzt werden, sonst verdoppelt der
+		// nächste Durchgang die eben gesetzten Fluchtzeichen wieder.
+		`50%\`: `50\%\\`,
+	}
+	for in, want := range cases {
+		if got := escapeLike(in); got != want {
+			t.Errorf("escapeLike(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
diff --git a/backend/internal/files/store.go b/backend/internal/files/store.go
new file mode 100644
index 0000000..5e6c5d3
--- /dev/null
+++ b/backend/internal/files/store.go
@@ -0,0 +1,535 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("not found")
+var ErrNameTaken = errors.New("name already exists in this folder")
+var ErrCycle = errors.New("target is a descendant of the folder being moved")
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store {
+	return &Store{db: db}
+}
+
+const fileCols = `id, owner_id, group_id, folder_id, name, mime_type, size, checksum, storage_key, has_thumbnail, version, versioning_enabled, document_date, created_at, updated_at`
+
+func scanFile(row interface{ Scan(...any) error }, f *File) error {
+	return row.Scan(
+		&f.ID, &f.OwnerID, &f.GroupID, &f.FolderID, &f.Name, &f.MimeType,
+		&f.Size, &f.Checksum, &f.StorageKey, &f.HasThumbnail,
+		&f.Version, &f.VersioningEnabled, &f.DocumentDate, &f.CreatedAt, &f.UpdatedAt,
+	)
+}
+
+// ── Files ────────────────────────────────────────────────────────────────────
+
+func (s *Store) CreateFile(ctx context.Context, f *File) (*File, error) {
+	var out File
+	err := scanFile(s.db.QueryRow(ctx,
+		`INSERT INTO files (owner_id, group_id, folder_id, name, mime_type, size, checksum, storage_key)
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+		 RETURNING `+fileCols,
+		f.OwnerID, f.GroupID, f.FolderID, f.Name, f.MimeType, f.Size, f.Checksum, f.StorageKey,
+	), &out)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("create file: %w", err)
+	}
+	return &out, nil
+}
+
+// GetFileByID fetches a file without owner check (used by public share downloads).
+func (s *Store) GetFileByID(ctx context.Context, id uuid.UUID) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`SELECT `+fileCols+` FROM files WHERE id = $1 AND is_deleted = false`, id,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("get file by id: %w", err)
+	}
+	return &f, nil
+}
+
+func (s *Store) GetFile(ctx context.Context, id, ownerID uuid.UUID) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`SELECT `+fileCols+` FROM files WHERE id = $1 AND (owner_id = $2 OR group_id = $2) AND is_deleted = false`,
+		id, ownerID,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("get file: %w", err)
+	}
+	return &f, nil
+}
+
+func (s *Store) ListFiles(ctx context.Context, ownerID uuid.UUID, folderID *uuid.UUID) ([]*File, error) {
+	var rows pgx.Rows
+	var err error
+	if folderID == nil {
+		rows, err = s.db.Query(ctx,
+			`SELECT `+fileCols+` FROM files
+			 WHERE (owner_id = $1 OR group_id = $1) AND folder_id IS NULL AND is_deleted = false ORDER BY name`,
+			ownerID,
+		)
+	} else {
+		rows, err = s.db.Query(ctx,
+			`SELECT `+fileCols+` FROM files
+			 WHERE (owner_id = $1 OR group_id = $1) AND folder_id = $2 AND is_deleted = false ORDER BY name`,
+			ownerID, folderID,
+		)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("list files: %w", err)
+	}
+	defer rows.Close()
+	return scanFiles(rows)
+}
+
+// SoftDeleteFile marks a file as deleted and updates its storage_key to the trash path.
+// The caller must move the blob to trashKey before calling this.
+func (s *Store) SoftDeleteFile(ctx context.Context, id, ownerID uuid.UUID, trashKey string) error {
+	tag, err := s.db.Exec(ctx,
+		`UPDATE files SET is_deleted = true, deleted_at = NOW(), storage_key = $3
+		 WHERE id = $1 AND (owner_id = $2 OR group_id = $2) AND is_deleted = false`,
+		id, ownerID, trashKey,
+	)
+	if err != nil {
+		return fmt.Errorf("soft delete file: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// GetTrashedFile returns a soft-deleted file by ID (needed before restore/hard-delete).
+func (s *Store) GetTrashedFile(ctx context.Context, id, ownerID uuid.UUID) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`SELECT `+fileCols+` FROM files WHERE id=$1 AND (owner_id = $2 OR group_id = $2) AND is_deleted=true`,
+		id, ownerID,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("get trashed file: %w", err)
+	}
+	return &f, nil
+}
+
+func (s *Store) RenameFile(ctx context.Context, id, ownerID uuid.UUID, name, storageKey string) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`UPDATE files SET name=$3, storage_key=$4
+		 WHERE id=$1 AND (owner_id = $2 OR group_id = $2) AND is_deleted=false
+		 RETURNING `+fileCols,
+		id, ownerID, name, storageKey,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("rename file: %w", err)
+	}
+	return &f, nil
+}
+
+func (s *Store) MoveFile(ctx context.Context, id, ownerID uuid.UUID, newFolderID *uuid.UUID, storageKey string) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`UPDATE files SET folder_id=$3, storage_key=$4
+		 WHERE id=$1 AND (owner_id = $2 OR group_id = $2) AND is_deleted=false
+		 RETURNING `+fileCols,
+		id, ownerID, newFolderID, storageKey,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("move file: %w", err)
+	}
+	return &f, nil
+}
+
+type TrashFile struct {
+	File
+	FolderPath *string `json:"folder_path"`
+}
+
+func (s *Store) ListTrash(ctx context.Context, userID uuid.UUID) ([]*TrashFile, error) {
+	// Sichtbar ist der eigene Papierkorb plus der jeder Gruppe, in der man
+	// Mitglied ist. Ohne den zweiten Teil verschwände eine gelöschte
+	// Gruppendatei spurlos: Sie gehört keinem Konto, tauchte also in keinem
+	// persönlichen Papierkorb auf und wäre nicht wiederherstellbar.
+	const principal = `(f.owner_id = $1 OR f.group_id IN (
+	                        SELECT group_id FROM group_members WHERE user_id = $1))`
+
+	rows, err := s.db.Query(ctx,
+		`WITH RECURSIVE folder_paths AS (
+		   SELECT id, name::text AS full_path
+		   FROM folders
+		    WHERE parent_id IS NULL
+		      AND (owner_id = $1 OR group_id IN (
+		               SELECT group_id FROM group_members WHERE user_id = $1))
+		   UNION ALL
+		   SELECT fo.id, fp.full_path || ' / ' || fo.name
+		   FROM folders fo JOIN folder_paths fp ON fo.parent_id = fp.id
+		 )
+		 SELECT f.id, f.owner_id, f.group_id, f.folder_id, f.name, f.mime_type, f.size, f.checksum,
+		        f.storage_key, f.has_thumbnail, f.version, f.versioning_enabled,
+		        f.created_at, f.updated_at,
+		        fp.full_path AS folder_path
+		 FROM files f
+		 LEFT JOIN folder_paths fp ON fp.id = f.folder_id
+		 WHERE `+principal+` AND f.is_deleted = true
+		 ORDER BY f.deleted_at DESC`,
+		userID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list trash: %w", err)
+	}
+	defer rows.Close()
+	result := make([]*TrashFile, 0)
+	for rows.Next() {
+		var item TrashFile
+		if err := rows.Scan(
+			&item.ID, &item.OwnerID, &item.GroupID, &item.FolderID, &item.Name, &item.MimeType,
+			&item.Size, &item.Checksum, &item.StorageKey, &item.HasThumbnail,
+			&item.Version, &item.VersioningEnabled, &item.CreatedAt, &item.UpdatedAt,
+			&item.FolderPath,
+		); err != nil {
+			return nil, err
+		}
+		result = append(result, &item)
+	}
+	return result, rows.Err()
+}
+
+// RestoreFile marks a file as active again and updates its storage_key to the restored path.
+// The caller must move the blob from .trash/ back to newStorageKey before calling this.
+func (s *Store) RestoreFile(ctx context.Context, id, ownerID uuid.UUID, newStorageKey string) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`UPDATE files SET is_deleted = false, deleted_at = NULL, storage_key = $3
+		 WHERE id = $1 AND (owner_id = $2 OR group_id = $2) AND is_deleted = true
+		 RETURNING `+fileCols,
+		id, ownerID, newStorageKey,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("restore file: %w", err)
+	}
+	return &f, nil
+}
+
+// HardDeleteFile permanently removes a file and returns its storage key plus all version
+// storage keys so the caller can delete the blobs. file_versions rows are removed by
+// the ON DELETE CASCADE on the FK.
+// EmptyTrash löscht alle Papierkorb-Einträge eines Nutzers endgültig und
+// liefert sämtliche Blob-Schlüssel zurück, damit der Aufrufer die Bytes
+// entfernen kann.
+//
+// Die IDs werden mit zurückgegeben, weil zu jeder Datei noch ein
+// Vorschaubild unter "thumbs/<id>.jpg" liegen kann.
+func (s *Store) EmptyTrash(ctx context.Context, ownerID uuid.UUID) (fileIDs []uuid.UUID, keys []string, err error) {
+	// Erst die Versionsblobs einsammeln – die Kaskade räumt die Zeilen mit weg.
+	rows, err := s.db.Query(ctx,
+		`SELECT v.storage_key
+		   FROM file_versions v
+		   JOIN files f ON f.id = v.file_id
+		  WHERE (f.owner_id = $1 OR f.group_id = $1) AND f.is_deleted = true`, ownerID)
+	if err != nil {
+		return nil, nil, fmt.Errorf("list trash version keys: %w", err)
+	}
+	for rows.Next() {
+		var k string
+		if err := rows.Scan(&k); err != nil {
+			rows.Close()
+			return nil, nil, err
+		}
+		keys = append(keys, k)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, nil, err
+	}
+
+	rows, err = s.db.Query(ctx,
+		`DELETE FROM files WHERE (owner_id = $1 OR group_id = $1) AND is_deleted = true
+		 RETURNING id, storage_key`, ownerID)
+	if err != nil {
+		return nil, nil, fmt.Errorf("empty trash: %w", err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var id uuid.UUID
+		var k string
+		if err := rows.Scan(&id, &k); err != nil {
+			return nil, nil, err
+		}
+		fileIDs = append(fileIDs, id)
+		keys = append(keys, k)
+	}
+	return fileIDs, keys, rows.Err()
+}
+
+func (s *Store) HardDeleteFile(ctx context.Context, id, ownerID uuid.UUID) (storageKey string, versionKeys []string, err error) {
+	// Collect version blobs before the cascade removes them.
+	rows, err := s.db.Query(ctx,
+		`SELECT storage_key FROM file_versions WHERE file_id = $1`, id)
+	if err != nil {
+		return "", nil, fmt.Errorf("list version keys: %w", err)
+	}
+	for rows.Next() {
+		var k string
+		if err := rows.Scan(&k); err != nil {
+			rows.Close()
+			return "", nil, err
+		}
+		versionKeys = append(versionKeys, k)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return "", nil, err
+	}
+
+	err = s.db.QueryRow(ctx,
+		`DELETE FROM files WHERE id = $1 AND (owner_id = $2 OR group_id = $2) AND is_deleted = true
+		 RETURNING storage_key`,
+		id, ownerID,
+	).Scan(&storageKey)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return "", nil, ErrNotFound
+	}
+	if err != nil {
+		return "", nil, fmt.Errorf("hard delete file: %w", err)
+	}
+	return storageKey, versionKeys, nil
+}
+
+func (s *Store) UsedBytes(ctx context.Context, ownerID uuid.UUID) (int64, error) {
+	var n int64
+	err := s.db.QueryRow(ctx,
+		`SELECT COALESCE(SUM(size), 0) FROM files WHERE (owner_id = $1 OR group_id = $1) AND is_deleted = false`,
+		ownerID,
+	).Scan(&n)
+	return n, err
+}
+
+// GetFolderPath resolves the full slash-separated path for a folder, e.g. "Urlaub/2024".
+// Returns "" for root (nil folderID).
+func (s *Store) GetFolderPath(ctx context.Context, folderID *uuid.UUID) (string, error) {
+	if folderID == nil {
+		return "", nil
+	}
+	var path string
+	err := s.db.QueryRow(ctx,
+		`WITH RECURSIVE p AS (
+		   SELECT id, name, parent_id, name::text AS full_path
+		   FROM folders WHERE id = $1
+		   UNION ALL
+		   SELECT f.id, f.name, f.parent_id, f.name || '/' || p.full_path
+		   FROM folders f JOIN p ON f.id = p.parent_id
+		 )
+		 SELECT full_path FROM p WHERE parent_id IS NULL`,
+		*folderID,
+	).Scan(&path)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return "", nil
+	}
+	return path, err
+}
+
+// GetFileByName finds a non-deleted file by name in a folder (for versioning on re-upload).
+func (s *Store) GetFileByName(ctx context.Context, ownerID uuid.UUID, folderID *uuid.UUID, name string) (*File, error) {
+	var f File
+	var err error
+	if folderID == nil {
+		err = scanFile(s.db.QueryRow(ctx,
+			`SELECT `+fileCols+` FROM files
+			 WHERE (owner_id = $1 OR group_id = $1) AND folder_id IS NULL AND name=$2 AND is_deleted=false`,
+			ownerID, name,
+		), &f)
+	} else {
+		err = scanFile(s.db.QueryRow(ctx,
+			`SELECT `+fileCols+` FROM files
+			 WHERE (owner_id = $1 OR group_id = $1) AND folder_id=$2 AND name=$3 AND is_deleted=false`,
+			ownerID, *folderID, name,
+		), &f)
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &f, err
+}
+
+func (s *Store) CreateVersion(ctx context.Context, fileID uuid.UUID, version int, size int64, checksum, storageKey string) error {
+	_, err := s.db.Exec(ctx,
+		`INSERT INTO file_versions (file_id, version, size, checksum, storage_key)
+		 VALUES ($1, $2, $3, $4, $5)`,
+		fileID, version, size, checksum, storageKey,
+	)
+	return err
+}
+
+// UpdateFileContent replaces blob metadata and increments version. Resets has_thumbnail.
+func (s *Store) UpdateFileContent(ctx context.Context, id uuid.UUID, size int64, checksum, storageKey string) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`UPDATE files SET size=$2, checksum=$3, storage_key=$4, version=version+1, has_thumbnail=false
+		 WHERE id=$1 AND is_deleted=false RETURNING `+fileCols,
+		id, size, checksum, storageKey,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &f, err
+}
+
+// DeleteVersion entfernt einen Versionseintrag. Wird beim Wiederherstellen
+// gebraucht: dessen Inhalt ist danach die aktive Fassung, der Eintrag also
+// gegenstandslos. Der Blob wird nicht angefasst – er wandert zur Datei.
+func (s *Store) DeleteVersion(ctx context.Context, versionID, fileID uuid.UUID) error {
+	_, err := s.db.Exec(ctx,
+		`DELETE FROM file_versions WHERE id=$1 AND file_id=$2`, versionID, fileID)
+	return err
+}
+
+// SetVersioning schaltet die Versionierung einer Datei um.
+//
+// Bestehende Fassungen bleiben beim Ausschalten erhalten – sie zu löschen wäre
+// stiller Datenverlust. Es entstehen ab dann nur keine neuen mehr.
+func (s *Store) SetVersioning(ctx context.Context, id, ownerID uuid.UUID, enabled bool) (*File, error) {
+	var f File
+	err := scanFile(s.db.QueryRow(ctx,
+		`UPDATE files SET versioning_enabled=$3
+		 WHERE id=$1 AND (owner_id = $2 OR group_id = $2) AND is_deleted=false RETURNING `+fileCols,
+		id, ownerID, enabled,
+	), &f)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &f, err
+}
+
+// PruneVersions keeps the newest maxKeep versions and deletes the rest.
+// Returns storage keys of deleted versions so the caller can remove the blobs.
+func (s *Store) PruneVersions(ctx context.Context, fileID uuid.UUID, maxKeep int) ([]string, error) {
+	rows, err := s.db.Query(ctx,
+		`DELETE FROM file_versions
+		 WHERE id IN (
+		   SELECT id FROM file_versions WHERE file_id=$1
+		   ORDER BY version DESC OFFSET $2
+		 ) RETURNING storage_key`,
+		fileID, maxKeep,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var keys []string
+	for rows.Next() {
+		var k string
+		if err := rows.Scan(&k); err == nil {
+			keys = append(keys, k)
+		}
+	}
+	return keys, rows.Err()
+}
+
+func (s *Store) ListVersions(ctx context.Context, fileID, ownerID uuid.UUID) ([]*FileVersion, error) {
+	// Verify ownership via JOIN
+	rows, err := s.db.Query(ctx,
+		`SELECT fv.id, fv.file_id, fv.version, fv.size, fv.checksum, fv.storage_key, fv.created_at
+		 FROM file_versions fv
+		 JOIN files f ON f.id = fv.file_id
+		 WHERE fv.file_id=$1 AND (f.owner_id = $2 OR f.group_id = $2)
+		 ORDER BY fv.version DESC`,
+		fileID, ownerID,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	result := make([]*FileVersion, 0)
+	for rows.Next() {
+		var v FileVersion
+		if err := rows.Scan(&v.ID, &v.FileID, &v.Version, &v.Size, &v.Checksum, &v.StorageKey, &v.CreatedAt); err != nil {
+			return nil, err
+		}
+		result = append(result, &v)
+	}
+	return result, rows.Err()
+}
+
+func (s *Store) GetVersion(ctx context.Context, versionID, fileID, ownerID uuid.UUID) (*FileVersion, error) {
+	var v FileVersion
+	err := s.db.QueryRow(ctx,
+		`SELECT fv.id, fv.file_id, fv.version, fv.size, fv.checksum, fv.storage_key, fv.created_at
+		 FROM file_versions fv
+		 JOIN files f ON f.id = fv.file_id
+		 WHERE fv.id=$1 AND fv.file_id=$2 AND (f.owner_id = $3 OR f.group_id = $3)`,
+		versionID, fileID, ownerID,
+	).Scan(&v.ID, &v.FileID, &v.Version, &v.Size, &v.Checksum, &v.StorageKey, &v.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &v, err
+}
+
+func (s *Store) UpdateThumbnail(ctx context.Context, id uuid.UUID, hasThumbnail bool) error {
+	_, err := s.db.Exec(ctx,
+		`UPDATE files SET has_thumbnail = $2 WHERE id = $1`, id, hasThumbnail)
+	return err
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+func scanFiles(rows pgx.Rows) ([]*File, error) {
+	result := make([]*File, 0)
+	for rows.Next() {
+		var f File
+		if err := scanFile(rows, &f); err != nil {
+			return nil, err
+		}
+		result = append(result, &f)
+	}
+	return result, rows.Err()
+}
+
+func isUniqueViolation(err error) bool {
+	if err == nil {
+		return false
+	}
+	type sqlStater interface{ SQLState() string }
+	var se sqlStater
+	if errors.As(err, &se) {
+		return se.SQLState() == "23505"
+	}
+	return false
+}
diff --git a/backend/internal/files/store_favorites.go b/backend/internal/files/store_favorites.go
new file mode 100644
index 0000000..86e3737
--- /dev/null
+++ b/backend/internal/files/store_favorites.go
@@ -0,0 +1,129 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+)
+
+// Favoriten der Seitenleiste. Reihenfolge und Auf-/Zugeklappt-Zustand
+// liegen serverseitig, damit sie auf jedem Gerät gleich sind.
+
+// ── Favorites ─────────────────────────────────────────────────────────────────
+
+func (s *Store) ListFavorites(ctx context.Context, userID uuid.UUID) ([]*Favorite, error) {
+	// Nur Favoriten anzeigen, die noch erreichbar sind. Ein Lesezeichen auf
+	// einen Ordner, den man nicht mehr öffnen darf – weil man die Gruppe
+	// verlassen hat oder die Freigabe zurückgezogen wurde – bliebe sonst als
+	// toter Eintrag in der Seitenleiste stehen und liefe beim Klick ins Leere.
+	rows, err := s.db.Query(ctx,
+		`WITH RECURSIVE shared_roots AS (
+		   SELECT e.resource_folder_id AS id
+		     FROM acl_entries e
+		    WHERE e.resource_folder_id IS NOT NULL
+		      AND (e.subject_user_id = $1
+		           OR e.subject_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))
+		   UNION
+		   -- Nach unten aufspannen: Wer einen Ordner freigegeben bekommt, darf
+		   -- auch alles darunter, und darf sich das ebenso merken.
+		   SELECT fo.id FROM folders fo JOIN shared_roots sr ON fo.parent_id = sr.id
+		 )
+		 SELECT f.id, f.user_id, f.folder_id, f.position, f.is_expanded, f.created_at,
+		        fo.name, fo.parent_id
+		 FROM favorites f
+		 JOIN folders fo ON fo.id = f.folder_id
+		 WHERE f.user_id = $1
+		   AND ( fo.owner_id = $1
+		      OR fo.group_id IN (SELECT group_id FROM group_members WHERE user_id = $1)
+		      OR fo.id IN (SELECT id FROM shared_roots) )
+		 ORDER BY f.position`,
+		userID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list favorites: %w", err)
+	}
+	defer rows.Close()
+	favs := make([]*Favorite, 0)
+	for rows.Next() {
+		var fav Favorite
+		if err := rows.Scan(
+			&fav.ID, &fav.UserID, &fav.FolderID, &fav.Position, &fav.IsExpanded, &fav.CreatedAt,
+			&fav.FolderName, &fav.FolderParentID,
+		); err != nil {
+			return nil, err
+		}
+		favs = append(favs, &fav)
+	}
+	return favs, rows.Err()
+}
+
+func (s *Store) AddFavorite(ctx context.Context, userID, folderID uuid.UUID) (*Favorite, error) {
+	var fav Favorite
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO favorites (user_id, folder_id, position)
+		 VALUES ($1, $2, (SELECT COALESCE(MAX(position)+1, 0) FROM favorites WHERE user_id=$1))
+		 ON CONFLICT (user_id, folder_id) DO NOTHING
+		 RETURNING id, user_id, folder_id, position, is_expanded, created_at`,
+		userID, folderID,
+	).Scan(&fav.ID, &fav.UserID, &fav.FolderID, &fav.Position, &fav.IsExpanded, &fav.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNameTaken // already a favorite
+	}
+	if err != nil {
+		return nil, fmt.Errorf("add favorite: %w", err)
+	}
+	// Fetch folder name for response.
+	var f Folder
+	_ = s.db.QueryRow(ctx,
+		`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders WHERE id=$1`, folderID,
+	).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+	fav.FolderName = f.Name
+	fav.FolderParentID = f.ParentID
+	return &fav, nil
+}
+
+func (s *Store) RemoveFavorite(ctx context.Context, userID, folderID uuid.UUID) error {
+	tag, err := s.db.Exec(ctx,
+		`DELETE FROM favorites WHERE user_id=$1 AND folder_id=$2`, userID, folderID)
+	if err != nil {
+		return fmt.Errorf("remove favorite: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+func (s *Store) SetFavoriteExpanded(ctx context.Context, userID, folderID uuid.UUID, expanded bool) error {
+	tag, err := s.db.Exec(ctx,
+		`UPDATE favorites SET is_expanded=$3 WHERE user_id=$1 AND folder_id=$2`,
+		userID, folderID, expanded,
+	)
+	if err != nil {
+		return fmt.Errorf("set favorite expanded: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+func (s *Store) ReorderFavorites(ctx context.Context, userID uuid.UUID, folderIDs []uuid.UUID) error {
+	tx, err := s.db.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+	for i, fid := range folderIDs {
+		if _, err := tx.Exec(ctx,
+			`UPDATE favorites SET position=$3 WHERE user_id=$1 AND folder_id=$2`,
+			userID, fid, i,
+		); err != nil {
+			return fmt.Errorf("reorder favorites: %w", err)
+		}
+	}
+	return tx.Commit(ctx)
+}
diff --git a/backend/internal/files/store_folders.go b/backend/internal/files/store_folders.go
new file mode 100644
index 0000000..a221586
--- /dev/null
+++ b/backend/internal/files/store_folders.go
@@ -0,0 +1,209 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+)
+
+// Ordner: anlegen, umbenennen, verschieben, löschen, auflisten.
+
+// ── Folders ──────────────────────────────────────────────────────────────────
+
+func (s *Store) CreateFolder(ctx context.Context, f *Folder) (*Folder, error) {
+	var out Folder
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO folders (owner_id, group_id, parent_id, name)
+		 VALUES ($1, $2, $3, $4)
+		 RETURNING id, owner_id, group_id, parent_id, name, created_at`,
+		f.OwnerID, f.GroupID, f.ParentID, f.Name,
+	).Scan(&out.ID, &out.OwnerID, &out.GroupID, &out.ParentID, &out.Name, &out.CreatedAt)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("create folder: %w", err)
+	}
+	return &out, nil
+}
+
+func (s *Store) GetFolder(ctx context.Context, id, ownerID uuid.UUID) (*Folder, error) {
+	var f Folder
+	err := s.db.QueryRow(ctx,
+		`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders WHERE id = $1 AND (owner_id = $2 OR group_id = $2)`,
+		id, ownerID,
+	).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("get folder: %w", err)
+	}
+	return &f, nil
+}
+
+// ListFilesInSubtree returns all non-deleted files inside a folder and all its descendants.
+func (s *Store) ListFilesInSubtree(ctx context.Context, ownerID, rootFolderID uuid.UUID) ([]*File, error) {
+	rows, err := s.db.Query(ctx,
+		`WITH RECURSIVE subtree AS (
+		   SELECT id FROM folders WHERE id=$1 AND (owner_id = $2 OR group_id = $2)
+		   UNION ALL
+		   SELECT f.id FROM folders f JOIN subtree s ON f.parent_id=s.id WHERE (f.owner_id = $2 OR f.group_id = $2)
+		 )
+		 SELECT `+fileCols+`
+		 FROM files
+		 WHERE (owner_id = $2 OR group_id = $2) AND is_deleted=false AND folder_id IN (SELECT id FROM subtree)`,
+		rootFolderID, ownerID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list files in subtree: %w", err)
+	}
+	defer rows.Close()
+	files := make([]*File, 0)
+	for rows.Next() {
+		var f File
+		if err := scanFile(rows, &f); err != nil {
+			return nil, err
+		}
+		files = append(files, &f)
+	}
+	return files, rows.Err()
+}
+
+// UpdateFileStorageKey updates only the storage_key of a file (used after blob moves).
+func (s *Store) UpdateFileStorageKey(ctx context.Context, id uuid.UUID, storageKey string) error {
+	_, err := s.db.Exec(ctx, `UPDATE files SET storage_key=$2 WHERE id=$1`, id, storageKey)
+	return err
+}
+
+// RenameFolder renames a folder. Blob path cascading is handled by the handler.
+func (s *Store) RenameFolder(ctx context.Context, id, ownerID uuid.UUID, name string) (*Folder, error) {
+	var f Folder
+	err := s.db.QueryRow(ctx,
+		`UPDATE folders SET name=$3 WHERE id=$1 AND (owner_id = $2 OR group_id = $2)
+		 RETURNING id, owner_id, group_id, parent_id, name, created_at`,
+		id, ownerID, name,
+	).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("rename folder: %w", err)
+	}
+	return &f, nil
+}
+
+// DeleteFolder soft-deletes all files in the subtree (storage_keys must already be
+// updated to trash paths by the caller) and hard-deletes the folder tree.
+func (s *Store) DeleteFolder(ctx context.Context, id, ownerID uuid.UUID) error {
+	tx, err := s.db.Begin(ctx)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback(ctx)
+
+	_, err = tx.Exec(ctx,
+		`WITH RECURSIVE subtree AS (
+		   SELECT id FROM folders WHERE id=$1 AND (owner_id = $2 OR group_id = $2)
+		   UNION ALL
+		   SELECT f.id FROM folders f JOIN subtree s ON f.parent_id=s.id WHERE (f.owner_id = $2 OR f.group_id = $2)
+		 )
+		 UPDATE files SET is_deleted=true, deleted_at=NOW()
+		 WHERE (owner_id = $2 OR group_id = $2) AND is_deleted=false AND folder_id IN (SELECT id FROM subtree)`,
+		id, ownerID,
+	)
+	if err != nil {
+		return fmt.Errorf("soft-delete files in folder: %w", err)
+	}
+
+	_, err = tx.Exec(ctx,
+		`WITH RECURSIVE subtree AS (
+		   SELECT id FROM folders WHERE id=$1 AND (owner_id = $2 OR group_id = $2)
+		   UNION ALL
+		   SELECT f.id FROM folders f JOIN subtree s ON f.parent_id=s.id WHERE (f.owner_id = $2 OR f.group_id = $2)
+		 )
+		 DELETE FROM folders WHERE id IN (SELECT id FROM subtree) AND (owner_id = $2 OR group_id = $2)`,
+		id, ownerID,
+	)
+	if err != nil {
+		return fmt.Errorf("delete folders: %w", err)
+	}
+
+	return tx.Commit(ctx)
+}
+
+func (s *Store) ListFolders(ctx context.Context, ownerID uuid.UUID, parentID *uuid.UUID) ([]*Folder, error) {
+	var rows pgx.Rows
+	var err error
+	if parentID == nil {
+		rows, err = s.db.Query(ctx,
+			`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders
+			 WHERE (owner_id = $1 OR group_id = $1) AND parent_id IS NULL ORDER BY name`,
+			ownerID,
+		)
+	} else {
+		rows, err = s.db.Query(ctx,
+			`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders
+			 WHERE (owner_id = $1 OR group_id = $1) AND parent_id = $2 ORDER BY name`,
+			ownerID, parentID,
+		)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("list folders: %w", err)
+	}
+	defer rows.Close()
+	folders := make([]*Folder, 0)
+	for rows.Next() {
+		var f Folder
+		if err := rows.Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt); err != nil {
+			return nil, err
+		}
+		folders = append(folders, &f)
+	}
+	return folders, rows.Err()
+}
+
+// MoveFolder changes a folder's parent. Returns ErrCycle if newParentID is a descendant.
+func (s *Store) MoveFolder(ctx context.Context, id, ownerID uuid.UUID, newParentID *uuid.UUID) (*Folder, error) {
+	if newParentID != nil {
+		var isDescendant bool
+		err := s.db.QueryRow(ctx,
+			`WITH RECURSIVE subtree AS (
+			   SELECT id FROM folders WHERE id=$1 AND (owner_id = $2 OR group_id = $2)
+			   UNION ALL
+			   SELECT f.id FROM folders f JOIN subtree s ON f.parent_id=s.id WHERE (f.owner_id = $2 OR f.group_id = $2)
+			 )
+			 SELECT EXISTS(SELECT 1 FROM subtree WHERE id=$3)`,
+			id, ownerID, *newParentID,
+		).Scan(&isDescendant)
+		if err != nil {
+			return nil, fmt.Errorf("cycle check: %w", err)
+		}
+		if isDescendant {
+			return nil, ErrCycle
+		}
+	}
+
+	var f Folder
+	err := s.db.QueryRow(ctx,
+		`UPDATE folders SET parent_id=$3 WHERE id=$1 AND (owner_id = $2 OR group_id = $2)
+		 RETURNING id, owner_id, group_id, parent_id, name, created_at`,
+		id, ownerID, newParentID,
+	).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		if isUniqueViolation(err) {
+			return nil, ErrNameTaken
+		}
+		return nil, fmt.Errorf("move folder: %w", err)
+	}
+	return &f, nil
+}
diff --git a/backend/internal/files/store_webdav.go b/backend/internal/files/store_webdav.go
new file mode 100644
index 0000000..7248db5
--- /dev/null
+++ b/backend/internal/files/store_webdav.go
@@ -0,0 +1,102 @@
+package files
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+)
+
+// Auflösung von Pfaden zu Ordnern – gebraucht von WebDAV, das über Pfade
+// adressiert statt über IDs.
+
+// ── WebDAV helpers ────────────────────────────────────────────────────────────
+
+// FolderByPath resolves a path like ["photos", "2024"] to a Folder.
+// Returns a zero-ID folder for an empty parts slice (root).
+func (s *Store) FolderByPath(ctx context.Context, principalID uuid.UUID, parts []string) (*Folder, error) {
+	return s.FolderByPathFrom(ctx, principalID, nil, parts)
+}
+
+// FolderByPathFrom löst Pfadteile ab einem bestimmten Ordner auf. base == nil
+// heißt: ab der Wurzel des Prinzipals.
+//
+// Der Einstiegspunkt ist nötig, weil WebDAV geteilte Ordner unter einem
+// virtuellen Pfad einhängt: Dort beginnt der Weg nicht bei der Wurzel des
+// Eigentümers, sondern genau bei dem Ordner, der freigegeben wurde – alles
+// darüber geht den Empfänger nichts an.
+func (s *Store) FolderByPathFrom(ctx context.Context, principalID uuid.UUID, base *uuid.UUID, parts []string) (*Folder, error) {
+	if len(parts) == 0 {
+		if base == nil {
+			return &Folder{OwnerID: &principalID, Name: "/"}, nil
+		}
+		return s.folderByID(ctx, *base)
+	}
+	parentID := base
+	var current *Folder
+	for _, part := range parts {
+		var f Folder
+		var err error
+		if parentID == nil {
+			err = s.db.QueryRow(ctx,
+				`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders
+				 WHERE (owner_id = $1 OR group_id = $1) AND parent_id IS NULL AND name=$2`,
+				principalID, part,
+			).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+		} else {
+			err = s.db.QueryRow(ctx,
+				`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders
+				 WHERE (owner_id = $1 OR group_id = $1) AND parent_id=$2 AND name=$3`,
+				principalID, parentID, part,
+			).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+		}
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		if err != nil {
+			return nil, fmt.Errorf("folder by path: %w", err)
+		}
+		parentID = &f.ID
+		current = &f
+	}
+	return current, nil
+}
+
+func (s *Store) folderByID(ctx context.Context, id uuid.UUID) (*Folder, error) {
+	var f Folder
+	err := s.db.QueryRow(ctx,
+		`SELECT id, owner_id, group_id, parent_id, name, created_at FROM folders WHERE id = $1`, id,
+	).Scan(&f.ID, &f.OwnerID, &f.GroupID, &f.ParentID, &f.Name, &f.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("folder by id: %w", err)
+	}
+	return &f, nil
+}
+
+// FileInFolder finds a non-deleted file by name within a folder (nil = root).
+func (s *Store) FileInFolder(ctx context.Context, ownerID uuid.UUID, folderID *uuid.UUID, name string) (*File, error) {
+	var f File
+	var err error
+	if folderID == nil {
+		err = scanFile(s.db.QueryRow(ctx,
+			`SELECT `+fileCols+` FROM files
+			 WHERE (owner_id = $1 OR group_id = $1) AND folder_id IS NULL AND name=$2 AND is_deleted=false`,
+			ownerID, name,
+		), &f)
+	} else {
+		err = scanFile(s.db.QueryRow(ctx,
+			`SELECT `+fileCols+` FROM files
+			 WHERE (owner_id = $1 OR group_id = $1) AND folder_id=$2 AND name=$3 AND is_deleted=false`,
+			ownerID, folderID, name,
+		), &f)
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	return &f, err
+}
diff --git a/backend/internal/files/store_zip.go b/backend/internal/files/store_zip.go
new file mode 100644
index 0000000..693e5f7
--- /dev/null
+++ b/backend/internal/files/store_zip.go
@@ -0,0 +1,120 @@
+package files
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/uuid"
+)
+
+// ZipEntry ist eine Datei samt ihrem Pfad **innerhalb** des Archivs.
+type ZipEntry struct {
+	ID         uuid.UUID
+	Name       string
+	Path       string // z. B. "Belege/2026/rechnung.pdf"
+	Size       int64
+	StorageKey string
+	MimeType   string
+}
+
+// maxZipEntries begrenzt, wie viele Dateien in ein Archiv gehen.
+//
+// Nicht wegen des Speichers – das Archiv wird gestreamt und liegt nie ganz
+// irgendwo –, sondern wegen der Zeit: Bei zehntausend Dateien liefe die
+// Anfrage minutenlang, und ein Abbruch mittendrin hinterließe ein halbes
+// Archiv, dem man das nicht ansieht.
+const MaxZipEntries = 2000
+
+// FilesInFolderTree liefert alle Dateien unterhalb eines Ordners **mit ihrem
+// relativen Pfad**, damit das Archiv die Ordnerstruktur behält.
+//
+// Der Pfad entsteht in der Abfrage selbst: Ihn nachträglich in Go
+// zusammenzusetzen hieße, für jeden Ordner die Kette nach oben einzeln
+// abzufragen – bei fünfzig Unterordnern fünfzig Rundreisen.
+func (s *Store) FilesInFolderTree(ctx context.Context, principalID, rootFolderID uuid.UUID) ([]ZipEntry, error) {
+	const q = `
+WITH RECURSIVE tree AS (
+    -- Die Wurzel selbst trägt den leeren Pfad: Ihr eigener Name wird zum Namen
+    -- des Archivs, nicht zu einem Ordner darin.
+    SELECT id, ''::text AS path
+      FROM folders
+     WHERE id = $1 AND (owner_id = $2 OR group_id = $2)
+    UNION ALL
+    SELECT f.id, CASE WHEN t.path = '' THEN f.name ELSE t.path || '/' || f.name END
+      FROM folders f
+      JOIN tree t ON f.parent_id = t.id
+     WHERE (f.owner_id = $2 OR f.group_id = $2)
+)
+SELECT fi.id, fi.name,
+       CASE WHEN t.path = '' THEN fi.name ELSE t.path || '/' || fi.name END AS path,
+       fi.size, fi.storage_key, fi.mime_type
+  FROM files fi
+  JOIN tree t ON t.id = fi.folder_id
+ WHERE fi.is_deleted = false
+   AND (fi.owner_id = $2 OR fi.group_id = $2)
+ ORDER BY path
+ LIMIT $3`
+
+	return s.scanZipEntries(ctx, q, rootFolderID, principalID, MaxZipEntries+1)
+}
+
+// FilesForZipByIDs liefert genau die genannten Dateien – aber nur die, die der
+// Anfragende auch erreichen darf.
+//
+// Der Umfang steckt wie bei der Suche in der Abfrage, nicht in einer Prüfung
+// danach. Eine erratene Kennung in der Liste fällt hier still heraus, statt
+// im Archiv zu landen.
+//
+// Die Pfade sind flach: Eine Auswahl kommt aus einem Ordner oder aus einer
+// Etikettenliste, wo eine nachgebaute Ordnerstruktur nur im Weg wäre.
+func (s *Store) FilesForZipByIDs(ctx context.Context, userID uuid.UUID, ids []uuid.UUID) ([]ZipEntry, error) {
+	const q = `
+WITH RECURSIVE my_groups AS (
+    SELECT group_id FROM group_members WHERE user_id = $2
+),
+granted_roots AS (
+    SELECT resource_folder_id AS id FROM acl_entries
+     WHERE resource_folder_id IS NOT NULL
+       AND (subject_user_id = $2 OR subject_group_id IN (SELECT group_id FROM my_groups))
+),
+shared_tree AS (
+    SELECT id FROM granted_roots
+    UNION
+    SELECT f.id FROM folders f JOIN shared_tree s ON f.parent_id = s.id
+),
+granted_files AS (
+    SELECT resource_file_id AS id FROM acl_entries
+     WHERE resource_file_id IS NOT NULL
+       AND (subject_user_id = $2 OR subject_group_id IN (SELECT group_id FROM my_groups))
+)
+SELECT fi.id, fi.name, fi.name AS path, fi.size, fi.storage_key, fi.mime_type
+  FROM files fi
+ WHERE fi.id = ANY($1)
+   AND fi.is_deleted = false
+   AND (fi.owner_id = $2
+        OR fi.group_id IN (SELECT group_id FROM my_groups)
+        OR fi.folder_id IN (SELECT id FROM shared_tree)
+        OR fi.id IN (SELECT id FROM granted_files))
+ ORDER BY fi.name
+ LIMIT $3`
+
+	return s.scanZipEntries(ctx, q, ids, userID, MaxZipEntries+1)
+}
+
+func (s *Store) scanZipEntries(ctx context.Context, q string, args ...any) ([]ZipEntry, error) {
+	rows, err := s.db.Query(ctx, q, args...)
+	if err != nil {
+		return nil, fmt.Errorf("zip entries: %w", err)
+	}
+	defer rows.Close()
+
+	out := []ZipEntry{}
+	for rows.Next() {
+		var e ZipEntry
+		if err := rows.Scan(&e.ID, &e.Name, &e.Path, &e.Size, &e.StorageKey, &e.MimeType); err != nil {
+			return nil, fmt.Errorf("scan zip entry: %w", err)
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
diff --git a/backend/internal/gc/gc.go b/backend/internal/gc/gc.go
new file mode 100644
index 0000000..c4bf949
--- /dev/null
+++ b/backend/internal/gc/gc.go
@@ -0,0 +1,245 @@
+// Package gc räumt verwaiste Blobs auf: Dateien im Speicher, auf die keine
+// Datenbankzeile mehr zeigt.
+//
+// Solche Waisen entstehen, wenn ein Vorgang zwischen Blob-Schreiben und
+// Datenbank-Commit abbricht – etwa weil der Prozess stirbt oder ein Löschen
+// nur halb durchläuft. Ohne Aufräumen belegen sie für immer Platz, ohne dass
+// sie irgendwo auftauchen.
+//
+// Der Ablauf ist bewusst defensiv: Es wird nur gelöscht, was die Datenbank
+// nicht kennt UND älter als eine Schonfrist ist. Der Sinn der Schonfrist:
+// Zwischen `storage.Put` und dem `INSERT` liegt ein kurzer Moment, in dem ein
+// völlig gesunder Upload wie eine Waise aussieht.
+package gc
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/storage"
+)
+
+const (
+	// gracePeriod schützt frische Blobs, deren Datenbankzeile noch unterwegs
+	// ist. Großzügig bemessen – ein Tag zu spät aufgeräumt kostet nichts, einen
+	// laufenden Upload zu löschen dagegen sehr wohl.
+	gracePeriod = 24 * time.Hour
+
+	// Interval zwischen zwei Durchläufen.
+	Interval = 12 * time.Hour
+)
+
+type Collector struct {
+	db      *pgxpool.Pool
+	storage storage.Storage
+}
+
+func New(db *pgxpool.Pool, st storage.Storage) *Collector {
+	return &Collector{db: db, storage: st}
+}
+
+// Result fasst einen Durchlauf zusammen.
+type Result struct {
+	Scanned      int
+	Orphans      int
+	Deleted      int
+	FreedBytes   int64
+	SkippedYoung int
+}
+
+// Run führt einen Durchlauf aus.
+func (c *Collector) Run(ctx context.Context) (Result, error) {
+	var res Result
+
+	referenced, err := c.referencedKeys(ctx)
+	if err != nil {
+		return res, err
+	}
+
+	cutoff := time.Now().Add(-gracePeriod)
+	type orphan struct {
+		key  string
+		size int64
+	}
+	var orphans []orphan
+
+	// "tmp/" bleibt außen vor: Das gehört dem Upload-Pfad und wird dort
+	// aufgeräumt; ein GC, der dort mitmischt, zerrisse laufende Uploads.
+	for _, prefix := range []string{"users", "thumbs", "branding"} {
+		err := c.storage.Walk(ctx, prefix, func(key string, info storage.FileInfo) error {
+			res.Scanned++
+			if referenced[key] {
+				return nil
+			}
+			if info.ModTime.After(cutoff) {
+				res.SkippedYoung++
+				return nil
+			}
+			orphans = append(orphans, orphan{key: key, size: info.Size})
+			return nil
+		})
+		if err != nil {
+			return res, fmt.Errorf("walk %q: %w", prefix, err)
+		}
+	}
+	res.Orphans = len(orphans)
+
+	if shouldAbort(len(referenced), res.Scanned) {
+		log.Ctx(ctx).Error().
+			Int("scanned", res.Scanned).
+			Msg("gc: database reports no referenced blobs while storage is not empty – skipping run")
+		return res, nil
+	}
+
+	for _, o := range orphans {
+		if err := c.storage.Delete(ctx, o.key); err != nil {
+			log.Ctx(ctx).Warn().Err(err).Str("key", o.key).Msg("gc: could not delete orphan")
+			continue
+		}
+		res.Deleted++
+		res.FreedBytes += o.size
+		log.Ctx(ctx).Info().
+			Str("key", o.key).Int64("bytes", o.size).
+			Msg("gc: orphaned blob removed")
+	}
+	return res, nil
+}
+
+// shouldAbort ist die Notbremse vor dem Löschen: Kennt die Datenbank keinen
+// einzigen Blob, obwohl im Speicher welche liegen, ist mit hoher
+// Wahrscheinlichkeit die Abfrage kaputt oder die Verbindung auf die falsche
+// Datenbank gerichtet. Das Ergebnis wäre "alles ist verwaist" – der GC würde
+// den kompletten Bestand löschen. Dann lieber gar nichts tun und laut sein.
+//
+// Die leere Installation (nichts in der Datenbank, nichts auf der Platte) ist
+// davon ausgenommen: da gibt es schlicht nichts zu verwechseln.
+func shouldAbort(referencedCount, scanned int) bool {
+	return referencedCount == 0 && scanned > 0
+}
+
+// referencedKeys sammelt jeden Speicherschlüssel, auf den die Datenbank zeigt –
+// aktive Dateien, Papierkorb und Versionen gleichermaßen. Thumbnails haben
+// keine eigene Spalte, ihr Schlüssel leitet sich aus der Datei-ID ab.
+func (c *Collector) referencedKeys(ctx context.Context) (map[string]bool, error) {
+	keys := make(map[string]bool)
+
+	// files.storage_key deckt aktive UND gelöschte Dateien ab: beim Löschen
+	// wandert der Schlüssel auf den Papierkorb-Pfad mit.
+	rows, err := c.db.Query(ctx, `SELECT storage_key, id, has_thumbnail FROM files`)
+	if err != nil {
+		return nil, fmt.Errorf("query file keys: %w", err)
+	}
+	for rows.Next() {
+		var key, id string
+		var hasThumb bool
+		if err := rows.Scan(&key, &id, &hasThumb); err != nil {
+			rows.Close()
+			return nil, fmt.Errorf("scan file key: %w", err)
+		}
+		keys[strings.TrimPrefix(key, "/")] = true
+		if hasThumb {
+			keys["thumbs/"+id+".jpg"] = true
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterate file keys: %w", err)
+	}
+
+	// Logo und App-Symbol haben keine Zeile in files, sondern stehen in den
+	// Einstellungen. Ohne diese Abfrage hielte der GC sie für verwaist, sobald
+	// "branding" mit durchsucht wird – und löschte sie beim nächsten Lauf.
+	//
+	// Das Logo ist ein einzelner Schlüssel, das App-Symbol ein Verzeichnis:
+	// Endet der Wert auf "/", zählt alles darunter als referenziert.
+	brows, err := c.db.Query(ctx,
+		`SELECT COALESCE(value, '') FROM settings
+		  WHERE key IN ('logo_storage_key', 'app_icon_storage_key')`)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return nil, fmt.Errorf("query branding keys: %w", err)
+	}
+	if err == nil {
+		for brows.Next() {
+			var key string
+			if err := brows.Scan(&key); err != nil {
+				brows.Close()
+				return nil, fmt.Errorf("scan branding key: %w", err)
+			}
+			if key == "" {
+				continue
+			}
+			key = strings.TrimPrefix(key, "/")
+			if !strings.HasSuffix(key, "/") {
+				keys[key] = true
+				continue
+			}
+			if err := c.storage.Walk(ctx, key, func(k string, _ storage.FileInfo) error {
+				keys[k] = true
+				return nil
+			}); err != nil {
+				brows.Close()
+				return nil, fmt.Errorf("walk branding dir %s: %w", key, err)
+			}
+		}
+		brows.Close()
+		if err := brows.Err(); err != nil {
+			return nil, fmt.Errorf("iterate branding keys: %w", err)
+		}
+	}
+
+	vrows, err := c.db.Query(ctx, `SELECT storage_key FROM file_versions`)
+	if err != nil {
+		return nil, fmt.Errorf("query version keys: %w", err)
+	}
+	defer vrows.Close()
+	for vrows.Next() {
+		var key string
+		if err := vrows.Scan(&key); err != nil {
+			return nil, fmt.Errorf("scan version key: %w", err)
+		}
+		keys[strings.TrimPrefix(key, "/")] = true
+	}
+	return keys, vrows.Err()
+}
+
+// Start lässt den GC im Hintergrund laufen: einmal kurz nach dem Start, danach
+// im Intervall. Der erste Durchlauf ist verzögert, damit er nicht mit dem
+// Hochfahren konkurriert.
+func (c *Collector) Start(ctx context.Context, onDone func(Result)) {
+	go func() {
+		timer := time.NewTimer(5 * time.Minute)
+		defer timer.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-timer.C:
+			}
+
+			res, err := c.Run(ctx)
+			if err != nil {
+				log.Ctx(ctx).Error().Err(err).Msg("gc: run failed")
+			} else {
+				log.Ctx(ctx).Info().
+					Int("scanned", res.Scanned).
+					Int("orphans", res.Orphans).
+					Int("deleted", res.Deleted).
+					Int64("freed_bytes", res.FreedBytes).
+					Int("skipped_young", res.SkippedYoung).
+					Msg("gc: run complete")
+				if onDone != nil && res.Deleted > 0 {
+					onDone(res)
+				}
+			}
+			timer.Reset(Interval)
+		}
+	}()
+}
diff --git a/backend/internal/gc/gc_test.go b/backend/internal/gc/gc_test.go
new file mode 100644
index 0000000..8504a96
--- /dev/null
+++ b/backend/internal/gc/gc_test.go
@@ -0,0 +1,28 @@
+package gc
+
+import "testing"
+
+// Die Notbremse ist die letzte Verteidigungslinie: Hinter ihr löscht der GC
+// echte Nutzerdateien. Eine kaputte Abfrage oder eine Verbindung zur falschen
+// Datenbank sieht von hier aus exakt wie "alles ist verwaist" aus.
+func TestShouldAbort(t *testing.T) {
+	tests := []struct {
+		name       string
+		referenced int
+		scanned    int
+		want       bool
+	}{
+		{"database knows nothing but storage is full", 0, 500, true},
+		{"fresh install – nothing anywhere", 0, 0, false},
+		{"normal run", 120, 125, false},
+		{"single orphan among many", 1, 2, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := shouldAbort(tt.referenced, tt.scanned); got != tt.want {
+				t.Errorf("shouldAbort(%d, %d) = %v, want %v",
+					tt.referenced, tt.scanned, got, tt.want)
+			}
+		})
+	}
+}
diff --git a/backend/internal/office/discovery.go b/backend/internal/office/discovery.go
new file mode 100644
index 0000000..f1a5e36
--- /dev/null
+++ b/backend/internal/office/discovery.go
@@ -0,0 +1,200 @@
+package office
+
+import (
+	"context"
+	"crypto/tls"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Die Ermittlungsliste („discovery") sagt, welche Adresse ein Office-Server
+// für welchen Dateityp anbietet.
+//
+// Fest verdrahten ließe sich das nicht: Collabora und OnlyOffice bauen ihre
+// Adressen verschieden auf, und beide ändern sie zwischen Fassungen. Gefragt
+// wird deshalb der Server selbst – einmal, dann für eine Weile gemerkt.
+
+type discoveryXML struct {
+	NetZone struct {
+		Apps []struct {
+			Name    string `xml:"name,attr"`
+			Actions []struct {
+				Name   string `xml:"name,attr"`
+				Ext    string `xml:"ext,attr"`
+				URLSrc string `xml:"urlsrc,attr"`
+			} `xml:"action"`
+		} `xml:"app"`
+	} `xml:"net-zone"`
+}
+
+// discoveryTTL: Wie lange die Liste gilt. Kurz genug, dass ein Neustart des
+// Office-Servers nach einer Aktualisierung durchschlägt; lang genug, dass
+// nicht jedes Öffnen eine zusätzliche Anfrage auslöst.
+const discoveryTTL = 30 * time.Minute
+
+// Client spricht mit dem Office-Server.
+type Client struct {
+	provider string
+	baseURL  string
+	// publicBase ist die Adresse, unter der der **Browser** den Office-Server
+	// erreicht. Die Ermittlungsliste nennt die, unter der der Server sich
+	// selbst sieht – im Compose-Netz also `collabora:9980`. Die schickt man
+	// keinem Browser.
+	publicBase string
+	http       *http.Client
+
+	mu      sync.Mutex
+	actions map[string]string // ".docx|edit" -> urlsrc
+	fetched time.Time
+}
+
+// NewClient baut den Zugang zum Office-Server.
+//
+// allowedHosts begrenzt, wohin überhaupt verbunden werden darf. **Das ist
+// keine Formalie:** Das Backend ruft hier eine Adresse aus der Konfiguration
+// auf – ohne Grenze wird daraus ein Weg ins interne Netz, sobald jemand die
+// Konfiguration beeinflussen kann (SSRF). Die Adresse aus OFFICE_URL zählt
+// immer dazu, sonst wäre die Voreinstellung unbrauchbar.
+func NewClient(provider, baseURL, publicURL string, allowedHosts []string, insecureTLS bool) (*Client, error) {
+	u, err := url.Parse(baseURL)
+	if err != nil || u.Host == "" {
+		return nil, fmt.Errorf("OFFICE_URL is not a valid address: %q", baseURL)
+	}
+
+	allowed := map[string]bool{strings.ToLower(u.Hostname()): true}
+	for _, h := range allowedHosts {
+		allowed[strings.ToLower(strings.TrimSpace(h))] = true
+	}
+
+	transport := &http.Transport{
+		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+			host, _, err := net.SplitHostPort(addr)
+			if err != nil {
+				return nil, err
+			}
+			if !allowed[strings.ToLower(host)] {
+				return nil, fmt.Errorf("office: host %q is not in OFFICE_ALLOWED_HOSTS", host)
+			}
+			return (&net.Dialer{Timeout: 10 * time.Second}).DialContext(ctx, network, addr)
+		},
+		// #nosec G402 – nur wenn ausdrücklich eingeschaltet, für den
+		// Testaufbau mit selbstsigniertem Zertifikat auf demselben Rechner.
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: insecureTLS},
+	}
+
+	if publicURL == "" {
+		publicURL = baseURL
+	}
+	return &Client{
+		provider:   provider,
+		baseURL:    strings.TrimRight(baseURL, "/"),
+		publicBase: strings.TrimRight(publicURL, "/"),
+		http:       &http.Client{Timeout: 20 * time.Second, Transport: transport},
+	}, nil
+}
+
+// toPublic schreibt Schema und Host einer Adresse aus der Ermittlungsliste auf
+// die Adresse um, unter der der Browser den Server erreicht.
+//
+// Der Pfad bleibt unangetastet – er enthält die Fassungsnummer des Servers
+// (`/browser/1ec9f2b9/cool.html`) und ändert sich mit jeder Aktualisierung.
+func (c *Client) toPublic(raw string) string {
+	u, err := url.Parse(raw)
+	if err != nil {
+		return raw
+	}
+	pub, err := url.Parse(c.publicBase)
+	if err != nil || pub.Host == "" {
+		return raw
+	}
+	u.Scheme, u.Host = pub.Scheme, pub.Host
+	return u.String()
+}
+
+func (c *Client) Provider() string { return c.provider }
+
+// EditURL liefert die Adresse, unter der ein Dateityp bearbeitet wird.
+//
+// Fällt auf „view" zurück, wenn der Server für diesen Typ kein Bearbeiten
+// anbietet – lesen ist besser als eine Fehlermeldung.
+func (c *Client) EditURL(ctx context.Context, ext string, write bool) (string, error) {
+	if err := c.refresh(ctx); err != nil {
+		return "", err
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	order := []string{"edit", "view"}
+	if !write {
+		order = []string{"view", "edit"}
+	}
+	for _, action := range order {
+		if u, ok := c.actions[ext+"|"+action]; ok {
+			return c.toPublic(u), nil
+		}
+	}
+	return "", ErrNoSupport
+}
+
+// refresh holt die Liste, wenn sie fehlt oder zu alt ist.
+func (c *Client) refresh(ctx context.Context) error {
+	c.mu.Lock()
+	fresh := c.actions != nil && time.Since(c.fetched) < discoveryTTL
+	c.mu.Unlock()
+	if fresh {
+		return nil
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/hosting/discovery", nil)
+	if err != nil {
+		return err
+	}
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return fmt.Errorf("office server unreachable: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("office discovery returned %d", resp.StatusCode)
+	}
+	// Grenze gegen eine Antwort, die kein Ende nimmt: Die Liste ist wenige
+	// hundert Kilobyte groß.
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
+	if err != nil {
+		return err
+	}
+
+	var doc discoveryXML
+	if err := xml.Unmarshal(body, &doc); err != nil {
+		return fmt.Errorf("office discovery is not valid XML: %w", err)
+	}
+
+	actions := map[string]string{}
+	for _, app := range doc.NetZone.Apps {
+		for _, a := range app.Actions {
+			if a.Ext == "" || a.URLSrc == "" {
+				continue
+			}
+			ext := a.Ext
+			if !strings.HasPrefix(ext, ".") {
+				ext = "." + ext
+			}
+			actions[strings.ToLower(ext)+"|"+a.Name] = a.URLSrc
+		}
+	}
+	if len(actions) == 0 {
+		return fmt.Errorf("office discovery listed no file types")
+	}
+
+	c.mu.Lock()
+	c.actions, c.fetched = actions, time.Now()
+	c.mu.Unlock()
+	return nil
+}
diff --git a/backend/internal/office/handler.go b/backend/internal/office/handler.go
new file mode 100644
index 0000000..2ed8b79
--- /dev/null
+++ b/backend/internal/office/handler.go
@@ -0,0 +1,305 @@
+package office
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+
+	"aether/internal/acl"
+	"aether/internal/auth"
+	"aether/internal/files"
+	"aether/internal/storage"
+	"aether/pkg/response"
+)
+
+// maxSaveBytes begrenzt, was der Office-Server zurückschreiben darf.
+//
+// Ein Textdokument, das größer ist, hat kein Mensch geschrieben. Ohne Grenze
+// wäre der Endpunkt eine Möglichkeit, die Platte zu füllen – er ist der
+// einzige, der ohne Sitzung schreibt.
+const maxSaveBytes = 512 << 20
+
+type Handler struct {
+	client *Client
+	signer *Signer
+	files  *files.Store
+	blobs  storage.Storage
+	acl    *acl.Store
+	// baseURL ist die Adresse dieser Anwendung im **Browser**. Sie steht als
+	// PostMessageOrigin in der Auskunft – der Office-Server prüft damit, an
+	// wen er Nachrichten aus dem Rahmen schicken darf.
+	baseURL string
+	// wopiURL ist die Adresse, unter der der **Office-Server** hierher findet.
+	// Aus seinem Container heraus ist „localhost" er selbst.
+	wopiURL string
+}
+
+func NewHandler(c *Client, s *Signer, fileStore *files.Store, blobs storage.Storage, aclStore *acl.Store, publicURL, wopiURL string) *Handler {
+	if wopiURL == "" {
+		wopiURL = publicURL
+	}
+	return &Handler{
+		client: c, signer: s, files: fileStore, blobs: blobs, acl: aclStore,
+		baseURL: strings.TrimRight(publicURL, "/"),
+		wopiURL: strings.TrimRight(wopiURL, "/"),
+	}
+}
+
+// Enabled sagt der Oberfläche, ob es die Bearbeitung überhaupt gibt. Ein
+// nil-Handler heißt „abgeschaltet" – dann ist die Antwort eine Auskunft, kein
+// Fehler.
+func (h *Handler) Enabled() bool { return h != nil && h.client != nil }
+
+// ── Vom Browser aufgerufen ───────────────────────────────────────────────────
+
+// Session beantwortet GET /api/v1/office/session/{id}.
+//
+// Gibt zurück, wohin der Browser den Rahmen zeigen soll und mit welchem Token.
+// Das Token entsteht **hier**, im angemeldeten Zusammenhang – der WOPI-Weg
+// selbst kennt die Sitzung nicht.
+func (h *Handler) Session(w http.ResponseWriter, r *http.Request) {
+	if !h.Enabled() {
+		response.JSON(w, http.StatusOK, map[string]any{"enabled": false})
+		return
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	user := auth.UserFromContext(r.Context())
+	if user == nil {
+		response.Error(w, http.StatusUnauthorized, "not signed in")
+		return
+	}
+
+	// Zugriff auflösen: eigene Datei, geliehene oder Gruppenordner. Wer nur
+	// lesen darf, bekommt ein Token ohne Schreibrecht – nicht etwa gar keins.
+	access, err := h.acl.ResolveFile(r.Context(), user.ID, id)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	f, err := h.files.GetFile(r.Context(), id, access.OwnerID)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	if !Editable(f.Name) {
+		response.Error(w, http.StatusUnsupportedMediaType, "this file type cannot be opened in Office")
+		return
+	}
+
+	write := access.Permission == acl.PermWrite
+	src, err := h.client.EditURL(r.Context(), Extension(f.Name), write)
+	if err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Msg("office: discovery failed")
+		response.Error(w, http.StatusBadGateway, "the office server is not reachable")
+		return
+	}
+
+	token, exp := h.signer.Issue(f.ID, user.ID, write)
+	wopiSrc := fmt.Sprintf("%s/wopi/files/%s", h.wopiURL, f.ID)
+
+	// Die Adresse aus der Ermittlungsliste trägt Platzhalter in <>-Klammern
+	// („<ui=UI_LLCC&>"). Alles, was wir nicht setzen, muss weg – sonst
+	// schickt der Browser die Klammern mit.
+	src = stripPlaceholders(src)
+	sep := "?"
+	if strings.Contains(src, "?") {
+		sep = "&"
+	}
+	// **Vollständig kodiert**, nicht nur die auffälligen Zeichen: Collabora
+	// weist eine unkodierte WOPISrc zurück („WOPISrc must be URI-encoded.
+	// This is highly problematic with proxies, load balancers, and when
+	// tunneling") – Doppelpunkt und Schrägstrich eingeschlossen.
+	src = fmt.Sprintf("%s%sWOPISrc=%s", src, sep, url.QueryEscape(wopiSrc))
+
+	response.JSON(w, http.StatusOK, map[string]any{
+		"enabled":   true,
+		"provider":  h.client.Provider(),
+		"url":       src,
+		"token":     token,
+		"token_ttl": exp.UnixMilli(),
+		"can_write": write,
+		"file_name": f.Name,
+	})
+}
+
+// ── Vom Office-Server aufgerufen (WOPI) ──────────────────────────────────────
+
+// authorize prüft das Token und holt Datei und Zugriffskontext.
+//
+// Absichtlich ohne Sitzung und ohne CSRF: Diese Aufrufe kommen vom
+// Office-Server, nicht aus einem Browser. Das Token ist die einzige Berechtigung
+// – und es gilt für **genau eine Datei**, damit ein entwendetes Token nicht
+// zum Generalschlüssel wird.
+func (h *Handler) authorize(w http.ResponseWriter, r *http.Request, needWrite bool) (*files.File, acl.Access, bool) {
+	raw := r.URL.Query().Get("access_token")
+	if raw == "" {
+		raw = strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+	}
+	access, err := h.signer.Verify(raw)
+	if err != nil {
+		// 401, nicht 403: Der Office-Server versucht es damit gar nicht erst
+		// erneut, statt in eine Schleife zu laufen.
+		http.Error(w, "invalid or expired token", http.StatusUnauthorized)
+		return nil, acl.Access{}, false
+	}
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil || id != access.FileID {
+		// Das Token gehört zu einer anderen Datei. 404 statt 403 – sonst
+		// verriete die Antwort, dass es die Datei gibt.
+		http.Error(w, "not found", http.StatusNotFound)
+		return nil, acl.Access{}, false
+	}
+	if needWrite && !access.Write {
+		http.Error(w, "read only", http.StatusForbidden)
+		return nil, acl.Access{}, false
+	}
+
+	// Die Rechte werden **bei jedem Aufruf neu** aufgelöst, nicht aus dem
+	// Token übernommen: Eine zurückgezogene Freigabe soll sofort wirken und
+	// nicht erst, wenn das Token abläuft.
+	ctxAccess, err := h.acl.ResolveFile(r.Context(), access.UserID, id)
+	if err != nil {
+		http.Error(w, "not found", http.StatusNotFound)
+		return nil, acl.Access{}, false
+	}
+	if needWrite && ctxAccess.Permission != acl.PermWrite {
+		http.Error(w, "read only", http.StatusForbidden)
+		return nil, acl.Access{}, false
+	}
+	f, err := h.files.GetFile(r.Context(), id, ctxAccess.OwnerID)
+	if err != nil {
+		http.Error(w, "not found", http.StatusNotFound)
+		return nil, acl.Access{}, false
+	}
+	return f, ctxAccess, true
+}
+
+// CheckFileInfo beantwortet GET /wopi/files/{id} – die Auskunft über die Datei.
+func (h *Handler) CheckFileInfo(w http.ResponseWriter, r *http.Request) {
+	f, access, ok := h.authorize(w, r, false)
+	if !ok {
+		return
+	}
+	canWrite := access.Permission == acl.PermWrite
+
+	// **Ohne die Hülle `{"data": …}` dieser Anwendung.** WOPI ist ein fremdes
+	// Protokoll mit festem Antwortformat; ein Feld drumherum verstünde der
+	// Office-Server nicht.
+	writeRawJSON(w, map[string]any{
+		"BaseFileName": f.Name,
+		"Size":         f.Size,
+		"Version":      fmt.Sprintf("%d", f.Version),
+		// Wer speichert, steht später in der Versionshistorie – dort soll ein
+		// Name stehen und nicht eine Kennung.
+		"OwnerId":                 f.OwnerID.String(),
+		"UserId":                  access.OwnerID.String(),
+		"UserFriendlyName":        access.OwnerUsername,
+		"UserCanWrite":            canWrite,
+		"UserCanNotWriteRelative": true,
+		// Kein „Speichern unter", kein Drucken-nach-Hause, keine Verweise auf
+		// fremde Dienste: Was die Datei verlassen könnte, bleibt aus.
+		"DisablePrint":      false,
+		"DisableExport":     false,
+		"DisableCopy":       false,
+		"HideSaveOption":    !canWrite,
+		"HideExportOption":  false,
+		"PostMessageOrigin": h.baseURL,
+		"LastModifiedTime":  f.UpdatedAt.UTC().Format(time.RFC3339),
+	})
+}
+
+// GetFile beantwortet GET /wopi/files/{id}/contents.
+func (h *Handler) GetFile(w http.ResponseWriter, r *http.Request) {
+	f, _, ok := h.authorize(w, r, false)
+	if !ok {
+		return
+	}
+	rc, err := h.blobs.Get(r.Context(), f.StorageKey)
+	if err != nil {
+		http.Error(w, "storage error", http.StatusInternalServerError)
+		return
+	}
+	defer rc.Close()
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Header().Set("X-WOPI-ItemVersion", fmt.Sprintf("%d", f.Version))
+	if _, err := io.Copy(w, rc); err != nil {
+		log.Ctx(r.Context()).Warn().Err(err).Msg("office: sending file failed")
+	}
+}
+
+// PutFile beantwortet POST /wopi/files/{id}/contents – das Speichern.
+func (h *Handler) PutFile(w http.ResponseWriter, r *http.Request) {
+	f, access, ok := h.authorize(w, r, true)
+	if !ok {
+		return
+	}
+	body := http.MaxBytesReader(w, r.Body, maxSaveBytes)
+	defer body.Close()
+
+	updated, err := files.ReplaceContent(r.Context(), h.files, h.blobs, f, access, body)
+	if err != nil {
+		if errors.Is(err, files.ErrQuotaExceeded) {
+			// 413 sagt dem Office-Server, dass es an der Größe lag – er zeigt
+			// das dem Menschen an, statt still nicht zu speichern.
+			http.Error(w, "storage quota exceeded", http.StatusRequestEntityTooLarge)
+			return
+		}
+		log.Ctx(r.Context()).Error().Err(err).Str("file_id", f.ID.String()).
+			Msg("office: saving failed")
+		http.Error(w, "could not save", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("X-WOPI-ItemVersion", fmt.Sprintf("%d", updated.Version))
+	w.WriteHeader(http.StatusOK)
+}
+
+// stripPlaceholders entfernt die <…>-Platzhalter aus einer urlsrc.
+//
+// Die Ermittlungsliste liefert z. B.
+//
+//	https://office/browser/dist/cool.html?<ui=UI_LLCC&><rs=DC_LLCC&>
+//
+// Jeder Platzhalter, den der Host nicht ersetzt, muss weg – sonst landen die
+// spitzen Klammern in der Adresse und der Server lehnt sie ab.
+func stripPlaceholders(src string) string {
+	var b strings.Builder
+	depth := 0
+	for _, r := range src {
+		switch r {
+		case '<':
+			depth++
+		case '>':
+			if depth > 0 {
+				depth--
+			}
+		default:
+			if depth == 0 {
+				b.WriteRune(r)
+			}
+		}
+	}
+	out := b.String()
+	// Ein zurückbleibendes „?" oder „&" am Ende stört keinen Server, ist aber
+	// unsauber in der Adresszeile.
+	return strings.TrimRight(out, "?&")
+}
+
+// writeRawJSON schreibt ein Objekt ohne die Hülle dieser Anwendung.
+func writeRawJSON(w http.ResponseWriter, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	_ = json.NewEncoder(w).Encode(v)
+}
diff --git a/backend/internal/office/office.go b/backend/internal/office/office.go
new file mode 100644
index 0000000..c215bcc
--- /dev/null
+++ b/backend/internal/office/office.go
@@ -0,0 +1,167 @@
+// Package office bindet einen Office-Server an – Collabora oder OnlyOffice.
+//
+// **Ein Adapter für beide.** Beide sprechen WOPI („Web Application Open
+// Platform Interface"), die Schnittstelle, über die ein Office-Server sich
+// eine Datei holt und wieder zurückschreibt. Zwei getrennte Integrationen zu
+// bauen hieße, dieselbe Sache zweimal zu pflegen; umgeschaltet wird über
+// OFFICE_PROVIDER in der .env.
+//
+// **Die Richtung der Aufrufe ist das Entscheidende.** Der Office-Server ist
+// kein Anhängsel des Browsers – er holt die Datei selbst hier ab:
+//
+//	Browser        ──► Office-Server     (die Bedienoberfläche im <iframe>)
+//	Office-Server  ──► Aether /wopi/...  (Datei holen, Datei zurückschreiben)
+//
+// Daraus folgt alles Weitere: Der Office-Server muss Aether unter seiner
+// **öffentlichen** Adresse erreichen (PUBLIC_URL), nicht unter localhost. Und
+// weil dieser Weg an der Sitzung vorbeiführt, trägt jeder Aufruf ein eigenes,
+// kurzlebiges Zugriffstoken.
+package office
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+var (
+	ErrBadToken  = errors.New("invalid access token")
+	ErrExpired   = errors.New("access token expired")
+	ErrNoSupport = errors.New("this file type cannot be opened in Office")
+)
+
+// tokenTTL ist die Lebensdauer eines Zugriffstokens.
+//
+// Zwölf Stunden klingt lang für ein Token – es ist aber die Zeit, die ein
+// geöffnetes Dokument im Browser stehen darf, bevor das Speichern scheitert.
+// Kürzer hieße: Wer ein Dokument über die Mittagspause offen lässt, verliert
+// beim Zurückkommen seine Änderungen. Der Schaden bei einem entwendeten Token
+// ist begrenzt, weil es **an genau eine Datei** gebunden ist.
+const tokenTTL = 12 * time.Hour
+
+// Access beschreibt, was ein Token erlaubt.
+type Access struct {
+	FileID uuid.UUID
+	UserID uuid.UUID
+	Write  bool
+	Expiry time.Time
+}
+
+// Signer stellt Zugriffstoken aus und prüft sie.
+//
+// HMAC über den Inhalt, nichts in der Datenbank: Ein Token ist damit
+// überprüfbar, ohne bei jedem Zugriff nachzuschlagen – und es verfällt von
+// selbst, statt eine Aufräumaufgabe zu brauchen.
+type Signer struct {
+	key []byte
+}
+
+func NewSigner(secret string) *Signer {
+	// Abgeleitet statt direkt verwendet: Dasselbe Geheimnis signiert die
+	// Sitzungscookies. Zwei Zwecke sollen nie denselben Schlüssel teilen –
+	// sonst wäre ein Fehler im einen Verfahren einer im anderen.
+	sum := sha256.Sum256([]byte("aether-wopi\x00" + secret))
+	return &Signer{key: sum[:]}
+}
+
+// Issue stellt ein Token für genau diese Datei und diesen Nutzer aus.
+func (s *Signer) Issue(fileID, userID uuid.UUID, write bool) (string, time.Time) {
+	exp := time.Now().Add(tokenTTL)
+	payload := make([]byte, 0, 41)
+	payload = append(payload, fileID[:]...)
+	payload = append(payload, userID[:]...)
+	var w byte
+	if write {
+		w = 1
+	}
+	payload = append(payload, w)
+	payload = binary.BigEndian.AppendUint64(payload, uint64(exp.Unix()))
+
+	mac := hmac.New(sha256.New, s.key)
+	mac.Write(payload)
+	full := append(payload, mac.Sum(nil)...)
+	return base64.RawURLEncoding.EncodeToString(full), exp
+}
+
+// Verify prüft ein Token und gibt zurück, was es erlaubt.
+func (s *Signer) Verify(token string) (Access, error) {
+	raw, err := base64.RawURLEncoding.DecodeString(token)
+	if err != nil || len(raw) != 41+sha256.Size {
+		return Access{}, ErrBadToken
+	}
+	payload, sig := raw[:41], raw[41:]
+
+	mac := hmac.New(sha256.New, s.key)
+	mac.Write(payload)
+	// Zeitkonstanter Vergleich: Ein normaler Vergleich verrät über die
+	// Laufzeit, wie viele Bytes stimmen – daraus lässt sich eine Signatur
+	// Byte für Byte erraten.
+	if !hmac.Equal(sig, mac.Sum(nil)) {
+		return Access{}, ErrBadToken
+	}
+
+	var a Access
+	copy(a.FileID[:], payload[0:16])
+	copy(a.UserID[:], payload[16:32])
+	a.Write = payload[32] == 1
+	a.Expiry = time.Unix(int64(binary.BigEndian.Uint64(payload[33:41])), 0)
+	if time.Now().After(a.Expiry) {
+		return Access{}, ErrExpired
+	}
+	return a, nil
+}
+
+// editableExtensions sind die Endungen, die ein Office-Server bearbeiten kann.
+//
+// Eine **Positivliste**, keine Ausschlussliste: Was hier nicht steht, wird
+// nicht an den Office-Server gereicht. Ein PDF gehört bewusst nicht dazu – es
+// hat seinen eigenen Betrachter, und ein Office-Server würde daraus beim
+// Speichern ein anderes Dokument machen.
+var editableExtensions = map[string]bool{
+	// Textdokumente
+	"odt": true, "docx": true, "doc": true, "rtf": true, "txt": true,
+	// Tabellen
+	"ods": true, "xlsx": true, "xls": true, "csv": true,
+	// Präsentationen
+	"odp": true, "pptx": true, "ppt": true,
+	// Zeichnungen
+	"odg": true,
+}
+
+// Editable sagt, ob eine Datei im Office-Server geöffnet werden kann.
+func Editable(name string) bool {
+	i := strings.LastIndexByte(name, '.')
+	if i < 0 {
+		return false
+	}
+	return editableExtensions[strings.ToLower(name[i+1:])]
+}
+
+// Extension liefert die Endung in Kleinbuchstaben, mit Punkt – so, wie die
+// Ermittlungsliste des Office-Servers sie führt.
+func Extension(name string) string {
+	i := strings.LastIndexByte(name, '.')
+	if i < 0 {
+		return ""
+	}
+	return strings.ToLower(name[i:])
+}
+
+// ProviderName ist der Anzeigename für die Oberfläche.
+func ProviderName(provider string) string {
+	switch provider {
+	case "collabora":
+		return "Collabora Online"
+	case "onlyoffice":
+		return "OnlyOffice"
+	default:
+		return fmt.Sprintf("Office (%s)", provider)
+	}
+}
diff --git a/backend/internal/oidc/handler.go b/backend/internal/oidc/handler.go
new file mode 100644
index 0000000..429bff3
--- /dev/null
+++ b/backend/internal/oidc/handler.go
@@ -0,0 +1,196 @@
+package oidc
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	gooidc "github.com/coreos/go-oidc/v3/oidc"
+	"golang.org/x/oauth2"
+
+	"aether/internal/auth"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+const stateCookie = "oidc_state"
+
+// Config holds OIDC provider settings (all required if OIDC is enabled).
+type Config struct {
+	Issuer       string
+	ClientID     string
+	ClientSecret string
+	RedirectURL  string
+	// LinkByUsername: bestehendes Konto gleichen Namens übernehmen statt ein
+	// zweites anzulegen. Siehe auth.Store.GetOrCreateByOIDC.
+	LinkByUsername bool
+}
+
+// Handler implements /auth/oidc/login and /auth/oidc/callback.
+type Handler struct {
+	cfg      Config
+	provider *gooidc.Provider
+	oauth2   *oauth2.Config
+	verifier *gooidc.IDTokenVerifier
+
+	authStore *auth.Store
+	sessions  *auth.SessionStore
+}
+
+// New creates an OIDC handler. Returns nil if cfg.Issuer is empty (OIDC disabled).
+func New(ctx context.Context, cfg Config, authStore *auth.Store, sessions *auth.SessionStore) (*Handler, error) {
+	if cfg.Issuer == "" {
+		return nil, nil
+	}
+	provider, err := gooidc.NewProvider(ctx, cfg.Issuer)
+	if err != nil {
+		return nil, fmt.Errorf("oidc provider: %w", err)
+	}
+	oauthCfg := &oauth2.Config{
+		ClientID:     cfg.ClientID,
+		ClientSecret: cfg.ClientSecret,
+		RedirectURL:  cfg.RedirectURL,
+		Endpoint:     provider.Endpoint(),
+		Scopes:       []string{gooidc.ScopeOpenID, "profile"},
+	}
+	return &Handler{
+		cfg:      cfg,
+		provider: provider,
+		oauth2:   oauthCfg,
+		verifier: provider.Verifier(&gooidc.Config{ClientID: cfg.ClientID}),
+
+		authStore: authStore,
+		sessions:  sessions,
+	}, nil
+}
+
+// GET /api/v1/auth/oidc/login – redirect to OIDC provider.
+func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
+	state, err := randomState()
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "state generation failed")
+		return
+	}
+	// Secure wie bei Sitzungs- und CSRF-Cookie: Hinter dem Reverse Proxy sieht
+	// die App selbst kein TLS, deshalb über IsHTTPS (das X-Forwarded-Proto
+	// auswertet – aber nur von vertrauenswürdigen Proxys). Ohne das ginge der
+	// Zustandswert auch über eine unverschlüsselte Verbindung mit.
+	http.SetCookie(w, &http.Cookie{
+		Name: stateCookie, Value: state, Path: "/",
+		MaxAge: 300, HttpOnly: true, SameSite: http.SameSiteLaxMode,
+		Secure: middleware.IsHTTPS(r),
+	})
+	http.Redirect(w, r, h.oauth2.AuthCodeURL(state), http.StatusFound)
+}
+
+// GET /api/v1/auth/oidc/callback – exchange code, create session, redirect to SPA.
+func (h *Handler) Callback(w http.ResponseWriter, r *http.Request) {
+	// Validate state.
+	stateCk, err := r.Cookie(stateCookie)
+	if err != nil || r.URL.Query().Get("state") != stateCk.Value {
+		http.Redirect(w, r, "/?error=oidc_state", http.StatusFound)
+		return
+	}
+	// Clear state cookie.
+	http.SetCookie(w, &http.Cookie{Name: stateCookie, Value: "", Path: "/", MaxAge: -1})
+
+	code := r.URL.Query().Get("code")
+	if code == "" {
+		http.Redirect(w, r, "/?error=oidc_no_code", http.StatusFound)
+		return
+	}
+
+	// Exchange code for tokens.
+	token, err := h.oauth2.Exchange(r.Context(), code)
+	if err != nil {
+		http.Redirect(w, r, "/?error=oidc_exchange", http.StatusFound)
+		return
+	}
+
+	rawIDToken, ok := token.Extra("id_token").(string)
+	if !ok {
+		http.Redirect(w, r, "/?error=oidc_no_id_token", http.StatusFound)
+		return
+	}
+
+	idToken, err := h.verifier.Verify(r.Context(), rawIDToken)
+	if err != nil {
+		http.Redirect(w, r, "/?error=oidc_verify", http.StatusFound)
+		return
+	}
+
+	// Extract claims.
+	var claims struct {
+		Sub               string `json:"sub"`
+		PreferredUsername string `json:"preferred_username"`
+		Name              string `json:"name"`
+	}
+	if err := idToken.Claims(&claims); err != nil {
+		http.Redirect(w, r, "/?error=oidc_claims", http.StatusFound)
+		return
+	}
+
+	// Derive username: prefer preferred_username, fall back to sub.
+	username := sanitizeUsername(claims.PreferredUsername)
+	if username == "" {
+		username = sanitizeUsername(claims.Sub)
+	}
+	if username == "" {
+		http.Redirect(w, r, "/?error=oidc_no_username", http.StatusFound)
+		return
+	}
+
+	// Find or create user.
+	user, err := h.authStore.GetOrCreateByOIDC(r.Context(), claims.Sub, username, claims.Name, h.cfg.LinkByUsername)
+	if err != nil {
+		http.Redirect(w, r, "/?error=oidc_user", http.StatusFound)
+		return
+	}
+
+	if err := h.sessions.SetUser(w, r, user.ID); err != nil {
+		http.Redirect(w, r, "/?error=oidc_session", http.StatusFound)
+		return
+	}
+
+	// Set CSRF cookie so the SPA can function immediately after redirect.
+	_, _ = auth.SetCSRFCookie(w, r)
+
+	http.Redirect(w, r, "/", http.StatusFound)
+}
+
+// PublicConfig returns whether OIDC is enabled (called without auth).
+func (h *Handler) IsEnabled() bool { return h != nil }
+
+// ConfigJSON writes the OIDC config state (for login page).
+func ConfigJSON(enabled bool, cloudName string) []byte {
+	b, _ := json.Marshal(map[string]any{
+		"oidc_enabled": enabled,
+		"cloud_name":   cloudName,
+	})
+	return b
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+func randomState() (string, error) {
+	b := make([]byte, 16)
+	if _, err := rand.Read(b); err != nil {
+		return "", err
+	}
+	return base64.URLEncoding.EncodeToString(b), nil
+}
+
+func sanitizeUsername(s string) string {
+	s = strings.ToLower(strings.TrimSpace(s))
+	var out strings.Builder
+	for _, r := range s {
+		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r == '-' || r == '.' {
+			out.WriteRune(r)
+		}
+	}
+	return out.String()
+}
diff --git a/backend/internal/sharing/handler.go b/backend/internal/sharing/handler.go
new file mode 100644
index 0000000..39333d1
--- /dev/null
+++ b/backend/internal/sharing/handler.go
@@ -0,0 +1,202 @@
+package sharing
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+
+	"aether/internal/audit"
+	"aether/internal/auth"
+	"aether/internal/files"
+	"aether/internal/storage"
+	"aether/pkg/middleware"
+	"aether/pkg/response"
+)
+
+type Handler struct {
+	store     *Store
+	fileStore *files.Store
+	storage   storage.Storage
+	auditor   *audit.Logger
+}
+
+func NewHandler(store *Store, fileStore *files.Store, st storage.Storage, auditor *audit.Logger) *Handler {
+	return &Handler{store: store, fileStore: fileStore, storage: st, auditor: auditor}
+}
+
+// POST /api/v1/files/{id}/share
+func (h *Handler) Create(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	fileID, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid file id")
+		return
+	}
+	if _, err := h.fileStore.GetFile(r.Context(), fileID, user.ID); err != nil {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+
+	var body struct {
+		Password  string `json:"password"`
+		ExpiresIn *int   `json:"expires_in_hours"`
+	}
+	_ = json.NewDecoder(r.Body).Decode(&body)
+
+	var passwordHash string
+	if body.Password != "" {
+		passwordHash, err = auth.HashPassword(body.Password)
+		if err != nil {
+			response.Error(w, http.StatusInternalServerError, "hash error")
+			return
+		}
+	}
+
+	var expiresAt *time.Time
+	if body.ExpiresIn != nil && *body.ExpiresIn > 0 {
+		t := time.Now().Add(time.Duration(*body.ExpiresIn) * time.Hour)
+		expiresAt = &t
+	}
+
+	link, err := h.store.Create(r.Context(), fileID, user.ID, passwordHash, expiresAt)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "create share link failed")
+		return
+	}
+	// Ein Freigabelink macht eine Datei öffentlich erreichbar – gehört ins
+	// Protokoll. Der Token selbst nicht: er IST der Zugang.
+	detail := "no password"
+	if passwordHash != "" {
+		detail = "password protected"
+	}
+	if expiresAt != nil {
+		detail += ", expires " + expiresAt.Format(time.RFC3339)
+	}
+	h.auditor.Log(r.Context(), audit.Event{
+		ActorID:    &user.ID,
+		ActorName:  user.Username,
+		Action:     audit.ActionShareCreate,
+		TargetType: "file",
+		TargetID:   fileID.String(),
+		IP:         middleware.RealIP(r),
+		Detail:     detail,
+	})
+	response.JSON(w, http.StatusCreated, link)
+}
+
+// GET /api/v1/shares – list all share links owned by user
+func (h *Handler) List(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	links, err := h.store.ListByOwner(r.Context(), user.ID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	if links == nil {
+		links = []*ShareLink{}
+	}
+	response.JSON(w, http.StatusOK, links)
+}
+
+// DELETE /api/v1/shares/{id}
+func (h *Handler) Delete(w http.ResponseWriter, r *http.Request) {
+	user := auth.UserFromContext(r.Context())
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid share id")
+		return
+	}
+	if err := h.store.Delete(r.Context(), id, user.ID); errors.Is(err, ErrNotFound) {
+		response.Error(w, http.StatusNotFound, "share link not found")
+		return
+	} else if err != nil {
+		response.Error(w, http.StatusInternalServerError, "database error")
+		return
+	}
+	h.auditor.Log(r.Context(), audit.Event{
+		ActorID:    &user.ID,
+		ActorName:  user.Username,
+		Action:     audit.ActionShareDelete,
+		TargetType: "share",
+		TargetID:   id.String(),
+		IP:         middleware.RealIP(r),
+	})
+	response.NoContent(w)
+}
+
+// GET /s/{token} – public share info (no auth required)
+func (h *Handler) GetPublicInfo(w http.ResponseWriter, r *http.Request) {
+	token := chi.URLParam(r, "token")
+	link, _, err := h.store.GetByToken(r.Context(), token)
+	if errors.Is(err, ErrNotFound) || errors.Is(err, ErrExpired) {
+		response.Error(w, http.StatusNotFound, "share link not found or expired")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "error")
+		return
+	}
+	f, err := h.fileStore.GetFileByID(r.Context(), link.FileID)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+	response.JSON(w, http.StatusOK, map[string]any{
+		"link":      link,
+		"file_name": f.Name,
+		"file_size": f.Size,
+		"mime_type": f.MimeType,
+	})
+}
+
+// POST /s/{token}/download – public download, optional password in body
+func (h *Handler) Download(w http.ResponseWriter, r *http.Request) {
+	token := chi.URLParam(r, "token")
+	link, passwordHash, err := h.store.GetByToken(r.Context(), token)
+	if errors.Is(err, ErrNotFound) || errors.Is(err, ErrExpired) {
+		response.Error(w, http.StatusNotFound, "share link not found or expired")
+		return
+	}
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "error")
+		return
+	}
+
+	if link.HasPassword {
+		var body struct {
+			Password string `json:"password"`
+		}
+		_ = json.NewDecoder(r.Body).Decode(&body)
+		ok, _ := auth.VerifyPassword(body.Password, passwordHash)
+		if !ok {
+			response.Error(w, http.StatusUnauthorized, "incorrect password")
+			return
+		}
+	}
+
+	f, err := h.fileStore.GetFileByID(r.Context(), link.FileID)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "file not found")
+		return
+	}
+
+	rc, err := h.storage.Get(r.Context(), f.StorageKey)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "storage error")
+		return
+	}
+	defer rc.Close()
+
+	go h.store.IncrementDownloads(r.Context(), token)
+
+	w.Header().Set("Content-Type", f.MimeType)
+	w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename=%q`, f.Name))
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", f.Size))
+	_, _ = io.Copy(w, rc)
+}
diff --git a/backend/internal/sharing/model.go b/backend/internal/sharing/model.go
new file mode 100644
index 0000000..2724398
--- /dev/null
+++ b/backend/internal/sharing/model.go
@@ -0,0 +1,18 @@
+package sharing
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type ShareLink struct {
+	ID            uuid.UUID  `json:"id"`
+	FileID        uuid.UUID  `json:"file_id"`
+	OwnerID       uuid.UUID  `json:"owner_id"`
+	Token         string     `json:"token"`
+	HasPassword   bool       `json:"has_password"`
+	ExpiresAt     *time.Time `json:"expires_at"`
+	DownloadCount int        `json:"download_count"`
+	CreatedAt     time.Time  `json:"created_at"`
+}
diff --git a/backend/internal/sharing/store.go b/backend/internal/sharing/store.go
new file mode 100644
index 0000000..146ac60
--- /dev/null
+++ b/backend/internal/sharing/store.go
@@ -0,0 +1,123 @@
+package sharing
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("share link not found")
+var ErrExpired = errors.New("share link expired")
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store { return &Store{db: db} }
+
+func (s *Store) Create(ctx context.Context, fileID, ownerID uuid.UUID, passwordHash string, expiresAt *time.Time) (*ShareLink, error) {
+	token, err := generateToken()
+	if err != nil {
+		return nil, fmt.Errorf("generate token: %w", err)
+	}
+
+	var ph *string
+	if passwordHash != "" {
+		ph = &passwordHash
+	}
+
+	var link ShareLink
+	err = s.db.QueryRow(ctx,
+		`INSERT INTO share_links (file_id, owner_id, token, password_hash, expires_at)
+		 VALUES ($1, $2, $3, $4, $5)
+		 RETURNING id, file_id, owner_id, token,
+		           (password_hash IS NOT NULL), expires_at, download_count, created_at`,
+		fileID, ownerID, token, ph, expiresAt,
+	).Scan(&link.ID, &link.FileID, &link.OwnerID, &link.Token,
+		&link.HasPassword, &link.ExpiresAt, &link.DownloadCount, &link.CreatedAt)
+	if err != nil {
+		return nil, fmt.Errorf("create share link: %w", err)
+	}
+	return &link, nil
+}
+
+func (s *Store) GetByToken(ctx context.Context, token string) (*ShareLink, string, error) {
+	var link ShareLink
+	var passwordHash *string
+	err := s.db.QueryRow(ctx,
+		`SELECT id, file_id, owner_id, token,
+		        (password_hash IS NOT NULL), password_hash, expires_at, download_count, created_at
+		 FROM share_links WHERE token = $1`,
+		token,
+	).Scan(&link.ID, &link.FileID, &link.OwnerID, &link.Token,
+		&link.HasPassword, &passwordHash, &link.ExpiresAt, &link.DownloadCount, &link.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, "", ErrNotFound
+	}
+	if err != nil {
+		return nil, "", fmt.Errorf("get share link: %w", err)
+	}
+	if link.ExpiresAt != nil && time.Now().After(*link.ExpiresAt) {
+		return nil, "", ErrExpired
+	}
+	ph := ""
+	if passwordHash != nil {
+		ph = *passwordHash
+	}
+	return &link, ph, nil
+}
+
+func (s *Store) ListByOwner(ctx context.Context, ownerID uuid.UUID) ([]*ShareLink, error) {
+	rows, err := s.db.Query(ctx,
+		`SELECT id, file_id, owner_id, token,
+		        (password_hash IS NOT NULL), expires_at, download_count, created_at
+		 FROM share_links WHERE owner_id = $1 ORDER BY created_at DESC`,
+		ownerID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list share links: %w", err)
+	}
+	defer rows.Close()
+	var links []*ShareLink
+	for rows.Next() {
+		var l ShareLink
+		if err := rows.Scan(&l.ID, &l.FileID, &l.OwnerID, &l.Token,
+			&l.HasPassword, &l.ExpiresAt, &l.DownloadCount, &l.CreatedAt); err != nil {
+			return nil, err
+		}
+		links = append(links, &l)
+	}
+	return links, rows.Err()
+}
+
+func (s *Store) Delete(ctx context.Context, id, ownerID uuid.UUID) error {
+	tag, err := s.db.Exec(ctx,
+		`DELETE FROM share_links WHERE id = $1 AND owner_id = $2`, id, ownerID)
+	if err != nil {
+		return fmt.Errorf("delete share link: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+func (s *Store) IncrementDownloads(ctx context.Context, token string) {
+	_, _ = s.db.Exec(ctx,
+		`UPDATE share_links SET download_count = download_count + 1 WHERE token = $1`, token)
+}
+
+func generateToken() (string, error) {
+	b := make([]byte, 24)
+	if _, err := rand.Read(b); err != nil {
+		return "", err
+	}
+	return base64.RawURLEncoding.EncodeToString(b), nil
+}
diff --git a/backend/internal/storage/localfs.go b/backend/internal/storage/localfs.go
new file mode 100644
index 0000000..19f94e9
--- /dev/null
+++ b/backend/internal/storage/localfs.go
@@ -0,0 +1,280 @@
+package storage
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// LocalFS stores blobs on the local filesystem.
+// Every write is atomic: temp file → fsync → rename.
+type LocalFS struct {
+	root    string // absolute, canonical path
+	tmpRoot string // where temp files land during upload
+}
+
+func NewLocalFS(root, tmpRoot string) (*LocalFS, error) {
+	root, err := filepath.Abs(root)
+	if err != nil {
+		return nil, fmt.Errorf("abs root: %w", err)
+	}
+	tmpRoot, err = filepath.Abs(tmpRoot)
+	if err != nil {
+		return nil, fmt.Errorf("abs tmpRoot: %w", err)
+	}
+	for _, dir := range []string{root, tmpRoot} {
+		if err := os.MkdirAll(dir, 0750); err != nil {
+			return nil, fmt.Errorf("mkdir %s: %w", dir, err)
+		}
+	}
+	return &LocalFS{root: root, tmpRoot: tmpRoot}, nil
+}
+
+// safePath returns the absolute path for key and ensures it stays under root.
+func (fs *LocalFS) safePath(key string) (string, error) {
+	// Reject keys that try to escape with .. or absolute paths.
+	if filepath.IsAbs(key) || strings.Contains(key, "..") {
+		return "", fmt.Errorf("invalid storage key: %q", key)
+	}
+	full := filepath.Join(fs.root, filepath.FromSlash(key))
+	// Canonical check: the resolved path must still be under root.
+	canonical, err := filepath.Abs(full)
+	if err != nil {
+		return "", fmt.Errorf("abs path: %w", err)
+	}
+	if !strings.HasPrefix(canonical+string(filepath.Separator), fs.root+string(filepath.Separator)) {
+		return "", fmt.Errorf("path traversal detected: %q", key)
+	}
+	return canonical, nil
+}
+
+func (fs *LocalFS) Put(ctx context.Context, key string, r io.Reader) (string, int64, error) {
+	dest, err := fs.safePath(key)
+	if err != nil {
+		return "", 0, err
+	}
+	if err := os.MkdirAll(filepath.Dir(dest), 0750); err != nil {
+		return "", 0, fmt.Errorf("mkdir parent: %w", err)
+	}
+
+	// Write to temp file in tmpRoot (same filesystem for atomic rename).
+	tmp, err := os.CreateTemp(fs.tmpRoot, "upload-*")
+	if err != nil {
+		return "", 0, fmt.Errorf("create temp: %w", err)
+	}
+	tmpName := tmp.Name()
+	committed := false
+	defer func() {
+		if !committed {
+			tmp.Close()
+			os.Remove(tmpName)
+		}
+	}()
+
+	h := sha256.New()
+	multi := io.MultiWriter(tmp, h)
+
+	size, err := io.Copy(multi, r)
+	if err != nil {
+		return "", 0, fmt.Errorf("write temp: %w", err)
+	}
+
+	// fsync: flush to physical storage before rename.
+	if err := tmp.Sync(); err != nil {
+		return "", 0, fmt.Errorf("fsync: %w", err)
+	}
+	if err := tmp.Close(); err != nil {
+		return "", 0, fmt.Errorf("close temp: %w", err)
+	}
+
+	// Atomic rename: either fully committed or not.
+	if err := os.Rename(tmpName, dest); err != nil {
+		return "", 0, fmt.Errorf("rename to final: %w", err)
+	}
+	committed = true
+
+	checksum := hex.EncodeToString(h.Sum(nil))
+	return checksum, size, nil
+}
+
+func (fs *LocalFS) Get(ctx context.Context, key string) (io.ReadCloser, error) {
+	path, err := fs.safePath(key)
+	if err != nil {
+		return nil, err
+	}
+	f, err := os.Open(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("blob not found: %q", key)
+		}
+		return nil, fmt.Errorf("open blob: %w", err)
+	}
+	return f, nil
+}
+
+func (fs *LocalFS) Delete(ctx context.Context, key string) error {
+	path, err := fs.safePath(key)
+	if err != nil {
+		return err
+	}
+	if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("delete blob: %w", err)
+	}
+	return nil
+}
+
+func (fs *LocalFS) Stat(ctx context.Context, key string) (FileInfo, error) {
+	path, err := fs.safePath(key)
+	if err != nil {
+		return FileInfo{}, err
+	}
+	fi, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return FileInfo{}, fmt.Errorf("blob not found: %q", key)
+		}
+		return FileInfo{}, fmt.Errorf("stat blob: %w", err)
+	}
+	// Recompute checksum on stat (used for integrity verification).
+	checksum, err := fileChecksum(path)
+	if err != nil {
+		return FileInfo{}, err
+	}
+	return FileInfo{
+		Size:     fi.Size(),
+		Checksum: checksum,
+		ModTime:  fi.ModTime().UTC().Truncate(time.Second),
+	}, nil
+}
+
+// CreateTemp legt eine Datei im Staging-Verzeichnis an. Gedacht für Uploads,
+// deren Größe erst beim Schreiben feststeht: Der Inhalt landet auf derselben
+// Platte wie die späteren Blobs, nicht im Arbeitsspeicher. Der Aufrufer ist für
+// Schließen und Entfernen zuständig.
+func (fs *LocalFS) CreateTemp(pattern string) (*os.File, error) {
+	f, err := os.CreateTemp(fs.tmpRoot, pattern)
+	if err != nil {
+		return nil, fmt.Errorf("create temp file: %w", err)
+	}
+	return f, nil
+}
+
+// LocalPath gibt den Pfad im Dateisystem heraus (siehe LocalPather).
+//
+// Die Prüfung auf Ausbruch aus dem Wurzelverzeichnis ist dieselbe wie bei jedem
+// anderen Zugriff – ein Schlüssel mit ".." kommt hier so wenig durch wie bei
+// Get oder Delete. Der Rückgabewert ist zum **Lesen** gedacht; wer über diesen
+// Pfad schreibt, umgeht das atomare Schreiben und hat die Garantien verspielt.
+func (fs *LocalFS) LocalPath(key string) (string, error) {
+	path, err := fs.safePath(key)
+	if err != nil {
+		return "", err
+	}
+	if _, err := os.Stat(path); err != nil {
+		return "", fmt.Errorf("stat %s: %w", key, err)
+	}
+	return path, nil
+}
+
+// Walk läuft den Baum unterhalb von prefix ab und meldet jede Datei.
+// Verzeichnisse werden übersprungen; die Prüfsumme bleibt leer, weil das
+// Nachrechnen über den gesamten Speicher unverhältnismäßig teuer wäre – wer
+// sie braucht, holt sie über Stat.
+func (fs *LocalFS) Walk(ctx context.Context, prefix string, fn func(key string, info FileInfo) error) error {
+	prefix = strings.Trim(prefix, "/")
+	base := fs.root
+	if prefix != "" {
+		var err error
+		base, err = fs.safePath(prefix)
+		if err != nil {
+			return err
+		}
+	}
+	if _, err := os.Stat(base); os.IsNotExist(err) {
+		return nil
+	}
+
+	return filepath.WalkDir(base, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		if d.IsDir() {
+			return nil
+		}
+		info, err := d.Info()
+		if err != nil {
+			// Datei ist zwischen Auflisten und Abfragen verschwunden – das ist
+			// im laufenden Betrieb normal und kein Grund abzubrechen.
+			if os.IsNotExist(err) {
+				return nil
+			}
+			return err
+		}
+		rel, err := filepath.Rel(fs.root, path)
+		if err != nil {
+			return err
+		}
+		return fn(filepath.ToSlash(rel), FileInfo{Size: info.Size(), ModTime: info.ModTime()})
+	})
+}
+
+// DeletePrefix entfernt ein ganzes Unterverzeichnis des Speichers.
+//
+// Absichtlich streng: ein leerer Präfix würde den gesamten Speicher löschen,
+// deshalb wird er abgelehnt. Der aufgelöste Pfad muss ausserdem echt unterhalb
+// der Wurzel liegen – safePath prüft das bereits, der zusätzliche Vergleich
+// schützt davor, versehentlich die Wurzel selbst zu treffen.
+func (fs *LocalFS) DeletePrefix(ctx context.Context, prefix string) error {
+	prefix = strings.Trim(prefix, "/")
+	if prefix == "" {
+		return fmt.Errorf("refusing to delete empty prefix")
+	}
+	dir, err := fs.safePath(prefix)
+	if err != nil {
+		return err
+	}
+	if dir == fs.root {
+		return fmt.Errorf("refusing to delete storage root")
+	}
+	if err := os.RemoveAll(dir); err != nil {
+		return fmt.Errorf("delete prefix %q: %w", prefix, err)
+	}
+	return nil
+}
+
+func (fs *LocalFS) Move(ctx context.Context, oldKey, newKey string) error {
+	oldPath, err := fs.safePath(oldKey)
+	if err != nil {
+		return err
+	}
+	newPath, err := fs.safePath(newKey)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(newPath), 0750); err != nil {
+		return fmt.Errorf("mkdir parent: %w", err)
+	}
+	return os.Rename(oldPath, newPath)
+}
+
+func fileChecksum(path string) (string, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return "", fmt.Errorf("open for checksum: %w", err)
+	}
+	defer f.Close()
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return "", fmt.Errorf("hash file: %w", err)
+	}
+	return hex.EncodeToString(h.Sum(nil)), nil
+}
diff --git a/backend/internal/storage/localfs_test.go b/backend/internal/storage/localfs_test.go
new file mode 100644
index 0000000..7b4b99a
--- /dev/null
+++ b/backend/internal/storage/localfs_test.go
@@ -0,0 +1,223 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"os"
+	"strings"
+	"testing"
+)
+
+func newTestFS(t *testing.T) *LocalFS {
+	t.Helper()
+	root := t.TempDir()
+	tmp := t.TempDir()
+	fs, err := NewLocalFS(root, tmp)
+	if err != nil {
+		t.Fatalf("NewLocalFS: %v", err)
+	}
+	return fs
+}
+
+func TestPutAndGet(t *testing.T) {
+	fs := newTestFS(t)
+	ctx := context.Background()
+	content := []byte("hello aether")
+
+	checksum, size, err := fs.Put(ctx, "testfile", bytes.NewReader(content))
+	if err != nil {
+		t.Fatalf("Put: %v", err)
+	}
+	if size != int64(len(content)) {
+		t.Errorf("size: got %d want %d", size, len(content))
+	}
+
+	// verify checksum
+	h := sha256.Sum256(content)
+	expected := hex.EncodeToString(h[:])
+	if checksum != expected {
+		t.Errorf("checksum: got %s want %s", checksum, expected)
+	}
+
+	// get and read back
+	rc, err := fs.Get(ctx, "testfile")
+	if err != nil {
+		t.Fatalf("Get: %v", err)
+	}
+	defer rc.Close()
+	got, err := io.ReadAll(rc)
+	if err != nil {
+		t.Fatalf("ReadAll: %v", err)
+	}
+	if !bytes.Equal(got, content) {
+		t.Errorf("content mismatch")
+	}
+}
+
+func TestChecksumVerification(t *testing.T) {
+	fs := newTestFS(t)
+	ctx := context.Background()
+	content := []byte("important data")
+
+	storedChecksum, _, err := fs.Put(ctx, "file", bytes.NewReader(content))
+	if err != nil {
+		t.Fatalf("Put: %v", err)
+	}
+
+	info, err := fs.Stat(ctx, "file")
+	if err != nil {
+		t.Fatalf("Stat: %v", err)
+	}
+	if info.Checksum != storedChecksum {
+		t.Errorf("checksum mismatch after stat: got %s want %s", info.Checksum, storedChecksum)
+	}
+}
+
+func TestPathTraversal(t *testing.T) {
+	fs := newTestFS(t)
+	ctx := context.Background()
+
+	cases := []string{
+		"../escape",
+		"../../etc/passwd",
+		"/absolute/path",
+		"a/../../b",
+		"foo/../../../bar",
+	}
+	for _, key := range cases {
+		_, _, err := fs.Put(ctx, key, strings.NewReader("data"))
+		if err == nil {
+			t.Errorf("expected error for traversal key %q but got none", key)
+		}
+	}
+}
+
+func TestAtomicWrite_NoPartialFile(t *testing.T) {
+	fs := newTestFS(t)
+	ctx := context.Background()
+
+	// Simulate an interrupted reader (fails mid-stream).
+	bad := &failReader{data: []byte("partial"), failAt: 3}
+	_, _, err := fs.Put(ctx, "partial", bad)
+	if err == nil {
+		t.Fatal("expected error from failing reader")
+	}
+
+	// The destination file must NOT exist.
+	dest := fs.root + "/partial"
+	if _, statErr := os.Stat(dest); !os.IsNotExist(statErr) {
+		t.Error("partial file must not exist after failed write")
+	}
+}
+
+func TestDelete(t *testing.T) {
+	fs := newTestFS(t)
+	ctx := context.Background()
+
+	if _, _, err := fs.Put(ctx, "todelete", strings.NewReader("bye")); err != nil {
+		t.Fatalf("Put: %v", err)
+	}
+	if err := fs.Delete(ctx, "todelete"); err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	if _, err := fs.Get(ctx, "todelete"); err == nil {
+		t.Error("expected error getting deleted file")
+	}
+	// Double-delete should be a no-op.
+	if err := fs.Delete(ctx, "todelete"); err != nil {
+		t.Errorf("second Delete should be no-op, got: %v", err)
+	}
+}
+
+// failReader returns data normally up to failAt bytes, then errors.
+type failReader struct {
+	data   []byte
+	pos    int
+	failAt int
+}
+
+func (r *failReader) Read(p []byte) (int, error) {
+	if r.pos >= r.failAt {
+		return 0, io.ErrUnexpectedEOF
+	}
+	n := copy(p, r.data[r.pos:min(r.failAt, len(r.data))])
+	r.pos += n
+	return n, nil
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// Walk ist die Grundlage der Blob-Bereinigung: Übersieht es Dateien, bleiben
+// Waisen liegen; meldet es Schlüssel in einer anderen Form als die Datenbank
+// sie speichert, hält der GC gesunde Blobs für verwaist und löscht sie.
+func TestWalkReportsEveryBlobWithDBStyleKeys(t *testing.T) {
+	fs := newTestFS(t)
+	ctx := context.Background()
+
+	want := map[string]bool{
+		"users/alice/home/notiz.txt":            true,
+		"users/alice/home/Unterordner/bild.png": true,
+		"users/alice/.versions/abc-123":         true,
+		"users/alice/.trash/deadbeef_alt.txt":   true,
+	}
+	for key := range want {
+		if _, _, err := fs.Put(ctx, key, strings.NewReader("inhalt")); err != nil {
+			t.Fatalf("Put(%q): %v", key, err)
+		}
+	}
+	// Außerhalb des Präfixes – darf nicht mitkommen.
+	if _, _, err := fs.Put(ctx, "thumbs/xyz.jpg", strings.NewReader("x")); err != nil {
+		t.Fatalf("Put thumb: %v", err)
+	}
+
+	got := map[string]bool{}
+	if err := fs.Walk(ctx, "users", func(key string, info FileInfo) error {
+		got[key] = true
+		if info.Size != int64(len("inhalt")) {
+			t.Errorf("Walk reported size %d for %q, want %d", info.Size, key, len("inhalt"))
+		}
+		if info.ModTime.IsZero() {
+			t.Errorf("Walk reported zero ModTime for %q – the GC grace period relies on it", key)
+		}
+		return nil
+	}); err != nil {
+		t.Fatalf("Walk: %v", err)
+	}
+
+	for key := range want {
+		if !got[key] {
+			t.Errorf("Walk missed %q – the GC would never reclaim it", key)
+		}
+	}
+	if got["thumbs/xyz.jpg"] {
+		t.Error("Walk crossed the prefix boundary")
+	}
+	if len(got) != len(want) {
+		t.Errorf("Walk returned %d keys, want %d: %v", len(got), len(want), got)
+	}
+}
+
+// Ein fehlender Präfix ist kein Fehler – sonst bräche der GC auf einer frischen
+// Installation ab, bevor er irgendetwas tut.
+func TestWalkMissingPrefixIsNotAnError(t *testing.T) {
+	fs := newTestFS(t)
+
+	called := false
+	if err := fs.Walk(context.Background(), "gibtesnicht", func(string, FileInfo) error {
+		called = true
+		return nil
+	}); err != nil {
+		t.Fatalf("Walk on missing prefix: %v", err)
+	}
+	if called {
+		t.Error("callback ran although the prefix does not exist")
+	}
+}
diff --git a/backend/internal/storage/storage.go b/backend/internal/storage/storage.go
new file mode 100644
index 0000000..3139f02
--- /dev/null
+++ b/backend/internal/storage/storage.go
@@ -0,0 +1,70 @@
+package storage
+
+import (
+	"context"
+	"io"
+	"os"
+	"time"
+)
+
+// TempFiler kann Uploads unbekannter Größe auf der Platte zwischenlagern,
+// statt sie im Arbeitsspeicher zu halten. Bewusst eine eigene, optionale
+// Schnittstelle: *os.File gehört nicht in den allgemeinen Storage-Vertrag, und
+// eine Implementierung ohne lokales Dateisystem kann sie schlicht weglassen.
+type TempFiler interface {
+	CreateTemp(pattern string) (*os.File, error)
+}
+
+// LocalPather gibt den echten Pfad eines Blobs heraus – nur lesend gedacht.
+//
+// Gebraucht von der Texterkennung: ocrmypdf und tesseract sind externe
+// Programme und wollen einen Pfad, keinen Datenstrom. Ohne diese Schnittstelle
+// müsste jede Datei erst in eine vollständige Kopie geschrieben werden, bevor
+// sie erkannt werden kann – bei einem 300-MB-Scan also 300 MB zusätzlich auf
+// einer Platte, die ohnehin knapp sein kann.
+//
+// Wie TempFiler bewusst optional: Eine Ablage ohne lokales Dateisystem (S3)
+// lässt sie weg, und der Aufrufer fällt dann auf die Kopie zurück.
+type LocalPather interface {
+	LocalPath(key string) (string, error)
+}
+
+// FileInfo holds metadata about a stored blob.
+type FileInfo struct {
+	Size     int64
+	Checksum string // SHA-256 hex
+	ModTime  time.Time
+}
+
+// Storage is the blob storage abstraction.
+// All implementations must guarantee atomic writes and never corrupt existing data.
+type Storage interface {
+	// Put streams r to the given key atomically (temp → fsync → rename).
+	// Returns the SHA-256 checksum and byte count written.
+	Put(ctx context.Context, key string, r io.Reader) (checksum string, size int64, err error)
+
+	// Get returns a reader for the blob at key. Caller must close it.
+	Get(ctx context.Context, key string) (io.ReadCloser, error)
+
+	// Delete removes a blob. In Phase 1 this is a hard delete used only by
+	// cleanup/GC paths; user-facing deletes are soft-deletes in the DB.
+	Delete(ctx context.Context, key string) error
+
+	// Stat returns metadata for a blob.
+	Stat(ctx context.Context, key string) (FileInfo, error)
+
+	// Move atomically moves a blob from oldKey to newKey within the same storage root.
+	Move(ctx context.Context, oldKey, newKey string) error
+
+	// Walk ruft fn für jeden Blob unterhalb von prefix auf. Existiert der
+	// Präfix nicht, ist das kein Fehler – nur nichts zu tun. Gedacht für die
+	// Bereinigung verwaister Blobs, die den Bestand auf der Platte gegen die
+	// Datenbank abgleichen muss.
+	Walk(ctx context.Context, prefix string, fn func(key string, info FileInfo) error) error
+
+	// DeletePrefix entfernt alles unterhalb eines Präfixes, etwa den kompletten
+	// Bereich eines Nutzers ("users/alice/"). Gedacht für das endgültige Löschen
+	// eines Kontos: danach existiert keine Datenbankzeile mehr, die noch auf die
+	// einzelnen Blobs zeigen könnte.
+	DeletePrefix(ctx context.Context, prefix string) error
+}
diff --git a/backend/internal/tags/correspondents.go b/backend/internal/tags/correspondents.go
new file mode 100644
index 0000000..4273731
--- /dev/null
+++ b/backend/internal/tags/correspondents.go
@@ -0,0 +1,235 @@
+package tags
+
+// Absender („Korrespondent") – das zweite Ordnungsmerkmal in diesem Paket.
+//
+// **Warum hier und nicht in einem eigenen Paket:** Etiketten, Belegdatum und
+// Absender werden in *einem* Dialog gesetzt und müssen deshalb in *einer*
+// Transaktion geschrieben werden (siehe SetForFile). Ein eigenes Paket hieße
+// zwei Transaktionen – und damit einen Zustand, in dem die Etiketten sitzen
+// und der Absender nicht. Das Paket verwaltet also nicht „Etiketten", sondern
+// die Ordnungsmerkmale einer Datei.
+//
+// **Der Unterschied zum Etikett ist die Anzahl:** Ein Dokument trägt beliebig
+// viele Etiketten, aber genau einen Absender. Daraus folgt alles Übrige – die
+// eigene Liste in der Seitenleiste, das Feld statt der Mehrfachauswahl im
+// Dialog, und die Möglichkeit, „von wem" und „wofür" getrennt zu fragen.
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+)
+
+var ErrCorrespondentNotFound = errors.New("correspondent not found")
+
+// maxCorrespondentLen: Firmennamen sind länger als Etiketten („Stadtwerke
+// München Netzgesellschaft mbH"), aber ein Feld ist kein Aufsatz.
+const maxCorrespondentLen = 80
+
+// Correspondent ist ein Absender samt der Zahl seiner Dokumente.
+type Correspondent struct {
+	ID   uuid.UUID `json:"id"`
+	Name string    `json:"name"`
+	// Icon ist ein Emoji oder leer – dieselbe Regel wie beim Etikett.
+	Icon string `json:"icon"`
+	// GroupID ist gesetzt, wenn der Absender einer Gruppe gehört.
+	GroupID   *uuid.UUID `json:"group_id,omitempty"`
+	GroupName string     `json:"group_name,omitempty"`
+	FileCount int        `json:"file_count"`
+	CreatedAt time.Time  `json:"created_at"`
+}
+
+// ListCorrespondents liefert die eigenen Absender und die der eigenen Gruppen.
+func (s *Store) ListCorrespondents(ctx context.Context, userID uuid.UUID) ([]Correspondent, error) {
+	const q = `
+WITH my_groups AS (
+    SELECT group_id FROM group_members WHERE user_id = $1
+)
+SELECT c.id, c.name, c.icon, c.group_id, COALESCE(g.name, ''),
+       -- Gelöschtes zählt nicht mit: Ein Absender mit „3 Dateien", von denen
+       -- zwei im Papierkorb liegen, führt beim Filtern zu einer kürzeren
+       -- Liste als angekündigt.
+       (SELECT COUNT(*) FROM files f
+         WHERE f.correspondent_id = c.id AND f.is_deleted = false) AS file_count,
+       c.created_at
+  FROM correspondents c
+  LEFT JOIN groups g ON g.id = c.group_id
+ WHERE c.owner_id = $1
+    OR c.group_id IN (SELECT group_id FROM my_groups)
+ ORDER BY (c.group_id IS NOT NULL), lower(c.name)`
+
+	rows, err := s.db.Query(ctx, q, userID)
+	if err != nil {
+		return nil, fmt.Errorf("list correspondents: %w", err)
+	}
+	defer rows.Close()
+
+	out := []Correspondent{}
+	for rows.Next() {
+		var c Correspondent
+		if err := rows.Scan(&c.ID, &c.Name, &c.Icon, &c.GroupID, &c.GroupName,
+			&c.FileCount, &c.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan correspondent: %w", err)
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+// CreateCorrespondent legt einen Absender an.
+func (s *Store) CreateCorrespondent(ctx context.Context, userID uuid.UUID, groupID *uuid.UUID, name, icon string) (*Correspondent, error) {
+	name = normalizeName(name)
+	icon = normalizeIcon(icon)
+	if name == "" {
+		return nil, ErrEmptyName
+	}
+	if len([]rune(name)) > maxCorrespondentLen {
+		return nil, fmt.Errorf("%w: at most %d characters", ErrEmptyName, maxCorrespondentLen)
+	}
+
+	owner := &userID
+	if groupID != nil {
+		owner = nil
+	}
+	var c Correspondent
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO correspondents (owner_id, group_id, name, icon)
+		 VALUES ($1, $2, $3, $4)
+		 RETURNING id, name, icon, group_id, created_at`,
+		owner, groupID, name, icon,
+	).Scan(&c.ID, &c.Name, &c.Icon, &c.GroupID, &c.CreatedAt)
+	if isUniqueViolation(err) {
+		return nil, ErrNameTaken
+	}
+	if err != nil {
+		return nil, fmt.Errorf("create correspondent: %w", err)
+	}
+	return &c, nil
+}
+
+// UpdateCorrespondent benennt einen Absender um.
+//
+// Umbenennen statt neu anlegen ist der Normalfall: Aus „Amazon" wird „Amazon
+// EU S.à r.l.", und alle bisherigen Rechnungen sollen mitkommen. Genau das
+// leistet ein eigenes Feld gegenüber einem in den Dateinamen geschriebenen
+// Absender.
+func (s *Store) UpdateCorrespondent(ctx context.Context, userID, id uuid.UUID, name, icon string) (*Correspondent, error) {
+	name = normalizeName(name)
+	icon = normalizeIcon(icon)
+	if name == "" {
+		return nil, ErrEmptyName
+	}
+	if len([]rune(name)) > maxCorrespondentLen {
+		return nil, fmt.Errorf("%w: at most %d characters", ErrEmptyName, maxCorrespondentLen)
+	}
+
+	var c Correspondent
+	err := s.db.QueryRow(ctx,
+		`UPDATE correspondents SET name = $3, icon = $4
+		  WHERE id = $2 AND (owner_id = $1 OR group_id IN (
+		        SELECT group_id FROM group_members WHERE user_id = $1))
+		 RETURNING id, name, icon, group_id, created_at`,
+		userID, id, name, icon,
+	).Scan(&c.ID, &c.Name, &c.Icon, &c.GroupID, &c.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrCorrespondentNotFound
+	}
+	if isUniqueViolation(err) {
+		return nil, ErrNameTaken
+	}
+	if err != nil {
+		return nil, fmt.Errorf("update correspondent: %w", err)
+	}
+	return &c, nil
+}
+
+// DeleteCorrespondent entfernt einen Absender. Die Dokumente bleiben – sie
+// verlieren nur ihre Zuordnung (ON DELETE SET NULL in Migration 000017).
+func (s *Store) DeleteCorrespondent(ctx context.Context, userID, id uuid.UUID) error {
+	tag, err := s.db.Exec(ctx,
+		`DELETE FROM correspondents
+		  WHERE id = $2 AND (owner_id = $1 OR group_id IN (
+		        SELECT group_id FROM group_members WHERE user_id = $1))`,
+		userID, id)
+	if err != nil {
+		return fmt.Errorf("delete correspondent: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrCorrespondentNotFound
+	}
+	return nil
+}
+
+// FilesWithCorrespondent: „alles von Stadtwerke".
+//
+// Der Umfang steckt wie bei FilesWithTag in der Abfrage selbst, nicht in einem
+// nachträglichen Filter. Sortiert nach Belegdatum absteigend – wer sich alle
+// Rechnungen eines Absenders ansieht, will sie in zeitlicher Ordnung.
+func (s *Store) FilesWithCorrespondent(ctx context.Context, userID, id uuid.UUID) ([]TaggedFile, error) {
+	const q = `
+WITH my_groups AS (
+    SELECT group_id FROM group_members WHERE user_id = $1
+),
+allowed AS (
+    SELECT id FROM correspondents
+     WHERE id = $2
+       AND (owner_id = $1 OR group_id IN (SELECT group_id FROM my_groups))
+)
+SELECT f.id, f.name, f.folder_id, COALESCE(p.name, ''),
+       f.mime_type, f.size, f.has_thumbnail, f.document_date, f.updated_at
+  FROM files f
+  JOIN allowed a ON a.id = f.correspondent_id
+  LEFT JOIN folders p ON p.id = f.folder_id
+ WHERE f.is_deleted = false
+ ORDER BY f.document_date DESC NULLS LAST, f.name`
+
+	rows, err := s.db.Query(ctx, q, userID, id)
+	if err != nil {
+		return nil, fmt.Errorf("files with correspondent: %w", err)
+	}
+	defer rows.Close()
+
+	out := []TaggedFile{}
+	for rows.Next() {
+		var f TaggedFile
+		if err := rows.Scan(&f.ID, &f.Name, &f.FolderID, &f.FolderName,
+			&f.MimeType, &f.Size, &f.HasThumbnail, &f.DocumentDate, &f.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("scan file: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
+
+// CorrespondentsForFiles liefert die Absender mehrerer Dateien auf einmal.
+//
+// In einer Abfrage, nicht je Kachel: Eine Ordnerliste mit fünfzig Dateien
+// löste sonst einundfünfzig Abfragen aus.
+func (s *Store) CorrespondentsForFiles(ctx context.Context, fileIDs []uuid.UUID) (map[uuid.UUID]Correspondent, error) {
+	out := map[uuid.UUID]Correspondent{}
+	if len(fileIDs) == 0 {
+		return out, nil
+	}
+	rows, err := s.db.Query(ctx,
+		`SELECT f.id, c.id, c.name, c.icon, c.group_id
+		   FROM files f
+		   JOIN correspondents c ON c.id = f.correspondent_id
+		  WHERE f.id = ANY($1)`, fileIDs)
+	if err != nil {
+		return nil, fmt.Errorf("correspondents for files: %w", err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var fileID uuid.UUID
+		var c Correspondent
+		if err := rows.Scan(&fileID, &c.ID, &c.Name, &c.Icon, &c.GroupID); err != nil {
+			return nil, fmt.Errorf("scan correspondent: %w", err)
+		}
+		out[fileID] = c
+	}
+	return out, rows.Err()
+}
diff --git a/backend/internal/tags/handler.go b/backend/internal/tags/handler.go
new file mode 100644
index 0000000..daaef4b
--- /dev/null
+++ b/backend/internal/tags/handler.go
@@ -0,0 +1,362 @@
+package tags
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+
+	"aether/internal/acl"
+	"aether/internal/auth"
+	"aether/pkg/response"
+)
+
+type Handler struct {
+	store *Store
+	acl   *acl.Store
+}
+
+func NewHandler(store *Store, aclStore *acl.Store) *Handler {
+	return &Handler{store: store, acl: aclStore}
+}
+
+func userID(r *http.Request) uuid.UUID {
+	if u := auth.UserFromContext(r.Context()); u != nil {
+		return u.ID
+	}
+	return uuid.Nil
+}
+
+// GET /api/v1/tags
+func (h *Handler) List(w http.ResponseWriter, r *http.Request) {
+	list, err := h.store.List(r.Context(), userID(r))
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load tags")
+		return
+	}
+	response.JSON(w, http.StatusOK, list)
+}
+
+// POST /api/v1/tags
+func (h *Handler) Create(w http.ResponseWriter, r *http.Request) {
+	var body struct {
+		Name    string `json:"name"`
+		Color   string `json:"color"`
+		Icon    string `json:"icon"`
+		GroupID string `json:"group_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+
+	var groupID *uuid.UUID
+	if body.GroupID != "" {
+		id, err := uuid.Parse(body.GroupID)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid group_id")
+			return
+		}
+		// Nur für die eigenen Gruppen. Ohne diese Prüfung könnte man einer
+		// fremden Gruppe Etiketten in die Liste legen.
+		member, err := h.acl.IsGroupMember(r.Context(), userID(r), id)
+		if err != nil || !member {
+			response.Error(w, http.StatusNotFound, "group not found")
+			return
+		}
+		groupID = &id
+	}
+
+	tag, err := h.store.Create(r.Context(), userID(r), groupID, body.Name, body.Color, body.Icon)
+	switch {
+	case errors.Is(err, ErrNameTaken):
+		response.Error(w, http.StatusConflict, "a tag with that name already exists")
+		return
+	case errors.Is(err, ErrEmptyName):
+		response.Error(w, http.StatusBadRequest, err.Error())
+		return
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "could not create tag")
+		return
+	}
+	response.JSON(w, http.StatusCreated, tag)
+}
+
+// PATCH /api/v1/tags/{id}
+func (h *Handler) Update(w http.ResponseWriter, r *http.Request) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	var body struct {
+		Name  string `json:"name"`
+		Color string `json:"color"`
+		Icon  string `json:"icon"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	tag, err := h.store.Update(r.Context(), userID(r), id, body.Name, body.Color, body.Icon)
+	switch {
+	case errors.Is(err, ErrNotFound):
+		// 404, nicht 403: Sonst verrät die Antwort, dass es das Etikett gibt.
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	case errors.Is(err, ErrNameTaken):
+		response.Error(w, http.StatusConflict, "a tag with that name already exists")
+		return
+	case errors.Is(err, ErrEmptyName):
+		response.Error(w, http.StatusBadRequest, err.Error())
+		return
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "could not update tag")
+		return
+	}
+	response.JSON(w, http.StatusOK, tag)
+}
+
+// DELETE /api/v1/tags/{id}
+func (h *Handler) Delete(w http.ResponseWriter, r *http.Request) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	if err := h.store.Delete(r.Context(), userID(r), id); err != nil {
+		if errors.Is(err, ErrNotFound) {
+			response.Error(w, http.StatusNotFound, "not found")
+			return
+		}
+		response.Error(w, http.StatusInternalServerError, "could not delete tag")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// GET /api/v1/tags/{id}/files – die Abfrage, für die Etiketten gebaut werden.
+func (h *Handler) Files(w http.ResponseWriter, r *http.Request) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	files, err := h.store.FilesWithTag(r.Context(), userID(r), id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load files")
+		return
+	}
+	response.JSON(w, http.StatusOK, files)
+}
+
+// PUT /api/v1/files/{id}/tags – setzt die Etiketten einer Datei.
+func (h *Handler) SetForFile(w http.ResponseWriter, r *http.Request) {
+	fileID, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	var body struct {
+		TagIDs       []string `json:"tag_ids"`
+		DocumentDate *string  `json:"document_date"`
+		// Absender: entweder eine ID (Auswahl aus der Liste, leerer String
+		// heißt „keiner mehr") oder ein getippter Name, der bei Bedarf
+		// angelegt wird. Fehlt beides, bleibt der Absender, wie er ist.
+		CorrespondentID   *string `json:"correspondent_id"`
+		CorrespondentName string  `json:"correspondent_name"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+
+	// Etikettieren ist eine Änderung an der Datei – also Schreibrecht, nicht
+	// Leserecht. Wer eine Datei nur lesen darf, soll sie nicht für den
+	// Eigentümer umsortieren können.
+	access, err := h.acl.RequireFileWrite(r.Context(), userID(r), fileID)
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+
+	ids := make([]uuid.UUID, 0, len(body.TagIDs))
+	for _, raw := range body.TagIDs {
+		id, err := uuid.Parse(raw)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid tag id")
+			return
+		}
+		ids = append(ids, id)
+	}
+
+	fields := FileFields{
+		TagIDs:            ids,
+		DocumentDate:      body.DocumentDate,
+		CorrespondentName: body.CorrespondentName,
+	}
+	if body.CorrespondentID != nil {
+		// Leerer String heißt ausdrücklich „keinen Absender mehr" – das ist
+		// etwas anderes als „Feld nicht mitgeschickt".
+		cid := uuid.Nil
+		if *body.CorrespondentID != "" {
+			parsed, err := uuid.Parse(*body.CorrespondentID)
+			if err != nil {
+				response.Error(w, http.StatusBadRequest, "invalid correspondent id")
+				return
+			}
+			cid = parsed
+		}
+		fields.CorrespondentID = &cid
+	}
+
+	// Etiketten, Belegdatum und Absender gehen zusammen in einen Vorgang –
+	// entweder gilt alles oder nichts.
+	switch err := h.store.SetFieldsForFile(r.Context(), fileID, access.OwnerID, userID(r), fields); {
+	case errors.Is(err, ErrBadDate):
+		response.Error(w, http.StatusBadRequest, "invalid document_date (expected YYYY-MM-DD)")
+		return
+	case errors.Is(err, ErrWrongOwner):
+		// Deckt zwei Fälle ab, die von außen ununterscheidbar bleiben sollen:
+		// Das Etikett gibt es nicht – oder es gehört jemand anderem. Ein
+		// eigener Text für den zweiten Fall verriete dessen Existenz.
+		response.Error(w, http.StatusBadRequest,
+			"unknown tag or correspondent — a file can only carry those of its own owner or group")
+		return
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "could not set tags")
+		return
+	}
+
+	list, err := h.store.ForFile(r.Context(), fileID)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load tags")
+		return
+	}
+	response.JSON(w, http.StatusOK, list)
+}
+
+// ── Absender ─────────────────────────────────────────────────────────────────
+
+// GET /api/v1/correspondents
+func (h *Handler) ListCorrespondents(w http.ResponseWriter, r *http.Request) {
+	list, err := h.store.ListCorrespondents(r.Context(), userID(r))
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load correspondents")
+		return
+	}
+	response.JSON(w, http.StatusOK, list)
+}
+
+// POST /api/v1/correspondents
+func (h *Handler) CreateCorrespondent(w http.ResponseWriter, r *http.Request) {
+	var body struct {
+		Name    string `json:"name"`
+		Icon    string `json:"icon"`
+		GroupID string `json:"group_id"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+
+	var groupID *uuid.UUID
+	if body.GroupID != "" {
+		id, err := uuid.Parse(body.GroupID)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid group_id")
+			return
+		}
+		member, err := h.acl.IsGroupMember(r.Context(), userID(r), id)
+		if err != nil || !member {
+			response.Error(w, http.StatusNotFound, "group not found")
+			return
+		}
+		groupID = &id
+	}
+
+	c, err := h.store.CreateCorrespondent(r.Context(), userID(r), groupID, body.Name, body.Icon)
+	switch {
+	case errors.Is(err, ErrNameTaken):
+		response.Error(w, http.StatusConflict, "a correspondent with that name already exists")
+		return
+	case errors.Is(err, ErrEmptyName):
+		response.Error(w, http.StatusBadRequest, err.Error())
+		return
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "could not create correspondent")
+		return
+	}
+	response.JSON(w, http.StatusCreated, c)
+}
+
+// PATCH /api/v1/correspondents/{id}
+func (h *Handler) UpdateCorrespondent(w http.ResponseWriter, r *http.Request) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	var body struct {
+		Name string `json:"name"`
+		Icon string `json:"icon"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		response.Error(w, http.StatusBadRequest, "invalid body")
+		return
+	}
+	c, err := h.store.UpdateCorrespondent(r.Context(), userID(r), id, body.Name, body.Icon)
+	switch {
+	case errors.Is(err, ErrCorrespondentNotFound):
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	case errors.Is(err, ErrNameTaken):
+		response.Error(w, http.StatusConflict, "a correspondent with that name already exists")
+		return
+	case errors.Is(err, ErrEmptyName):
+		response.Error(w, http.StatusBadRequest, err.Error())
+		return
+	case err != nil:
+		response.Error(w, http.StatusInternalServerError, "could not update correspondent")
+		return
+	}
+	response.JSON(w, http.StatusOK, c)
+}
+
+// DELETE /api/v1/correspondents/{id}
+//
+// Die Dokumente bleiben, sie verlieren nur ihre Zuordnung. Wer einen Absender
+// löscht, will ihn aus der Liste haben – nicht seine Rechnungen.
+func (h *Handler) DeleteCorrespondent(w http.ResponseWriter, r *http.Request) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	if err := h.store.DeleteCorrespondent(r.Context(), userID(r), id); err != nil {
+		if errors.Is(err, ErrCorrespondentNotFound) {
+			response.Error(w, http.StatusNotFound, "not found")
+			return
+		}
+		response.Error(w, http.StatusInternalServerError, "could not delete correspondent")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// GET /api/v1/correspondents/{id}/files – „alles von Stadtwerke".
+func (h *Handler) CorrespondentFiles(w http.ResponseWriter, r *http.Request) {
+	id, err := uuid.Parse(chi.URLParam(r, "id"))
+	if err != nil {
+		response.Error(w, http.StatusNotFound, "not found")
+		return
+	}
+	files, err := h.store.FilesWithCorrespondent(r.Context(), userID(r), id)
+	if err != nil {
+		response.Error(w, http.StatusInternalServerError, "could not load files")
+		return
+	}
+	response.JSON(w, http.StatusOK, files)
+}
diff --git a/backend/internal/tags/store.go b/backend/internal/tags/store.go
new file mode 100644
index 0000000..6eef9ed
--- /dev/null
+++ b/backend/internal/tags/store.go
@@ -0,0 +1,535 @@
+// Package tags verwaltet Etiketten an Dateien.
+//
+// Etiketten sind das dritte Ordnungsmittel neben Ordnern und Volltext, und sie
+// beantworten eine Frage, die die anderen beiden nicht können: **wofür** ein
+// Dokument gebraucht wird. „Absetzbar" steht in keiner Rechnung – das ist eine
+// Einschätzung des Menschen und muss deshalb irgendwo hin.
+//
+// Der Fall, an dem Ordner scheitern: Der Kaufbeleg eines Notebooks ist zugleich
+// Garantienachweis *und* absetzbar. In einen Ordner passt er nur einmal.
+package tags
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	ErrNotFound   = errors.New("tag not found")
+	ErrNameTaken  = errors.New("a tag with that name already exists")
+	ErrEmptyName  = errors.New("tag name must not be empty")
+	ErrWrongOwner = errors.New("unknown tag, or it belongs to someone else")
+	ErrBadDate    = errors.New("invalid date")
+)
+
+// maxNameLen hält die Namen kurz genug, dass ein Aufkleber an einer Kachel
+// lesbar bleibt. Wer mehr braucht, meint eigentlich einen Ordner.
+const maxNameLen = 40
+
+// MaxTagsPerFile: Mehr sind kein Ordnungssystem mehr, sondern ein Symptom.
+const MaxTagsPerFile = 20
+
+type Store struct {
+	db *pgxpool.Pool
+}
+
+func NewStore(db *pgxpool.Pool) *Store {
+	return &Store{db: db}
+}
+
+// Tag ist ein Etikett samt der Zahl der Dateien, die es tragen.
+type Tag struct {
+	ID   uuid.UUID `json:"id"`
+	Name string    `json:"name"`
+	// Color ist leer, solange keine gewählt wurde – die Oberfläche leitet dann
+	// eine aus dem Namen ab, damit ein neues Etikett nicht farblos ist.
+	Color string `json:"color"`
+	// Icon ist ein Emoji oder leer. Es steht **neben** der Farbe, nicht statt
+	// ihrer: Die Farbe trägt die Wiedererkennung im Augenwinkel, das Symbol
+	// die Bedeutung.
+	Icon string `json:"icon"`
+	// GroupID ist gesetzt, wenn das Etikett einer Gruppe gehört. Die Oberfläche
+	// kennzeichnet solche Etiketten, damit klar ist, dass andere sie sehen.
+	GroupID   *uuid.UUID `json:"group_id,omitempty"`
+	GroupName string     `json:"group_name,omitempty"`
+	FileCount int        `json:"file_count"`
+	CreatedAt time.Time  `json:"created_at"`
+}
+
+// normalizeName macht aus einer Eingabe einen speicherbaren Namen.
+//
+// Nur Rand-Leerraum und Mehrfach-Leerzeichen werden zusammengezogen; die
+// Schreibweise bleibt, wie der Mensch sie getippt hat. Verglichen wird
+// trotzdem ohne Rücksicht darauf (Index in Migration 000015) – „Stadtwerke" und
+// „stadtwerke" sollen nicht nebeneinander stehen, aber wer Großbuchstaben
+// tippt, soll sie auch sehen.
+func normalizeName(s string) string {
+	return strings.Join(strings.Fields(s), " ")
+}
+
+// maxIconRunes begrenzt das Symbol.
+//
+// Nicht auf ein Zeichen: Ein Emoji ist selten ein Codepunkt – 👨‍🎓 sind fünf,
+// 🏳️‍🌈 vier, Hautfarben und Flaggen kommen noch dazu. Acht lässt jedes
+// gängige Emoji durch und verhindert, dass jemand einen Satz ins Feld
+// schreibt und damit die Seitenleiste sprengt.
+const maxIconRunes = 8
+
+// normalizeIcon macht aus einer Eingabe ein speicherbares Symbol.
+//
+// Steuerzeichen und Zeilenumbrüche fliegen raus – die haben in einer Kachel
+// nichts verloren und würden die Darstellung zerreißen. Was übrig bleibt,
+// wird auf maxIconRunes gekürzt statt abgelehnt: Ein zu langes Symbol ist
+// kein Grund, das Etikett nicht anzulegen.
+func normalizeIcon(s string) string {
+	var b strings.Builder
+	n := 0
+	for _, r := range strings.TrimSpace(s) {
+		if r < 0x20 || r == 0x7f {
+			continue
+		}
+		if n >= maxIconRunes {
+			break
+		}
+		b.WriteRune(r)
+		n++
+	}
+	return b.String()
+}
+
+// List liefert die Etiketten des Anfragenden und die seiner Gruppen.
+//
+// Beides in einer Liste, unterschieden durch group_id: Für den Benutzer ist es
+// dieselbe Auswahl, aus der er beim Etikettieren wählt – nur dass die
+// Gruppen-Etiketten auch andere sehen.
+func (s *Store) List(ctx context.Context, userID uuid.UUID) ([]Tag, error) {
+	const q = `
+WITH my_groups AS (
+    SELECT group_id FROM group_members WHERE user_id = $1
+)
+SELECT t.id, t.name, t.color, t.icon, t.group_id, COALESCE(g.name, ''),
+       -- Gelöschtes zählt nicht mit: Ein Etikett mit "3 Dateien", von denen
+       -- zwei im Papierkorb liegen, führt beim Filtern zu einer kürzeren Liste
+       -- als angekündigt.
+       (SELECT COUNT(*) FROM file_tags ft
+          JOIN files f ON f.id = ft.file_id AND f.is_deleted = false
+         WHERE ft.tag_id = t.id) AS file_count,
+       t.created_at
+  FROM tags t
+  LEFT JOIN groups g ON g.id = t.group_id
+ WHERE t.owner_id = $1
+    OR t.group_id IN (SELECT group_id FROM my_groups)
+ ORDER BY (t.group_id IS NOT NULL), lower(t.name)`
+
+	rows, err := s.db.Query(ctx, q, userID)
+	if err != nil {
+		return nil, fmt.Errorf("list tags: %w", err)
+	}
+	defer rows.Close()
+
+	out := []Tag{}
+	for rows.Next() {
+		var t Tag
+		if err := rows.Scan(&t.ID, &t.Name, &t.Color, &t.Icon, &t.GroupID, &t.GroupName,
+			&t.FileCount, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan tag: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}
+
+// Create legt ein Etikett an. groupID leer heißt: es gehört dem Anfragenden.
+func (s *Store) Create(ctx context.Context, userID uuid.UUID, groupID *uuid.UUID, name, color, icon string) (*Tag, error) {
+	icon = normalizeIcon(icon)
+	name = normalizeName(name)
+	if name == "" {
+		return nil, ErrEmptyName
+	}
+	if len([]rune(name)) > maxNameLen {
+		return nil, fmt.Errorf("%w: at most %d characters", ErrEmptyName, maxNameLen)
+	}
+
+	var ownerID *uuid.UUID
+	if groupID == nil {
+		ownerID = &userID
+	}
+
+	var t Tag
+	err := s.db.QueryRow(ctx,
+		`INSERT INTO tags (owner_id, group_id, name, color, icon)
+		 VALUES ($1, $2, $3, $4, $5)
+		 RETURNING id, name, color, icon, group_id, created_at`,
+		ownerID, groupID, name, color, icon,
+	).Scan(&t.ID, &t.Name, &t.Color, &t.Icon, &t.GroupID, &t.CreatedAt)
+	if isUniqueViolation(err) {
+		return nil, ErrNameTaken
+	}
+	if err != nil {
+		return nil, fmt.Errorf("create tag: %w", err)
+	}
+	return &t, nil
+}
+
+// Update ändert Namen und Farbe. Nur der Prinzipal des Etiketts darf das –
+// die Prüfung steckt in der WHERE-Klausel, nicht davor.
+func (s *Store) Update(ctx context.Context, userID, tagID uuid.UUID, name, color, icon string) (*Tag, error) {
+	icon = normalizeIcon(icon)
+	name = normalizeName(name)
+	if name == "" {
+		return nil, ErrEmptyName
+	}
+	var t Tag
+	err := s.db.QueryRow(ctx, `
+		UPDATE tags SET name = $3, color = $4, icon = $5
+		 WHERE id = $2
+		   AND (owner_id = $1
+		        OR group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))
+		RETURNING id, name, color, icon, group_id, created_at`,
+		userID, tagID, name, color, icon,
+	).Scan(&t.ID, &t.Name, &t.Color, &t.Icon, &t.GroupID, &t.CreatedAt)
+	if isUniqueViolation(err) {
+		return nil, ErrNameTaken
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("update tag: %w", err)
+	}
+	return &t, nil
+}
+
+// Delete entfernt das Etikett; die Zuordnungen fallen per CASCADE mit. Die
+// Dateien selbst bleiben unberührt – ein Etikett zu löschen ist eine Aussage
+// über die Ordnung, nicht über den Bestand.
+func (s *Store) Delete(ctx context.Context, userID, tagID uuid.UUID) error {
+	tag, err := s.db.Exec(ctx, `
+		DELETE FROM tags
+		 WHERE id = $2
+		   AND (owner_id = $1
+		        OR group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))`,
+		userID, tagID)
+	if err != nil {
+		return fmt.Errorf("delete tag: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+func isUniqueViolation(err error) bool {
+	var pgErr *pgconn.PgError
+	return errors.As(err, &pgErr) && pgErr.Code == "23505"
+}
+
+// ── Zuordnung zu Dateien ─────────────────────────────────────────────────────
+
+// SetForFile setzt die Etiketten einer Datei auf genau diese Liste.
+//
+// Setzen statt einzeln anhängen und lösen: Der Dialog zeigt ohnehin alle
+// Etiketten mit Häkchen, und ein einziger Aufruf kann nicht auf halbem Weg
+// stehenbleiben. Zwei Aufrufe („anhängen", „lösen") könnten das.
+//
+// principalID ist der Eigentümer der Datei – ein Konto oder eine Gruppe (siehe
+// acl.Access.OwnerID). **Nur Etiketten desselben Prinzipals sind erlaubt.** Das
+// ist die Regel, die Gruppenordner zusammenhält: Eine Datei im Gruppenordner
+// trägt Gruppen-Etiketten, die alle Mitglieder sehen – nicht die privaten des
+// Einzelnen, die für die anderen unsichtbar blieben.
+//
+// documentDate wird **im selben Vorgang** gesetzt, nicht in einem zweiten
+// Aufruf danach. Der erste Entwurf tat genau das – und ein ungültiges Datum
+// hatte die Etiketten dann bereits geändert, bevor es scheiterte. Beim Testen
+// aufgefallen: „15.01.2026" wurde abgelehnt, das zweite Etikett war trotzdem
+// weg. nil heißt „nicht anfassen", ein leerer Zeiger-Inhalt heißt „löschen".
+// FileFields sind die Ordnungsmerkmale, die der Dialog an einer Datei setzt.
+//
+// Ein Zeiger auf nil heißt jeweils „nicht mitgeschickt, also unverändert" –
+// das ist etwas anderes als „leeren". Ohne diese Unterscheidung löschte ein
+// Aufruf, der nur die Etiketten ändern will, stillschweigend das Belegdatum.
+type FileFields struct {
+	TagIDs []uuid.UUID
+	// DocumentDate: "" leert das Feld, nil lässt es stehen.
+	DocumentDate *string
+	// CorrespondentID: uuid.Nil leert das Feld, nil lässt es stehen.
+	CorrespondentID *uuid.UUID
+	// CorrespondentName wird angelegt, falls es ihn noch nicht gibt – der
+	// Normalfall beim Tippen im Dialog. Hat Vorrang vor CorrespondentID.
+	//
+	// Bewusst hier und nicht als zweiter Aufruf der Oberfläche: Sonst entsteht
+	// bei einem Fehler dazwischen ein Absender, der an keiner Datei hängt.
+	CorrespondentName string
+}
+
+func (s *Store) SetForFile(ctx context.Context, fileID, principalID, userID uuid.UUID, tagIDs []uuid.UUID, documentDate *string) error {
+	return s.SetFieldsForFile(ctx, fileID, principalID, userID,
+		FileFields{TagIDs: tagIDs, DocumentDate: documentDate})
+}
+
+// SetFieldsForFile schreibt Etiketten, Belegdatum und Absender in **einem**
+// Vorgang. Entweder gilt alles oder nichts – ein Zustand, in dem die
+// Etiketten sitzen und der Absender nicht, wäre für den Menschen davor nicht
+// erkennbar.
+func (s *Store) SetFieldsForFile(ctx context.Context, fileID, principalID, userID uuid.UUID, f FileFields) error {
+	tagIDs, documentDate := f.TagIDs, f.DocumentDate
+	if len(tagIDs) > MaxTagsPerFile {
+		return fmt.Errorf("at most %d tags per file", MaxTagsPerFile)
+	}
+
+	// Das Datum vor allem anderen prüfen: Was scheitern kann, soll scheitern,
+	// bevor irgendetwas geschrieben wurde.
+	var parsedDate *time.Time
+	if documentDate != nil {
+		if v := strings.TrimSpace(*documentDate); v != "" {
+			d, err := time.Parse("2006-01-02", v)
+			if err != nil {
+				return fmt.Errorf("%w: %s", ErrBadDate, v)
+			}
+			parsedDate = &d
+		}
+	}
+
+	tx, err := s.db.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("begin: %w", err)
+	}
+	defer tx.Rollback(ctx)
+
+	if len(tagIDs) > 0 {
+		// Erst prüfen, dass jedes genannte Etikett wirklich dem Prinzipal der
+		// Datei gehört. Ohne diese Prüfung könnte man über eine erratene ID ein
+		// fremdes Etikett anhängen – und dessen Besitzer sähe eine Datei
+		// darunter, die ihm nichts sagt.
+		var ok int
+		if err := tx.QueryRow(ctx,
+			`SELECT COUNT(*) FROM tags
+			  WHERE id = ANY($1) AND (owner_id = $2 OR group_id = $2)`,
+			tagIDs, principalID,
+		).Scan(&ok); err != nil {
+			return fmt.Errorf("verify tags: %w", err)
+		}
+		if ok != len(tagIDs) {
+			return ErrWrongOwner
+		}
+	}
+
+	// Alte Zuordnungen weg, neue rein. Nicht „nur die Differenz", weil die
+	// Differenz zu berechnen mehr Code wäre als der Gewinn – es geht um
+	// höchstens 20 Zeilen.
+	if _, err := tx.Exec(ctx, `DELETE FROM file_tags WHERE file_id = $1`, fileID); err != nil {
+		return fmt.Errorf("clear tags: %w", err)
+	}
+	for _, id := range tagIDs {
+		if _, err := tx.Exec(ctx,
+			`INSERT INTO file_tags (file_id, tag_id, tagged_by) VALUES ($1, $2, $3)`,
+			fileID, id, userID,
+		); err != nil {
+			return fmt.Errorf("attach tag: %w", err)
+		}
+	}
+
+	// In derselben Transaktion: Entweder gilt beides oder nichts.
+	if documentDate != nil {
+		if _, err := tx.Exec(ctx,
+			`UPDATE files SET document_date = $2 WHERE id = $1`, fileID, parsedDate,
+		); err != nil {
+			return fmt.Errorf("set document date: %w", err)
+		}
+	}
+
+	// Absender. Ein getippter Name gewinnt gegen eine mitgeschickte ID: Wer
+	// im Feld etwas anderes stehen hat als das, was ausgewählt war, meint das
+	// Getippte.
+	if name := normalizeName(f.CorrespondentName); name != "" {
+		if len([]rune(name)) > maxCorrespondentLen {
+			return fmt.Errorf("%w: at most %d characters", ErrEmptyName, maxCorrespondentLen)
+		}
+		// Suchen oder anlegen, beides am Prinzipal der **Datei** – nicht am
+		// Anfragenden. Sonst bekäme eine Datei im Gruppenordner einen privaten
+		// Absender, den außer dem Ersteller niemand sieht.
+		var id uuid.UUID
+		err := tx.QueryRow(ctx,
+			`SELECT id FROM correspondents
+			  WHERE (owner_id = $1 OR group_id = $1) AND lower(btrim(name)) = lower(btrim($2))`,
+			principalID, name,
+		).Scan(&id)
+		if errors.Is(err, pgx.ErrNoRows) {
+			// Ob der Prinzipal ein Konto oder eine Gruppe ist, steht nicht in
+			// der ID. Beide Spalten mit derselben ID zu versuchen wäre Raten –
+			// deshalb die Frage an die Datenbank.
+			var isGroup bool
+			if err := tx.QueryRow(ctx,
+				`SELECT EXISTS (SELECT 1 FROM groups WHERE id = $1)`, principalID,
+			).Scan(&isGroup); err != nil {
+				return fmt.Errorf("principal kind: %w", err)
+			}
+			var owner, group *uuid.UUID
+			if isGroup {
+				group = &principalID
+			} else {
+				owner = &principalID
+			}
+			if err := tx.QueryRow(ctx,
+				`INSERT INTO correspondents (owner_id, group_id, name) VALUES ($1, $2, $3)
+				 RETURNING id`, owner, group, name,
+			).Scan(&id); err != nil {
+				return fmt.Errorf("create correspondent: %w", err)
+			}
+		} else if err != nil {
+			return fmt.Errorf("find correspondent: %w", err)
+		}
+		if _, err := tx.Exec(ctx,
+			`UPDATE files SET correspondent_id = $2 WHERE id = $1`, fileID, id,
+		); err != nil {
+			return fmt.Errorf("set correspondent: %w", err)
+		}
+	} else if f.CorrespondentID != nil {
+		var id *uuid.UUID
+		if *f.CorrespondentID != uuid.Nil {
+			// Dieselbe Prüfung wie bei den Etiketten: Über eine erratene ID
+			// darf kein fremder Absender an eine Datei geraten.
+			var ok int
+			if err := tx.QueryRow(ctx,
+				`SELECT COUNT(*) FROM correspondents
+				  WHERE id = $1 AND (owner_id = $2 OR group_id = $2)`,
+				*f.CorrespondentID, principalID,
+			).Scan(&ok); err != nil {
+				return fmt.Errorf("verify correspondent: %w", err)
+			}
+			if ok != 1 {
+				return ErrWrongOwner
+			}
+			id = f.CorrespondentID
+		}
+		if _, err := tx.Exec(ctx,
+			`UPDATE files SET correspondent_id = $2 WHERE id = $1`, fileID, id,
+		); err != nil {
+			return fmt.Errorf("set correspondent: %w", err)
+		}
+	}
+
+	return tx.Commit(ctx)
+}
+
+// ForFile liefert die Etiketten einer einzelnen Datei.
+func (s *Store) ForFile(ctx context.Context, fileID uuid.UUID) ([]Tag, error) {
+	rows, err := s.db.Query(ctx, `
+		SELECT t.id, t.name, t.color, t.icon, t.group_id, t.created_at
+		  FROM file_tags ft JOIN tags t ON t.id = ft.tag_id
+		 WHERE ft.file_id = $1
+		 ORDER BY lower(t.name)`, fileID)
+	if err != nil {
+		return nil, fmt.Errorf("tags for file: %w", err)
+	}
+	defer rows.Close()
+
+	out := []Tag{}
+	for rows.Next() {
+		var t Tag
+		if err := rows.Scan(&t.ID, &t.Name, &t.Color, &t.Icon, &t.GroupID, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}
+
+// ForFiles holt die Etiketten vieler Dateien auf einmal.
+//
+// Eine Abfrage statt einer je Datei: Bei fünfzig Kacheln wären das sonst
+// fünfzig Rundreisen zur Datenbank, nur um ein paar Aufkleber zu zeichnen.
+func (s *Store) ForFiles(ctx context.Context, fileIDs []uuid.UUID) (map[uuid.UUID][]Tag, error) {
+	out := map[uuid.UUID][]Tag{}
+	if len(fileIDs) == 0 {
+		return out, nil
+	}
+	rows, err := s.db.Query(ctx, `
+		SELECT ft.file_id, t.id, t.name, t.color, t.icon, t.group_id, t.created_at
+		  FROM file_tags ft JOIN tags t ON t.id = ft.tag_id
+		 WHERE ft.file_id = ANY($1)
+		 ORDER BY lower(t.name)`, fileIDs)
+	if err != nil {
+		return nil, fmt.Errorf("tags for files: %w", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var fileID uuid.UUID
+		var t Tag
+		if err := rows.Scan(&fileID, &t.ID, &t.Name, &t.Color, &t.Icon, &t.GroupID, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("scan: %w", err)
+		}
+		out[fileID] = append(out[fileID], t)
+	}
+	return out, rows.Err()
+}
+
+// TaggedFile ist ein Treffer beim Filtern nach einem Etikett.
+type TaggedFile struct {
+	ID           uuid.UUID  `json:"id"`
+	Name         string     `json:"name"`
+	FolderID     *uuid.UUID `json:"folder_id"`
+	FolderName   string     `json:"folder_name"`
+	MimeType     string     `json:"mime_type"`
+	Size         int64      `json:"size"`
+	HasThumbnail bool       `json:"has_thumbnail"`
+	DocumentDate *time.Time `json:"document_date,omitempty"`
+	UpdatedAt    time.Time  `json:"updated_at"`
+}
+
+// FilesWithTag ist die Abfrage, für die Etiketten überhaupt gebaut werden:
+// „zeig mir alles mit steuer-2026".
+//
+// Der Umfang steckt wie bei der Suche in der Abfrage selbst, nicht in einem
+// nachträglichen Filter: Erreichbar ist, was dem Anfragenden gehört oder einer
+// seiner Gruppen. Etiketten sind Prinzipal-gebunden, deshalb genügt hier die
+// einfachere Prüfung – eine Datei mit einem meiner Etiketten kann gar nicht
+// jemand anderem gehören.
+//
+// Sortiert nach Belegdatum, absteigend: Beim Filtern nach „steuer-2026" will
+// man die Belege in ihrer zeitlichen Ordnung sehen, nicht alphabetisch. Wer
+// kein Belegdatum gesetzt hat, rutscht ans Ende statt zu verschwinden.
+func (s *Store) FilesWithTag(ctx context.Context, userID, tagID uuid.UUID) ([]TaggedFile, error) {
+	const q = `
+WITH my_groups AS (
+    SELECT group_id FROM group_members WHERE user_id = $1
+),
+allowed AS (
+    SELECT id FROM tags
+     WHERE id = $2
+       AND (owner_id = $1 OR group_id IN (SELECT group_id FROM my_groups))
+)
+SELECT f.id, f.name, f.folder_id, COALESCE(p.name, ''),
+       f.mime_type, f.size, f.has_thumbnail, f.document_date, f.updated_at
+  FROM file_tags ft
+  JOIN allowed a ON a.id = ft.tag_id
+  JOIN files f ON f.id = ft.file_id AND f.is_deleted = false
+  LEFT JOIN folders p ON p.id = f.folder_id
+ ORDER BY f.document_date DESC NULLS LAST, f.name`
+
+	rows, err := s.db.Query(ctx, q, userID, tagID)
+	if err != nil {
+		return nil, fmt.Errorf("files with tag: %w", err)
+	}
+	defer rows.Close()
+
+	out := []TaggedFile{}
+	for rows.Next() {
+		var f TaggedFile
+		if err := rows.Scan(&f.ID, &f.Name, &f.FolderID, &f.FolderName,
+			&f.MimeType, &f.Size, &f.HasThumbnail, &f.DocumentDate, &f.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("scan tagged file: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
diff --git a/backend/internal/thumbnails/thumbnails.go b/backend/internal/thumbnails/thumbnails.go
new file mode 100644
index 0000000..0d72bf8
--- /dev/null
+++ b/backend/internal/thumbnails/thumbnails.go
@@ -0,0 +1,95 @@
+package thumbnails
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"image"
+	_ "image/gif"
+	"image/jpeg"
+	_ "image/png"
+
+	_ "golang.org/x/image/webp" // SupportedMIME nennt WebP – ohne den Dekodierer entstand dafür nie ein Vorschaubild
+	"io"
+	"strings"
+
+	"golang.org/x/image/draw"
+
+	"aether/internal/storage"
+)
+
+const (
+	maxWidth  = 256
+	maxHeight = 256
+)
+
+// SupportedMIME returns true if we can generate a thumbnail for this MIME type.
+func SupportedMIME(mime string) bool {
+	m := strings.ToLower(mime)
+	return strings.HasPrefix(m, "image/jpeg") ||
+		strings.HasPrefix(m, "image/png") ||
+		strings.HasPrefix(m, "image/gif") ||
+		strings.HasPrefix(m, "image/webp")
+}
+
+// ThumbnailKey returns the storage key for a file's thumbnail.
+func ThumbnailKey(fileID string) string {
+	return "thumbs/" + fileID + ".jpg"
+}
+
+// Generate reads an image from src, creates a thumbnail, and stores it.
+// Returns nil if generation succeeds, error otherwise.
+func Generate(ctx context.Context, st storage.Storage, fileID, mimeType string, src io.Reader) error {
+	if !SupportedMIME(mimeType) {
+		return fmt.Errorf("unsupported MIME type: %s", mimeType)
+	}
+
+	img, _, err := image.Decode(src)
+	if err != nil {
+		return fmt.Errorf("decode image: %w", err)
+	}
+
+	thumb := resize(img, maxWidth, maxHeight)
+
+	var buf bytes.Buffer
+	if err := jpeg.Encode(&buf, thumb, &jpeg.Options{Quality: 80}); err != nil {
+		return fmt.Errorf("encode thumbnail: %w", err)
+	}
+
+	key := ThumbnailKey(fileID)
+	if _, _, err := st.Put(ctx, key, &buf); err != nil {
+		return fmt.Errorf("store thumbnail: %w", err)
+	}
+	return nil
+}
+
+func resize(src image.Image, maxW, maxH int) image.Image {
+	bounds := src.Bounds()
+	w, h := bounds.Dx(), bounds.Dy()
+	if w == 0 || h == 0 {
+		return src
+	}
+
+	scaleW := float64(maxW) / float64(w)
+	scaleH := float64(maxH) / float64(h)
+	scale := scaleW
+	if scaleH < scale {
+		scale = scaleH
+	}
+	if scale >= 1 {
+		return src // already smaller than max
+	}
+
+	newW := int(float64(w) * scale)
+	newH := int(float64(h) * scale)
+	if newW < 1 {
+		newW = 1
+	}
+	if newH < 1 {
+		newH = 1
+	}
+
+	dst := image.NewRGBA(image.Rect(0, 0, newW, newH))
+	draw.BiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), draw.Over, nil)
+	return dst
+}
diff --git a/backend/internal/webdav/fs.go b/backend/internal/webdav/fs.go
new file mode 100644
index 0000000..b3e02a4
--- /dev/null
+++ b/backend/internal/webdav/fs.go
@@ -0,0 +1,873 @@
+package webdav
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/rs/zerolog/log"
+	xwebdav "golang.org/x/net/webdav"
+
+	"aether/internal/acl"
+	"aether/internal/auth"
+	"aether/internal/files"
+	"aether/internal/storage"
+)
+
+// aetherFS implements webdav.FileSystem for a single authenticated user.
+type aetherFS struct {
+	fileStore *files.Store
+	storage   storage.Storage
+	acl       *acl.Store
+	user      *auth.User
+
+	// quotaHit meldet dem Handler, dass ein Schreibvorgang am Kontingent
+	// gescheitert ist. Nötig, weil x/net/webdav jeden Fehler aus io.Copy
+	// pauschal als 405 beantwortet – für „voll" ist 507 der richtige Code.
+	quotaHit *bool
+	// denied meldet dem Handler, dass eine Aktion an fehlenden Rechten
+	// gescheitert ist – siehe statusWriter.
+	denied *bool
+
+	// contentLength ist die vom Client angekündigte Größe des Request-Bodys
+	// (-1 bei chunked). Close vergleicht damit, ob der Upload vollständig
+	// ankam – siehe davWriteFile.Close.
+	contentLength int64
+}
+
+func newFS(fileStore *files.Store, st storage.Storage, aclStore *acl.Store, user *auth.User, quotaHit, denied *bool, contentLength int64) xwebdav.FileSystem {
+	return &aetherFS{
+		fileStore:     fileStore,
+		storage:       st,
+		acl:           aclStore,
+		user:          user,
+		quotaHit:      quotaHit,
+		denied:        denied,
+		contentLength: contentLength,
+	}
+}
+
+// splitPath converts a WebDAV path into clean path parts.
+func splitPath(name string) []string {
+	name = path.Clean("/" + name)
+	if name == "/" {
+		return nil
+	}
+	return strings.Split(strings.TrimPrefix(name, "/"), "/")
+}
+
+// resolve löst einen WebDAV-Pfad auf. Der Scope bestimmt vorher, in wessen
+// Namen das geschieht – eigener Baum, Gruppenordner oder fremde Freigabe.
+func (fs *aetherFS) resolve(ctx context.Context, name string) (folder *files.Folder, file *files.File, parentID *uuid.UUID, sc *davScope, err error) {
+	sc, serr := fs.scopeFor(ctx, splitPath(name))
+	if serr != nil {
+		return nil, nil, nil, nil, serr
+	}
+	// Virtuelle Ebenen haben keinen Ordner dahinter; der Aufrufer erkennt das
+	// an sc.virtual und behandelt sie als Verzeichnis ohne Inhalt in der DB.
+	if sc.virtual {
+		return nil, nil, nil, sc, nil
+	}
+	if sc.sharedFile != nil {
+		return nil, sc.sharedFile, sc.sharedFile.FolderID, sc, nil
+	}
+
+	if f, ferr := fs.fileStore.FolderByPathFrom(ctx, sc.principal, sc.base, sc.parts); ferr == nil {
+		return f, nil, nil, sc, nil
+	}
+
+	if len(sc.parts) == 0 {
+		return nil, nil, nil, sc, os.ErrNotExist
+	}
+
+	parentParts := sc.parts[:len(sc.parts)-1]
+	fileName := sc.parts[len(sc.parts)-1]
+
+	parent, perr := fs.fileStore.FolderByPathFrom(ctx, sc.principal, sc.base, parentParts)
+	if perr != nil {
+		return nil, nil, nil, sc, os.ErrNotExist
+	}
+
+	var pid *uuid.UUID
+	if parent.ID != uuid.Nil {
+		pid = &parent.ID
+	}
+
+	fi, fierr := fs.fileStore.FileInFolder(ctx, sc.principal, pid, fileName)
+	if fierr != nil {
+		return nil, nil, pid, sc, os.ErrNotExist
+	}
+	return nil, fi, pid, sc, nil
+}
+
+func (fs *aetherFS) Mkdir(ctx context.Context, name string, _ os.FileMode) error {
+	parts := splitPath(name)
+	if len(parts) == 0 {
+		return fs.forbid()
+	}
+	sc, err := fs.scopeFor(ctx, parts[:len(parts)-1])
+	if err != nil {
+		return os.ErrNotExist
+	}
+	// In /Shared und /Shared/<Eigentümer> lässt sich nichts anlegen – die
+	// Ebenen sind virtuell, es gäbe keinen Ort, an dem der Ordner läge.
+	if sc.virtual || !sc.writable {
+		return fs.forbid()
+	}
+
+	folderName := parts[len(parts)-1]
+	parent, err := fs.fileStore.FolderByPathFrom(ctx, sc.principal, sc.base, sc.parts)
+	if err != nil {
+		return os.ErrNotExist
+	}
+	var parentID *uuid.UUID
+	if parent.ID != uuid.Nil {
+		parentID = &parent.ID
+	}
+
+	// Der neue Ordner gehört dem Prinzipal des Elternordners, nicht dem, der
+	// ihn anlegt – sonst stünde in einem Gruppenordner plötzlich ein privater.
+	f := &files.Folder{Name: folderName, ParentID: parentID}
+	if sc.principal == fs.user.ID {
+		id := fs.user.ID
+		f.OwnerID = &id
+	} else if parent.GroupID != nil {
+		f.GroupID = parent.GroupID
+	} else {
+		f.OwnerID = parent.OwnerID
+	}
+	_, err = fs.fileStore.CreateFolder(ctx, f)
+	return err
+}
+
+func (fs *aetherFS) RemoveAll(ctx context.Context, name string) error {
+	folder, file, _, sc, err := fs.resolve(ctx, name)
+	if err != nil {
+		return err
+	}
+	// /Shared und /Shared/<Eigentümer> gibt es nicht wirklich – da ist nichts
+	// zu löschen. Und ohne Schreibrecht wird auch darunter nichts entfernt.
+	if sc.virtual || !sc.writable {
+		return fs.forbid()
+	}
+	if folder != nil && folder.ID != uuid.Nil {
+		return fs.fileStore.DeleteFolder(ctx, folder.ID, sc.principal)
+	}
+	if file != nil {
+		trashKey := fmt.Sprintf("%s/.trash/%s_%s", sc.storageRoot, uuid.New().String()[:8], file.Name)
+		if merr := fs.storage.Move(ctx, file.StorageKey, trashKey); merr != nil {
+			return merr
+		}
+		return fs.fileStore.SoftDeleteFile(ctx, file.ID, sc.principal, trashKey)
+	}
+	return os.ErrNotExist
+}
+
+func (fs *aetherFS) Rename(ctx context.Context, oldName, newName string) error {
+	newParts := splitPath(newName)
+	if len(newParts) == 0 {
+		return fs.forbid()
+	}
+
+	newScope, err := fs.scopeFor(ctx, newParts[:len(newParts)-1])
+	if err != nil {
+		return os.ErrNotExist
+	}
+	if newScope.virtual || !newScope.writable {
+		return fs.forbid()
+	}
+
+	newBaseName := newParts[len(newParts)-1]
+	newParent, err := fs.fileStore.FolderByPathFrom(ctx, newScope.principal, newScope.base, newScope.parts)
+	if err != nil {
+		return os.ErrNotExist
+	}
+	var newParentID *uuid.UUID
+	if newParent.ID != uuid.Nil {
+		newParentID = &newParent.ID
+	}
+
+	folder, file, oldParentID, oldScope, err := fs.resolve(ctx, oldName)
+	if err != nil {
+		return err
+	}
+	if oldScope.virtual || !oldScope.writable {
+		return fs.forbid()
+	}
+	// Über Eigentumsgrenzen hinweg wird nicht verschoben: Das buchte Bytes
+	// zwischen Kontingenten um und hängte Freigaben unter der Hand um.
+	// Herunterladen und neu hochladen ist der ehrliche Weg.
+	if oldScope.principal != newScope.principal {
+		return fs.forbid()
+	}
+
+	if file != nil {
+		// Rename (same parent) or move (different parent).
+		sameFolder := ptrEqual(oldParentID, newParentID)
+		renamed := newBaseName != file.Name
+		if sameFolder && !renamed {
+			return nil
+		}
+
+		// Der Storage-Pfad enthält Ordner und Dateinamen – der Blob muss der
+		// Umbenennung folgen, sonst zeigt der Schlüssel in der Datenbank ins Leere.
+		newFolderPath, err := fs.fileStore.GetFolderPath(ctx, newParentID)
+		if err != nil {
+			return err
+		}
+		newKey := files.BuildStorageKey(newScope.storageRoot, newFolderPath, newBaseName)
+
+		movedBlob := false
+		if newKey != file.StorageKey {
+			if err := fs.storage.Move(ctx, file.StorageKey, newKey); err != nil {
+				return err
+			}
+			movedBlob = true
+		}
+		// Scheitert die Datenbank, muss der Blob zurück – sonst laufen Metadaten
+		// und Storage auseinander.
+		rollback := func() {
+			if !movedBlob {
+				return
+			}
+			if err := fs.storage.Move(ctx, newKey, file.StorageKey); err != nil {
+				log.Ctx(ctx).Error().Err(err).
+					Str("file_id", file.ID.String()).
+					Msg("webdav: rollback of rename move failed – blob orphaned")
+			}
+		}
+
+		if !sameFolder {
+			if _, err = fs.fileStore.MoveFile(ctx, file.ID, oldScope.principal, newParentID, newKey); err != nil {
+				rollback()
+				return err
+			}
+		}
+		if renamed {
+			if _, err = fs.fileStore.RenameFile(ctx, file.ID, oldScope.principal, newBaseName, newKey); err != nil {
+				rollback()
+				return err
+			}
+		}
+		return nil
+	}
+
+	if folder != nil && folder.ID != uuid.Nil {
+		sameParent := true
+		if folder.ParentID != nil {
+			sameParent = newParentID != nil && *folder.ParentID == *newParentID
+		} else {
+			sameParent = newParentID == nil
+		}
+		renamed := newBaseName != folder.Name
+		if sameParent && !renamed {
+			return nil
+		}
+
+		// Dateien vor der Umbenennung einsammeln – danach sind die alten
+		// Storage-Schlüssel nicht mehr rekonstruierbar.
+		affected, err := fs.fileStore.ListFilesInSubtree(ctx, oldScope.principal, folder.ID)
+		if err != nil {
+			return err
+		}
+
+		if renamed {
+			if _, err = fs.fileStore.RenameFolder(ctx, folder.ID, oldScope.principal, newBaseName); err != nil {
+				return err
+			}
+		}
+		if !sameParent {
+			if _, err = fs.fileStore.MoveFolder(ctx, folder.ID, oldScope.principal, newParentID); err != nil {
+				return err
+			}
+		}
+
+		// Der Ordnername steckt im Pfad jeder Datei darunter – Blobs nachziehen.
+		files.ResyncBlobPaths(ctx, fs.fileStore, fs.storage, newScope.storageRoot, affected)
+		return nil
+	}
+
+	return os.ErrNotExist
+}
+
+func (fs *aetherFS) Stat(ctx context.Context, name string) (os.FileInfo, error) {
+	folder, file, _, sc, err := fs.resolve(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	if sc != nil && sc.virtual {
+		return &davFileInfo{name: path.Base(name), modTime: time.Now(), isDir: true}, nil
+	}
+	if folder != nil {
+		modTime := folder.CreatedAt
+		if modTime.IsZero() {
+			modTime = time.Now()
+		}
+		return &davFileInfo{name: path.Base(name), modTime: modTime, isDir: true}, nil
+	}
+	return &davFileInfo{name: file.Name, size: file.Size, modTime: file.UpdatedAt}, nil
+}
+
+func (fs *aetherFS) OpenFile(ctx context.Context, name string, flag int, _ os.FileMode) (xwebdav.File, error) {
+	parts := splitPath(name)
+	sc, err := fs.scopeFor(ctx, parts)
+	if err != nil {
+		return nil, err
+	}
+	writing := flag&(os.O_WRONLY|os.O_RDWR|os.O_CREATE) != 0
+
+	// Virtuelle Ebenen: Verzeichnisse ohne Eintrag in der Datenbank.
+	if sc.virtual {
+		if writing {
+			return nil, fs.forbid()
+		}
+		return &davDir{
+			name:     path.Base(name),
+			modTime:  time.Now(),
+			virtual:  true,
+			shared:   sc.virtualEntries,
+			atShared: len(parts) == 1,
+		}, nil
+	}
+
+	// Einzeln freigegebene Datei – der Scope zeigt direkt auf sie.
+	if sc.sharedFile != nil {
+		if writing {
+			return nil, fs.forbid()
+		}
+		return fs.openForReading(ctx, sc.sharedFile)
+	}
+
+	// Verzeichnis im Baum des Prinzipals.
+	if folder, ferr := fs.fileStore.FolderByPathFrom(ctx, sc.principal, sc.base, sc.parts); ferr == nil {
+		if writing {
+			return nil, fs.forbid()
+		}
+		var folderID *uuid.UUID
+		if folder.ID != uuid.Nil {
+			folderID = &folder.ID
+		}
+		d := &davDir{
+			name:      path.Base(name),
+			modTime:   folder.CreatedAt,
+			fileStore: fs.fileStore,
+			user:      fs.user,
+			principal: sc.principal,
+			folderID:  folderID,
+		}
+		// In der Wurzel kommen die Gruppenordner dazu – gleichrangig neben den
+		// eigenen, wie in der Weboberfläche. Personen-Freigaben liegen dagegen
+		// gebündelt unter „Shared", und dieser Eintrag erscheint nur, wenn es
+		// überhaupt welche gibt.
+		if len(parts) == 0 && fs.acl != nil {
+			now := time.Now()
+			if groups, err := fs.rootGroupFolders(ctx); err == nil {
+				for _, g := range groups {
+					d.extra = append(d.extra, &davFileInfo{name: g.name, modTime: now, isDir: true})
+				}
+			}
+			if shares, err := fs.aclShares(ctx); err == nil && len(shares) > 0 {
+				d.extra = append(d.extra, &davFileInfo{name: sharedRoot, modTime: now, isDir: true})
+			}
+		}
+		return d, nil
+	}
+
+	if len(parts) == 0 {
+		return nil, os.ErrNotExist
+	}
+
+	if len(sc.parts) == 0 {
+		return nil, os.ErrNotExist
+	}
+
+	fileName := sc.parts[len(sc.parts)-1]
+	parent, err := fs.fileStore.FolderByPathFrom(ctx, sc.principal, sc.base, sc.parts[:len(sc.parts)-1])
+	if err != nil {
+		return nil, os.ErrNotExist
+	}
+	var parentID *uuid.UUID
+	if parent.ID != uuid.Nil {
+		parentID = &parent.ID
+	}
+
+	// Write mode.
+	if writing {
+		if !sc.writable {
+			return nil, fs.forbid()
+		}
+		return &davWriteFile{
+			ctx:         ctx,
+			name:        fileName,
+			folderID:    parentID,
+			user:        fs.user,
+			principal:   sc.principal,
+			storageRoot: sc.storageRoot,
+			quota:       sc.quota,
+			parentOwner: parent,
+			fileStore:   fs.fileStore,
+			storage:     fs.storage,
+			quotaHit:    fs.quotaHit,
+			expected:    fs.contentLength,
+		}, nil
+	}
+
+	file, err := fs.fileStore.FileInFolder(ctx, sc.principal, parentID, fileName)
+	if err != nil {
+		return nil, os.ErrNotExist
+	}
+	return fs.openForReading(ctx, file)
+}
+
+// virtualEntries baut die Auflistung der beiden künstlichen Ebenen.
+func virtualEntries(shared []sharedEntry, atShared bool) []os.FileInfo {
+	now := time.Now()
+	if atShared {
+		out := []os.FileInfo{}
+		for _, owner := range owners(shared) {
+			out = append(out, &davFileInfo{name: owner, modTime: now, isDir: true})
+		}
+		return out
+	}
+	out := []os.FileInfo{}
+	for _, e := range shared {
+		if e.file != nil {
+			out = append(out, &davFileInfo{
+				name: e.name, size: e.file.Size, modTime: e.file.UpdatedAt,
+			})
+			continue
+		}
+		out = append(out, &davFileInfo{name: e.name, modTime: now, isDir: true})
+	}
+	return out
+}
+
+func (fs *aetherFS) openForReading(ctx context.Context, file *files.File) (xwebdav.File, error) {
+	rc, err := fs.storage.Get(ctx, file.StorageKey)
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	data, err := io.ReadAll(rc)
+	if err != nil {
+		return nil, err
+	}
+	return &davReadFile{
+		name:    file.Name,
+		size:    file.Size,
+		modTime: file.UpdatedAt,
+		reader:  bytes.NewReader(data),
+	}, nil
+}
+
+// ── FileInfo ──────────────────────────────────────────────────────────────────
+
+type davFileInfo struct {
+	name    string
+	size    int64
+	modTime time.Time
+	isDir   bool
+}
+
+func (fi *davFileInfo) Name() string       { return fi.name }
+func (fi *davFileInfo) Size() int64        { return fi.size }
+func (fi *davFileInfo) Mode() os.FileMode  { return 0644 }
+func (fi *davFileInfo) ModTime() time.Time { return fi.modTime }
+func (fi *davFileInfo) IsDir() bool        { return fi.isDir }
+func (fi *davFileInfo) Sys() any           { return nil }
+
+// ── Directory ────────────────────────────────────────────────────────────────
+
+type davDir struct {
+	name      string
+	modTime   time.Time
+	fileStore *files.Store
+	user      *auth.User
+	folderID  *uuid.UUID
+	entries   []os.FileInfo
+	pos       int
+
+	// principal ist der Eigentümer des Ordners – bei geliehenen Ordnern nicht
+	// der angemeldete Nutzer.
+	principal uuid.UUID
+
+	// virtual markiert /Shared und /Shared/<Eigentümer>: Ebenen, hinter denen
+	// kein Ordner in der Datenbank steht.
+	virtual bool
+	// atShared unterscheidet die beiden: /Shared listet Eigentümer,
+	// /Shared/<Eigentümer> listet dessen Freigaben.
+	atShared bool
+	shared   []sharedEntry
+
+	// extra hängt zusätzliche Einträge an eine echte Auflistung – in der
+	// eigenen Wurzel den virtuellen Shared-Ordner.
+	extra []os.FileInfo
+}
+
+func (d *davDir) Close() error                       { return nil }
+func (d *davDir) Read(_ []byte) (int, error)         { return 0, io.EOF }
+func (d *davDir) Seek(_ int64, _ int) (int64, error) { return 0, nil }
+func (d *davDir) Write(_ []byte) (int, error)        { return 0, os.ErrPermission }
+
+func (d *davDir) Stat() (os.FileInfo, error) {
+	name := d.name
+	if name == "" {
+		name = "/"
+	}
+	modTime := d.modTime
+	if modTime.IsZero() {
+		modTime = time.Now()
+	}
+	return &davFileInfo{name: name, modTime: modTime, isDir: true}, nil
+}
+
+func (d *davDir) Readdir(count int) ([]os.FileInfo, error) {
+	if d.entries == nil {
+		if err := d.loadEntries(); err != nil {
+			return nil, err
+		}
+	}
+	if d.pos >= len(d.entries) {
+		if count > 0 {
+			return nil, io.EOF
+		}
+		return nil, nil
+	}
+	end := len(d.entries)
+	if count > 0 && d.pos+count < end {
+		end = d.pos + count
+	}
+	out := d.entries[d.pos:end]
+	d.pos = end
+	return out, nil
+}
+
+func (d *davDir) loadEntries() error {
+	if d.virtual {
+		d.entries = virtualEntries(d.shared, d.atShared)
+		return nil
+	}
+	ctx := context.Background()
+	childFolders, err := d.fileStore.ListFolders(ctx, d.principal, d.folderID)
+	if err != nil {
+		return err
+	}
+	childFiles, err := d.fileStore.ListFiles(ctx, d.principal, d.folderID)
+	if err != nil {
+		return err
+	}
+	d.entries = make([]os.FileInfo, 0, len(childFolders)+len(childFiles))
+	for _, f := range childFolders {
+		d.entries = append(d.entries, &davFileInfo{name: f.Name, modTime: f.CreatedAt, isDir: true})
+	}
+	for _, f := range childFiles {
+		d.entries = append(d.entries, &davFileInfo{name: f.Name, size: f.Size, modTime: f.UpdatedAt})
+	}
+	d.entries = append(d.entries, d.extra...)
+	return nil
+}
+
+// ── Read file ────────────────────────────────────────────────────────────────
+
+type davReadFile struct {
+	name    string
+	size    int64
+	modTime time.Time
+	reader  *bytes.Reader
+}
+
+func (f *davReadFile) Close() error                         { return nil }
+func (f *davReadFile) Read(p []byte) (int, error)           { return f.reader.Read(p) }
+func (f *davReadFile) Seek(o int64, w int) (int64, error)   { return f.reader.Seek(o, w) }
+func (f *davReadFile) Write(_ []byte) (int, error)          { return 0, os.ErrPermission }
+func (f *davReadFile) Readdir(_ int) ([]os.FileInfo, error) { return nil, os.ErrInvalid }
+func (f *davReadFile) Stat() (os.FileInfo, error) {
+	return &davFileInfo{name: f.name, size: f.size, modTime: f.modTime}, nil
+}
+
+// ── Write file ───────────────────────────────────────────────────────────────
+
+type davWriteFile struct {
+	ctx       context.Context
+	name      string
+	folderID  *uuid.UUID
+	user      *auth.User
+	fileStore *files.Store
+	storage   storage.Storage
+
+	// principal, storageRoot und quota beziehen sich auf den Eigentümer des
+	// Zielordners – in einem Gruppenordner oder einer fremden Freigabe ist das
+	// nicht der angemeldete Nutzer. Die Datei landet in dessen Bereich und
+	// zählt gegen dessen Kontingent.
+	principal   uuid.UUID
+	storageRoot string
+	quota       int64
+	parentOwner *files.Folder
+
+	// Der Upload wird auf der Platte zwischengelagert, nicht im Arbeitsspeicher:
+	// x/net/webdav übergibt den Inhalt häppchenweise, die endgültige Größe steht
+	// erst bei Close fest. Gepuffert im RAM belegte eine 122-MB-Datei auch 122 MB
+	// Speicher – bei mehreren Uploads gleichzeitig ist der Server damit weg.
+	tmp     *os.File
+	written int64
+
+	// Kontingent, lazy beim ersten Write ermittelt – zu diesem Zeitpunkt steht
+	// fest, ob eine bestehende Datei überschrieben wird.
+	quotaChecked bool
+	unlimited    bool
+	remaining    int64
+	quotaHit     *bool
+
+	// expected ist die angekündigte Body-Größe, writeErr der erste Fehler aus
+	// Write. Beides entscheidet in Close, ob überhaupt geschrieben wird.
+	expected int64
+	writeErr error
+}
+
+// checkQuota ermittelt das verbleibende Kontingent einmalig pro Schreibvorgang.
+func (f *davWriteFile) checkQuota() error {
+	if f.quotaChecked {
+		return nil
+	}
+	f.quotaChecked = true
+
+	// Wird eine bestehende Datei ersetzt, zählt deren alte Größe nicht mehr mit.
+	var allowance int64
+	if existing, err := f.fileStore.FileInFolder(f.ctx, f.principal, f.folderID, f.name); err == nil {
+		allowance = existing.Size
+	}
+
+	remaining, unlimited, err := f.fileStore.RemainingQuota(f.ctx, f.principal, f.quota, allowance)
+	if err != nil {
+		return err
+	}
+	f.remaining, f.unlimited = remaining, unlimited
+	return nil
+}
+
+// discardTemp räumt die Zwischendatei weg. Muss auf jedem Pfad laufen, auch
+// beim Abbruch – sonst füllt jeder fehlgeschlagene Upload das Staging.
+func (f *davWriteFile) discardTemp() {
+	if f.tmp == nil {
+		return
+	}
+	name := f.tmp.Name()
+	_ = f.tmp.Close()
+	if err := os.Remove(name); err != nil && !os.IsNotExist(err) {
+		log.Ctx(f.ctx).Warn().Err(err).Str("path", name).Msg("webdav: temp file not removed")
+	}
+	f.tmp = nil
+}
+
+func (f *davWriteFile) Close() error {
+	defer f.discardTemp()
+
+	// x/net/webdav ruft Close per defer auf – auch wenn io.Copy vorher
+	// abgebrochen ist (Kontingent voll, Verbindung weg). Ohne diese Sperre
+	// würde der halb gefüllte Puffer als vollständige Datei committet: der
+	// Client sieht einen Fehler, in der Cloud liegt trotzdem ein abgeschnittenes
+	// Blob – mit passender Prüfsumme, also unentdeckbar. Ein abgebrochener
+	// Upload darf nichts hinterlassen.
+	if f.writeErr != nil {
+		return f.writeErr
+	}
+	if f.expected >= 0 && f.written != f.expected {
+		return fmt.Errorf("incomplete upload: got %d of %d bytes", f.written, f.expected)
+	}
+
+	// Ab hier wird gelesen, was geschrieben wurde – zurück an den Anfang.
+	content, err := f.contentReader()
+	if err != nil {
+		return err
+	}
+
+	// Gleicher lesbarer Pfad wie beim Web-Upload, damit beide Wege identisch
+	// ablegen und die Dateien auch ohne Datenbank auffindbar bleiben.
+	folderPath, err := f.fileStore.GetFolderPath(f.ctx, f.folderID)
+	if err != nil {
+		return err
+	}
+	storageKey := files.BuildStorageKey(f.storageRoot, folderPath, f.name)
+	mime := mimeByName(f.name)
+
+	existing, findErr := f.fileStore.FileInFolder(f.ctx, f.principal, f.folderID, f.name)
+
+	// Overwrite: der neue Blob landet auf demselben lesbaren Pfad wie der alte.
+	// Bei aktivierter Versionierung muss die bestehende Fassung deshalb erst
+	// zur Seite – sonst überschriebe Put sie, und die Version zeigte auf den
+	// neuen Inhalt. Ohne Versionierung ersetzt Put sie atomar.
+	if findErr == nil {
+		var versionKey string
+		if existing.VersioningEnabled {
+			versionKey = fmt.Sprintf("%s/.versions/%s", f.storageRoot, uuid.New().String())
+			if err := f.storage.Move(f.ctx, existing.StorageKey, versionKey); err != nil {
+				return err
+			}
+		}
+		checksum, size, err := f.storage.Put(f.ctx, storageKey, content)
+		if err != nil {
+			// Zurückrollen, sonst ist die bestehende Datei verloren.
+			if versionKey != "" {
+				if mvErr := f.storage.Move(f.ctx, versionKey, existing.StorageKey); mvErr != nil {
+					log.Ctx(f.ctx).Error().Err(mvErr).
+						Str("file_id", existing.ID.String()).
+						Msg("webdav: rollback of version move failed – blob orphaned")
+				}
+			}
+			return err
+		}
+		if versionKey != "" {
+			if err := f.fileStore.CreateVersion(f.ctx, existing.ID, existing.Version, existing.Size, existing.Checksum, versionKey); err != nil {
+				return err
+			}
+		} else if existing.StorageKey != storageKey {
+			// Altbestand unter abweichendem Pfad – sonst verwaist der Blob.
+			_ = f.storage.Delete(f.ctx, existing.StorageKey)
+		}
+		_, err = f.fileStore.UpdateFileContent(f.ctx, existing.ID, size, checksum, storageKey)
+		return err
+	}
+
+	// New file.
+	checksum, size, err := f.storage.Put(f.ctx, storageKey, content)
+	if err != nil {
+		return err
+	}
+	// Die neue Datei gehört dem Prinzipal des Zielordners: in einem
+	// Gruppenordner der Gruppe, in einer fremden Freigabe deren Eigentümer.
+	newFile := &files.File{
+		FolderID:   f.folderID,
+		Name:       f.name,
+		MimeType:   mime,
+		Size:       size,
+		Checksum:   checksum,
+		StorageKey: storageKey,
+	}
+	if f.parentOwner != nil && f.parentOwner.GroupID != nil {
+		newFile.GroupID = f.parentOwner.GroupID
+	} else {
+		id := f.principal
+		newFile.OwnerID = &id
+	}
+	if _, err := f.fileStore.CreateFile(f.ctx, newFile); err != nil {
+		// Ohne DB-Zeile ist das Blob unerreichbar und würde für immer Platz
+		// belegen. Eigener Kontext, weil f.ctx hier oft schon abgebrochen ist.
+		cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(f.ctx), 10*time.Second)
+		defer cancel()
+		if delErr := f.storage.Delete(cleanupCtx, storageKey); delErr != nil {
+			log.Ctx(f.ctx).Error().Err(delErr).
+				Str("storage_key", storageKey).
+				Msg("webdav: orphaned blob after failed file creation")
+		}
+		return err
+	}
+	return nil
+}
+
+func (f *davWriteFile) Read(_ []byte) (int, error)         { return 0, os.ErrPermission }
+func (f *davWriteFile) Seek(_ int64, _ int) (int64, error) { return 0, nil }
+
+// contentReader spult die Zwischendatei zurück, damit Put sie von vorn lesen
+// kann. Ohne einen einzigen Write (leere Datei per PUT) gibt es keine – dann
+// liefert ein leerer Reader das richtige Ergebnis.
+func (f *davWriteFile) contentReader() (io.Reader, error) {
+	if f.tmp == nil {
+		return bytes.NewReader(nil), nil
+	}
+	if _, err := f.tmp.Seek(0, io.SeekStart); err != nil {
+		return nil, fmt.Errorf("rewind temp file: %w", err)
+	}
+	return f.tmp, nil
+}
+
+// ensureTemp legt die Zwischendatei beim ersten Schreibzugriff an. Bevorzugt im
+// Staging-Verzeichnis des Speichers, damit sie auf derselben Platte liegt wie
+// die späteren Blobs; kann der Speicher das nicht, tut es das System-Temp.
+func (f *davWriteFile) ensureTemp() error {
+	if f.tmp != nil {
+		return nil
+	}
+	var err error
+	if tf, ok := f.storage.(storage.TempFiler); ok {
+		f.tmp, err = tf.CreateTemp("dav-upload-*")
+	} else {
+		f.tmp, err = os.CreateTemp("", "dav-upload-*")
+	}
+	if err != nil {
+		return fmt.Errorf("create upload buffer: %w", err)
+	}
+	return nil
+}
+
+// Write lagert den Inhalt zwischen und bricht ab, sobald das Kontingent
+// überschritten wird – so wächst auch die Zwischendatei nicht über das
+// Erlaubte hinaus.
+func (f *davWriteFile) Write(p []byte) (int, error) {
+	if err := f.checkQuota(); err != nil {
+		return 0, err
+	}
+	if !f.unlimited {
+		if int64(len(p)) > f.remaining {
+			if f.quotaHit != nil {
+				*f.quotaHit = true
+			}
+			f.writeErr = files.ErrQuotaExceeded
+			return 0, files.ErrQuotaExceeded
+		}
+		f.remaining -= int64(len(p))
+	}
+	if err := f.ensureTemp(); err != nil {
+		f.writeErr = err
+		return 0, err
+	}
+	n, err := f.tmp.Write(p)
+	f.written += int64(n)
+	if err != nil {
+		f.writeErr = err
+	}
+	return n, err
+}
+
+func (f *davWriteFile) Readdir(_ int) ([]os.FileInfo, error) { return nil, os.ErrInvalid }
+func (f *davWriteFile) Stat() (os.FileInfo, error) {
+	return &davFileInfo{name: f.name, modTime: time.Now()}, nil
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+func ptrEqual(a, b *uuid.UUID) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return *a == *b
+}
+
+func mimeByName(name string) string {
+	ext := strings.ToLower(path.Ext(name))
+	m := map[string]string{
+		".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
+		".gif": "image/gif", ".webp": "image/webp", ".svg": "image/svg+xml",
+		".pdf": "application/pdf",
+		".txt": "text/plain", ".md": "text/markdown",
+		".doc":  "application/msword",
+		".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		".xls":  "application/vnd.ms-excel",
+		".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		".mp4":  "video/mp4", ".mov": "video/quicktime", ".avi": "video/x-msvideo",
+		".mp3": "audio/mpeg", ".wav": "audio/wav",
+		".zip": "application/zip", ".tar": "application/x-tar",
+	}
+	if t, ok := m[ext]; ok {
+		return t
+	}
+	return "application/octet-stream"
+}
diff --git a/backend/internal/webdav/fs_test.go b/backend/internal/webdav/fs_test.go
new file mode 100644
index 0000000..497d3a2
--- /dev/null
+++ b/backend/internal/webdav/fs_test.go
@@ -0,0 +1,59 @@
+package webdav
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"aether/internal/files"
+)
+
+// Ein abgebrochener Upload darf nichts hinterlassen. x/net/webdav ruft Close
+// per defer auf – auch nach einem Fehler in io.Copy. Ohne die Sperre in Close
+// landete der halb gefüllte Puffer als vollständige Datei in Cloud und
+// Datenbank: der Client meldet einen Fehler, die Datei ist trotzdem da, nur
+// abgeschnitten – und die Prüfsumme passt zum Torso, fällt also nie auf.
+//
+// fileStore und storage sind hier absichtlich nil: greift Close doch darauf
+// zu, paniert der Test statt still durchzulaufen.
+func TestWriteFileCloseDiscardsAbortedUpload(t *testing.T) {
+	t.Run("quota exceeded during write", func(t *testing.T) {
+		f := &davWriteFile{
+			ctx: context.Background(), name: "big.bin", expected: -1,
+			written: 31, writeErr: files.ErrQuotaExceeded,
+		}
+
+		if err := f.Close(); !errors.Is(err, files.ErrQuotaExceeded) {
+			t.Fatalf("Close() = %v, want ErrQuotaExceeded", err)
+		}
+	})
+
+	t.Run("connection dropped mid-upload", func(t *testing.T) {
+		f := &davWriteFile{
+			ctx: context.Background(), name: "abort.bin",
+			expected: 4096, written: 14,
+		}
+
+		if err := f.Close(); err == nil {
+			t.Fatal("Close() = nil, want error for incomplete upload")
+		}
+	})
+}
+
+// Chunked Uploads kündigen keine Größe an (Content-Length -1). Dann kann Close
+// die Vollständigkeit nicht prüfen und darf deshalb nicht blockieren – sonst
+// wäre jeder chunked Upload kaputt.
+func TestWriteFileCloseAcceptsUnknownLength(t *testing.T) {
+	f := &davWriteFile{
+		ctx: context.Background(), name: "chunked.bin",
+		expected: -1, written: 12,
+	}
+
+	// Kommt bis zum Store durch – der ist nil, also panic statt Fehler.
+	defer func() {
+		if recover() == nil {
+			t.Fatal("Close() should have proceeded to the store, but returned early")
+		}
+	}()
+	_ = f.Close()
+}
diff --git a/backend/internal/webdav/handler.go b/backend/internal/webdav/handler.go
new file mode 100644
index 0000000..68f71ed
--- /dev/null
+++ b/backend/internal/webdav/handler.go
@@ -0,0 +1,155 @@
+package webdav
+
+import (
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	xwebdav "golang.org/x/net/webdav"
+
+	"aether/internal/acl"
+	"aether/internal/auth"
+	"aether/internal/files"
+	"aether/internal/storage"
+	"aether/pkg/middleware"
+)
+
+// Brute-force-Schutz für /dav/. Der Endpunkt nutzt Basic Auth und läuft am
+// Rate-Limit des normalen Logins vorbei – ohne eigene Bremse ließe sich hier
+// beliebig oft raten.
+const (
+	davMaxFailures = 10
+	davWindow      = 15 * time.Minute
+	davLockout     = 15 * time.Minute
+)
+
+// maxChallengeDrain begrenzt, wie viel von einem unauthentifizierten Upload
+// verworfen wird, um die Verbindung am Leben zu halten – siehe drainForChallenge.
+const maxChallengeDrain = 4 << 30 // 4 GiB
+
+// Handler serves WebDAV at /dav/ with HTTP Basic Auth.
+type Handler struct {
+	authStore *auth.Store
+	fileStore *files.Store
+	acl       *acl.Store
+	storage   storage.Storage
+	locks     xwebdav.LockSystem
+	limiter   *middleware.FailureLimiter
+}
+
+func NewHandler(authStore *auth.Store, fileStore *files.Store, aclStore *acl.Store, st storage.Storage) *Handler {
+	return &Handler{
+		authStore: authStore,
+		fileStore: fileStore,
+		acl:       aclStore,
+		storage:   st,
+		locks:     xwebdav.NewMemLS(),
+		limiter:   middleware.NewFailureLimiter(davMaxFailures, davWindow, davLockout),
+	}
+}
+
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	clientIP := middleware.RealIP(r)
+	if allowed, retryAfter := h.limiter.Allowed(clientIP); !allowed {
+		w.Header().Set("Retry-After", strconv.Itoa(int(retryAfter.Seconds())+1))
+		http.Error(w, "Too many failed login attempts", http.StatusTooManyRequests)
+		return
+	}
+
+	username, password, ok := r.BasicAuth()
+	if !ok || username == "" || password == "" {
+		drainForChallenge(r)
+		challenge(w)
+		return
+	}
+
+	// Nur App-Passwörter. Das Kontopasswort ist zugleich der Zugang zum
+	// Admin-Bereich – wer es hier errät, bekommt weit mehr als Dateizugriff.
+	// Ein App-Passwort öffnet ausschließlich diesen Endpunkt und lässt sich
+	// einzeln widerrufen, ohne dass jeder andere Client neu eingerichtet werden
+	// muss. Nebeneffekt: ein indizierter Lookup statt eines Argon2-Durchlaufs
+	// bei jeder einzelnen Anfrage (gemessen 0,5 ms statt 22,7 ms).
+	user, err := h.authStore.VerifyAppPassword(r.Context(), username, password)
+	if err != nil {
+		h.limiter.Fail(clientIP)
+		challenge(w)
+		return
+	}
+	h.limiter.Reset(clientIP)
+
+	quotaHit, denied := false, false
+	dav := &xwebdav.Handler{
+		FileSystem: newFS(h.fileStore, h.storage, h.acl, user, &quotaHit, &denied, r.ContentLength),
+		LockSystem: h.locks,
+		Prefix:     "/dav",
+	}
+	dav.ServeHTTP(&statusWriter{ResponseWriter: w, quotaHit: &quotaHit, denied: &denied}, r)
+}
+
+// challenge fordert zur Anmeldung auf. Der Realm-Text nennt ausdrücklich das
+// App-Passwort: Clients zeigen ihn im Anmeldedialog an, und ohne diesen Hinweis
+// tippt man dort wieder und wieder sein Kontopasswort ein und versteht nicht,
+// warum es abgelehnt wird.
+func challenge(w http.ResponseWriter) {
+	w.Header().Set("WWW-Authenticate", `Basic realm="Aether WebDAV - use an app password, not your account password"`)
+	http.Error(w, "Unauthorized - WebDAV requires an app password (Profile -> App passwords)", http.StatusUnauthorized)
+}
+
+// drainForChallenge liest den Rumpf einer unauthentifizierten Anfrage weg,
+// bevor die Aufforderung zur Anmeldung rausgeht.
+//
+// Klingt verschwenderisch, ist aber der Unterschied zwischen „Upload geht" und
+// „Upload geht nicht": Manche Clients – KDEs KIO etwa – schicken grundsätzlich
+// erst ohne Zugangsdaten und wiederholen die Anfrage nach der 401. Dabei senden
+// sie den Rumpf sofort mit, ohne `Expect: 100-continue` abzuwarten. Antwortet
+// der Server dann sofort mit 401, kann Go den angefangenen Rumpf nicht mehr
+// loswerden und schließt die Verbindung. Der Client steckt aber noch mitten im
+// Schreiben, bekommt einen Verbindungsabbruch und meldet einen nichtssagenden
+// Fehler, statt die 401 zu lesen und sich anzumelden.
+//
+// Wer `Expect: 100-continue` schickt (curl, rclone, Finder), zahlt hier nichts:
+// Go beantwortet die Aufforderung, bevor auch nur ein Byte des Rumpfes fließt.
+// Die doppelte Übertragung trifft also nur Clients, die es nicht besser machen.
+func drainForChallenge(r *http.Request) {
+	if r.ContentLength <= 0 || r.Header.Get("Expect") != "" {
+		return
+	}
+	// Obergrenze, damit eine unauthentifizierte Anfrage den Server nicht
+	// beliebig lange beschäftigen kann. Darüber bleibt es beim Abbruch.
+	_, _ = io.CopyN(io.Discard, r.Body, maxChallengeDrain)
+}
+
+// statusWriter korrigiert Statuscodes, die x/net/webdav pauschal vergibt.
+//
+// Die Bibliothek bildet jeden Fehler aus einer Operation auf einen festen Code
+// ab – ein gescheiterter io.Copy wird zu 405, ein OpenFile-Fehler zu 404. Der
+// Client zeigt dann „Methode nicht erlaubt" oder „nicht gefunden", obwohl die
+// Ursache eine ganz andere war. Zwei Fälle lohnen die Korrektur:
+//
+//   - Kontingent voll → 507 Insufficient Storage (RFC 4918)
+//   - fehlendes Recht → 403 Forbidden
+//
+// Ohne die zweite Zuordnung sähe jemand, der in einem nur lesbar freigegebenen
+// Ordner schreiben will, ein „nicht gefunden" – und suchte den Fehler beim
+// Pfad statt bei seinen Rechten.
+type statusWriter struct {
+	http.ResponseWriter
+	quotaHit    *bool
+	denied      *bool
+	wroteHeader bool
+}
+
+func (w *statusWriter) WriteHeader(code int) {
+	if w.wroteHeader {
+		return
+	}
+	w.wroteHeader = true
+	switch {
+	case *w.quotaHit && code == http.StatusMethodNotAllowed:
+		code = http.StatusInsufficientStorage
+	case *w.denied && (code == http.StatusMethodNotAllowed || code == http.StatusNotFound || code == http.StatusConflict):
+		code = http.StatusForbidden
+	}
+	w.ResponseWriter.WriteHeader(code)
+}
diff --git a/backend/internal/webdav/scope.go b/backend/internal/webdav/scope.go
new file mode 100644
index 0000000..d816a8b
--- /dev/null
+++ b/backend/internal/webdav/scope.go
@@ -0,0 +1,310 @@
+package webdav
+
+import (
+	"context"
+	"os"
+	"sort"
+	"strconv"
+
+	"github.com/google/uuid"
+
+	"aether/internal/acl"
+	"aether/internal/files"
+)
+
+// Geteilte Ordner und Gruppenordner über WebDAV.
+//
+// WebDAV kennt keine IDs, es navigiert über Pfade – und ein Pfad lief bisher
+// immer durch den Baum genau eines Prinzipals: des angemeldeten Nutzers. Damit
+// waren Gruppenordner und Freigaben dort unsichtbar; sie gehören einer Gruppe
+// oder einem anderen Konto.
+//
+// Der Aufbau bildet die Weboberfläche nach, damit man nicht umdenken muss:
+//
+//	/dav/<Gruppenordner>/…        – wie in der Wurzel der Weboberfläche
+//	/dav/Shared/<Person>/<Freigabe>/…  – wie die Ansicht „Shared with me"
+//
+// Beim Betreten wechselt der Prinzipal. Personen-Freigaben bleiben verschachtelt:
+// Ein flacher Aufbau müsste bei gleichnamigen Freigaben Namen vergeben, die sich
+// ändern, sobald eine weitere dazukommt – und ein Sync-Client, dem sich Pfade
+// unter den Füßen verschieben, lädt alles neu hoch oder löscht es.
+const sharedRoot = "Shared"
+
+// davScope beschreibt, in wessen Namen ein Pfad aufgelöst wird.
+type davScope struct {
+	principal   uuid.UUID
+	storageRoot string
+	quota       int64
+	writable    bool
+
+	// base ist der Ordner, ab dem parts zählen. nil = Wurzel des Prinzipals.
+	// Bei einer Freigabe zeigt er auf den freigegebenen Ordner, damit alles
+	// darüber unerreichbar bleibt.
+	base  *uuid.UUID
+	parts []string
+
+	// sharedFile ist gesetzt, wenn der Pfad genau auf eine einzeln freigegebene
+	// Datei zeigt. Ohne dieses Feld liefe die Auflösung in die Wurzel des
+	// Eigentümers – und die gilt als Ordner, wodurch die Datei als Verzeichnis
+	// gemeldet würde.
+	sharedFile *files.File
+
+	// virtual markiert die beiden Ebenen ohne echten Ordner dahinter:
+	// /Shared und /Shared/<Eigentümer>.
+	virtual bool
+	// virtualEntries sind die Einträge, die eine virtuelle Ebene auflistet.
+	virtualEntries []sharedEntry
+}
+
+// sharedEntry ist eine Freigabe oder ein Gruppenordner, wie er unter /Shared
+// erscheint.
+type sharedEntry struct {
+	owner     string // Verzeichnisname der Ebene 2
+	name      string // Name der Freigabe selbst
+	principal uuid.UUID
+	root      string // Speicherwurzel des Prinzipals
+	quota     int64
+	writable  bool
+	folderID  *uuid.UUID // gesetzt bei Ordnern
+	file      *files.File
+}
+
+// forbid meldet dem Handler ein fehlendes Recht und liefert den passenden
+// Fehler. Nur für Ablehnungen aus Rechtegründen – nicht für „gibt es nicht",
+// sonst würde eine schlicht fehlende Datei als „verboten" gemeldet und
+// verriete damit, dass an dem Pfad etwas ist.
+func (fs *aetherFS) forbid() error {
+	if fs.denied != nil {
+		*fs.denied = true
+	}
+	return os.ErrPermission
+}
+
+func (fs *aetherFS) ownScope(parts []string) *davScope {
+	return &davScope{
+		principal:   fs.user.ID,
+		storageRoot: "users/" + fs.user.Username,
+		quota:       fs.user.QuotaBytes,
+		writable:    true,
+		parts:       parts,
+	}
+}
+
+// scopeFor klärt für einen WebDAV-Pfad, welcher Prinzipal gilt und welcher
+// Rest des Pfades in dessen Baum aufzulösen ist.
+func (fs *aetherFS) scopeFor(ctx context.Context, parts []string) (*davScope, error) {
+	if len(parts) == 0 {
+		return fs.ownScope(parts), nil
+	}
+
+	if parts[0] != sharedRoot {
+		// Gruppenordner liegen in der Wurzel, gleichrangig neben den eigenen –
+		// so wie in der Weboberfläche. Die Namen sind bereits eindeutig
+		// gemacht, ein eigener Ordner gewinnt also bei Gleichheit.
+		groups, err := fs.rootGroupFolders(ctx)
+		if err != nil {
+			return nil, err
+		}
+		for _, e := range groups {
+			if e.name == parts[0] {
+				return &davScope{
+					principal: e.principal, storageRoot: e.root, quota: e.quota,
+					writable: e.writable, base: e.folderID, parts: parts[1:],
+				}, nil
+			}
+		}
+		return fs.ownScope(parts), nil
+	}
+
+	if fs.acl == nil {
+		return nil, os.ErrNotExist
+	}
+
+	entries, err := fs.aclShares(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	// Gibt es nichts Geliehenes, gibt es auch kein /Shared. Sonst bliebe bei
+	// Clients ein leerer Ordner stehen, den niemand loswird.
+	if len(entries) == 0 {
+		return nil, os.ErrNotExist
+	}
+
+	// /Shared – Liste der Eigentümer.
+	if len(parts) == 1 {
+		return &davScope{virtual: true, virtualEntries: entries}, nil
+	}
+
+	// /Shared/<Eigentümer> – Liste von dessen Freigaben.
+	owned := []sharedEntry{}
+	for _, e := range entries {
+		if e.owner == parts[1] {
+			owned = append(owned, e)
+		}
+	}
+	if len(owned) == 0 {
+		return nil, os.ErrNotExist
+	}
+	if len(parts) == 2 {
+		return &davScope{virtual: true, virtualEntries: owned}, nil
+	}
+
+	// /Shared/<Eigentümer>/<Freigabe>/… – ab hier gilt ein echter Prinzipal.
+	for _, e := range owned {
+		if e.name != parts[2] {
+			continue
+		}
+		if e.file != nil {
+			// Eine einzeln freigegebene Datei hat nichts unter sich.
+			if len(parts) > 3 {
+				return nil, os.ErrNotExist
+			}
+			return &davScope{
+				principal: e.principal, storageRoot: e.root, quota: e.quota,
+				writable: e.writable, sharedFile: e.file,
+			}, nil
+		}
+		return &davScope{
+			principal: e.principal, storageRoot: e.root, quota: e.quota,
+			writable: e.writable, base: e.folderID, parts: parts[3:],
+		}, nil
+	}
+	return nil, os.ErrNotExist
+}
+
+// rootGroupFolders liefert die Gruppenordner des Nutzers mit dem Namen, unter
+// dem sie in der Wurzel erscheinen.
+//
+// Bei Namensgleichheit gewinnt der eigene Ordner und der Gruppenordner bekommt
+// den Gruppennamen angehängt. Grund: WebDAV adressiert über Pfade – zwei
+// gleichnamige Einträge in einem Verzeichnis kann ein Client nicht auseinander-
+// halten. In der Weboberfläche ist das harmlos, dort führen IDs zum Ziel.
+func (fs *aetherFS) rootGroupFolders(ctx context.Context) ([]sharedEntry, error) {
+	groupFolders, err := fs.fileStore.ListGroupFoldersForUser(ctx, fs.user.ID)
+	if err != nil {
+		return nil, err
+	}
+	if len(groupFolders) == 0 {
+		return nil, nil
+	}
+	ownFolders, err := fs.fileStore.ListFolders(ctx, fs.user.ID, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	taken := map[string]bool{}
+	for _, f := range ownFolders {
+		taken[f.Name] = true
+	}
+
+	out := make([]sharedEntry, 0, len(groupFolders))
+	for _, gf := range groupFolders {
+		if gf.GroupID == nil || fs.acl == nil {
+			continue
+		}
+		info, err := fs.acl.ResolveFolder(ctx, fs.user.ID, gf.ID)
+		if err != nil {
+			continue
+		}
+		group, _ := fs.fileStore.GroupName(ctx, *gf.GroupID)
+
+		name := gf.Name
+		if taken[name] && group != "" {
+			name = gf.Name + " (" + group + ")"
+		}
+		for n := 2; taken[name]; n++ {
+			name = gf.Name + " (" + strconv.Itoa(n) + ")"
+		}
+		taken[name] = true
+
+		id := gf.ID
+		out = append(out, sharedEntry{
+			owner:     group,
+			name:      name,
+			principal: info.OwnerID,
+			root:      info.StorageRoot(),
+			quota:     info.OwnerQuota,
+			writable:  info.CanWrite(),
+			folderID:  &id,
+		})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].name < out[j].name })
+	return out, nil
+}
+
+// aclShares sammelt, was andere Personen freigegeben haben – der Inhalt von
+// /Shared. Gruppenordner gehören nicht dazu, die liegen in der Wurzel.
+func (fs *aetherFS) aclShares(ctx context.Context) ([]sharedEntry, error) {
+	var out []sharedEntry
+
+	shared, err := fs.acl.ListSharedWith(ctx, fs.user.ID)
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range shared {
+		e := sharedEntry{
+			owner:    r.OwnerName,
+			name:     r.Name,
+			writable: r.Permission == acl.PermWrite,
+		}
+		if r.Type == "folder" {
+			info, err := fs.acl.ResolveFolder(ctx, fs.user.ID, r.ID)
+			if err != nil {
+				continue
+			}
+			id := r.ID
+			e.principal, e.root, e.quota = info.OwnerID, info.StorageRoot(), info.OwnerQuota
+			e.folderID = &id
+		} else {
+			info, err := fs.acl.ResolveFile(ctx, fs.user.ID, r.ID)
+			if err != nil {
+				continue
+			}
+			f, err := fs.fileStore.GetFile(ctx, r.ID, info.OwnerID)
+			if err != nil {
+				continue
+			}
+			e.principal, e.root, e.quota = info.OwnerID, info.StorageRoot(), info.OwnerQuota
+			e.file = f
+		}
+		out = append(out, e)
+	}
+
+	return dedupe(out), nil
+}
+
+// dedupe stellt sicher, dass in einem Verzeichnis kein Name zweimal vorkommt –
+// zwei gleichnamige Einträge machen eine PROPFIND-Antwort für Clients
+// unbrauchbar. Sortiert wird vorher, damit die Vergabe bei gleichem Bestand
+// immer gleich ausfällt und Pfade sich nicht von Lauf zu Lauf ändern.
+func dedupe(entries []sharedEntry) []sharedEntry {
+	sort.Slice(entries, func(i, j int) bool {
+		if entries[i].owner != entries[j].owner {
+			return entries[i].owner < entries[j].owner
+		}
+		return entries[i].name < entries[j].name
+	})
+	seen := map[string]int{}
+	for i := range entries {
+		key := entries[i].owner + "/" + entries[i].name
+		seen[key]++
+		if n := seen[key]; n > 1 {
+			entries[i].name += " (" + strconv.Itoa(n) + ")"
+		}
+	}
+	return entries
+}
+
+// owners fasst die Einträge zur zweiten Ebene zusammen.
+func owners(entries []sharedEntry) []string {
+	seen := map[string]bool{}
+	var out []string
+	for _, e := range entries {
+		if !seen[e.owner] {
+			seen[e.owner] = true
+			out = append(out, e.owner)
+		}
+	}
+	return out
+}
diff --git a/backend/internal/webdav/scope_test.go b/backend/internal/webdav/scope_test.go
new file mode 100644
index 0000000..4018c19
--- /dev/null
+++ b/backend/internal/webdav/scope_test.go
@@ -0,0 +1,64 @@
+package webdav
+
+import "testing"
+
+// dedupe vergibt Namen für gleichnamige Freigaben. Entscheidend ist, dass die
+// Vergabe bei gleichem Bestand immer gleich ausfällt: Ein Sync-Client, dem sich
+// Pfade zwischen zwei Läufen verschieben, lädt alles neu hoch oder löscht es.
+func TestDedupeIsStable(t *testing.T) {
+	in := []sharedEntry{
+		{owner: "anna", name: "Projekt"},
+		{owner: "ben", name: "Projekt"},
+		{owner: "anna", name: "Projekt"},
+		{owner: "anna", name: "Notizen"},
+	}
+	first := namesOf(dedupe(append([]sharedEntry(nil), in...)))
+
+	// Andere Eingabereihenfolge, gleicher Bestand → gleiches Ergebnis.
+	shuffled := []sharedEntry{in[3], in[2], in[1], in[0]}
+	second := namesOf(dedupe(shuffled))
+
+	if len(first) != len(second) {
+		t.Fatalf("unterschiedlich viele Einträge: %v vs %v", first, second)
+	}
+	for i := range first {
+		if first[i] != second[i] {
+			t.Fatalf("Reihenfolge nicht stabil:\n  %v\n  %v", first, second)
+		}
+	}
+}
+
+func TestDedupeMakesNamesUniquePerOwner(t *testing.T) {
+	got := namesOf(dedupe([]sharedEntry{
+		{owner: "anna", name: "Projekt"},
+		{owner: "anna", name: "Projekt"},
+		{owner: "anna", name: "Projekt"},
+		// Gleicher Name bei einem anderen Eigentümer ist kein Konflikt – die
+		// beiden liegen in verschiedenen Verzeichnissen.
+		{owner: "ben", name: "Projekt"},
+	}))
+	want := []string{"anna/Projekt", "anna/Projekt (2)", "anna/Projekt (3)", "ben/Projekt"}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Errorf("Eintrag %d = %q, erwartet %q", i, got[i], want[i])
+		}
+	}
+}
+
+// owners liefert die zweite Ebene unter /Shared – jede Person genau einmal.
+func TestOwnersAreUnique(t *testing.T) {
+	got := owners([]sharedEntry{
+		{owner: "anna"}, {owner: "anna"}, {owner: "ben"}, {owner: "anna"},
+	})
+	if len(got) != 2 || got[0] != "anna" || got[1] != "ben" {
+		t.Fatalf("owners = %v, erwartet [anna ben]", got)
+	}
+}
+
+func namesOf(entries []sharedEntry) []string {
+	out := make([]string, len(entries))
+	for i, e := range entries {
+		out[i] = e.owner + "/" + e.name
+	}
+	return out
+}
diff --git a/backend/pkg/config/config.go b/backend/pkg/config/config.go
new file mode 100644
index 0000000..348abd8
--- /dev/null
+++ b/backend/pkg/config/config.go
@@ -0,0 +1,271 @@
+package config
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Config struct {
+	AppEnv     string
+	ListenAddr string // APP_LISTEN_ADDR, e.g. ":8080"
+	PublicURL  string // PUBLIC_URL, e.g. "https://cloud.example.com"
+
+	// TrustedProxies is the list of IPs/CIDRs whose X-Forwarded-* headers are trusted.
+	TrustedProxies []*net.IPNet
+
+	DBHost     string
+	DBPort     string
+	DBName     string
+	DBUser     string
+	DBPassword string
+
+	SessionSecret string
+	SessionMaxAge int
+
+	StoragePath string
+	TmpPath     string
+
+	AdminUsername string
+	AdminPassword string
+
+	// ExternalApps erscheinen im App-Umschalter der Oberfläche. Kommt aus der
+	// Umgebung, damit neue Apps ohne Neubau des Frontends dazukommen können.
+	ExternalApps []ExternalApp
+
+	// OCR – Volltextsuche über den Inhalt von PDFs und Bildern.
+	// Standardmäßig an; fehlen die Programme im Image, schaltet sich der
+	// Arbeiter beim Start selbst ab, statt den Start zu verhindern.
+	OCREnabled   bool
+	OCRLanguages string        // OCR_LANGUAGES, z. B. "deu+eng"
+	OCRMaxPages  int           // je Datei; 0 = unbegrenzt
+	OCRTimeout   time.Duration // je Datei
+
+	// OIDC – all optional; if OIDCIssuer is empty, OIDC login is disabled.
+	OIDCIssuer       string
+	OIDCClientID     string
+	OIDCClientSecret string
+	OIDCRedirectURL  string
+	// OIDCLinkByUsername verbindet ein bestehendes Passwort-Konto mit der
+	// OIDC-Identität, statt ein zweites anzulegen. Voreingestellt **aus** –
+	// siehe die Begründung an auth.Store.GetOrCreateByOIDC.
+	OIDCLinkByUsername bool
+
+	// Office – optional. Ist OfficeProvider leer, ist die Bearbeitung aus und
+	// die Anwendung verhält sich wie zuvor.
+	//
+	// Ein Adapter für beide Anbieter: Collabora und OnlyOffice sprechen
+	// dieselbe Schnittstelle (WOPI). Zwei Integrationen zu bauen hieße,
+	// dieselbe Sache zweimal zu pflegen.
+	OfficeProvider string // "collabora" | "onlyoffice" | "" (aus)
+	OfficeURL      string // Adresse, unter der das **Backend** den Server erreicht
+	// OfficePublicURL ist die Adresse, unter der der **Browser** ihn erreicht.
+	//
+	// Die beiden sind selten gleich: Im Compose-Netz heißt der Server
+	// `collabora`, im Browser muss dort ein Name stehen, den der Rechner des
+	// Menschen auflösen kann. Seine Ermittlungsliste nennt zudem seinen
+	// eigenen internen Namen – die Adresse muss also umgeschrieben werden.
+	// Leer heißt: dieselbe wie OfficeURL.
+	OfficePublicURL string
+	// OfficeWopiURL ist die Adresse, unter der der **Office-Server** Aether
+	// erreicht.
+	//
+	// Der dritte Weg in diesem Dreieck, und der am leichtesten übersehene:
+	// Der Office-Server holt die Datei selbst hier ab. Aus seinem Container
+	// heraus ist „localhost" er selbst – PUBLIC_URL taugt dafür also nur,
+	// wenn es ein Name ist, den auch er auflöst. Leer heißt: PUBLIC_URL.
+	OfficeWopiURL string
+	// OfficeAllowedHosts begrenzt, welche Adressen das Backend anfragen darf.
+	// Ohne diese Grenze wird aus einem Tippfehler oder einer untergeschobenen
+	// Konfiguration ein Weg ins interne Netz (SSRF).
+	OfficeAllowedHosts []string
+	// OfficeInsecureTLS erlaubt ein selbstsigniertes Zertifikat am
+	// Office-Server. Nur für den Testaufbau auf demselben Rechner.
+	OfficeInsecureTLS bool
+}
+
+// splitList zerlegt eine kommagetrennte Liste und wirft Leeres weg.
+func splitList(raw string) []string {
+	var out []string
+	for _, part := range strings.Split(raw, ",") {
+		if v := strings.TrimSpace(part); v != "" {
+			out = append(out, v)
+		}
+	}
+	return out
+}
+
+// OfficeEnabled sagt, ob die Bearbeitung überhaupt in Frage kommt. Beides muss
+// gesetzt sein – ein Anbieter ohne Adresse wäre eine halbe Konfiguration, und
+// die soll nicht erst beim ersten Klick auffallen.
+func (c *Config) OfficeEnabled() bool {
+	return (c.OfficeProvider == "collabora" || c.OfficeProvider == "onlyoffice") && c.OfficeURL != ""
+}
+
+// ExternalApp ist ein Eintrag im App-Umschalter.
+type ExternalApp struct {
+	Name string `json:"name"`
+	URL  string `json:"url"`
+	Icon string `json:"icon"` // ein Emoji, optional
+}
+
+// parseExternalApps liest EXTERNAL_APPS im Format
+//
+//	Name|https://url|Emoji , Name|https://url|Emoji
+//
+// Einträge ohne Namen oder URL werden übersprungen, damit ein Tippfehler in der
+// .env nicht den Start verhindert.
+func parseExternalApps(raw string) []ExternalApp {
+	var apps []ExternalApp
+	for _, entry := range strings.Split(raw, ",") {
+		entry = strings.TrimSpace(entry)
+		if entry == "" {
+			continue
+		}
+		parts := strings.Split(entry, "|")
+		if len(parts) < 2 {
+			continue
+		}
+		app := ExternalApp{
+			Name: strings.TrimSpace(parts[0]),
+			URL:  strings.TrimSpace(parts[1]),
+		}
+		if len(parts) > 2 {
+			app.Icon = strings.TrimSpace(parts[2])
+		}
+		if app.Name == "" || app.URL == "" {
+			continue
+		}
+		apps = append(apps, app)
+	}
+	return apps
+}
+
+func Load() (*Config, error) {
+	cfg := &Config{
+		AppEnv:     getEnv("APP_ENV", "development"),
+		ListenAddr: getEnv("APP_LISTEN_ADDR", ":8080"),
+		PublicURL:  getEnv("PUBLIC_URL", "http://localhost:8080"),
+
+		DBHost:     getEnv("DB_HOST", "localhost"),
+		DBPort:     getEnv("DB_PORT", "5432"),
+		DBName:     getEnv("DB_NAME", "aether"),
+		DBUser:     getEnv("DB_USER", "aether"),
+		DBPassword: getEnv("DB_PASSWORD", ""),
+
+		SessionSecret: getEnv("SESSION_SECRET", ""),
+		StoragePath:   getEnv("STORAGE_PATH", "./data"),
+		TmpPath:       getEnv("TMP_PATH", "./data/tmp"),
+
+		AdminUsername: getEnv("ADMIN_USERNAME", ""),
+		AdminPassword: getEnv("ADMIN_PASSWORD", ""),
+
+		ExternalApps: parseExternalApps(getEnv("EXTERNAL_APPS", "")),
+
+		OCREnabled: getEnv("OCR_ENABLED", "true") != "false",
+
+		OfficeProvider:     strings.ToLower(strings.TrimSpace(getEnv("OFFICE_PROVIDER", ""))),
+		OfficeURL:          strings.TrimRight(getEnv("OFFICE_URL", ""), "/"),
+		OfficePublicURL:    strings.TrimRight(getEnv("OFFICE_PUBLIC_URL", ""), "/"),
+		OfficeWopiURL:      strings.TrimRight(getEnv("OFFICE_WOPI_URL", ""), "/"),
+		OfficeAllowedHosts: splitList(getEnv("OFFICE_ALLOWED_HOSTS", "")),
+		OfficeInsecureTLS:  getEnv("OFFICE_INSECURE_TLS", "false") == "true",
+		OCRLanguages:       getEnv("OCR_LANGUAGES", "deu+eng"),
+
+		OIDCIssuer:       getEnv("OIDC_ISSUER", ""),
+		OIDCClientID:     getEnv("OIDC_CLIENT_ID", ""),
+		OIDCClientSecret: getEnv("OIDC_CLIENT_SECRET", ""),
+		OIDCRedirectURL:  getEnv("OIDC_REDIRECT_URL", ""),
+		// Nur ein ausdrückliches "true" schaltet es ein: Ein Tippfehler soll
+		// nicht dazu führen, dass Konten stillschweigend übernommen werden.
+		OIDCLinkByUsername: getEnv("OIDC_LINK_BY_USERNAME", "false") == "true",
+	}
+
+	maxAge, err := strconv.Atoi(getEnv("SESSION_MAX_AGE", "86400"))
+	if err != nil {
+		return nil, fmt.Errorf("invalid SESSION_MAX_AGE: %w", err)
+	}
+	cfg.SessionMaxAge = maxAge
+
+	if cfg.SessionSecret == "" {
+		return nil, fmt.Errorf("SESSION_SECRET must be set")
+	}
+	if cfg.DBPassword == "" {
+		return nil, fmt.Errorf("DB_PASSWORD must be set")
+	}
+
+	// Grenzen für die Texterkennung. Ein Tippfehler in der .env soll den Start
+	// nicht verhindern – deshalb Rückfall auf den Standard statt Abbruch.
+	if n, err := strconv.Atoi(getEnv("OCR_MAX_PAGES", "50")); err == nil && n >= 0 {
+		cfg.OCRMaxPages = n
+	} else {
+		cfg.OCRMaxPages = 50
+	}
+	if d, err := time.ParseDuration(getEnv("OCR_TIMEOUT", "10m")); err == nil && d > 0 {
+		cfg.OCRTimeout = d
+	} else {
+		cfg.OCRTimeout = 10 * time.Minute
+	}
+
+	cfg.TrustedProxies, err = parseCIDRList(getEnv("TRUSTED_PROXIES", ""))
+	if err != nil {
+		return nil, fmt.Errorf("invalid TRUSTED_PROXIES: %w", err)
+	}
+
+	return cfg, nil
+}
+
+func (c *Config) DSN() string {
+	return fmt.Sprintf(
+		"host=%s port=%s dbname=%s user=%s password=%s sslmode=disable",
+		c.DBHost, c.DBPort, c.DBName, c.DBUser, c.DBPassword,
+	)
+}
+
+func (c *Config) IsDev() bool {
+	return c.AppEnv == "development"
+}
+
+// IsTrustedProxy reports whether ip is in the TrustedProxies list.
+func (c *Config) IsTrustedProxy(ip net.IP) bool {
+	for _, network := range c.TrustedProxies {
+		if network.Contains(ip) {
+			return true
+		}
+	}
+	return false
+}
+
+func parseCIDRList(raw string) ([]*net.IPNet, error) {
+	var networks []*net.IPNet
+	for _, entry := range strings.Split(raw, ",") {
+		entry = strings.TrimSpace(entry)
+		if entry == "" {
+			continue
+		}
+		// Accept plain IPs by appending /32 or /128.
+		if !strings.Contains(entry, "/") {
+			if strings.Contains(entry, ":") {
+				entry += "/128"
+			} else {
+				entry += "/32"
+			}
+		}
+		_, network, err := net.ParseCIDR(entry)
+		if err != nil {
+			return nil, fmt.Errorf("cannot parse %q: %w", entry, err)
+		}
+		networks = append(networks, network)
+	}
+	return networks, nil
+}
+
+func getEnv(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}
diff --git a/backend/pkg/db/db.go b/backend/pkg/db/db.go
new file mode 100644
index 0000000..d0ee5d7
--- /dev/null
+++ b/backend/pkg/db/db.go
@@ -0,0 +1,107 @@
+package db
+
+import (
+	"context"
+	"embed"
+	"fmt"
+
+	"github.com/golang-migrate/migrate/v4"
+	_ "github.com/golang-migrate/migrate/v4/database/postgres"
+	"github.com/golang-migrate/migrate/v4/source/iofs"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+//go:embed migrations/*.sql
+var migrationsFS embed.FS
+
+func Connect(ctx context.Context, dsn string) (*pgxpool.Pool, error) {
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		return nil, fmt.Errorf("create pool: %w", err)
+	}
+	if err := pool.Ping(ctx); err != nil {
+		return nil, fmt.Errorf("ping db: %w", err)
+	}
+	return pool, nil
+}
+
+func Migrate(dsn string) error {
+	src, err := iofs.New(migrationsFS, "migrations")
+	if err != nil {
+		return fmt.Errorf("load migrations: %w", err)
+	}
+	// convert pgx DSN → lib/pq DSN format for migrate
+	m, err := migrate.NewWithSourceInstance("iofs", src, "postgres://"+dsnToURL(dsn))
+	if err != nil {
+		return fmt.Errorf("init migrate: %w", err)
+	}
+	if err := m.Up(); err != nil && err != migrate.ErrNoChange {
+		return fmt.Errorf("run migrations: %w", err)
+	}
+	return nil
+}
+
+// dsnToURL converts "host=... port=... dbname=... user=... password=... sslmode=..."
+// to a postgres:// URL for golang-migrate.
+func dsnToURL(dsn string) string {
+	// pgxpool DSN is already accepted by migrate if we prefix with postgres://
+	// Actually golang-migrate accepts the postgres:// URL format.
+	// Since our DSN is key=value, we need to convert it.
+	// Simplest approach: parse key=value pairs.
+	params := map[string]string{}
+	for _, part := range splitDSN(dsn) {
+		if len(part) == 0 {
+			continue
+		}
+		idx := indexByte(part, '=')
+		if idx < 0 {
+			continue
+		}
+		params[part[:idx]] = part[idx+1:]
+	}
+	host := params["host"]
+	port := params["port"]
+	if port == "" {
+		port = "5432"
+	}
+	return fmt.Sprintf("%s:%s@%s:%s/%s?sslmode=%s",
+		params["user"], params["password"],
+		host, port, params["dbname"],
+		orDefault(params["sslmode"], "disable"),
+	)
+}
+
+func splitDSN(dsn string) []string {
+	var parts []string
+	cur := ""
+	for _, r := range dsn {
+		if r == ' ' {
+			if cur != "" {
+				parts = append(parts, cur)
+				cur = ""
+			}
+		} else {
+			cur += string(r)
+		}
+	}
+	if cur != "" {
+		parts = append(parts, cur)
+	}
+	return parts
+}
+
+func indexByte(s string, b byte) int {
+	for i := 0; i < len(s); i++ {
+		if s[i] == b {
+			return i
+		}
+	}
+	return -1
+}
+
+func orDefault(s, def string) string {
+	if s == "" {
+		return def
+	}
+	return s
+}
diff --git a/backend/pkg/db/migrations/000001_init.down.sql b/backend/pkg/db/migrations/000001_init.down.sql
new file mode 100644
index 0000000..5a6277c
--- /dev/null
+++ b/backend/pkg/db/migrations/000001_init.down.sql
@@ -0,0 +1,12 @@
+DROP TRIGGER IF EXISTS trg_files_updated_at ON files;
+DROP TRIGGER IF EXISTS trg_folders_updated_at ON folders;
+DROP TRIGGER IF EXISTS trg_users_updated_at ON users;
+DROP FUNCTION IF EXISTS update_updated_at();
+
+DROP TABLE IF EXISTS file_versions;
+DROP TABLE IF EXISTS files;
+DROP TABLE IF EXISTS folders;
+DROP TABLE IF EXISTS sessions;
+DROP TABLE IF EXISTS users;
+
+DROP EXTENSION IF EXISTS "pgcrypto";
diff --git a/backend/pkg/db/migrations/000001_init.up.sql b/backend/pkg/db/migrations/000001_init.up.sql
new file mode 100644
index 0000000..c2ddeac
--- /dev/null
+++ b/backend/pkg/db/migrations/000001_init.up.sql
@@ -0,0 +1,103 @@
+-- Aether – Initial schema
+-- Phase 0: users, sessions, folders, files (no email)
+
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+-- ── Users ─────────────────────────────────────────────────────────────────────
+CREATE TABLE users (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    username    TEXT        NOT NULL UNIQUE,
+    password    TEXT        NOT NULL,       -- Argon2id hash
+    is_admin    BOOLEAN     NOT NULL DEFAULT FALSE,
+    quota_bytes BIGINT      NOT NULL DEFAULT 10737418240, -- 10 GB default
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- ── Sessions ──────────────────────────────────────────────────────────────────
+CREATE TABLE sessions (
+    id         TEXT        PRIMARY KEY,
+    user_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    data       BYTEA       NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    expires_at TIMESTAMPTZ NOT NULL
+);
+
+CREATE INDEX idx_sessions_user_id  ON sessions(user_id);
+CREATE INDEX idx_sessions_expires  ON sessions(expires_at);
+
+-- ── Folders ───────────────────────────────────────────────────────────────────
+CREATE TABLE folders (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id   UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    parent_id  UUID        REFERENCES folders(id) ON DELETE CASCADE,
+    name       TEXT        NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (owner_id, parent_id, name)
+);
+
+CREATE INDEX idx_folders_owner   ON folders(owner_id);
+CREATE INDEX idx_folders_parent  ON folders(parent_id);
+
+-- ── Files ─────────────────────────────────────────────────────────────────────
+CREATE TABLE files (
+    id           UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id     UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    folder_id    UUID        REFERENCES folders(id) ON DELETE CASCADE,
+    name         TEXT        NOT NULL,
+    mime_type    TEXT        NOT NULL DEFAULT 'application/octet-stream',
+    size         BIGINT      NOT NULL DEFAULT 0,
+    checksum     TEXT        NOT NULL,   -- SHA-256 hex
+    storage_key  TEXT        NOT NULL,   -- path within blob storage
+    version      INTEGER     NOT NULL DEFAULT 1,
+    is_deleted   BOOLEAN     NOT NULL DEFAULT FALSE,
+    deleted_at   TIMESTAMPTZ,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_files_owner     ON files(owner_id);
+CREATE INDEX idx_files_folder    ON files(folder_id);
+CREATE INDEX idx_files_deleted   ON files(is_deleted);
+CREATE INDEX idx_files_storage   ON files(storage_key);
+
+-- Partial unique index: no two non-deleted files can share name+folder for the same owner.
+CREATE UNIQUE INDEX idx_files_unique_name
+    ON files(owner_id, folder_id, name)
+    WHERE NOT is_deleted;
+
+-- ── File versions ─────────────────────────────────────────────────────────────
+-- Previous versions of files (kept for Soft-Delete + versioning).
+CREATE TABLE file_versions (
+    id           UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_id      UUID        NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    version      INTEGER     NOT NULL,
+    size         BIGINT      NOT NULL,
+    checksum     TEXT        NOT NULL,
+    storage_key  TEXT        NOT NULL,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_file_versions_file ON file_versions(file_id);
+
+-- ── Updated_at trigger ────────────────────────────────────────────────────────
+CREATE OR REPLACE FUNCTION update_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER trg_users_updated_at
+    BEFORE UPDATE ON users
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER trg_folders_updated_at
+    BEFORE UPDATE ON folders
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER trg_files_updated_at
+    BEFORE UPDATE ON files
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at();
diff --git a/backend/pkg/db/migrations/000002_phase2.down.sql b/backend/pkg/db/migrations/000002_phase2.down.sql
new file mode 100644
index 0000000..33d013b
--- /dev/null
+++ b/backend/pkg/db/migrations/000002_phase2.down.sql
@@ -0,0 +1,3 @@
+DROP TABLE IF EXISTS uploads;
+DROP TABLE IF EXISTS share_links;
+ALTER TABLE files DROP COLUMN IF EXISTS has_thumbnail;
diff --git a/backend/pkg/db/migrations/000002_phase2.up.sql b/backend/pkg/db/migrations/000002_phase2.up.sql
new file mode 100644
index 0000000..36bd812
--- /dev/null
+++ b/backend/pkg/db/migrations/000002_phase2.up.sql
@@ -0,0 +1,35 @@
+-- Phase 2: share links, resumable uploads, thumbnails
+
+ALTER TABLE files ADD COLUMN has_thumbnail BOOLEAN NOT NULL DEFAULT FALSE;
+
+-- ── Share links ───────────────────────────────────────────────────────────────
+CREATE TABLE share_links (
+    id             UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_id        UUID        NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    owner_id       UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    token          TEXT        NOT NULL UNIQUE,
+    password_hash  TEXT,                   -- Argon2id, NULL = no password
+    expires_at     TIMESTAMPTZ,            -- NULL = never
+    download_count INTEGER     NOT NULL DEFAULT 0,
+    created_at     TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_share_links_token ON share_links(token);
+CREATE INDEX idx_share_links_owner ON share_links(owner_id);
+CREATE INDEX idx_share_links_file  ON share_links(file_id);
+
+-- ── Resumable uploads ────────────────────────────────────────────────────────
+CREATE TABLE uploads (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id    UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    folder_id   UUID        REFERENCES folders(id) ON DELETE SET NULL,
+    filename    TEXT        NOT NULL,
+    mime_type   TEXT        NOT NULL DEFAULT 'application/octet-stream',
+    total_size  BIGINT      NOT NULL,
+    uploaded    BIGINT      NOT NULL DEFAULT 0,
+    storage_key TEXT        NOT NULL UNIQUE,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    expires_at  TIMESTAMPTZ NOT NULL DEFAULT NOW() + INTERVAL '24 hours'
+);
+
+CREATE INDEX idx_uploads_owner ON uploads(owner_id);
diff --git a/backend/pkg/db/migrations/000003_favorites.down.sql b/backend/pkg/db/migrations/000003_favorites.down.sql
new file mode 100644
index 0000000..a006ce5
--- /dev/null
+++ b/backend/pkg/db/migrations/000003_favorites.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS favorites;
diff --git a/backend/pkg/db/migrations/000003_favorites.up.sql b/backend/pkg/db/migrations/000003_favorites.up.sql
new file mode 100644
index 0000000..e25437a
--- /dev/null
+++ b/backend/pkg/db/migrations/000003_favorites.up.sql
@@ -0,0 +1,11 @@
+CREATE TABLE favorites (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id     UUID        NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    folder_id   UUID        NOT NULL REFERENCES folders(id) ON DELETE CASCADE,
+    position    INTEGER     NOT NULL DEFAULT 0,
+    is_expanded BOOLEAN     NOT NULL DEFAULT false,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE (user_id, folder_id)
+);
+
+CREATE INDEX idx_favorites_user ON favorites(user_id);
diff --git a/backend/pkg/db/migrations/000004_phase3_admin.down.sql b/backend/pkg/db/migrations/000004_phase3_admin.down.sql
new file mode 100644
index 0000000..21b32a1
--- /dev/null
+++ b/backend/pkg/db/migrations/000004_phase3_admin.down.sql
@@ -0,0 +1,4 @@
+DROP TABLE IF EXISTS group_members;
+DROP TABLE IF EXISTS groups;
+DELETE FROM settings WHERE key IN ('cloud_name','primary_color','accent_color','logo_storage_key');
+ALTER TABLE users DROP COLUMN IF EXISTS display_name;
diff --git a/backend/pkg/db/migrations/000004_phase3_admin.up.sql b/backend/pkg/db/migrations/000004_phase3_admin.up.sql
new file mode 100644
index 0000000..a58b97a
--- /dev/null
+++ b/backend/pkg/db/migrations/000004_phase3_admin.up.sql
@@ -0,0 +1,35 @@
+-- Phase 3: Admin panel – groups, settings, user display names
+
+-- ── Users: display name ───────────────────────────────────────────────────────
+ALTER TABLE users ADD COLUMN IF NOT EXISTS display_name TEXT NOT NULL DEFAULT '';
+
+-- ── Groups ───────────────────────────────────────────────────────────────────
+CREATE TABLE groups (
+    id          UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    name        TEXT        NOT NULL UNIQUE,
+    description TEXT        NOT NULL DEFAULT '',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE group_members (
+    group_id    UUID        NOT NULL REFERENCES groups(id)  ON DELETE CASCADE,
+    user_id     UUID        NOT NULL REFERENCES users(id)   ON DELETE CASCADE,
+    joined_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (group_id, user_id)
+);
+
+CREATE INDEX idx_group_members_user ON group_members(user_id);
+
+-- ── Settings (key-value, admin-managed) ───────────────────────────────────────
+CREATE TABLE settings (
+    key         TEXT        PRIMARY KEY,
+    value       TEXT        NOT NULL DEFAULT '',
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Default settings
+INSERT INTO settings (key, value) VALUES
+    ('cloud_name',     'Aether'),
+    ('primary_color',  '#6366f1'),
+    ('accent_color',   '#8b5cf6'),
+    ('logo_storage_key', '');
diff --git a/backend/pkg/db/migrations/000005_oidc.down.sql b/backend/pkg/db/migrations/000005_oidc.down.sql
new file mode 100644
index 0000000..90be798
--- /dev/null
+++ b/backend/pkg/db/migrations/000005_oidc.down.sql
@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS oidc_sub;
diff --git a/backend/pkg/db/migrations/000005_oidc.up.sql b/backend/pkg/db/migrations/000005_oidc.up.sql
new file mode 100644
index 0000000..f1c6078
--- /dev/null
+++ b/backend/pkg/db/migrations/000005_oidc.up.sql
@@ -0,0 +1,3 @@
+-- OIDC subject for linking OIDC provider accounts to local users.
+-- NULL means the user only has a local password login.
+ALTER TABLE users ADD COLUMN oidc_sub TEXT UNIQUE;
diff --git a/backend/pkg/db/migrations/000006_file_versioning.down.sql b/backend/pkg/db/migrations/000006_file_versioning.down.sql
new file mode 100644
index 0000000..901c13a
--- /dev/null
+++ b/backend/pkg/db/migrations/000006_file_versioning.down.sql
@@ -0,0 +1 @@
+ALTER TABLE files DROP COLUMN IF EXISTS versioning_enabled;
diff --git a/backend/pkg/db/migrations/000006_file_versioning.up.sql b/backend/pkg/db/migrations/000006_file_versioning.up.sql
new file mode 100644
index 0000000..0c8ead6
--- /dev/null
+++ b/backend/pkg/db/migrations/000006_file_versioning.up.sql
@@ -0,0 +1,11 @@
+-- Versionierung ist ab hier eine Opt-in-Einstellung pro Datei.
+-- Standard: aus. Ohne den Schalter würde jede Überschreibung eine weitere
+-- Fassung aufheben und den Speicher unbemerkt volllaufen lassen.
+ALTER TABLE files
+    ADD COLUMN versioning_enabled BOOLEAN NOT NULL DEFAULT false;
+
+-- Dateien, die bereits Fassungen haben, behalten ihr bisheriges Verhalten –
+-- sonst würde ein bestehender Verlauf stillschweigend eingefroren.
+UPDATE files f
+   SET versioning_enabled = true
+ WHERE EXISTS (SELECT 1 FROM file_versions v WHERE v.file_id = f.id);
diff --git a/backend/pkg/db/migrations/000007_user_colors.down.sql b/backend/pkg/db/migrations/000007_user_colors.down.sql
new file mode 100644
index 0000000..32bf3ac
--- /dev/null
+++ b/backend/pkg/db/migrations/000007_user_colors.down.sql
@@ -0,0 +1,3 @@
+ALTER TABLE users
+    DROP COLUMN IF EXISTS primary_color,
+    DROP COLUMN IF EXISTS accent_color;
diff --git a/backend/pkg/db/migrations/000007_user_colors.up.sql b/backend/pkg/db/migrations/000007_user_colors.up.sql
new file mode 100644
index 0000000..39dc829
--- /dev/null
+++ b/backend/pkg/db/migrations/000007_user_colors.up.sql
@@ -0,0 +1,9 @@
+-- Persönliche Farbpalette pro Nutzer. NULL bedeutet: es gilt die globale
+-- Einstellung des Administrators.
+--
+-- Bis hierher zeigte die Profilseite zwar Farbwähler, schrieb damit aber in die
+-- globalen Einstellungen – für normale Nutzer scheiterte das an der
+-- Admin-Prüfung, beim Administrator färbte es die ganze Cloud um.
+ALTER TABLE users
+    ADD COLUMN primary_color TEXT,
+    ADD COLUMN accent_color  TEXT;
diff --git a/backend/pkg/db/migrations/000008_use_custom_theme.down.sql b/backend/pkg/db/migrations/000008_use_custom_theme.down.sql
new file mode 100644
index 0000000..fd5dee9
--- /dev/null
+++ b/backend/pkg/db/migrations/000008_use_custom_theme.down.sql
@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN IF EXISTS use_custom_theme;
diff --git a/backend/pkg/db/migrations/000008_use_custom_theme.up.sql b/backend/pkg/db/migrations/000008_use_custom_theme.up.sql
new file mode 100644
index 0000000..6c806a0
--- /dev/null
+++ b/backend/pkg/db/migrations/000008_use_custom_theme.up.sql
@@ -0,0 +1,13 @@
+-- Schalter zwischen persönlicher und globaler Palette.
+--
+-- Bisher bedeutete "keine eigene Farbe" = globale Einstellung. Zum Zurückschalten
+-- musste man die eigenen Werte löschen und war sie damit los. Der Schalter trennt
+-- beides: die Farben bleiben gespeichert, nur ihre Anwendung wird umgelegt.
+ALTER TABLE users
+    ADD COLUMN use_custom_theme BOOLEAN NOT NULL DEFAULT false;
+
+-- Wer bereits eine eigene Farbe gesetzt hat, hat sie sichtbar verwendet –
+-- das Verhalten soll durch die Migration nicht kippen.
+UPDATE users
+   SET use_custom_theme = true
+ WHERE primary_color IS NOT NULL OR accent_color IS NOT NULL;
diff --git a/backend/pkg/db/migrations/000009_app_passwords.down.sql b/backend/pkg/db/migrations/000009_app_passwords.down.sql
new file mode 100644
index 0000000..c4564ac
--- /dev/null
+++ b/backend/pkg/db/migrations/000009_app_passwords.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS app_passwords;
diff --git a/backend/pkg/db/migrations/000009_app_passwords.up.sql b/backend/pkg/db/migrations/000009_app_passwords.up.sql
new file mode 100644
index 0000000..f8fbc12
--- /dev/null
+++ b/backend/pkg/db/migrations/000009_app_passwords.up.sql
@@ -0,0 +1,15 @@
+-- App-Passwörter: widerrufbare Zugangsdaten für WebDAV-/Sync-Clients, damit das
+-- Hauptpasswort nicht auf Geräten liegt, die man verlieren kann.
+CREATE TABLE app_passwords (
+    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id       UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    name          TEXT NOT NULL,
+    -- SHA-256 des Tokens. Kein Argon2: das Token ist serverseitig zufällig und
+    -- hochentropisch, also nicht ratbar – und WebDAV authentifiziert jeden
+    -- einzelnen Request, wo Argon2 pro Aufruf zu teuer wäre.
+    token_hash    TEXT NOT NULL UNIQUE,
+    last_used_at  TIMESTAMPTZ,
+    created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX idx_app_passwords_user ON app_passwords(user_id);
diff --git a/backend/pkg/db/migrations/000010_audit_log.down.sql b/backend/pkg/db/migrations/000010_audit_log.down.sql
new file mode 100644
index 0000000..b750c3b
--- /dev/null
+++ b/backend/pkg/db/migrations/000010_audit_log.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS audit_log;
diff --git a/backend/pkg/db/migrations/000010_audit_log.up.sql b/backend/pkg/db/migrations/000010_audit_log.up.sql
new file mode 100644
index 0000000..cb4980f
--- /dev/null
+++ b/backend/pkg/db/migrations/000010_audit_log.up.sql
@@ -0,0 +1,27 @@
+-- Audit-Log: wer hat was wann getan. Zweck ist die Nachvollziehbarkeit nach
+-- einem Vorfall – deshalb muss ein Eintrag auch dann noch lesbar sein, wenn der
+-- handelnde oder betroffene Account längst gelöscht ist.
+CREATE TABLE audit_log (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    -- ON DELETE SET NULL statt CASCADE: sonst räumte das Löschen eines Users
+    -- genau die Spuren weg, die man danach untersuchen will.
+    actor_id     UUID REFERENCES users(id) ON DELETE SET NULL,
+    -- Denormalisiert, damit der Name den gelöschten Account überlebt.
+    actor_name   TEXT NOT NULL,
+
+    action       TEXT NOT NULL,
+    target_type  TEXT,
+    target_id    TEXT,
+    target_name  TEXT,
+
+    ip           TEXT,
+    detail       TEXT,
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Die Admin-Ansicht liest immer neueste zuerst, oft gefiltert nach Aktion oder
+-- handelndem Konto.
+CREATE INDEX idx_audit_log_created  ON audit_log (created_at DESC);
+CREATE INDEX idx_audit_log_actor    ON audit_log (actor_id, created_at DESC);
+CREATE INDEX idx_audit_log_action   ON audit_log (action, created_at DESC);
diff --git a/backend/pkg/db/migrations/000011_acl_entries.down.sql b/backend/pkg/db/migrations/000011_acl_entries.down.sql
new file mode 100644
index 0000000..ad56c9d
--- /dev/null
+++ b/backend/pkg/db/migrations/000011_acl_entries.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS acl_entries;
diff --git a/backend/pkg/db/migrations/000011_acl_entries.up.sql b/backend/pkg/db/migrations/000011_acl_entries.up.sql
new file mode 100644
index 0000000..e91fd22
--- /dev/null
+++ b/backend/pkg/db/migrations/000011_acl_entries.up.sql
@@ -0,0 +1,51 @@
+-- Interne Freigaben: Ordner oder Datei an einen anderen Nutzer oder eine Gruppe
+-- geben, ohne dass die Bytes umziehen. Der Empfänger sieht sie virtuell unter
+-- „Geteilt mit mir"; auf der Platte bleibt alles beim Eigentümer.
+--
+-- Abweichung vom Projektplan: dort war eine polymorphe Tabelle skizziert
+-- (subject_type + subject_id als Text/UUID ohne Fremdschlüssel). Hier stattdessen
+-- vier nullbare Fremdschlüssel mit CHECK-Bedingung. Grund: polymorph kann die
+-- Datenbank nichts erzwingen – ein gelöschter Nutzer oder Ordner hinterließe
+-- Einträge, die auf nichts mehr zeigen, und aus so einer Leiche später eine
+-- Freigabe für einen neu vergebenen Namen zu machen wäre ein Sicherheitsloch.
+-- Mit echten Fremdschlüsseln räumt ON DELETE CASCADE das von selbst auf.
+CREATE TABLE acl_entries (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+
+    -- Empfänger: genau eines von beiden.
+    subject_user_id  UUID REFERENCES users(id)  ON DELETE CASCADE,
+    subject_group_id UUID REFERENCES groups(id) ON DELETE CASCADE,
+
+    -- Freigegebene Ressource: genau eines von beiden.
+    resource_folder_id UUID REFERENCES folders(id) ON DELETE CASCADE,
+    resource_file_id   UUID REFERENCES files(id)   ON DELETE CASCADE,
+
+    permission TEXT NOT NULL CHECK (permission IN ('read', 'write')),
+
+    -- Wer die Freigabe erteilt hat. SET NULL statt CASCADE: die Freigabe soll
+    -- nicht verschwinden, nur weil das Konto des Erteilers gelöscht wurde.
+    granted_by UUID REFERENCES users(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    CONSTRAINT acl_one_subject  CHECK (num_nonnulls(subject_user_id, subject_group_id) = 1),
+    CONSTRAINT acl_one_resource CHECK (num_nonnulls(resource_folder_id, resource_file_id) = 1)
+);
+
+-- Zwei Freigaben derselben Ressource an denselben Empfänger wären mehrdeutig:
+-- welches Recht gilt dann? Partielle Unique-Indizes, weil NULL in einem
+-- gewöhnlichen UNIQUE nicht mit sich selbst kollidiert.
+CREATE UNIQUE INDEX idx_acl_user_folder  ON acl_entries (subject_user_id, resource_folder_id)
+    WHERE subject_user_id IS NOT NULL AND resource_folder_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_acl_user_file    ON acl_entries (subject_user_id, resource_file_id)
+    WHERE subject_user_id IS NOT NULL AND resource_file_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_acl_group_folder ON acl_entries (subject_group_id, resource_folder_id)
+    WHERE subject_group_id IS NOT NULL AND resource_folder_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_acl_group_file   ON acl_entries (subject_group_id, resource_file_id)
+    WHERE subject_group_id IS NOT NULL AND resource_file_id IS NOT NULL;
+
+-- Die Zugriffsprüfung läuft bei jedem Request; sie fragt nach Ressource.
+CREATE INDEX idx_acl_folder  ON acl_entries (resource_folder_id) WHERE resource_folder_id IS NOT NULL;
+CREATE INDEX idx_acl_file    ON acl_entries (resource_file_id)   WHERE resource_file_id IS NOT NULL;
+-- „Geteilt mit mir" fragt nach Empfänger.
+CREATE INDEX idx_acl_subject_user  ON acl_entries (subject_user_id)  WHERE subject_user_id IS NOT NULL;
+CREATE INDEX idx_acl_subject_group ON acl_entries (subject_group_id) WHERE subject_group_id IS NOT NULL;
diff --git a/backend/pkg/db/migrations/000012_group_folders.down.sql b/backend/pkg/db/migrations/000012_group_folders.down.sql
new file mode 100644
index 0000000..d82f56b
--- /dev/null
+++ b/backend/pkg/db/migrations/000012_group_folders.down.sql
@@ -0,0 +1,18 @@
+DROP INDEX IF EXISTS idx_files_group;
+DROP INDEX IF EXISTS idx_folders_group;
+DROP INDEX IF EXISTS idx_folders_group_root_name;
+DROP INDEX IF EXISTS idx_folders_group_name;
+
+ALTER TABLE groups  DROP COLUMN IF EXISTS quota_bytes;
+ALTER TABLE files   DROP CONSTRAINT IF EXISTS files_one_principal;
+ALTER TABLE folders DROP CONSTRAINT IF EXISTS folders_one_principal;
+
+-- Erst die Gruppendaten entfernen, sonst scheitert das NOT NULL unten.
+DELETE FROM files   WHERE group_id IS NOT NULL;
+DELETE FROM folders WHERE group_id IS NOT NULL;
+
+ALTER TABLE files   DROP COLUMN IF EXISTS group_id;
+ALTER TABLE folders DROP COLUMN IF EXISTS group_id;
+
+ALTER TABLE files   ALTER COLUMN owner_id SET NOT NULL;
+ALTER TABLE folders ALTER COLUMN owner_id SET NOT NULL;
diff --git a/backend/pkg/db/migrations/000012_group_folders.up.sql b/backend/pkg/db/migrations/000012_group_folders.up.sql
new file mode 100644
index 0000000..f683f70
--- /dev/null
+++ b/backend/pkg/db/migrations/000012_group_folders.up.sql
@@ -0,0 +1,35 @@
+-- Gruppenordner: ein Ordner, der keinem einzelnen Konto gehört, sondern einer
+-- Gruppe. Wer Mitglied ist, sieht ihn; wer die Gruppe verlässt, nicht mehr.
+--
+-- Ordner und Dateien gehören ab jetzt entweder einem Nutzer ODER einer Gruppe,
+-- nie beidem und nie keinem. Deshalb wird owner_id nullbar und bekommt eine
+-- CHECK-Bedingung als Gegengewicht – ohne die könnte ein Datensatz herrenlos
+-- werden und wäre über keine Abfrage mehr erreichbar.
+
+ALTER TABLE folders ALTER COLUMN owner_id DROP NOT NULL;
+ALTER TABLE files   ALTER COLUMN owner_id DROP NOT NULL;
+
+ALTER TABLE folders ADD COLUMN group_id UUID REFERENCES groups(id) ON DELETE CASCADE;
+ALTER TABLE files   ADD COLUMN group_id UUID REFERENCES groups(id) ON DELETE CASCADE;
+
+ALTER TABLE folders ADD CONSTRAINT folders_one_principal
+    CHECK (num_nonnulls(owner_id, group_id) = 1);
+ALTER TABLE files   ADD CONSTRAINT files_one_principal
+    CHECK (num_nonnulls(owner_id, group_id) = 1);
+
+-- Gruppen bekommen ein eigenes Kontingent. Die Alternative – „zählt beim
+-- Ersteller" – wäre für die Mitglieder nicht nachvollziehbar: Der Ordner wäre
+-- plötzlich voll, weil jemand anders privat etwas hochgeladen hat.
+ALTER TABLE groups ADD COLUMN quota_bytes BIGINT NOT NULL DEFAULT 10737418240;
+
+-- Die bestehende UNIQUE (owner_id, parent_id, name) greift für Gruppenordner
+-- nicht: In SQL kollidiert NULL nicht mit NULL, zwei Gruppenordner gleichen
+-- Namens rutschten also durch.
+CREATE UNIQUE INDEX idx_folders_group_name ON folders (group_id, parent_id, name)
+    WHERE group_id IS NOT NULL AND parent_id IS NOT NULL;
+-- Auf oberster Ebene ist parent_id NULL, das braucht einen eigenen Index.
+CREATE UNIQUE INDEX idx_folders_group_root_name ON folders (group_id, name)
+    WHERE group_id IS NOT NULL AND parent_id IS NULL;
+
+CREATE INDEX idx_folders_group ON folders (group_id) WHERE group_id IS NOT NULL;
+CREATE INDEX idx_files_group   ON files   (group_id) WHERE group_id IS NOT NULL;
diff --git a/backend/pkg/db/migrations/000013_search_indexes.down.sql b/backend/pkg/db/migrations/000013_search_indexes.down.sql
new file mode 100644
index 0000000..54e6ef3
--- /dev/null
+++ b/backend/pkg/db/migrations/000013_search_indexes.down.sql
@@ -0,0 +1,5 @@
+DROP INDEX IF EXISTS idx_folders_name_trgm;
+DROP INDEX IF EXISTS idx_files_name_trgm;
+
+-- Die Erweiterung bleibt bewusst stehen: Sie wieder zu entfernen würde alles
+-- mitreißen, was sonst noch auf ihr aufbaut, und sie kostet nichts.
diff --git a/backend/pkg/db/migrations/000013_search_indexes.up.sql b/backend/pkg/db/migrations/000013_search_indexes.up.sql
new file mode 100644
index 0000000..5ee3263
--- /dev/null
+++ b/backend/pkg/db/migrations/000013_search_indexes.up.sql
@@ -0,0 +1,12 @@
+-- Namenssuche über Dateien und Ordner.
+--
+-- pg_trgm statt einer Volltextsuche: Gesucht wird nach Namensteilen
+-- ("rechn" findet "Rechnung_2026.pdf"), und eine Volltextsuche zerlegt in
+-- Wörter, findet also gerade Teilwörter nicht. Volltext über den *Inhalt*
+-- kommt in Phase 6 dazu – das ist eine andere Aufgabe.
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+
+-- GIN mit Trigrammen macht ILIKE '%…%' indizierbar. Ohne den Index läuft jede
+-- Suche als vollständiger Tabellendurchlauf.
+CREATE INDEX idx_files_name_trgm ON files USING gin (name gin_trgm_ops);
+CREATE INDEX idx_folders_name_trgm ON folders USING gin (name gin_trgm_ops);
diff --git a/backend/pkg/db/migrations/000014_document_text.down.sql b/backend/pkg/db/migrations/000014_document_text.down.sql
new file mode 100644
index 0000000..12f1f5f
--- /dev/null
+++ b/backend/pkg/db/migrations/000014_document_text.down.sql
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS ocr_jobs;
+DROP TABLE IF EXISTS file_text;
diff --git a/backend/pkg/db/migrations/000014_document_text.up.sql b/backend/pkg/db/migrations/000014_document_text.up.sql
new file mode 100644
index 0000000..3806075
--- /dev/null
+++ b/backend/pkg/db/migrations/000014_document_text.up.sql
@@ -0,0 +1,63 @@
+-- Volltext über den *Inhalt* – die zweite Hälfte der Suche.
+--
+-- Migration 000013 machte Datei*namen* durchsuchbar. Das reicht, solange
+-- Dateien sprechende Namen haben. Ein Scanner nennt seine Ablage aber
+-- "scan_0042.pdf", und genau die Belege sollen auffindbar werden.
+
+-- ── Der erkannte Text ─────────────────────────────────────────────────────────
+-- Eigene Tabelle statt einer Spalte an files: Der Text ist um Größenordnungen
+-- länger als der Rest der Zeile, und files wird bei jedem Auflisten gelesen.
+-- Postgres lagert lange Werte zwar aus (TOAST), aber die tsvector-Spalte und
+-- ihr GIN-Index gehörten dann trotzdem an eine Tabelle, die ständig in
+-- Bewegung ist.
+CREATE TABLE file_text (
+    file_id    UUID        PRIMARY KEY REFERENCES files(id) ON DELETE CASCADE,
+    content    TEXT        NOT NULL,
+    -- Woher der Text stammt. 'layer' = das PDF hatte bereits eine Textebene
+    -- (pdftotext, verlustfrei); 'ocr' = aus dem Bild erkannt, kann Fehler
+    -- enthalten. Der Unterschied ist für die Fehlersuche wichtig: Findet die
+    -- Suche ein Wort nicht, sagt die Herkunft, ob OCR es verlesen hat.
+    source     TEXT        NOT NULL CHECK (source IN ('layer', 'ocr')),
+    -- Die Sprachen, mit denen erkannt wurde ("deu+eng"). Bei 'layer' leer.
+    lang       TEXT        NOT NULL DEFAULT '',
+    -- Zeichenzahl des Originals vor dem Kürzen – siehe maxTextBytes im Worker.
+    chars      INTEGER     NOT NULL DEFAULT 0,
+    pages      INTEGER     NOT NULL DEFAULT 0,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    -- Berechnete Spalte statt eines Triggers: Sie kann nie mit dem Inhalt
+    -- auseinanderlaufen, weil Postgres sie bei jedem Schreiben selbst füllt.
+    --
+    -- 'german' fest verdrahtet, nicht 'simple': Ohne Stammformen fände
+    -- "Rechnung" die "Rechnungen" nicht. Deutsch ist die Sprache der Belege,
+    -- um die es hier geht; englische Wörter darin verlieren nur ihre
+    -- Stammformbildung, sie bleiben wörtlich auffindbar. Eine Änderung wäre
+    -- eine Migration – der Preis dafür, dass der Ausdruck IMMUTABLE sein muss.
+    tsv tsvector GENERATED ALWAYS AS (to_tsvector('german', content)) STORED
+);
+
+CREATE INDEX idx_file_text_tsv ON file_text USING gin (tsv);
+
+-- ── Die Warteschlange ─────────────────────────────────────────────────────────
+-- Warum eine Tabelle und nicht einfach ein Goroutine-Aufruf wie bei den
+-- Vorschaubildern: OCR dauert Sekunden bis Minuten. Startet der Server in
+-- dieser Zeit neu – Update, Absturz, Neustart des Wirts –, ist ein Auftrag im
+-- Speicher verloren, und die Datei bleibt für immer unauffindbar, ohne dass es
+-- jemand merkt. Bei einem Vorschaubild fällt das auf; bei fehlendem Text nicht.
+CREATE TABLE ocr_jobs (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    -- Ein Auftrag je Datei. Wird dieselbe Datei erneut hochgeladen, ersetzt der
+    -- neue Auftrag den alten (ON CONFLICT), statt sich daneben zu stapeln.
+    file_id    UUID        NOT NULL UNIQUE REFERENCES files(id) ON DELETE CASCADE,
+    status     TEXT        NOT NULL DEFAULT 'pending'
+                           CHECK (status IN ('pending', 'running', 'done', 'failed')),
+    attempts   INTEGER     NOT NULL DEFAULT 0,
+    last_error TEXT        NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Der Arbeiter fragt nur nach offenen Aufträgen. Ein Teilindex bleibt klein,
+-- auch wenn sich zehntausend erledigte Zeilen ansammeln.
+CREATE INDEX idx_ocr_jobs_pending ON ocr_jobs(created_at)
+    WHERE status IN ('pending', 'running');
diff --git a/backend/pkg/db/migrations/000015_tags.down.sql b/backend/pkg/db/migrations/000015_tags.down.sql
new file mode 100644
index 0000000..812a011
--- /dev/null
+++ b/backend/pkg/db/migrations/000015_tags.down.sql
@@ -0,0 +1,4 @@
+DROP INDEX IF EXISTS idx_files_document_date;
+ALTER TABLE files DROP COLUMN IF EXISTS document_date;
+DROP TABLE IF EXISTS file_tags;
+DROP TABLE IF EXISTS tags;
diff --git a/backend/pkg/db/migrations/000015_tags.up.sql b/backend/pkg/db/migrations/000015_tags.up.sql
new file mode 100644
index 0000000..7c53d62
--- /dev/null
+++ b/backend/pkg/db/migrations/000015_tags.up.sql
@@ -0,0 +1,75 @@
+-- Etiketten für Dateien.
+--
+-- Warum neben Ordnern und Volltext noch ein drittes Ordnungsmittel: Ordner
+-- beantworten „wann" (Rechnungen/2026), der Volltext beantwortet „wo steht
+-- dieses Wort". Beides beantwortet **nicht**, wofür ein Beleg gebraucht wird –
+-- „absetzbar" steht in keiner Rechnung, das ist eine Einschätzung des Menschen.
+--
+-- Und der Fall, an dem Ordner scheitern: Der Kaufbeleg eines Notebooks ist
+-- zugleich Garantienachweis *und* absetzbar. In einen Ordner passt er nur
+-- einmal; Etiketten trägt dieselbe Datei beliebig viele.
+
+-- ── Die Etiketten selbst ─────────────────────────────────────────────────────
+-- Prinzipal-Modell wie bei files und folders: Ein Etikett gehört entweder einem
+-- Konto oder einer Gruppe, nie beidem und nie keinem.
+--
+-- Der Grund für die Gruppenvariante: In einem Gruppenordner arbeiten mehrere an
+-- denselben Dokumenten. Hätte dort jeder seine eigenen Etiketten, sortierte
+-- jeder dieselben Dateien für sich neu ein und niemand sähe die Arbeit des
+-- anderen – der Sinn eines geteilten Ordners wäre dahin.
+CREATE TABLE tags (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    owner_id   UUID        REFERENCES users(id)  ON DELETE CASCADE,
+    group_id   UUID        REFERENCES groups(id) ON DELETE CASCADE,
+    name       TEXT        NOT NULL,
+    -- Hex-Farbe für den Aufkleber. Leer heißt: die Oberfläche wählt eine aus
+    -- dem Namen, damit ein neues Etikett nicht erst eingefärbt werden muss.
+    color      TEXT        NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    CONSTRAINT tags_one_principal CHECK (
+        (owner_id IS NOT NULL AND group_id IS NULL) OR
+        (owner_id IS NULL AND group_id IS NOT NULL)
+    ),
+    CONSTRAINT tags_name_not_empty CHECK (length(btrim(name)) > 0)
+);
+
+-- Namen sind je Prinzipal eindeutig, und zwar **ohne Rücksicht auf
+-- Groß-/Kleinschreibung**. Sonst stehen nach drei Monaten "Stadtwerke",
+-- "stadtwerke" und "STADTWERKE" nebeneinander – genau der Zerfall, den
+-- Etiketten gegenüber freien Ordnernamen verhindern sollen.
+CREATE UNIQUE INDEX idx_tags_owner_name ON tags (owner_id, lower(btrim(name)))
+    WHERE owner_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_tags_group_name ON tags (group_id, lower(btrim(name)))
+    WHERE group_id IS NOT NULL;
+
+-- ── Die Zuordnung ────────────────────────────────────────────────────────────
+-- Eine reine Verknüpfungstabelle. Nichts davon wird in die Datei geschrieben:
+-- Das Dokument bleibt Byte für Byte, wie es hochgeladen wurde – dieselbe Regel
+-- wie beim erkannten Text (siehe internal/documents).
+CREATE TABLE file_tags (
+    file_id    UUID        NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+    tag_id     UUID        NOT NULL REFERENCES tags(id)  ON DELETE CASCADE,
+    -- Wer es angehängt hat. In einem Gruppenordner sonst nicht nachvollziehbar.
+    tagged_by  UUID        REFERENCES users(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (file_id, tag_id)
+);
+
+-- Der Primärschlüssel deckt die Richtung Datei → Etiketten ab. Die andere
+-- Richtung – „zeig mir alles mit steuer-2026" – ist genau die Abfrage, für die
+-- Etiketten gebaut werden, und braucht ihren eigenen Index.
+CREATE INDEX idx_file_tags_tag ON file_tags (tag_id);
+
+-- ── Belegdatum ───────────────────────────────────────────────────────────────
+-- Das Datum, das auf dem Dokument steht – nicht das des Uploads.
+--
+-- Für beide Zwecke entscheidend: Die Garantiefrist läuft ab dem **Kauf**, und in
+-- die Steuererklärung 2026 gehört, was 2026 gekauft wurde – auch wenn der Beleg
+-- erst im März 2027 eingescannt wird. created_at wäre für beides das falsche
+-- Datum, und zwar unauffällig falsch.
+--
+-- NULL heißt schlicht „nicht gesetzt": Bei einem Urlaubsfoto gibt es kein
+-- Belegdatum, und ein Vorgabewert wäre eine Behauptung.
+ALTER TABLE files ADD COLUMN document_date DATE;
+CREATE INDEX idx_files_document_date ON files (document_date) WHERE document_date IS NOT NULL;
diff --git a/backend/pkg/db/migrations/000016_text_pages.down.sql b/backend/pkg/db/migrations/000016_text_pages.down.sql
new file mode 100644
index 0000000..dcb095f
--- /dev/null
+++ b/backend/pkg/db/migrations/000016_text_pages.down.sql
@@ -0,0 +1 @@
+ALTER TABLE file_text DROP COLUMN IF EXISTS extract_version;
diff --git a/backend/pkg/db/migrations/000016_text_pages.up.sql b/backend/pkg/db/migrations/000016_text_pages.up.sql
new file mode 100644
index 0000000..59db624
--- /dev/null
+++ b/backend/pkg/db/migrations/000016_text_pages.up.sql
@@ -0,0 +1,13 @@
+-- Seitengrenzen im erkannten Text.
+--
+-- Bis hierher ersetzte clean() den Seitenumbruch (\f) durch einen Zeilenumbruch:
+-- Für die Volltextsuche ist er bedeutungslos, ein tsvector kennt keine Seiten.
+-- Für den PDF-Betrachter ist er das Gegenteil von bedeutungslos – bei einem
+-- Scan steht der Text *nur* hier, im PDF selbst liegt bloß ein Bild. Ohne die
+-- Marke lässt sich nicht sagen, auf welcher Seite ein Suchwort steht, und der
+-- Betrachter beginnt bei einem Beleg-Scan wieder stumpf auf Seite 1.
+--
+-- extract_version sagt, nach welcher Regel ein Eintrag entstanden ist. Ältere
+-- Einträge werden beim Start erneut in die Warteschlange gelegt, statt still
+-- ohne Seitenmarken liegen zu bleiben.
+ALTER TABLE file_text ADD COLUMN IF NOT EXISTS extract_version smallint NOT NULL DEFAULT 0;
diff --git a/backend/pkg/db/migrations/000017_correspondents.down.sql b/backend/pkg/db/migrations/000017_correspondents.down.sql
new file mode 100644
index 0000000..af119fa
--- /dev/null
+++ b/backend/pkg/db/migrations/000017_correspondents.down.sql
@@ -0,0 +1,3 @@
+DROP INDEX IF EXISTS idx_files_correspondent;
+ALTER TABLE files DROP COLUMN IF EXISTS correspondent_id;
+DROP TABLE IF EXISTS correspondents;
diff --git a/backend/pkg/db/migrations/000017_correspondents.up.sql b/backend/pkg/db/migrations/000017_correspondents.up.sql
new file mode 100644
index 0000000..1580cda
--- /dev/null
+++ b/backend/pkg/db/migrations/000017_correspondents.up.sql
@@ -0,0 +1,52 @@
+-- Absender („Korrespondent") an Dateien.
+--
+-- Warum neben Etiketten noch ein Feld: Es sind **zwei verschiedene Fragen**.
+-- Ein Etikett sagt, *wofür* ein Dokument gebraucht wird („absetzbar",
+-- „garantie") – davon trägt eine Datei beliebig viele. Der Absender sagt, *von
+-- wem* es kommt („Stadtwerke", „Finanzamt") – davon hat eine Datei genau einen.
+--
+-- Als Etikett gelöst stünden beide in derselben Liste: „Stadtwerke" neben
+-- „absetzbar", Absender und Verwendungszweck durcheinander. Bei zwanzig
+-- Etiketten fällt das nicht auf, bei achtzig ist die Liste unbenutzbar. Und
+-- „alle Rechnungen von X" ließe sich nicht von „alles Absetzbare" trennen –
+-- genau die Verknüpfung, für die es gebaut wird.
+--
+-- Die Eins-Regel ist dabei kein Mangel, sondern der Zweck: Sie erzwingt eine
+-- Entscheidung und hält die Liste kurz.
+
+CREATE TABLE correspondents (
+    id         UUID        PRIMARY KEY DEFAULT gen_random_uuid(),
+    -- Prinzipal-Modell wie bei tags: entweder ein Konto oder eine Gruppe.
+    -- In einem Gruppenordner müssen alle dieselben Absender sehen, sonst
+    -- sortiert jeder dieselben Dokumente für sich neu ein.
+    owner_id   UUID        REFERENCES users(id)  ON DELETE CASCADE,
+    group_id   UUID        REFERENCES groups(id) ON DELETE CASCADE,
+    name       TEXT        NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    CONSTRAINT correspondents_one_principal CHECK (
+        (owner_id IS NOT NULL AND group_id IS NULL) OR
+        (owner_id IS NULL AND group_id IS NOT NULL)
+    ),
+    CONSTRAINT correspondents_name_not_empty CHECK (length(btrim(name)) > 0)
+);
+
+-- Eindeutig je Prinzipal, ohne Rücksicht auf Groß-/Kleinschreibung – dieselbe
+-- Regel wie bei Etiketten. Hier wiegt sie schwerer: „Amazon" und „amazon"
+-- nebeneinander hieße, dass „alle Rechnungen von Amazon" nur die Hälfte
+-- findet, und zwar unauffällig.
+CREATE UNIQUE INDEX idx_correspondents_owner_name
+    ON correspondents (owner_id, lower(btrim(name))) WHERE owner_id IS NOT NULL;
+CREATE UNIQUE INDEX idx_correspondents_group_name
+    ON correspondents (group_id, lower(btrim(name))) WHERE group_id IS NOT NULL;
+
+-- Am Datei-Datensatz, nicht in einer Verknüpfungstabelle: Genau einer je
+-- Datei – das steht damit im Schema und nicht bloß in einer Zusicherung des
+-- Codes.
+--
+-- ON DELETE SET NULL statt CASCADE: Wer einen Absender löscht, will ihn aus
+-- der Liste haben – nicht seine Rechnungen.
+ALTER TABLE files ADD COLUMN correspondent_id UUID REFERENCES correspondents(id) ON DELETE SET NULL;
+
+-- „Alles von Stadtwerke" ist die Abfrage, für die das Feld gebaut wird.
+CREATE INDEX idx_files_correspondent ON files (correspondent_id) WHERE correspondent_id IS NOT NULL;
diff --git a/backend/pkg/db/migrations/000018_tag_icons.down.sql b/backend/pkg/db/migrations/000018_tag_icons.down.sql
new file mode 100644
index 0000000..813c620
--- /dev/null
+++ b/backend/pkg/db/migrations/000018_tag_icons.down.sql
@@ -0,0 +1,2 @@
+ALTER TABLE tags           DROP COLUMN IF EXISTS icon;
+ALTER TABLE correspondents DROP COLUMN IF EXISTS icon;
diff --git a/backend/pkg/db/migrations/000018_tag_icons.up.sql b/backend/pkg/db/migrations/000018_tag_icons.up.sql
new file mode 100644
index 0000000..906936d
--- /dev/null
+++ b/backend/pkg/db/migrations/000018_tag_icons.up.sql
@@ -0,0 +1,15 @@
+-- Ein Symbol je Etikett und je Absender.
+--
+-- Die Farbe allein trägt nicht weit genug: Sie unterscheidet zuverlässig etwa
+-- fünf Einträge. Danach fragt man sich, ob Blau nun „Uni" oder „Versicherung"
+-- war. Ein Emoji ist sofort erkennbar, braucht keine Legende und ist in jeder
+-- Schrift schon da – kein Symbolsatz, keine Grafikdateien, keine zusätzliche
+-- Ladezeit.
+--
+-- Leer heißt „keins": Die Farbe bleibt der Rückfall, niemand muss ein Symbol
+-- wählen. Ein Vorgabe-Emoji wäre eine Behauptung über den Inhalt.
+--
+-- TEXT statt eines einzelnen Zeichens: Ein Emoji ist selten ein Codepunkt.
+-- 👨‍🎓 sind fünf, 🏳️‍🌈 vier – ein CHAR(1) hätte sie zerschnitten.
+ALTER TABLE tags           ADD COLUMN IF NOT EXISTS icon TEXT NOT NULL DEFAULT '';
+ALTER TABLE correspondents ADD COLUMN IF NOT EXISTS icon TEXT NOT NULL DEFAULT '';
diff --git a/backend/pkg/middleware/failurelimit.go b/backend/pkg/middleware/failurelimit.go
new file mode 100644
index 0000000..b92eb67
--- /dev/null
+++ b/backend/pkg/middleware/failurelimit.go
@@ -0,0 +1,102 @@
+package middleware
+
+import (
+	"sync"
+	"time"
+)
+
+// FailureLimiter throttles repeated authentication failures per key (usually a
+// client IP).
+//
+// Deliberately not a request limiter: a WebDAV sync client legitimately sends
+// hundreds of requests per minute, so capping requests would break normal use.
+// Only failed logins count, and a single success clears the record — which
+// leaves honest clients untouched while a password guesser runs out of tries.
+type FailureLimiter struct {
+	mu      sync.Mutex
+	entries map[string]*failureEntry
+
+	maxFailures int
+	window      time.Duration
+	lockout     time.Duration
+	lastSweep   time.Time
+}
+
+type failureEntry struct {
+	count       int
+	windowStart time.Time
+	lockedUntil time.Time
+}
+
+// NewFailureLimiter allows maxFailures within window; exceeding that locks the
+// key out for lockout.
+func NewFailureLimiter(maxFailures int, window, lockout time.Duration) *FailureLimiter {
+	return &FailureLimiter{
+		entries:     make(map[string]*failureEntry),
+		maxFailures: maxFailures,
+		window:      window,
+		lockout:     lockout,
+		lastSweep:   time.Now(),
+	}
+}
+
+// Allowed reports whether the key may attempt authentication. The second return
+// value is how long the caller must wait, for a Retry-After header.
+func (l *FailureLimiter) Allowed(key string) (bool, time.Duration) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	e, ok := l.entries[key]
+	if !ok {
+		return true, 0
+	}
+	now := time.Now()
+	if now.Before(e.lockedUntil) {
+		return false, e.lockedUntil.Sub(now)
+	}
+	return true, 0
+}
+
+// Fail records a failed attempt and locks the key out once the limit is hit.
+func (l *FailureLimiter) Fail(key string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	now := time.Now()
+	l.sweepLocked(now)
+
+	e, ok := l.entries[key]
+	if !ok || now.Sub(e.windowStart) > l.window {
+		l.entries[key] = &failureEntry{count: 1, windowStart: now}
+		return
+	}
+	e.count++
+	if e.count >= l.maxFailures {
+		e.lockedUntil = now.Add(l.lockout)
+		// Restart the window so the lockout does not extend forever on the
+		// retries that arrive while it is already active.
+		e.count = 0
+		e.windowStart = now
+	}
+}
+
+// Reset clears the record after a successful authentication.
+func (l *FailureLimiter) Reset(key string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	delete(l.entries, key)
+}
+
+// sweepLocked drops stale records so the map cannot grow without bound from
+// one-off failures across many addresses. Caller must hold the mutex.
+func (l *FailureLimiter) sweepLocked(now time.Time) {
+	if now.Sub(l.lastSweep) < l.window {
+		return
+	}
+	l.lastSweep = now
+	for k, e := range l.entries {
+		if now.After(e.lockedUntil) && now.Sub(e.windowStart) > l.window {
+			delete(l.entries, k)
+		}
+	}
+}
diff --git a/backend/pkg/middleware/failurelimit_test.go b/backend/pkg/middleware/failurelimit_test.go
new file mode 100644
index 0000000..f2d999d
--- /dev/null
+++ b/backend/pkg/middleware/failurelimit_test.go
@@ -0,0 +1,63 @@
+package middleware
+
+import (
+	"testing"
+	"time"
+)
+
+func TestFailureLimiterLocksOutAfterLimit(t *testing.T) {
+	l := NewFailureLimiter(3, time.Minute, time.Minute)
+
+	for i := 0; i < 2; i++ {
+		l.Fail("10.0.0.1")
+		if allowed, _ := l.Allowed("10.0.0.1"); !allowed {
+			t.Fatalf("locked out after %d of 3 failures", i+1)
+		}
+	}
+
+	l.Fail("10.0.0.1")
+	allowed, retryAfter := l.Allowed("10.0.0.1")
+	if allowed {
+		t.Fatal("still allowed after reaching the failure limit")
+	}
+	if retryAfter <= 0 {
+		t.Fatalf("retryAfter = %v, want positive so Retry-After is usable", retryAfter)
+	}
+}
+
+// Ein Sync-Client darf nicht unter fremden Fehlversuchen leiden: Erfolg räumt
+// den Zähler weg.
+func TestFailureLimiterResetOnSuccess(t *testing.T) {
+	l := NewFailureLimiter(2, time.Minute, time.Minute)
+
+	l.Fail("10.0.0.2")
+	l.Reset("10.0.0.2")
+	l.Fail("10.0.0.2")
+
+	if allowed, _ := l.Allowed("10.0.0.2"); !allowed {
+		t.Fatal("locked out although a success cleared the earlier failure")
+	}
+}
+
+func TestFailureLimiterIsolatesKeys(t *testing.T) {
+	l := NewFailureLimiter(1, time.Minute, time.Minute)
+	l.Fail("10.0.0.3")
+
+	if allowed, _ := l.Allowed("10.0.0.4"); !allowed {
+		t.Fatal("a different address was locked out")
+	}
+}
+
+// Nach Ablauf des Fensters zählt der Versuch nicht mehr mit – sonst summierten
+// sich Vertipper über Wochen zu einer Sperre.
+func TestFailureLimiterWindowExpires(t *testing.T) {
+	l := NewFailureLimiter(2, 10*time.Millisecond, time.Minute)
+
+	l.Fail("10.0.0.5")
+	time.Sleep(20 * time.Millisecond)
+	l.Fail("10.0.0.5")
+
+	if allowed, _ := l.Allowed("10.0.0.5"); !allowed {
+		t.Fatal("locked out although the first failure was outside the window")
+	}
+}
diff --git a/backend/pkg/middleware/logger.go b/backend/pkg/middleware/logger.go
new file mode 100644
index 0000000..6138b99
--- /dev/null
+++ b/backend/pkg/middleware/logger.go
@@ -0,0 +1,43 @@
+package middleware
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+)
+
+func Logger(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+		ww := &responseWriter{ResponseWriter: w, status: http.StatusOK}
+
+		next.ServeHTTP(ww, r)
+
+		level := zerolog.InfoLevel
+		if ww.status >= 500 {
+			level = zerolog.ErrorLevel
+		} else if ww.status >= 400 {
+			level = zerolog.WarnLevel
+		}
+
+		log.WithLevel(level).
+			Str("method", r.Method).
+			Str("path", r.URL.Path).
+			Int("status", ww.status).
+			Dur("duration", time.Since(start)).
+			Str("ip", r.RemoteAddr).
+			Msg("")
+	})
+}
+
+type responseWriter struct {
+	http.ResponseWriter
+	status int
+}
+
+func (rw *responseWriter) WriteHeader(status int) {
+	rw.status = status
+	rw.ResponseWriter.WriteHeader(status)
+}
diff --git a/backend/pkg/middleware/proxy.go b/backend/pkg/middleware/proxy.go
new file mode 100644
index 0000000..f093dc6
--- /dev/null
+++ b/backend/pkg/middleware/proxy.go
@@ -0,0 +1,75 @@
+package middleware
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"strings"
+
+	"aether/pkg/config"
+)
+
+type contextKey int
+
+const (
+	keyRealIP  contextKey = iota
+	keyIsHTTPS contextKey = iota
+)
+
+// RealIP returns the real client IP stored in context by TrustedProxy middleware.
+// Falls back to r.RemoteAddr if the middleware was not applied.
+func RealIP(r *http.Request) string {
+	if ip, ok := r.Context().Value(keyRealIP).(string); ok && ip != "" {
+		return ip
+	}
+	host, _, err := net.SplitHostPort(r.RemoteAddr)
+	if err != nil {
+		return r.RemoteAddr
+	}
+	return host
+}
+
+// IsHTTPS reports whether the original client connection was HTTPS,
+// either directly or via a trusted proxy's X-Forwarded-Proto header.
+func IsHTTPS(r *http.Request) bool {
+	if v, ok := r.Context().Value(keyIsHTTPS).(bool); ok {
+		return v
+	}
+	return r.TLS != nil
+}
+
+// TrustedProxy extracts the real client IP and protocol from X-Forwarded-*
+// headers, but only when the immediate peer is in the trusted proxy list.
+// Untrusted peers never override RemoteAddr.
+func TrustedProxy(cfg *config.Config) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			remoteHost, _, err := net.SplitHostPort(r.RemoteAddr)
+			if err != nil {
+				remoteHost = r.RemoteAddr
+			}
+			peerIP := net.ParseIP(remoteHost)
+
+			realIP := remoteHost
+			isHTTPS := r.TLS != nil
+
+			if peerIP != nil && cfg.IsTrustedProxy(peerIP) {
+				if xfp := r.Header.Get("X-Forwarded-Proto"); xfp != "" {
+					isHTTPS = strings.EqualFold(strings.TrimSpace(xfp), "https")
+				}
+				// X-Forwarded-For may be a comma-separated chain; the leftmost
+				// entry is the original client (set by the first proxy).
+				if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
+					parts := strings.SplitN(xff, ",", 2)
+					if candidate := strings.TrimSpace(parts[0]); candidate != "" {
+						realIP = candidate
+					}
+				}
+			}
+
+			ctx := context.WithValue(r.Context(), keyRealIP, realIP)
+			ctx = context.WithValue(ctx, keyIsHTTPS, isHTTPS)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
diff --git a/backend/pkg/middleware/security.go b/backend/pkg/middleware/security.go
new file mode 100644
index 0000000..8c83521
--- /dev/null
+++ b/backend/pkg/middleware/security.go
@@ -0,0 +1,55 @@
+package middleware
+
+import (
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// SecurityHeaders adds security headers that the app controls.
+// HSTS is intentionally omitted — it belongs on the edge reverse proxy.
+//
+// frameSrc nennt zusätzliche Ursprünge, die in einem Rahmen erscheinen dürfen.
+// Gebraucht für den Office-Server: Seine Bedienoberfläche läuft in einem
+// <iframe>, und `default-src 'self'` deckt auch `frame-src` ab – ohne
+// Ausnahme blockt der Browser sie, noch bevor eine Anfrage hinausgeht.
+// Gemessen als „Framing 'http://…:9980/' violates … default-src 'self'".
+//
+// Bewusst **nur der eine konfigurierte Ursprung** und kein Platzhalter: Die
+// Ausnahme soll so schmal sein wie der Anlass.
+func SecurityHeaders(frameSrc ...string) func(http.Handler) http.Handler {
+	frame := "frame-src 'self'"
+	for _, raw := range frameSrc {
+		if origin := originOf(raw); origin != "" {
+			frame += " " + origin
+		}
+	}
+	csp := "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; " +
+		"img-src 'self' data: blob:; " + frame
+
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			h := w.Header()
+			h.Set("X-Content-Type-Options", "nosniff")
+			h.Set("X-Frame-Options", "DENY")
+			h.Set("Referrer-Policy", "strict-origin-when-cross-origin")
+			h.Set("Content-Security-Policy", csp)
+			next.ServeHTTP(w, r)
+		})
+	}
+}
+
+// originOf reduziert eine Adresse auf Schema und Host. Ein Pfad in einer
+// CSP-Quelle wäre nicht falsch, aber enger als gemeint – und ein Tippfehler
+// darin fiele erst auf, wenn der Rahmen leer bleibt.
+func originOf(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	u, err := url.Parse(raw)
+	if err != nil || u.Scheme == "" || u.Host == "" {
+		return ""
+	}
+	return u.Scheme + "://" + u.Host
+}
diff --git a/backend/pkg/response/response.go b/backend/pkg/response/response.go
new file mode 100644
index 0000000..64099fc
--- /dev/null
+++ b/backend/pkg/response/response.go
@@ -0,0 +1,27 @@
+package response
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+type envelope struct {
+	Data  any    `json:"data,omitempty"`
+	Error string `json:"error,omitempty"`
+}
+
+func JSON(w http.ResponseWriter, status int, data any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(envelope{Data: data})
+}
+
+func Error(w http.ResponseWriter, status int, msg string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(envelope{Error: msg})
+}
+
+func NoContent(w http.ResponseWriter) {
+	w.WriteHeader(http.StatusNoContent)
+}
diff --git a/cloud-projekt-plan.md b/cloud-projekt-plan.md
new file mode 100644
index 0000000..83f9220
--- /dev/null
+++ b/cloud-projekt-plan.md
@@ -0,0 +1,596 @@
+# Eigene Cloud – Projektplan & Claude-Code-Prompt
+
+> Self-hosted Cloud-Lösung als schlanke, schnelle Alternative zu Nextcloud.
+> Ziel: schnell, modular, gut wartbar, **nicht** plugin-abhängig, **nicht** überladen.
+
+---
+
+## 1. Tech-Stack (Entscheidung & Begründung)
+
+| Schicht | Wahl | Warum |
+|---|---|---|
+| Backend | **Go** (`net/http` + `chi` Router) | Einzelnes Binary, top File-Throughput, fertige Libs für WebDAV & OIDC, löst das „langsam wie Nextcloud (PHP)"-Problem |
+| Frontend | **React + TypeScript + Vite**, als **PWA** | Modern, riesiges Ökosystem, Claude Code ist darin sehr stark; PWA ersetzt Flutter für Mobile |
+| DB (Metadaten) | **PostgreSQL** | Robust, Volltextsuche eingebaut (`tsvector`), gute Migrations |
+| Blob-Storage | **Lokales FS** über Storage-Abstraktion | Später ohne Umbau auf S3 umstellbar |
+| Suche | Start: **Postgres FTS** → optional **Meilisearch** | Erst keine Extra-Dependency; bei Bedarf upgraden |
+| WebDAV | `golang.org/x/net/webdav` | Standard-Bibliothek, an Storage + Auth angebunden |
+| OIDC | `coreos/go-oidc` + `golang.org/x/oauth2` | Lokaler Login **und** OIDC parallel |
+| Office | **WOPI-Host** im Backend → Collabora **oder** OnlyOffice als Provider (per Config) | NICHT selbst bauen. Beide sprechen WOPI → ein Adapter, Provider per `.env` umschaltbar |
+| PDF-Anzeige | **PDF.js** (Frontend) | Standard |
+| OCR | **ocrmypdf** / Tesseract (Worker-Job) | Für gescannte PDFs durchsuchbar machen |
+| Reverse Proxy / TLS | **Eigener Reverse Proxy** (Traefik/nginx/Cloudflare …); App lauscht intern auf HTTP | TLS terminiert extern. Das Projekt liefert **keinen** Proxy mit (23.08.2026, Entscheidung von Marc – er baut ihn selbst) |
+| Jobs | In-Process Worker-Queue (z. B. `asynq` mit Redis, oder simpler Channel-Worker) | OCR, Thumbnails, Indexierung asynchron |
+| Deployment | **Docker Compose**, Multi-Stage-Build | Wie geplant |
+
+**Alternative (nur falls EINE Sprache gewünscht):** Full-TypeScript-Monorepo
+(Backend: Fastify oder Hono; Frontend: React). Vorteil: geteilte Typen. Nachteil: schwereres Runtime.
+→ Empfehlung bleibt Go-Backend + React/TS-Frontend.
+
+### Office-Entscheidung (Stand Juni 2026)
+
+**Beide unterstützen** – die Cloud ist ein **WOPI-Host**, dahinter wahlweise Collabora oder OnlyOffice (per `.env`).
+
+- **OnlyOffice** = beste Round-Trip-Treue für MS-Office-Dateien (nativ OOXML). Ideal, wenn man .docx/.xlsx aktiv zwischen Desktop-MS-Office und Web bearbeitet. Gegenargument (russische Code-Herkunft) wiegt bei einer privaten, nicht öffentlichen Instanz gering.
+- **Collabora** = LibreOffice-Engine (nativ ODF), europäisch, unabhängig. Solide, aber minimal höheres Risiko für Layout-Drift bei sehr komplexen OOXML-Dokumenten.
+- **Euro-Office** = junger OnlyOffice-Fork (Nextcloud/IONOS), laut Analyse Juni 2026 noch ~98 % OnlyOffice-/russischer Code. Beobachten, später via gleicher WOPI-Integration nutzbar.
+
+**Architektur:** internes `OfficeProvider`-Interface; primäre Implementierung ist der WOPI-Host (deckt Collabora + OnlyOffice ab). `.env`: `OFFICE_PROVIDER=collabora|onlyoffice` + Server-URL. Empfehlung: **einen** Server aktiv laufen lassen (beide sind ressourcenhungrig), Wechsel = Neustart. Optionaler nativer OnlyOffice-Adapter nur, falls WOPI-Treue mal nicht reicht.
+
+---
+
+## 2. Architektur-Prinzipien
+
+- **Modularer Monolith**, keine Microservices. Klare Domänen-Pakete:
+  `auth`, `storage`, `files`, `sharing`, `documents` (PDF/Paperless), `admin`, `groups`, `webdav`.
+- **Storage-Abstraktion**: ein `Storage`-Interface (`Put/Get/Delete/Stat/List`), Implementierung `LocalFS` jetzt, `S3` später.
+- **API**: REST + JSON für die SPA. WebDAV als eigener, abgegrenzter Endpunkt.
+- **Auth**: lokale Accounts (Username + Argon2id-Hashing) **und** OIDC parallel; **Session-Cookies** (httpOnly, Secure, SameSite) — Entscheidung getroffen, keine JWTs.
+- **Keine E-Mail-Adressen.** Persönliche, nicht öffentliche Cloud → kein E-Mail-Feld, keine E-Mail-Verifizierung, kein Passwort-Reset per Mail. Passwort-Reset läuft ausschließlich über den Admin.
+- **Trennung Metadaten vs. Blobs**: Postgres kennt Datei-Metadaten/Rechte; Bytes liegen im Storage.
+- **Datenintegrität zuerst**: die App darf eine Datei niemals beschädigen oder unwiederbringlich verlieren. Garantien siehe unten.
+- **Plugin-Strategie**: ERST sauberer Core. Extension-Points (Server-Hooks via Event-Bus + Frontend-Slots) erst definieren, wenn der Core stabil ist. Kernfeatures bleiben erstklassig, nicht als Plugin.
+
+### Datenintegritäts-Garantien (ab Phase 1, nicht verhandelbar)
+
+Wichtige Dateien (Hausarbeiten, Tabellen) dürfen durch die Cloud selbst nicht kaputtgehen. Verbindlich:
+
+- **Atomare Schreibvorgänge.** Nie in-place überschreiben. Immer in Temp-Datei schreiben → `fsync` (Daten auf Platte erzwingen) → atomares `rename` an den Zielpfad. Ein abgebrochener Upload kann nie eine halbe/korrupte Datei hinterlassen.
+- **Prüfsummen (SHA-256).** Beim Upload berechnen und in der DB speichern; beim Download verifizieren. Erkennt stille Korruption (Bit-Rot) sofort statt erst beim Öffnen.
+- **Nie hart löschen / nie blind überschreiben.** „Löschen" = Soft-Delete (Papierkorb). „Speichern" über einen bestehenden Inhalt legt eine neue Version an, die alte bleibt erhalten. Echtes Entfernen der Bytes nur verzögert und kontrolliert per Garbage-Collection.
+- **Konsistenz DB ↔ Storage.** Metadaten erst nach erfolgreichem Blob-Write committen; bei Fehler sauber zurückrollen, keine „verwaisten" oder „halben" Zustände.
+- **Verifizierende Tests.** Crash-/Abbruch-Simulation beim Upload, Checksum-Verifikation, Soft-Delete-Recovery sind Pflicht-Tests.
+
+---
+
+## 3. Datenablage & Deployment
+
+```
+/data
+  /users
+    /{username}
+      /home     # eigentliche Dateien (spiegelt App-Ordnerstruktur)
+      /.trash   # Soft-deleted Dateien ({shortID}_{name})
+      /.versions# Versionierungsblobs ({uuid})
+  /groups       # Gruppenordner (ab Phase 4.5)
+    /{groupID}
+      /home     # geteilte Dateien der Gruppe
+      /.trash
+      /.versions
+  /thumbs       # generierte Vorschauen ({fileID}.jpg)
+  /tmp          # Upload-Staging (temp → fsync → rename)
+/postgres       # DB-Volume (eigener Container)
+/config
+  .env          # Secrets & Konfiguration
+```
+
+**Hinweis (ab Phase 4.5):** Ein `folder`/`file` gehört entweder einem User (`owner_id`)
+**oder** einer Gruppe (`group_id`) – nie beidem. Storage-Keys folgen entsprechend
+`users/{username}/home/…` bzw. `groups/{groupID}/home/…`. Persönliche Ordner können
+zusätzlich per ACL an andere User/Gruppen freigegeben werden (interne Shares), ohne dass
+die Bytes umziehen – der Empfänger sieht sie virtuell unter „Geteilt mit mir".
+
+`docker-compose.yml` Services:
+1. `app` (Go-Binary, serviert auch das gebaute Frontend; lauscht intern auf HTTP `APP_LISTEN_ADDR`)
+2. `postgres`
+3. *(optional)* `meilisearch`
+4. *(optional)* `onlyoffice` / `collabora`
+5. *(optional)* `redis` (für Job-Queue)
+
+Ein Proxy-Service ist **nicht** dabei und war zuletzt nur auskommentiert
+vorhanden; am 23.08.2026 auf Marcs Wunsch samt `Caddyfile` entfernt.
+
+**Reverse Proxy = extern (Bring Your Own).** TLS wird vom eigenen Proxy (Traefik/nginx/Cloudflare)
+terminiert; die App läuft dahinter auf reinem HTTP. Die App muss proxy-aware sein:
+- `APP_LISTEN_ADDR` – konfigurierbarer Listen-Port
+- `TRUSTED_PROXIES` – nur von diesen IPs/CIDRs werden `X-Forwarded-*`-Header akzeptiert
+- Echte Client-IP für Rate-Limiting über `middleware.RealIP(r)` (nicht die Proxy-IP)
+- `Secure`-Cookie über `middleware.IsHTTPS(r)` (erkennt Forwarded-Proto)
+- `PUBLIC_URL` für OIDC-Redirects, WOPI- und Share-Links
+- HSTS beim Edge-Proxy, CSP in der App
+
+`.env` enthält: DB-Credentials, `SESSION_SECRET`, `APP_LISTEN_ADDR`, `PUBLIC_URL`, `TRUSTED_PROXIES`,
+OIDC-Client-ID/Secret/Issuer, Storage-Pfade, Feature-Flags.
+**Nie** Secrets ins Image bauen – immer über `.env` / Compose-Env.
+
+---
+
+## 4. Feature → Lösung (deine Checkliste)
+
+| Anforderung | Umsetzung |
+|---|---|
+| OIDC-Anbindung | `go-oidc`, parallel zu lokalem Login, Mapping OIDC-Claims → User/Gruppen |
+| WebDAV (erstellen + verbinden) | `x/net/webdav` mit Auth-Middleware + Storage-Adapter; testbar mit `cadaver`/Finder/Windows |
+| Modernes Frontend zum Weiterbauen | React + TS + Vite, klare Komponentenstruktur, Tailwind |
+| Office-Support | Backend als **WOPI-Host**; Collabora **oder** OnlyOffice als Provider, per `.env` wählbar |
+| PDF-Support + Paperless-artig | Eigenes `documents`-Modul: PDF.js-Viewer, OCR-Worker, Volltextsuche, Tags |
+| Sicher + getestet | siehe Abschnitt 6 & 7 |
+| Datenintegrität | Atomare Writes, SHA-256-Prüfsummen, Soft-Delete/Versionierung – Datei geht durch die Cloud nicht kaputt (Abschnitt 2) |
+| Admin-Oberfläche | User anlegen/bearbeiten/löschen **inkl. Passwort zurücksetzen**, Gruppen-Verwaltung, Quotas, Settings |
+| Theming (Admin) | Globales Branding: Logo, Cloud-Name, freie Farbpaletten (main, akzent, …), Styling |
+| Theming (User) | User darf **nur** seine **eigene** Farbpalette für sich wählen – sonst keine Theming-Rechte |
+| Gruppenordner | Geteilte Ordner mit gruppenbasierten ACLs |
+| Plugin-Gedanke | Modularer Monolith + spätere Extension-Points (Abschnitt 2) |
+
+---
+
+## 5. Phasen-Roadmap (MVP → vollständig)
+
+**Phase 0 – Fundament** ✅
+Monorepo (`/backend`, `/frontend`, `/deploy`), Docker Compose, Postgres + Migrations, CI-Skelett, `CLAUDE.md` mit Konventionen, Health-Endpoint.
+
+**Phase 1 – Core (MVP)** ✅
+Lokale Auth (Argon2id, Sessions), Storage-Interface + LocalFS **mit atomaren Schreibvorgängen + SHA-256-Prüfsummen + Soft-Delete**, Datei-CRUD (Upload/Download/Move/Rename/Delete), Ordner, React-Datei-Browser mit Upload-Queue. Datenintegrität ist ab hier Pflicht (siehe Garantien in Abschnitt 2). **Hier stoppen & reviewen.**
+
+**Phase 2 – Dateien fortgeschritten** ✅
+Upload mit Fortschritt + paralleler Queue, Papierkorb (Soft-Delete, voller Pfad), Versionierung (automatisch beim Re-Upload, max. 10 Versionen, Restore), Share-Links (passwortgeschützt, ablaufend, öffentliche Download-Seite), Thumbnails/Vorschauen, Drag & Drop (Dateien in Ordner), Quota-Anzeige in Sidebar, Shared-Links-Übersicht, Ordner umbenennen/löschen (Blob-Kaskade), lesbare Dateipfade auf Disk (`users/{name}/home/…`), `.trash/`-Ordner auf Disk (Blobs wandern beim Löschen/Wiederherstellen mit), Versions-Blobs werden bei Hard-Delete bereinigt.
+
+**Phase 2.5 – Sidebar-Favoriten & Ordner-Features** ✅
+- **Favoriten:** User kann beliebige Ordner als Favorit markieren; erscheinen als eigener Abschnitt „Favoriten" in der Sidebar. Reihenfolge per Drag & Drop änderbar. Auf-/Zugeklappt-Zustand pro Favorit ebenfalls serverseitig in DB gespeichert (`favorites`-Tabelle, ON DELETE CASCADE). Klick navigiert direkt in den Ordner.
+- **Ordner verschieben:** Drag & Drop eines Ordners in einen anderen Ordner (Move-Folder-Endpoint mit Blob-Kaskade analog zu Rename-Folder).
+- **Dateien/Ordner nach oben verschieben:** Kontextmenü „Verschieben nach…" mit Ordner-Picker (Baumansicht) – ermöglicht auch Verschieben zurück in Root oder beliebige andere Ebene, nicht nur Drag & Drop eine Ebene tiefer.
+- **Ordner hochladen:** Upload eines ganzen Verzeichnisses inkl. Unterstruktur (Browser `webkitdirectory`-API); Ordner werden serverseitig rekursiv angelegt, Pfade beibehalten.
+
+**Phase 3 – Admin + Gruppen + Theming** ✅
+Admin-Panel: User anlegen/bearbeiten/löschen inkl. Passwort-Reset; Gruppen-Verwaltung; Quotas; Settings. **Theming Admin:** Cloud-Name, freie Farbpaletten (main/akzent/…), globales Styling. **Theming User:** nur eigene Farbpalette für sich selbst. Profil-Seite für reguläre User (Anzeigename, Passwort ändern, persönliche Farben).
+
+**Phase 4 – WebDAV + OIDC** ✅ (im Test)
+WebDAV-Endpoint (`/dav/`) mit Basic-Auth (seit Phase 4.5/A **nur App-Passwörter**, nicht das Kontopasswort); OIDC-Login parallel zum lokalen (go-oidc + oauth2, Mapping OIDC-Claims → User, Auto-User-Anlage). Manuelle Test-Checkliste: `TESTING.md`.
+
+**Phase 4.5 – Härtung, interne Shares & Gruppenordner** ✅ (im Test)
+Zwischenphase: schließt zugesagte, aber noch offene Funktionen aus Phase 3 + die in Phase 4
+neu entstandenen Lücken (WebDAV). Aufgeteilt in vier Blöcke:
+
+**A) Sicherheits-Härtung (laut Plan „nicht verhandelbar", aber noch offen)**
+- ✅ **Quota-Enforcement:** Vor jedem Upload (normale API **und** WebDAV) `used_bytes + neue Größe ≤ quota_bytes` serverseitig geprüft – `413` über die API, `507` über WebDAV.
+- ✅ **Abgebrochene Uploads:** WebDAV committet einen unvollständigen Upload nicht mehr. Vorher legte ein Abbruch (Kontingent voll oder Verbindung weg) eine abgeschnittene Datei mit passender Prüfsumme an bzw. ein verwaistes Blob ohne DB-Zeile.
+- ✅ **WebDAV-Rate-Limiting:** eigener Fehlversuchszähler pro IP (10 / 15 min → `429` mit `Retry-After`). Bewusst kein Request-Limit: Sync-Clients senden legitim hunderte Requests pro Minute, nur Fehlversuche zählen, ein Erfolg räumt den Zähler weg.
+- ✅ **App-Passwörter:** pro User generierbare, widerrufbare Tokens (`app_passwords`, SHA-256 statt Argon2 – das Token ist serverseitig zufällig, und WebDAV authentifiziert jeden einzelnen Request). Gelten nur für `/dav/`, nie fürs Web-Login – und sind seit dem 22.08.2026 der **einzige** WebDAV-Zugang: Das Kontopasswort wird dort abgelehnt. Begründung: Es ist zugleich der Admin-Zugang, wer es über WebDAV errät, bekommt weit mehr als Dateizugriff; ein Widerruf trifft nur ein Gerät statt alle; und es liegt nicht mehr in fremden Passwortspeichern. Nebeneffekt: 0,5 ms statt 22,7 ms pro Anfrage, weil ein indizierter Lookup den Argon2-Durchlauf ersetzt. Der Realm-Text im `WWW-Authenticate`-Header nennt den Grund, sonst tippt man im Client vergeblich sein Kontopasswort ein.
+- ✅ **Audit-Log:** `audit_log` (Migration 000010) + `internal/audit/`. Protokolliert An-/Abmeldung inkl. Fehlversuchen, Passwortwechsel, App-Passwörter, alle Admin-Aktionen (User, Gruppen, Einstellungen), Freigaben und Löschungen. Admin-UI mit Filter und Blätterfunktion. `actor_id` ist `ON DELETE SET NULL` und der Name denormalisiert – sonst räumte das Löschen eines Kontos genau die Spuren weg, die man danach untersuchen will. Bewusst **nicht** protokolliert: normale Uploads/Downloads (ersäufen sonst das Wesentliche) und das Passwort bei einem Reset.
+- ✅ **Blob-GC:** `internal/gc/` – gleicht den Bestand auf der Platte gegen `files.storage_key` + `file_versions.storage_key` + Thumbnails ab und entfernt, was keine Datenbankzeile mehr kennt. Läuft alle 12 h und von Hand über „Run now" im Admin-Panel; jeder Lauf mit Wirkung landet im Audit-Log. Zwei Schutzmechanismen: 24 h Schonfrist (zwischen `Put` und `INSERT` sieht ein gesunder Upload wie eine Waise aus) und eine Notbremse, die den Lauf abbricht, wenn die Datenbank *keinen einzigen* Blob kennt, obwohl der Speicher voll ist – der Fingerabdruck einer kaputten Abfrage oder falschen Datenbankverbindung.
+- **Versionierung pro Ordner (Idee, später):** Ergänzend zum Datei-Schalter ein `versioning_default` auf `folders` – neue Dateien in diesem Ordner starten mit aktivierter Versionierung. Praktisch für einen Dokumente-Ordner, damit nicht jedes Dokument einzeln angeschaltet werden muss. Bestehende Dateien blieben unberührt (keine rückwirkende Änderung). Bewusst zurückgestellt, um das Datenmodell zunächst einfach zu halten.
+
+**B) Interne Shares (Ordner/Dateien an User oder Gruppe teilen)** ✅ (REST + WebDAV)
+- ✅ `acl_entries` (Migration 000011). **Abweichung von der Skizze oben:** statt polymorpher Spalten vier nullbare Fremdschlüssel mit CHECK-Bedingung. Polymorph kann die Datenbank nichts erzwingen – gelöschte Nutzer oder Ordner hinterließen Einträge, die ins Leere zeigen, und daraus später eine Freigabe für einen neu vergebenen Namen zu machen wäre ein Sicherheitsloch. Mit echten Fremdschlüsseln räumt `ON DELETE CASCADE` das von selbst auf (geprüft: nach dem Löschen zweier Testkonten 0 verwaiste Einträge).
+- ✅ AuthZ pro Request in `internal/acl/`: Zugriff hat der Eigentümer oder wer einen Eintrag besitzt – direkt, über eine Gruppe, oder geerbt von einem Ordner darüber (rekursiv nach oben, nicht nach unten: der Pfad zur Wurzel ist kurz, der Unterbaum kann riesig sein). Mehrere Wege → das stärkere Recht gilt.
+- ✅ Durchgesetzt in allen REST-Handlern für Dateien und Ordner. Die Datenbankschicht bleibt eigentümerbezogen; vorgeschaltet klärt `resolveFile`/`resolveFolder`, **in wessen Namen** die Operation läuft. Kein Zugriff → `404` statt `403`, sonst verriete die Antwort die Existenz der ID.
+- ✅ Frontend: „Share with people…" im Kontextmenü (Person/Gruppe + Recht), Ansicht „Shared with me" mit Herkunftshinweis bei Gruppenfreigaben.
+- ✅ **WebDAV nachgezogen** (`internal/webdav/scope.go`). Der Aufbau bildet die Weboberfläche nach, damit man nicht umdenken muss: **Gruppenordner liegen in der Wurzel** neben den eigenen, **Personen-Freigaben** gebündelt unter `/dav/Shared/<Person>/<Freigabe>/`. `davScope` klärt für jeden Pfad, welcher Prinzipal gilt, ab welchem Ordner die restlichen Pfadteile zählen und ob geschrieben werden darf; `FolderByPathFrom` löst ab diesem Einstiegspunkt auf, sodass alles oberhalb der Freigabe unerreichbar bleibt.
+  - **Namensgleichheit in der Wurzel:** Der eigene Ordner gewinnt, der Gruppenordner bekommt den Gruppennamen angehängt (`Projekt (Buero)`). Nötig, weil WebDAV über Pfade adressiert – zwei gleichnamige Einträge in einem Verzeichnis kann ein Client nicht auseinanderhalten. In der Weboberfläche ist das harmlos, dort führen IDs zum Ziel.
+  - **Personen-Freigaben bleiben nach Person verschachtelt.** Ein flacher Aufbau müsste bei gleichnamigen Freigaben Namen vergeben, die sich ändern, sobald eine weitere dazukommt – und ein Sync-Client, dem sich Pfade unter den Füßen verschieben, lädt alles neu hoch oder löscht es.
+  - `statusWriter` bildet Ablehnungen aus Rechtegründen auf `403` ab. x/net/webdav vergibt sonst pauschal `404` oder `405`, und man sucht den Fehler beim Pfad statt bei seinen Rechten. Nicht Vorhandenes bleibt bewusst `404`.
+  - `/Shared` existiert nur, solange etwas geteilt ist – sonst bliebe bei Clients ein leerer Ordner stehen.
+
+**Festlegungen aus der Umsetzung:**
+- Wer in einen geliehenen Ordner hochlädt, verbraucht das **Kontingent des Eigentümers** – die Bytes liegen in dessen Bereich. Alles andere wäre ein Weg, fremde Kontingente zu umgehen.
+- Ein Unterordner, den ein Empfänger anlegt, gehört dem **Eigentümer des Elternordners**. Sonst hätte der Eigentümer nach Entzug der Freigabe fremde Ordner in seinem Baum.
+- **Weitergeben ist nicht möglich:** nur der Eigentümer erteilt Freigaben. Sonst verlöre er die Kontrolle darüber, wer seine Daten sieht.
+- **Verschieben über Eigentumsgrenzen ist gesperrt** – es würde Bytes zwischen Kontingenten umbuchen und Freigaben unter der Hand umhängen.
+
+**C) Gruppenordner** ✅ (REST + WebDAV)
+- ✅ `folders`/`files` haben `group_id` (XOR mit `owner_id`, per CHECK erzwungen), Migration 000012. Ablage unter `groups/{groupID}/home/…` – auch Papierkorb und Versionen, damit man auf der Platte ansieht, dass die Daten keinem Konto gehören.
+- ✅ **Prinzipal statt Eigentümer:** Die Store-Abfragen prüfen `owner_id = $1 OR group_id = $1`. UUIDs sind global eindeutig, eine Gruppen-ID kann also nie auf ein Konto passen. Dadurch blieben die ~40 Store-Methoden unverändert – nur die WHERE-Klauseln wurden erweitert.
+- ✅ Admin legt den Ordner an (Admin → Groups). Jedes Mitglied sieht ihn in seiner Wurzel; Zugriff = Mitgliedschaft, ein Austritt entzieht ihn im selben Moment.
+- ✅ **Quota: eigene Gruppen-Quota** (`groups.quota_bytes`, Vorgabe 10 GB). Die Alternative „zählt beim Ersteller" wäre für die Mitglieder nicht nachvollziehbar – der Ordner wäre plötzlich voll, weil jemand anders privat etwas hochgeladen hat.
+- ✅ **Der Wurzelordner ist geschützt:** kein Löschen, Umbenennen oder Verschieben durch Mitglieder – serverseitig `403`, im Kontextmenü fehlen die Einträge ganz statt als Knöpfe, die nur eine Fehlermeldung liefern. Entfernt wird er allein im Admin-Bereich. Alles *innerhalb* bleibt normal bedienbar.
+- ✅ **Eine Gruppe hat genau einen Ordner.** Hält das Modell verständlich („der Ordner der Gruppe") und erlaubt es, beim Löschen `groups/<id>` am Stück zu entfernen – sonst blieben leere Verzeichnisse zurück.
+- ✅ Papierkorb: Gelöschte Gruppendateien erscheinen im Papierkorb *jedes* Mitglieds und sind wiederherstellbar. Ohne das wären sie spurlos verschwunden – sie gehören keinem Konto, tauchten also in keinem persönlichen Papierkorb auf.
+
+**D) Theming-Rest** ✅
+- ✅ **App-Symbol-Upload** neben dem Logo (22.08.2026). **Ein** Bild für Tab-Symbol *und* installierte App: Der Server rechnet aus der Vorlage 64, 192, 512 und eine maskable-Fassung (`internal/admin/appicon.go`). Ein zuerst gebauter reiner Favicon-Upload wurde wieder ersetzt – zwei Bilder zu pflegen, die dasselbe zeigen sollen, laufen mit der Zeit auseinander.
+  - **Nie hochskalieren.** Aus einer 256er-Vorlage entsteht kein 512er; das Manifest nennt dann nur die Größen, die es gibt. Ein hochgerechnetes Symbol sähe schlechter aus als gar keins.
+  - **Rahmen statt beschneiden** bei nicht quadratischen Vorlagen. Ein Zuschnitt würde ein Logo anschneiden, und das fällt erst auf, wenn das Symbol überall klebt.
+  - **maskable auf der Primärfarbe**, nicht durchsichtig: Android legt sonst eine weiße Kachel unter das Symbol, die im dunklen App-Menü leuchtet. Motiv auf 80 % – das ist die Schutzzone, die kein Gerät wegschneidet.
+  - Skaliert wird mit `draw.CatmullRom` statt des `BiLinear` aus `internal/thumbnails`: Vorschaubilder dürfen weich sein, ein Symbol soll scharfe Kanten behalten. Ausgabe PNG wegen der Transparenz.
+  - **ICO fällt weg** (der Favicon-Upload nahm es kurzzeitig an): Go bringt keinen Dekodierer mit, und ohne Dekodieren keine Größen. Dafür jetzt WebP – der Dekodierer `x/image/webp` fehlte im Projekt ganz, weshalb auch `internal/thumbnails` für WebP stillschweigend nie ein Vorschaubild erzeugte. Mit behoben.
+- ✅ **Manifest aus der Datenbank** (`internal/admin/manifest_handler.go`, Route `/manifest.webmanifest`). Vorher stand es fest in `vite.config.ts` und zeigte auf drei mitgelieferte Dateien – ein hochgeladenes Symbol konnte die installierte App also nie erreichen. Jetzt folgen Name, Farbe und Symbole dem Admin-Bereich; ohne eigenes Symbol die mitgelieferten als Rückfall. `Cache-Control: no-cache` für die Liste, die Bilder darin cachen weiter eine Woche.
+  - **Grenze, die bleibt:** Chrome baut bei der Installation ein eigenes Paket mit einer Kopie des Symbols und fragt das Manifest nur in Abständen von Tagen nach. Ein Wechsel ist auf dem Startbildschirm frühestens in ein, zwei Tagen zu sehen.
+- ✅ **Symbol-Satz als Verzeichnis** (`branding/icon-<zufall>/`), Schlüssel in `settings.app_icon_storage_key`. Der GC behandelt einen Wert mit `/` am Ende als Präfix und zählt alles darunter als referenziert – sonst hätte er den ganzen Satz nach 24 Stunden gelöscht. Beim Austausch räumt `DeletePrefix` das alte Verzeichnis **samt Ordner** weg: Einzelne Dateien zu löschen ließ bei jedem Wechsel einen leeren Ordner zurück, den der GC nie sieht, weil er nur Dateien betrachtet.
+- ✅ Logo-Upload durch Admin (`internal/admin/branding_handler.go`). Blob unter `branding/logo-<zufall>.<ext>`, Schlüssel in `settings.logo_storage_key` – keine Migration nötig, der Eintrag war seit 000004 vorgesehen.
+- **SVG ist bewusst nicht erlaubt.** Eine SVG-Datei darf Skripte enthalten, und das Logo wird auf der Anmeldeseite ausgeliefert – also dort, wo noch niemand angemeldet ist. Zugelassen sind PNG, JPEG, WebP und GIF, erkannt am Inhalt (`http.DetectContentType`), nicht an Endung oder mitgeschicktem Content-Type. Dazu `X-Content-Type-Options: nosniff` beim Ausliefern.
+- **Zufälliger Namensanteil statt festem Dateinamen:** So ändert sich die Adresse bei jedem Austausch und Browser zeigen sofort das neue Logo, statt tagelang das alte aus dem Zwischenspeicher. Deshalb darf mit `max-age=604800` lange zwischengespeichert werden.
+- Reihenfolge beim Austausch: neues Blob schreiben → Einstellung setzen → erst dann das alte löschen. Andersherum stünde man ohne Logo da, wenn der mittlere Schritt scheitert.
+- Der GC durchsucht `branding/` mit und kennt den Logo-Schlüssel als Referenz – sonst hielte er das Logo für verwaist und löschte es beim nächsten Lauf.
+
+**Phase 5 – UI-Überarbeitung & Design**
+Vollständiger Design-Pass: konsistente Abstände, Icons, Hover-Effekte, Dark/Light-Mode-Toggle.
+- ✅ **Vor/Zurück im Verlauf** (`frontend/src/hooks/useNavHistory.ts`, 22.08.2026). Ansicht und Ordnerkette liegen in `history.pushState`, nicht im Komponenten-State. Damit greifen die Zurück-Taste des Browsers, die Seitentasten der Maus und die Wischgeste – die Anwendung hat kein eigenes Verlaufsmodell daneben, das damit auseinanderlaufen könnte. Die Ordnerkette steckt im State des Eintrags (der Browser bringt ihn beim Neuladen mit, man landet also wieder im selben Ordner); die Adresse trägt nur die Ansicht (`/trash`, `/admin`), weil es keine Abfrage gibt, die zu einer Ordner-ID die Kette darüber liefert – ein Link auf einen tiefen Ordner hätte also keine Brotkrumen. Zweimal derselbe Ort erzeugt bewusst keinen zweiten Eintrag, sonst bräuchte ein Klick auf den Ordner, in dem man schon steht, ein Zurück. **Bedient wird ausschließlich über den Browser** – eigene Vor/Zurück-Knöpfe standen kurzzeitig in der Werkzeugleiste und sind am 23.08.2026 wieder raus: zwei Bedienelemente für dieselbe Sache, von denen eines nur die halbe Wahrheit kennt (ob es vorwärts weitergeht, verrät der Browser einer Seite nicht).
+- ✅ **Namenssuche** (`internal/files/search.go`, Feld in der Werkzeugleiste, 23.08.2026). Trigramm-Index (`pg_trgm`, Migration 000013) statt Volltextsuche: Gesucht wird nach Namens*teilen*, und eine Volltextsuche zerlegt in Wörter – „rechn" fände „Rechnung_2026.pdf" also gerade nicht. Volltext über den *Inhalt* bleibt Phase 6.
+  - **Der Umfang steckt in der Abfrage, nicht im Handler.** Eine Suche, die Treffer nachträglich filtert, ist die Variante, bei der man einen Fall vergisst – und ein vergessener Fall zeigt Dateinamen aus fremden Ordnern. Die Abfrage schneidet deshalb selbst zu: eigenes, Gruppenordner, Freigaben und alles *unterhalb* einer freigegebenen Ordnerfreigabe (rekursive CTE nach unten – die Einzelprüfung in `internal/acl` läuft andersherum nach oben, weil sie nur einen Pfad zur Wurzel braucht).
+  - Mit zwei Wegwerf-Konten geprüft: vor der Freigabe nichts, nach der Freigabe auch die Dateien in Unterordnern, nach dem Entzug sofort wieder nichts; Gruppenordner nur für Mitglieder, nach Austritt weg; Gelöschtes bleibt im Papierkorb und außerhalb der Suche.
+  - **LIKE-Platzhalter werden entschärft.** Ohne das fände die Suche nach `%e` alles mit einem „e" darin.
+  - Zum Index: Bei 20 000 Zeilen wählt Postgres noch den vollständigen Durchlauf (10 ms); erzwungen liegt der Trigramm-Index bei 4 ms. Er zahlt sich also erst bei wachsendem Bestand aus – angelegt ist er trotzdem, weil eine Migration später am vollen Bestand teurer ist.
+- ✅ **Dateivorschau** (`frontend/src/components/FilePreview.tsx`). Doppelklick zeigt Bild, PDF, Text, Video und Ton, statt herunterzuladen; alles andere lädt weiter herunter. Pfeiltasten blättern durch die anzeigbaren Dateien des Ordners.
+  - **`?inline=1` ist die gefährliche Richtung** und deshalb an eine Positivliste gebunden: Eine hochgeladene HTML- oder SVG-Datei liefe sonst im Ursprung der Anwendung und käme an die Sitzung. Was nicht auf der Liste steht, wird weiterhin als Anhang ausgeliefert – still, ohne Fehlermeldung. Dazu `nosniff` und ein `Content-Security-Policy: sandbox` auf der Antwort.
+  - Der PDF-Betrachter ist der eingebaute des Browsers. Ein eigener (PDF.js) käme mit Phase 6.
+  - ✅ **Range-Unterstützung nachgerüstet** (23.08.2026). Ohne `Accept-Ranges` hält der Browser die Antwort für unteilbar und gibt in der Abspielleiste kein Springen frei – Video und Ton ließen sich nur von vorn bis hinten abspielen. Jetzt beantwortet `http.ServeContent` einen `Range`-Kopf mit `206` und dem Ausschnitt. Die Prüfsumme bleibt dabei außen vor: Sie deckt die ganze Datei ab, ein Ausschnitt lässt sich nicht dagegen halten. Beim vollständigen Abruf – also bei jedem echten Download – wird weiter geprüft.
+  - ✅ **Typtabelle nachgerüstet** (`extraMIMETypes`, 23.08.2026). Go liest die MIME-Zuordnung aus `/etc/mime.types` – die Datei gibt es im Alpine-Image nicht, und die eingebaute Ersatztabelle kennt nur Web-Typen. Eine hochgeladene MP3 lag deshalb als `application/octet-stream` in der Datenbank: nicht abspielbar (die Vorschau entscheidet am Typ) und mit dem Symbol für „unbekannt". 94 Bestandsdateien waren betroffen. Statt sie nachträglich umzuschreiben, bestimmt der Download-Handler den Typ aus dem Namen neu, wenn der gespeicherte nichts aussagt – das wirkt sofort und rührt die Daten nicht an. Die Oberfläche zieht den Dateinamen aus demselben Grund mit heran.
+  - ✅ **Cover je Dateiart** (`components/filetypes.ts` + `FileCover.tsx`). Art, Farbe und Symbol werden an *einer* Stelle bestimmt – vorher leitete das jede Komponente selbst aus dem MIME-Typ ab, wobei Symbol und Farbe auseinanderlaufen. Ton, Video, Archiv, Tabelle, Code, Dokument und PDF haben je eigene Farbe, eigenes Symbol und die Endung als Aufkleber; `.tar.gz` wird über den Namen erkannt, weil die zweiteilige Endung sonst als `.gz` durchgeht.
+  - ✅ **Eine Kopfleiste für alle Ansichten** (`components/PageHeader.tsx`, 23.08.2026). Vorher zwei Muster nebeneinander: Dateien, Papierkorb und Freigabe-Links hatten eine feste Leiste, „Geteilt mit mir", Admin und Profil dagegen eine große Überschrift im Scrollbereich – beim Umschalten sprang der Inhalt. Und schon die drei Leisten waren unterschiedlich hoch, weil sich die Höhe aus dem jeweils höchsten Bedienelement ergab (die Dateiansicht hat mit Suchfeld und Auswahlfeld die größten). Jetzt eine **feste Höhe** statt einer gewachsenen: 57 px, Symbol 18, Titel 15/600, Bedienelemente rechts.
+  - ✅ **Office-Formate ergänzt** (23.08.2026): Word, Excel und **PowerPoint** – letzteres fehlte ganz und landete bei „unbekannt". Jede Familie mit eigener Farbe (blau / grün / orangerot) und eigenem Symbol; die OpenDocument-Entsprechungen laufen über dieselben Regeln. Backend-seitig dazu `.ppt`, `.pptx`, `.odp` und `.rtf` in `extraMIMETypes`. `.md` und `.txt` zählen bewusst als Text, nicht als Office-Dokument: Sie sind lesbarer Text und lassen sich hier sogar bearbeiten.
+  - ✅ **PDF-Vorschau tatsächlich zum Laufen gebracht** (23.08.2026). Sie war seit dem Einbau **blockiert**, ohne dass es jemandem auffiel: `pkg/middleware/security.go` setzt `X-Frame-Options: DENY` für alle Antworten – damit darf auch die eigene Anwendung die Datei nicht in einen Rahmen legen. Der Browser meldete „Refused to display … X-Frame-Options to 'deny'" und zeigte einen leeren Rahmen. Auf der Antwort einer Inline-Auslieferung steht jetzt `SAMEORIGIN` plus `frame-ancestors 'self'`; fremde Seiten können die Datei weiterhin nicht einbetten. Dazu `sandbox allow-scripts` **nur für PDF** – der eingebaute Betrachter von Chrome ist selbst ein Skript. Ohne `allow-same-origin` bleibt der Ursprung fremd, die Sitzung also unerreichbar.
+    - **Gefunden, weil ich es angesehen habe.** Der Server lieferte 200 mit korrektem Typ, die Bytes stimmten, Range funktionierte – nach jeder Prüfung per `curl` war alles grün. Erst ein Chromium im Container mit Bildschirmfoto zeigte den leeren Rahmen.
+  - ✅ **Speicherbalken nach der Anmeldung** (23.08.2026): Die Login-Antwort lieferte `used_bytes: 0`, nur `/me` rechnete den Wert aus. Direkt nach dem Anmelden stand der Balken deshalb auf 0 B und sprang erst beim nächsten Abgleich um. Ebenfalls im Bildschirmfoto aufgefallen.
+  - ✅ **`--color-warning` war nie definiert.** Vier Stellen benutzten den Namen – „Verschieben nach…", „Geteilt mit mir", der Admin-Bereich und der Papierkorb – und zeichneten ihre Ordner deshalb **schwarz**. Token nachgetragen und die betroffenen Symbole auf `FolderGlyph` umgestellt.
+  - ✅ **PDF-Symbol unterscheidbar gemacht.** Es teilte sich die Form mit dem Word-Dokument und unterschied sich nur in der Farbe – bei nebeneinanderliegenden Kacheln zu wenig. Ein gefüllter Block statt dünner Zeilen war der erste Versuch – auf Marcs Wunsch wieder zurück auf dieselbe Blattform in Rot: Farbe und Aufkleber trennen die beiden ausreichend. **Beim Zeichnen tatsächlich angesehen** statt geraten: Die Varianten wurden gerendert und verglichen.
+  - ✅ **Brotkrume auf die Schrift der Seitentitel gebracht.** Sie lief über Tailwind-Klassen (`text-sm`, `font-medium` = 14 px / 500), die Titel der anderen Ansichten über 15 px / 600 – nebeneinander sieht man das sofort. Ebenso das Symbol: 18 statt 15 Pixel und gedämpft statt in Textfarbe, wie in den anderen Leisten.
+  - ✅ **„My Files" heißt „Home"** (23.08.2026, Entscheidung von Marc). Die alte Bezeichnung stimmte nicht mehr: Seit dem WebDAV-Abgleich liegen **Gruppenordner in derselben Wurzel** – die gehören nicht dem Anmeldenden. „Home" benennt einen Ort statt Besitz und deckt sich mit dem Speicherpfad (`users/<name>/home`) und der WebDAV-Wurzel. Dazu ein Haus-Symbol in der Brotkrume, wie es die Einträge der Seitenleiste haben.
+  - ✅ **Ordner- und Bildkacheln nachgezogen** (`FolderCover`): Der Ordner ist eine Definition (`FolderGlyph` in `icons.tsx`) für Kachel, Liste und Suchtreffer – vorher lag die Form dreimal im Code. Ganzzahlige Koordinaten auf dem 48er-Raster und eine Anzeigegröße, die ein Vielfaches davon ist: So landet jede Kante auf einem ganzen Pixel statt zwischen zweien, wo die Kantenglättung sie weichzeichnet. Die vordere Lage deckt voll, nur die hintere ist durchscheinend – beide durchscheinend sah auf dem dunklen Grund blass aus. Zweilagig mit Verlauf statt eines flachen Symbols, Gruppenordner tragen die Primärfarbe und einen `GROUP`-Aufkleber. Bilder behalten ihr Vorschaubild und bekommen den Endungs-Aufkleber auf dunklem Grund darüber – einem Vorschaubild sieht man sonst nicht an, ob PNG, JPG oder GIF dahintersteckt.
+  - ✅ **MIME-Typen der Bestandsdateien nachgezogen** (87 Zeilen, 23.08.2026, auf Marcs Wunsch). Ohne Endung bleiben `Dockerfile`, `Caddyfile` und `.gitignore` bewusst `application/octet-stream`.
+  - ✅ **Textdateien bearbeiten** direkt in der Vorschau. Gespeichert wird über denselben Weg wie ein Upload (gleicher Name, gleicher Ordner): Der Server ersetzt die Datei und legt bei eingeschalteter Versionierung die alte Fassung in die Historie. Ein eigener Schreib-Endpunkt bräuchte dieselben Prüfungen – Quota, Freigaberecht, Prüfsumme – ein zweites Mal.
+- ✅ **Sortierung** nach Name, Größe und Datum, je in beide Richtungen. Ordner stehen immer vor Dateien und folgen nur der Namensrichtung – Größe und Datum sagen über einen Ordner in dieser Liste nichts aus. Sortierung und Ansicht liegen im `localStorage`: eine Einstellung, die man bei jedem Besuch neu treffen muss, ist keine.
+- ✅ **Große Dateien aufgeteilt** (23.08.2026). Rein mechanisch, keine Signatur geändert – `go test`, `go vet` und `tsc` vorher wie nachher grün, danach alle Ansichten im Browser durchgeklickt.
+  - Backend, gleiches Paket, also keine Änderung an den Aufrufern: `internal/files/handler.go` 1400 → 744 Zeilen, daneben `handler_folders.go`, `handler_trash.go`, `handler_versions.go`, `handler_favorites.go`; `store.go` 937 → 535, daneben `store_folders.go`, `store_favorites.go`, `store_webdav.go`.
+  - Frontend: `AdminPage.tsx` 1300 → 69 Zeilen (nur noch Reiterleiste), die vier Reiter unter `pages/admin/` mit `ui.tsx` für die geteilten Bausteine; `FileBrowser.tsx` 1123 → 823, Kachel- und Listenansicht in `components/FileViews.tsx`.
+- ✅ **Kopfleiste bis auf den Pixel abgeglichen** (23.08.2026). Der Unterschied war **messbar, nicht nur gefühlt**: Das Symbol saß auf „Home" bei x=246, in allen anderen Ansichten bei x=240 – die 6 px kamen vom Innenrand des Wurzel-Knopfs; und der Titel begann bei 265 statt 268, weil die Brotkrume 7 px Abstand zum Symbol hielt statt 10. Beides mit Chromium ausgemessen statt geschätzt, danach identisch.
+- ✅ **„Admin" aus der Seitenleiste entfernt** (23.08.2026, Wunsch von Marc). Die Leiste zeigt jetzt ausschließlich *Orte, an denen Dateien liegen* – Home, Papierkorb, Geteiltes, Favoriten. Die Verwaltung ist keiner davon; sie steckt im Nutzermenü, wo auch die Einstellungen liegen. Nebenbei fällt damit die einzige Stelle weg, an der ein Eintrag der Leiste je nach Rolle erschien oder nicht.
+- ✅ **Passwortänderung bei OIDC-Konten ausgeblendet** (23.08.2026, Hinweis von Marc). Konten aus dem Identitätsanbieter haben hier kein Passwort (`password = ''`); das Formular konnte nur fehlschlagen – und zwar mit „current password incorrect", was nach einem Tippfehler aussieht statt nach dem wahren Grund. Neues Feld `is_oidc` am Nutzer (aus `oidc_sub`), die Oberfläche zeigt stattdessen einen Hinweis.
+  - **Kein Sicherheitsloch geschlossen, sondern eine Sackgasse beseitigt:** Anmeldung und Passwortänderung scheiterten für solche Konten ohnehin schon daran, dass `''` kein gültiger Argon2-Hash ist. Der Server weist den Aufruf jetzt zusätzlich mit `400` und klarer Begründung ab, statt mit einem irreführenden `401`.
+- ✅ **Reiter „Audit log" heißt „Activity"** (23.08.2026, Wunsch von Marc). Er zeigt nicht mehr nur das Protokoll, sondern davor den Stand der Texterkennung und die Speicherbereinigung – also alles, was im Hintergrund läuft. Die interne Kennung bleibt `audit`: Sie steht in keiner Adresse, ein Umbenennen wäre reine Bewegung.
+- ✅ **Stand der Texterkennung sichtbar** (`pages/admin/AuditTab.tsx`, 23.08.2026). Vorher lieferte `/api/v1/admin/ocr` Zahlen, die niemand sah. Ohne die Anzeige ist nicht zu unterscheiden, ob die Volltextsuche nichts findet oder den Bestand noch gar nicht gelesen hat – und nach dem ersten Start dauert das je nach Menge Stunden.
+  - Steht bei der Speicherbereinigung, weil beides dasselbe Problem hat: ein Vorgang, der unbeobachtbar im Hintergrund läuft, ist schwer zu vertrauen.
+  - **Fragt nur nach, solange sich etwas bewegt.** Steht die Warteschlange still, ändert sich die Zahl erst beim nächsten Upload; jede weitere Anfrage wäre verschenkt.
+  - Ein farbiger Punkt sagt den Zustand ohne Lesen: grün fertig, gelb läuft, gedämpft abgeschaltet.
+- ✅ **Eigener Erkennungsstand für jeden Nutzer** (`GET /api/v1/ocr`, 23.08.2026, auf Marcs Nachfrage). Der Stand war zunächst nur im Admin-Bereich zu sehen – **die falsche Person**: Wissen muss es, wer gerade eine Rechnung hochgeladen hat und sie nicht findet. „Wird noch gelesen" und „ist nicht drin" sehen in einer leeren Trefferliste identisch aus.
+  - Getrennte Abfrage statt derselben mit Filter: Die Gesamtzahl der Dokumente auf dem Server verrät etwas über fremde Bestände und bleibt dem Administrator vorbehalten. Gezählt wird über `owner_id`; Gruppenordner bleiben außen vor, weil ihr Stand keine Auskunft über den eigenen Bestand wäre.
+  - Steht im Reiter „Storage" der Einstellungen – dort, wo ohnehin steht, was einem gehört. Damit trägt dieser Reiter auch genug, um einer zu sein.
+- ✅ **Reiterleiste als eine Definition** (`components/Tabs.tsx`, 23.08.2026). Einstellungen und Admin-Bereich hatten sie sonst zweimal im Code – zwei Kopien derselben Leiste laufen mit der Zeit auseinander, und beim Umschalten merkt man den Unterschied, ohne ihn benennen zu können. Genau das war bei den Kopfleisten schon einmal passiert. Nachgemessen: beide bei Höhe 39, Schrift 14 px, gleiche Position.
+- ✅ **Einstellungen sortiert** (`pages/ProfilePage.tsx`, 23.08.2026, Wunsch von Marc). Vorher gewachsen statt geordnet: Der Speicher stand ganz oben und war das Erste, was man sah – obwohl er eine reine Anzeige ist und derselbe Balken ohnehin in der Seitenleiste steht. Jetzt in **Reiter** unterteilt wie der Admin-Bereich, geordnet nach dem, was man tatsächlich aufsucht: **Account** (Profil, Passwort) → **Access** (App-Passwörter) → **Appearance** (Farben) → **Storage** (ans Ende).
+  - Die Seite heißt jetzt **Settings** statt „Profile" – so steht es auch im Nutzermenü, und „Profil" beschrieb nur die erste von vier Gruppen.
+  - Bei den App-Passwörtern steht jetzt dabei, *warum* das Kontopasswort an `/dav/` abgelehnt wird. Der Hinweis stand bisher nur im README – also dort, wo ihn niemand liest, der gerade ein Gerät anbindet.
+- ✅ **Nutzerbereich oben rechts** (`components/UserMenu.tsx`, 23.08.2026, Wunsch von Marc). Vorher unten links in der Seitenleiste, mit dem Abmelden-Symbol **unmittelbar neben** dem Knopf zu den Einstellungen – die einzige nicht rücknehmbare Handlung der Anwendung war die am leichtesten erreichbare. Jetzt liegt sie eine bewusste Handlung tief, im aufklappenden Menü, zuletzt und abgesetzt.
+  - Weitergereicht über einen Context, nicht über Eigenschaften: Sonst müsste jede der sechs Seiten Nutzer, Abmelden und Umschalten durchreichen, nur damit die Kopfleiste sie hat.
+  - **Nur der Anzeigename** in der Leiste. Vorher standen zwei Zeilen untereinander – Anzeigename und darunter die Rolle –, was bei einem Konto namens „Admin" als „Admin / Admin" ankam und wie eine Doppelung aussah. Die Kennung steht jetzt im Menü, und auch dort nur, wenn sie sich vom Anzeigenamen unterscheidet.
+  - **Der Speicherbalken bleibt unten links.** Er gehört zum *Ort*, nicht zur Person.
+- ✅ **Dateien liegen auf dem Wirt statt in einem Docker-Volume** (23.08.2026, Wunsch von Marc). `DATA_PATH` als Bind-Mount, dazu `APP_UID`/`APP_GID`, damit der Container unter Marcs Kennung läuft und die Dateien ihm gehören – per SFTP, rsync oder Dateimanager direkt erreichbar, ohne `root`. Vorher lag alles unter `/var/lib/docker/volumes/` und gehörte root.
+  - **Das ist die Eigenschaft, die ein Archiv erst zu einem macht:** ohne die Anwendung an die Unterlagen zu kommen. `scp -r` genügt.
+  - Umzug der 121 Bestandsdateien (654 MB) **mit Prüfsummenvergleich vor dem Umschalten**; das alte Volume `deploy_data` bleibt als Rückfall stehen. Danach Upload, OCR und Vorschau erneut geprüft – alles grün unter der neuen Kennung.
+  - `HOME=/tmp` im Compose, weil ghostscript und ocrmypdf Arbeitsdateien im Heimverzeichnis ablegen und das aus dem Image bei fremder Kennung nicht mehr beschreibbar ist.
+- **Hell-Modus verworfen** (23.08.2026, Entscheidung von Marc): Die Cloud ist persönlich und bleibt dunkel. Damit entfällt auch die Hauptbegründung, die ~40 fest eingetragenen Farbwerte auf Tokens umzustellen – das passiert künftig nebenbei, wenn eine Datei ohnehin angefasst wird.
+
+Geplante Ideen (noch nicht umgesetzt):
+- Custom Background (User kann eigenes Hintergrundbild setzen)
+- Glasmorphismus-Theme (transluzente Sidebar/Cards mit Blur-Effekt)
+- Logo und App-Symbol bereits in Phase 4.5/D umgesetzt
+
+**OIDC-Durchgang (23.08.2026)**
+
+Vor dem Produktivgang durchgesehen. Zwei Befunde, beide vorher unsichtbar:
+
+1. ⚠️ **Der erste OIDC-Login hätte ein zweites, leeres Konto erzeugt.** Zugeordnet wurde ausschließlich über `oidc_sub`; das bestehende `admin`-Konto hat keinen. Der Einfügeversuch scheitert am eindeutigen Benutzernamen (in der Datenbank nachgespielt: `duplicate key … users_username_key`), und der Code weicht auf `admin2` aus – **ohne Adminrechte** (`is_admin` steht per Vorgabe auf `false`), ohne Dateien, mit leerem Speicher. Wer seine Cloud bisher mit Passwort benutzt hat und dann OIDC einschaltet, landet in einer fremden, leeren Cloud.
+   - ✅ Behoben mit `OIDC_LINK_BY_USERNAME`: Ein bestehendes Konto gleichen Namens **ohne** Bindung wird mit der Identität verbunden, statt daneben ein zweites anzulegen. Dateien, Adminrecht und Freigaben bleiben.
+   - **Voreingestellt aus.** Verbinden heißt, dem Anbieter zu glauben, dass „marc" bei ihm derselbe „marc" ist wie hier. Bei einem eigenen Anbieter stimmt das; bei einem mit freier Registrierung wäre es die Übernahme fremder Konten. Deshalb eine Entscheidung in der `.env` statt einer stillen Annahme.
+   - Ein Konto, das **schon** zu einer Identität gehört, wird nie überschrieben – als Test mitgeschrieben (`oidclink_test.go`, vier Fälle gegen eine echte Datenbank, u. a. „fremde Identität übernimmt ein gebundenes Konto nicht").
+2. ✅ **Das `oidc_state`-Cookie hatte kein `Secure`-Flag** – anders als Sitzungs- und CSRF-Cookie. Jetzt über `middleware.IsHTTPS(r)`, das `X-Forwarded-Proto` auswertet, aber nur von vertrauenswürdigen Proxys.
+
+Unauffällig geblieben: Zustandswert gegen CSRF vorhanden und geprüft, ID-Token wird gegen die Signatur des Anbieters verifiziert, Benutzername aus `preferred_username` wird auf harmlose Zeichen beschränkt, Anmeldung mit Passwort ist für OIDC-Konten unmöglich (`''` ist kein gültiger Argon2-Hash).
+
+**Phase 6 – Dokumente-Modul (Paperless-lite)**
+PDF.js-Viewer ✅, OCR-Worker (ocrmypdf) ✅, Volltextsuche (Postgres FTS) ✅, Tags ✅ / Korrespondenten ✅.
+
+- ⏸️ **„Inbox"-Ordner mit Auto-Verarbeitung – vertagt** (23.08.2026, Entscheidung von Marc: „grade sehe noch keinen Nutzen drin für mich persönlich"). Festgehalten als Idee, nicht verworfen. Der Kern wäre nicht der Ordner – den kann man sich heute anlegen –, sondern drei Dinge daran: ein **Zähler**, der anzeigt, was noch nicht eingeordnet ist (ein Ordner sagt das nie und wird nie leer); ein **Sortier-Modus**, der Beleg und Eingabefelder nebeneinander stellt und mit „Speichern & nächster" durchgeht statt zwanzigmal Rechtsklick–Dialog–Schließen; und **Vorschläge** für Absender und Belegdatum aus dem erkannten Text. Der dritte Punkt wurde erst durch den Korrespondenten möglich – gegen ein geschlossenes Feld lässt sich abgleichen, gegen freie Etiketten wäre es Raterei. Sinnvoll wird das alles erst, wenn ein Bestand da ist, gegen den verglichen werden kann.
+
+- ✅ **Absender („Korrespondent")** (`internal/tags/correspondents.go`, Migration 000017, 23.08.2026, Wunsch von Marc). Das zweite Ordnungsmerkmal neben den Etiketten – und der Unterschied ist nicht die Technik, sondern die **Anzahl**: Ein Etikett sagt, *wofür* ein Dokument gebraucht wird, davon trägt eine Datei beliebig viele. Der Absender sagt, *von wem* es kommt – davon hat sie genau einen.
+  - **Warum nicht einfach ein Etikett „Stadtwerke".** Technisch ginge es, und ich hatte es Marc zunächst auch so empfohlen. Was dagegen spricht, zeigt sich erst mit der Zeit: Beide stünden in **derselben** Liste, „Stadtwerke" neben „absetzbar" – Absender und Verwendungszweck durcheinander. Bei zwanzig Einträgen fällt das nicht auf, bei achtzig ist die Seitenleiste unbenutzbar. Und „alle Rechnungen von X" ließe sich nicht von „alles Absetzbare" trennen, obwohl genau diese Verknüpfung der Zweck ist.
+  - **Die Eins-Regel steht im Schema**, nicht in einer Zusicherung des Codes: eine Spalte an `files`, keine Verknüpfungstabelle. Namen sind je Prinzipal eindeutig, ohne Rücksicht auf Groß-/Kleinschreibung – hier wiegt das schwerer als bei Etiketten: „Amazon" und „amazon" nebeneinander hieße, dass „alle Rechnungen von Amazon" nur die Hälfte findet, und zwar unauffällig.
+  - **`ON DELETE SET NULL`, nicht `CASCADE`.** Wer einen Absender löscht, will ihn aus der Liste haben – nicht seine Rechnungen. Der Bestätigungsdialog schreibt das auch hin; ohne den Satz klingt „Delete" nach dem Gegenteil, und niemand traut sich, aufzuräumen.
+  - **Ein Textfeld mit Vorschlägen, kein Auswahlfeld.** Ein Auswahlfeld zwänge dazu, den Absender vorher anzulegen – beim ersten Beleg von „Stadtwerke" gibt es ihn aber noch gar nicht. Der Server sucht den getippten Namen und legt ihn nur an, wenn es ihn nicht gibt, **in derselben Transaktion** wie Etiketten und Belegdatum. Ein zweiter Aufruf der Oberfläche hinterließe bei einem Fehler dazwischen einen Absender, der an keiner Datei hängt.
+  - **Im Paket `tags`, nicht in einem eigenen.** Alles drei wird in *einem* Dialog gesetzt und muss deshalb in *einer* Transaktion geschrieben werden. Ein eigenes Paket hieße zwei Transaktionen – und einen Zustand, in dem die Etiketten sitzen und der Absender nicht. Das Paket verwaltet also nicht „Etiketten", sondern die Ordnungsmerkmale einer Datei; der Paketkommentar sagt das jetzt auch.
+  - **Kostet keine Zeile an der Kachel.** Marc hatte zu Recht angemerkt, dass Etiketten die Kacheln höher machen. Der Absender steht deshalb *in* der Zeile mit der Größe, links davon und schrumpfbar – dort war ohnehin Platz. In der Listenansicht eine eigene Spalte: In einer Tabelle ändert eine leere Zelle die Zeilenhöhe nicht.
+  - Die Ansicht teilt sich die Seite mit den Etiketten (`/from/<id>` statt `/tags/<id>`) – es ist dieselbe Frage in anderer Richtung, und eine zweite, fast gleiche Seite liefe mit der Zeit auseinander. Genau das war bei den Kopfleisten schon einmal passiert.
+  - Der Menüpunkt heißt jetzt **„Organise…"** statt „Tags…": Der Dialog setzt drei Dinge, und ein Menüpunkt, der nur eines nennt, lässt die anderen beiden unauffindbar.
+- ✅ **Eigener PDF-Betrachter** (`components/PdfViewer.tsx`, Migration 000016, 23.08.2026). Vorher ein `<iframe>` mit dem eingebauten Betrachter des Browsers. Der ist gut – aber er gehört uns nicht: Wir können ihm nichts sagen und nichts von ihm erfahren.
+  - **Der Grund, der es getragen hat: das Telefon.** Chrome auf Android zeigt ein PDF in einem `<iframe>` nicht an, sondern bietet es zum Herunterladen an. Für ein Rechnungsarchiv, in das man beim Reklamieren im Laden hineinsieht, war die Vorschau dort also schlicht nicht vorhanden. Gemessen mit Handy-Kennung und 390 Pixeln Breite: vorher ein Download-Hinweis, jetzt die Seite.
+  - **Der zweite Grund: der Suchtreffer.** Die Volltextsuche findet ein Wort auf Seite 3 – der fremde Betrachter beginnt trotzdem auf Seite 1, und ein Suchwort lässt sich ihm nicht vorgeben. Jetzt wandert das Wort aus der Trefferliste bis in den Betrachter, der zur Seite springt und die Stelle einfärbt.
+  - **Beim Scan reicht das nicht – und das ist ausgerechnet der wichtigste Fall.** In einem gescannten Beleg steht im PDF kein einziges Wort, nur ein Bild; der erkannte Text liegt daneben in der Datenbank. Die Suche im Dokument meldete dort „keine Treffer" – bei genau dem Dateityp, für den die Texterkennung überhaupt gebaut wurde. Gefunden beim Prüfen am Telefon, nicht beim Bauen.
+    - Behoben über `GET /api/v1/files/{id}/text`: der erkannte Text, **in Seiten zerlegt**. Möglich wurde das erst dadurch, dass `clean()` den Seitenumbruch (`\f`) jetzt stehen lässt – vorher wurde er zu einem Zeilenumbruch, und damit war die Seitengrenze für immer verloren. Für die Volltextsuche ist er bedeutungslos, ein `tsvector` kennt keine Seiten; für den Betrachter ist er das Einzige, woran sich ablesen lässt, *wo* ein Wort steht.
+    - **Mehr als die Seite geht nicht.** Wo auf dem Blatt das Wort steht, weiß nur die Erkennung selbst, und ihre Koordinaten bewahren wir nicht auf. Der Betrachter springt deshalb an den Seitenanfang und markiert nichts – und sagt das auch, statt so zu tun: die Zählung liest sich dann „1 / 5 · page". Ein geratenes Wort einzufärben wäre schlimmer als keines.
+    - `extract_version` an `file_text` sagt, nach welcher Regel ein Eintrag entstanden ist; ältere werden beim Start erneut erkannt. Ohne so eine Marke fällt der Unterschied nie auf – der Text ist ja da, er kann nur weniger. Papierkorb bleibt außen vor.
+  - **Zwei Fehler, die erst der Browser gezeigt hat:**
+    1. **Zoomen sprang zurück zur Fundstelle.** Das Einfärben der Treffer scrollte selbst – und es läuft auch dann, wenn eine Seite bloß neu gezeichnet wird. Gemessen: von Seite 4 zurück auf Seite 3 bei jedem Zoomschritt. Gescrollt wird jetzt nur noch beim gezielten Sprung.
+    2. **„Auf die Breite einpassen" ergab 199 %.** Die Vorschau ist fast bildschirmbreit; ein A4-Blatt füllte sie und man sah das obere Drittel. Eingepasst wird jetzt gegen *beide* Kanten – am Telefon ergibt dieselbe Rechnung von selbst wieder die Breite, weil dort die Breite die engere Kante ist. Ein Sonderfall für kleine Bildschirme wäre nur eine zweite Wahrheit.
+  - **Zwei Nachbesserungen auf Marcs Hinweis** (23.08.2026):
+    1. **Das Markieren sah „komisch und unnatürlich" aus** – und das war mein Fehler, kein Darstellungsproblem. Ich hatte die Textebenen-CSS von PDF.js von Hand gekürzt („wir zeigen nur Seiten an"). Dabei fielen `--min-font-size`, `--text-scale-factor` und `scale(var(--min-font-size-inv))` weg. PDF.js misst damit, wie klein der Browser Schrift überhaupt noch darstellt – Chrome erzwingt eine Mindestgröße – und rechnet sie mit der Skalierung wieder heraus. Ohne dieses Paar bläht der Browser jede kleine Schrift auf: Die unsichtbaren Textstücke saßen **größer** da als die gemalten Buchstaben darunter, zu sehen erst beim Markieren als grobe, versetzte Kästen. Der Block wird jetzt wörtlich übernommen, mit einem Kommentar, der das Kürzen verbietet.
+    2. **Zwei gleich aussehende Knopfpaare.** Links blätterte durch Seiten, rechts durch Fundstellen – dasselbe Winkelzeichen, beide immer sichtbar. Das rechte Paar erscheint jetzt erst, wenn es Fundstellen gibt, und trägt einen Pfeil *mit Schaft*. Der Platz dafür bleibt trotzdem reserviert: Sonst rutschte das Suchfeld beim ersten Treffer um dreißig Pixel zur Seite, während man darin tippt.
+  - **Die Fundstelle war nicht zu lesen** (24.08.2026, Hinweis von Marc). Mit 0,95 Deckkraft lag ein satter oranger Block über dem Wort – ausgerechnet das gesuchte Wort war das einzige unleserliche auf der Seite. Jetzt 0,3 bzw. 0,55, der aktuelle Treffer zusätzlich mit einer Kante statt mit mehr Farbe.
+    - **Dass der Kasten nicht exakt sitzt, lässt sich nicht wegrechnen.** Die unsichtbare Schrift der Textebene ist eine *Ersatzschrift* – gemessen `sans-serif` 16,9 px für eine Serifenschrift im PDF. PDF.js dehnt sie über `--scale-x` (hier 1,055), damit die Zeile als Ganzes passt; die einzelnen Buchstaben darin sitzen aber leicht anders als die gemalten. Gemessen: Kasten 93 px breit, 23 px hoch bei 17 px Zeilenhöhe. Genau deshalb arbeitet auch der Betrachter von PDF.js selbst mit 0,25 Deckkraft: Ein blasser Streifen darf ungenau sitzen, ein satter Block darf es nicht. Dasselbe gilt für das Markieren mit der Maus.
+  - **Suchfeld breiter** (240 statt 150, 24.08.2026, Wunsch von Marc): In der Mitte einer 1440 Pixel breiten Leiste sah ein Feld in Knopfbreite aus wie ein Restposten.
+  - **Suchfeld mittig** (23.08.2026, Wunsch von Marc). Dafür wurde die Leiste ein **Dreispaltenraster** statt einer Reihe mit Abstandhaltern: Zwei `flex:1`-Halter teilen sich nur den Rest neben der Steuerung, das Feld landete gemessen 79 Pixel daneben – und ein erster Ausgleichsversuch machte 142 daraus. Mit `1fr auto 1fr` sind es 0. Am Telefon bleibt es beim Umbruch; ein Raster ergäbe dort eine gequetschte Suche neben gequetschten Knöpfen.
+  - **Der Zoom war vom Zufall abhängig** (beim Nachmessen gefunden): Dasselbe Dokument ging mal mit 96 %, mal mit 10 % auf. Der Größenbeobachter meldet sich auch, während die Vorschau noch aufgeht und der Bereich **keine Breite** hat; daraus wurde die Untergrenze von 10 %, und weil danach keine Größenänderung mehr kam, blieb das Dokument dabei stehen. Messungen unter 50 Pixeln gelten jetzt als „noch nicht sichtbar" statt als Ergebnis – dieselbe Falle steckte in der Innenabstands- und der Leistenbreiten-Messung. Dreimal hintereinander nachgemessen: stabil.
+  - **Nachgeladen, nicht mitgeliefert.** PDF.js wiegt 435 KB im Bündel und 1,3 MB im Arbeiter. Als Teil des Hauptbündels lud das jeder Besuch mit, auch wer nie ein PDF öffnet – gemessen 386 → 821 KB. Jetzt ein eigenes Stück, geholt beim ersten PDF. Der Service Worker legt es bewusst **nicht** vorab in den Cache: Offline wäre nichts gewonnen, weil die Dokumente selbst nicht mitgecacht werden. Ein Betrachter ohne Datei nützt nichts.
+  - **Kein CDN.** Arbeiter und die 14 Standardschriften kommen vom eigenen Server – die Sicherheitsrichtlinie erlaubt nur `'self'`, und eine Cloud für private Unterlagen soll beim Öffnen eines Dokuments keine fremde Adresse anfragen. Die Schriften werden beim Bauen aus `node_modules` kopiert statt eingecheckt (800 KB fremde Binärdateien gehören nicht in den Quelltext).
+  - **Was er absichtlich nicht kann:** Anmerkungen, Formulare, Unterschriften. Das Original wird in dieser Anwendung nie verändert – ein Betrachter, der schreiben kann, wäre ein Widerspruch dazu.
+  - Randfälle gemessen: 60 Seiten → höchstens 6 gleichzeitig im Speicher (bei A4 und doppelter Pixeldichte wären 60 Leinwände rund eine halbe Gigabyte); passwortgeschützt und kaputt → je eine klare Meldung statt einer leeren Fläche.
+
+- ✅ **OCR-Arbeiter und Volltextsuche** (`internal/documents`, Migration 000014, 23.08.2026). Damit ist der Punkt erledigt, der die Entscheidung überhaupt trug: Ein Beleg namens `scan_0042.pdf` ist jetzt über seinen *Inhalt* auffindbar.
+  - **Das Original wird nicht angefasst.** ocrmypdf schreibt normalerweise ein neues PDF mit eingebetteter Textebene – täten wir das, änderten sich Größe und Prüfsumme, die Versionshistorie bekäme einen Eintrag, den niemand ausgelöst hat, und WebDAV-Clients hielten die Datei für fremdverändert und lüden sie erneut. Für ein Archiv ist eine unangetastete Datei mehr wert als ein durchsuchbares PDF. Der Text liegt deshalb daneben in `file_text`, die Datei bleibt Byte für Byte, wie sie hochgeladen wurde.
+  - **Erst nachsehen, dann erkennen.** Hat das PDF bereits eine Textebene, liest `pdftotext` sie in Millisekunden aus – exakt so, wie sie gesetzt wurde. OCR wäre hier nicht nur langsamer, sondern *schlechter*: Es ersetzte fehlerfreien Text durch geratenen. Gemessen: Textebene 89 ms für 18 000 Zeichen, dieselbe Seite als Scan 66 s. Die Schwelle liegt bei 120 Zeichen je Seite – nicht bei „mehr als null", weil fast jeder Scan eine Kopfzeile oder ein Wasserzeichen als echten Text trägt und sonst als lesbar durchginge.
+  - **Warteschlange in der Datenbank, nicht im Speicher.** Vorschaubilder entstehen in einer Goroutine; geht eine verloren, fällt es sofort auf und sie ist in Millisekunden neu gemacht. Verlorener Text fällt *nie* auf – man sucht später vergeblich und weiß nicht, warum. `ocr_jobs` mit `FOR UPDATE SKIP LOCKED`, drei Versuchen und Fehlertext; ein beim Neustart unterbrochener Auftrag wird wieder aufgegriffen, statt für immer auf „running" stehen zu bleiben.
+  - **Zwei Fehler, die nur der echte Lauf gezeigt hat** – beide unsichtbar in Bau und Test:
+    1. `/dev/null` als Ausgabedatei lehnt ocrmypdf mit Exit 3 ab. Jetzt eine Wegwerfdatei, die sofort wieder verschwindet.
+    2. Tesseract vermisst beim allerersten Aufruf die OpenCL-Geräte und schreibt dabei einen langen Diagnoseblock, an dem ocrmypdfs Parser scheitert („Tesseract failed to report available languages"). Damit schlug **das erste Dokument nach jedem Neustart eines frischen Containers** fehl – gemessen: Versuch 1 Exit 3, Versuch 2 erfolgreich. Der Wiederholungszähler fing es auf, aber ein einbaubarer Fehlschlag gehört nicht in den Log. Die Vermessung passiert jetzt einmalig beim Bauen des Images.
+  - **Volltext und Namenssuche in *einem* Zweig der Abfrage**, nicht in zweien: Eine Datei, deren Name und Inhalt beide passen, käme sonst doppelt in der Trefferliste an. `matched_content` sagt, welche Hälfte den Treffer verursacht hat; die Reihenfolge ist Ordner → Namenstreffer → Inhaltstreffer.
+  - ✅ **Treffer springt nur zum Ordner, öffnet nicht mehr** (23.08.2026, Wunsch von Marc). Bis dahin klappte beim Klick zugleich die Vorschau auf – ein Klick in einer Trefferliste ließ unangekündigt einen Betrachter über den Bildschirm fahren, und wer nur nachsehen wollte, *wo* die Datei liegt, musste ihn erst wieder schließen. Geöffnet wird jetzt dort, wo man es erwartet: per Doppelklick auf die Datei.
+    - Damit der Sprung etwas taugt, wird die Datei **kurz umrandet und in den sichtbaren Bereich geholt** – in einem Ordner mit fünfzig Einträgen suchte man sonst von vorn. Die Markierung verschwindet nach 2,6 Sekunden von selbst; ein Rahmen, der bleibt, sähe irgendwann wie ein Zustand aus statt wie ein Hinweis.
+    - `boxShadow` statt eines dickeren Rahmens: Ein zweiter Pixel Rand ließe die Kachel wachsen und die ganze Reihe verrutschen.
+  - ✅ **Fundstelle über zwei Zeilen** (23.08.2026). Zuvor eine einzelne, mit „…" abgeschnittene Zeile – die endete oft, bevor klar wurde, worum es geht, und das Suchwort selbst konnte darin fehlen. Jetzt `line-clamp: 2`, das Feld von 380 auf 460 verbreitert und `MaxWords` in `ts_headline` von 18 auf 30 erhöht, damit die zweite Zeile auch voll wird. Links eine blasse Linie in der Farbe des Treffers: `--color-border` war dort **gemessen unsichtbar** (rgb(51,65,85) auf fast demselben Grund der hervorgehobenen Zeile).
+  - ✅ **Symbolspalte in der Trefferliste** (23.08.2026, beim Nachsehen aufgefallen). Das Ordnersymbol ist 24 Pixel breit, die Dateisymbole 18 – Ordnernamen begannen dadurch weiter rechts als Dateinamen, in einer gemischten Liste stand der Text also in zwei Spalten. Gemessen 107 gegen 95; jetzt alle bei derselben Kante.
+  - **Die Fundstelle wird nie als HTML eingesetzt.** `ts_headline` markiert mit `[[hl]]` statt mit `<b>`, und die Oberfläche zerlegt die Zeichenkette daran zu Textknoten. Der Text stammt aus einem hochgeladenen Dokument – als HTML eingesetzt wäre ein `<script>` darin eine Lücke.
+  - **Der Bestand wird beim Start nachgetragen.** Ohne das bliebe unauffindbar, was vor dem Einbau hochgeladen wurde – am Anfang also alles.
+  - ✅ **Gegen das Vollschreiben der Platte gesichert** (23.08.2026, auf Marcs Nachfrage – die Platte stand bei 85 %). OCR ist das einzige Stück dieser Anwendung, das ohne Zutun eines Menschen Platz verbraucht: Es arbeitet eine Warteschlange ab, solange etwas darin liegt. Drei Maßnahmen, alle gemessen:
+    1. **Kein Ergebnis-PDF mehr.** `--output-type none` schreibt 0 Bytes und liefert den Sidecar trotzdem vollständig. Vorher entstand bei jedem Scan ein rasterisiertes PDF, das ein Vielfaches der Vorlage wiegen kann – nur um sofort gelöscht zu werden.
+    2. **Keine Kopie der Eingabe.** Neue optionale Schnittstelle `storage.LocalPather`: Bei lokaler Ablage arbeiten die Werkzeuge direkt auf der Datei (nur lesend), statt sie erst vollständig zu duplizieren. Bei einem 300-MB-Scan waren das 300 MB zusätzlich.
+    3. **Platzbremse.** Unter 2 GiB frei pausiert der Arbeiter, statt weiterzuarbeiten – geprüft *vor* dem Zugreifen auf einen Auftrag, sonst verbrauchte er einen Versuch für etwas, das nicht an ihm lag. Die Warnung steht einmal je Zustandswechsel im Log, nicht alle fünf Sekunden.
+    - Dazu ein **Aufräumen beim Start**: Wird der Container hart beendet, läuft kein `defer` mehr und die angefangene Datei bleibt liegen. Entfernt wird nur, was diese Anwendung selbst angelegt hat (Präfix `ocr-`).
+    - Gemessen bei der Erkennung eines 4-MB-Scans: `/data/tmp` bleibt durchgehend bei **8 KB**, danach leer. Vorher wären es rund 8 MB gewesen.
+  - Preis: rund 330 MB im Image für ocrmypdf, tesseract (deu+eng) und poppler. `OCR_ENABLED=false` schaltet ab; fehlen die Programme, tut es der Server beim Start von selbst und läuft ohne Volltext weiter.
+  - Stand abfragbar über `GET /api/v1/admin/ocr` (pending/running/done/failed/indexed). **Noch ohne Oberfläche** – gehört in den anstehenden UI-Durchgang.
+- ✅ **Etiketten und Belegdatum** (`internal/tags`, Migration 000015, 23.08.2026). Das dritte Ordnungsmittel neben Ordnern und Volltext – und das einzige, das beantwortet, **wofür** ein Dokument gebraucht wird. „Absetzbar" steht in keiner Rechnung; das ist eine Einschätzung des Menschen.
+  - **Der Fall, an dem Ordner scheitern** und der bei Marc der Normalfall ist: Der Kaufbeleg eines Notebooks ist zugleich Garantienachweis *und* absetzbar. In einen Ordner passt er einmal, Etiketten trägt dieselbe Datei beliebig viele.
+  - **Prinzipal-Modell wie bei Dateien:** Ein Etikett gehört einem Konto **oder** einer Gruppe. Eine Datei kann nur Etiketten ihres eigenen Prinzipals tragen – das ist die Regel, die Gruppenordner zusammenhält: Hätte dort jeder seine privaten Etiketten, sortierte jeder dieselben Dateien für sich neu ein und niemand sähe die Arbeit des anderen.
+  - **Namen sind je Prinzipal eindeutig, ohne Rücksicht auf Groß-/Kleinschreibung.** Sonst stehen nach drei Monaten „Stadtwerke", „stadtwerke" und „STADTWERKE" nebeneinander – genau der Zerfall, den Etiketten gegenüber freien Ordnernamen verhindern sollen.
+  - **`document_date` an der Datei**, nicht als Etikett: Die Garantiefrist läuft ab dem Kauf, und in die Steuererklärung 2026 gehört, was 2026 gekauft wurde – auch wenn der Beleg im März 2027 eingescannt wird. `created_at` wäre für beides das falsche Datum, und zwar *unauffällig* falsch. Die Etikettenansicht sortiert danach absteigend, ohne Datum ans Ende.
+  - **Nichts davon wird in die Datei geschrieben** – dieselbe Regel wie beim erkannten Text. Das Dokument bleibt Byte für Byte, wie es hochgeladen wurde.
+  - **Zwei Fehler beim Prüfen gegen die laufende Instanz gefunden**, beide in meinem eigenen Code:
+    1. Ein ungültiges Belegdatum hatte die Etiketten **trotzdem schon geändert** – Datum und Etiketten liefen als zwei Schritte. Genau das, was der Kommentar daneben zu vermeiden behauptete. Jetzt eine Transaktion, und das Datum wird geprüft, bevor irgendetwas geschrieben wird; nachgestellt und bestätigt: nach dem abgelehnten Aufruf stehen beide Zählstände unverändert.
+    2. Das Datumsfeld im Dialog blieb **leer**, obwohl ein Datum gesetzt war: Der Server liefert `2026-01-15T00:00:00Z`, ein `<input type="date">` versteht nur `2026-01-15` und zeigt sonst kommentarlos nichts an. Im Bildschirmfoto aufgefallen.
+  - Etiketten stehen in der Seitenleiste unter den Favoriten (Farbpunkt + Zählstand), gesetzt wird über das Kontextmenü einer Datei; die Ansicht `/tags/<id>` ist verlinkbar und liegt im Verlauf des Browsers.
+  - ✅ **Farben und Bearbeiten** (23.08.2026, Wunsch von Marc): Beim Anlegen erscheint eine Farbwahl, sobald man tippt – vorher nicht, sonst ist sie nur Fläche. Die nächste Farbe wird vorgewählt, damit zwei nacheinander angelegte Etiketten nicht zufällig gleich aussehen. **Rechtsklick** auf ein Etikett in der Seitenleiste öffnet Umbenennen, Farbe und Löschen; beim Löschen steht ausdrücklich dabei, dass die Dateien bleiben.
+  - ✅ **Änderungen wirken sofort überall** (`tagsChangedEvent`). Vorher lud die Seitenleiste ihre Zählstände nur beim Ansichtswechsel, und nach einem Umbenennen stand an den Kacheln noch der alte Name. Ein Ereignis statt Zustand durch drei Ebenen zu reichen: Der Dialog steckt tief im Dateibrowser, die Seitenleiste hängt am Shell.
+  - ✅ **Aufkleber neben der Größe statt darunter** (Vorschlag von Marc). Vorher wuchs jede etikettierte Kachel um eine Zeile – in einem Raster sieht man das sofort. Gemessen: jetzt alle 157/159 px, mit und ohne Etikett. Dazu nur *ein* Aufkleber plus „+n": Bei zweien schrumpften beide auf „gar…" und „steue…", und zwei unlesbare sagen weniger als einer lesbarer.
+- ✅ **Kopfleiste auf schmalen Schirmen repariert** (23.08.2026, Marcs Bildschirmfoto vom Handy). Sie war eine Zeile ohne Umbruch und hat ihren Inhalt **gequetscht statt umgebrochen**: Bei 390 px stand die Brotkrume als einzelner Strich da, das Suchfeld schob sich über die Sortierauswahl, der Ansichts-Umschalter fehlte ganz und der Nutzerbereich war abgeschnitten. Nachgestellt und bestätigt.
+  - Unter 720 px bricht die Leiste jetzt auf zwei Zeilen um: Titel oben, Bedienelemente darunter über die volle Breite. **Nichts wird versteckt** – es steht nur untereinander. Gemessen: 8 Bedienelemente vollständig sichtbar, nichts abgeschnitten, kein waagerechtes Scrollen; auf dem Desktop unverändert 56 px einzeilig.
+  - Die feste Breite des Suchfelds (220 px) war die eigentliche Ursache – es kann jetzt schrumpfen, und seine Trefferliste passt sich der Schirmbreite an.
+  - ✅ **Rechtsklick öffnet erst ein Menü** (23.08.2026, Wunsch von Marc). Vorher sprang der Bearbeiten-Dialog sofort auf – das überrumpelt, und bei Dateien und Ordnern verhält sich der Rechtsklick anders. Jetzt „Edit…" und „Delete" wie überall sonst; Löschen fragt zurück und nennt die Zahl der betroffenen Dateien („The tag is removed from 1 file. The files themselves stay where they are — nothing is deleted."). Der Löschknopf ist dafür aus dem Bearbeiten-Dialog verschwunden: Ein Dialog, in dem „Save" und „Delete" nebeneinander liegen, lädt zum Fehlgriff ein.
+- ✅ **PWA-Durchgang** (23.08.2026). Vier Befunde, alle nur in der *installierten* App sichtbar und deshalb bisher übersehen:
+  1. **Kein `viewport-fit=cover`** – der Inhalt stand neben der Kamera-Aussparung eingerahmt statt über den ganzen Schirm.
+  2. **Keine sicheren Bereiche.** Mit (1) reicht die Seite bis unter Statusleiste und Wischbalken; ohne Abstände säße der Speicherbalken der Seitenleiste **hinter dem Wischbalken** und wäre nicht mehr erreichbar. `env(safe-area-inset-*)` nur unter `@media (display-mode: standalone)` – im Browser übernimmt die Adressleiste das schon, und auf Geräten ohne Aussparung ist der Wert ohnehin 0.
+  3. **`theme-color` stand fest auf dem Indigo der Voreinstellung**, während das Manifest die eingestellte Primärfarbe nannte. In der installierten App war die Statusleiste damit in einer Farbe, die sonst nirgends vorkommt. Jetzt zieht sie mit dem Theming mit; gemessen: `#1f6b5c` in beiden.
+  4. **Gummiband-Scrollen** am Anschlag – ohne Adressleiste, die mitfährt, sieht das nach einem Fehler aus. `overscroll-behavior-y: none`.
+  - Geprüft und in Ordnung: Service Worker aktiv, `apple-touch-icon` zeigt auf das **hochgeladene** Symbol, Manifest kommt aus der Datenbank.
+  - **Ehrlich zum Offline-Betrieb:** Die App startet ohne Netz und zeigt die Anmeldeseite – kein Fehlerbildschirm, aber auch nicht mehr. Jede Datei und jede Liste kommt vom Server. Ein Zwischenspeicher für Dateilisten wäre bei einem Dateiverwalter eher schädlich: Man sähe einen Bestand, der nicht mehr stimmt.
+- ✅ **Sammel-Download als ZIP** (`internal/files/handler_zip.go` + `store_zip.go`, 23.08.2026). Damit ist die Kette vollständig: **filtern → alles holen → weitergeben**. Ohne den letzten Schritt wären „alle Belege 2026 an den Steuerberater“ vierzig Einzeldownloads gewesen.
+  - Drei Wege: Mehrfachauswahl (Strg/Umschalt wie im Dateimanager), Rechtsklick auf einen Ordner (mit Unterordnerstruktur), und „Download all as ZIP“ in der Etikettenansicht.
+  - **Gestreamt, nicht gesammelt.** Das Archiv entsteht direkt in der Antwort und liegt nie ganz auf der Platte – bei einem 5-GB-Ordner wären das sonst 5 GB Bedarf auf einem Speicher, der bei 87 % steht, und der Nutzer sähe minutenlang nichts. Der Preis: Sobald das erste Byte draußen ist, steht der Statuscode auf 200. Deshalb wird alles, was scheitern kann – Rechte, Auswahl, Grenzen – **vor** dem ersten Byte geprüft.
+  - **POST über ein Formular**, nicht `fetch`: Nur eine Navigation behandelt der Browser als Download; `fetch` müsste das ganze Archiv erst in den Speicher holen. Ein Formular kann aber keine Header setzen – deshalb nimmt `ValidateCSRF` das Token jetzt auch als Formularfeld an. Am Schutz ändert das nichts, verglichen wird weiterhin gegen das Cookie.
+  - **Der Umfang steckt in der Abfrage**, nicht in einer Prüfung danach: Eine erratene Kennung fällt still heraus, statt im Archiv zu landen. Geprüft: `401` ohne Anmeldung, `403` ohne Token, `404` bei erfundener Kennung.
+  - Bereits gepackte Formate (.zip, .deb, .jpg, .pdf …) werden nur **gelagert**. Ein 116-MB-Paket durch Deflate zu schicken kostet Sekunden CPU und spart nichts.
+  - Namenskollisionen werden zu „name (2)“ – ein Archiv mit zwei gleichen Einträgen entpacken manche Programme kommentarlos zu einer Datei, die zweite wäre still verloren. **Beim Prüfen nachgebessert:** `path.Ext` sieht bei `paket.tar.gz` nur `.gz`, die Zahl landete als „paket.tar (2).gz“ mittendrin.
+  - ✅ **Escape hebt die Auswahl auf** (23.08.2026, Wunsch von Marc) – aber nur, wenn sonst nichts offen ist. Vorschau und Dialoge haben dieselbe Taste, und die soll zuerst *die* schließen; andernfalls stünde man nach dem Schließen eines Dialogs ohne Auswahl da, ohne zu wissen, warum. Ebenso nicht, während man in einem Feld tippt – dort heißt Escape „Eingabe verwerfen".
+  - ⚠️ **Beim Prüfen gefunden und behoben:** Der erste Entwurf ließ auch einen *einfachen* Klick auswählen, sobald schon etwas markiert war. Das kollidiert mit dem Doppelklick – dessen erster Klick löste dann eine Auswahl aus. Gemessen: aus drei Ausgewählten wurden vier, und die Vorschau blieb zu. Jetzt wählt nur noch das Kästchen bzw. Strg/Umschalt; der Doppelklick tut wieder genau eine Sache. Danach nachgemessen: Auswahl bleibt bei 2, Vorschau öffnet, erstes Escape schließt nur sie, zweites hebt die Auswahl auf.
+  - UTF-8-Bit im Eintragskopf gesetzt, sonst wird „Rechnung Müller.pdf“ im Windows-Explorer zu „Rechnung Müller.pdf“.
+- Offen: PDF.js-Viewer, Korrespondent, Inbox-Ordner mit Auto-Verarbeitung.
+
+> ⚠️ **Offene Entscheidung vor Beginn: überschneidet sich mit InkNote.**
+> InkNote hat bereits einen PDF-Import mit Betrachter, Markierungen und einer
+> Textebene – ausdrücklich als Grundlage fürs Rechnungsarchiv gebaut und
+> produktiv im Einsatz.
+>
+> Wird Phase 6 wie geplant umgesetzt, existiert dieselbe Funktion zweimal: zwei
+> Ablagen, zwei Suchen, und bei jedem Dokument die Frage, wo es liegt. Das ist
+> schlechter als jede der beiden Varianten für sich.
+>
+> **Korrektur zweier Annahmen (23.08.2026, im InkNote-Code nachgesehen):**
+>
+> 1. **InkNote ist nicht Zero-Knowledge.** Notizen, Anhänge und der Textindex
+>    liegen AES-256-GCM-verschlüsselt auf der Platte, aber mit dem Schlüssel aus
+>    der `.env` **des Servers** (`ENCRYPTION_KEY`, `backend/server.js`). Der
+>    Server kann alles lesen; im Code steht es sinngemäß so, dass eine Sicherung
+>    genau so viel wert ist wie ihre `.env`. Client-seitige Verschlüsselung gibt
+>    es nicht. Damit ist **serverseitiges OCR kein Widerspruch** zu InkNotes
+>    Modell – der vermeintliche Blocker existiert nicht.
+> 2. **InkNotes Suche findet keine Scans.** Der Textindex entsteht aus
+>    `page.getTextContent()`, also der **Textebene** des PDFs. Eine abfotografierte
+>    oder eingescannte Rechnung hat keine – sie bleibt unauffindbar. Genau diese
+>    Dokumente sind aber der Grund, warum man OCR einbaut.
+>
+> **Empfehlung nach dieser Prüfung: Variante B – die Dokumente gehören nach
+> Aether**, InkNote behält Notizen, Zeichnen und das Annotieren eines PDFs, mit
+> dem man gerade arbeitet.
+>
+> - **Scans.** Der ausschlaggebende Punkt: Was InkNote nicht lesen kann, findet
+>   Aether nach OCR. Papierbelege sind der Normalfall eines Rechnungsarchivs.
+> - **Hineinkommen.** Belege sind Dateien. Aether hat WebDAV, Ordner-Upload und
+>   Drag & Drop; in InkNote hängt man sie an eine Notiz.
+> - **Nicht verlieren.** Ein Archiv braucht Haltbarkeit: Prüfsummen, Versionen,
+>   Papierkorb und GC sind in Aether gebaut und geprüft.
+>
+> **Übergang ohne Umzug:** Aether kann heute schon als Ablage dienen – die
+> Namenssuche und die PDF-Vorschau stehen. Wer ab jetzt dort einsortiert,
+> bekommt OCR später als Ergänzung statt als Migration.
+>
+> Die Alternativen bleiben der Vollständigkeit halber: **A)** Dokumente bleiben
+> in InkNote, Phase 6 schrumpft auf „PDFs ablegen und ansehen" – verzichtet auf
+> Scans in der Suche. **C)** Beides bauen – nur bei bewusst getrennten Zwecken
+> sinnvoll, sonst die schlechteste Variante.
+>
+> Siehe auch die Plattform-Überlegung: getrennte Apps mit gemeinsamem Login
+> statt Verschmelzung.
+
+**Phase 7 – Office** ✅ (24.08.2026)
+
+- ✅ **WOPI-Host im Backend** (`internal/office`, 24.08.2026). Collabora läuft, der Kreis ist gemessen: tippen → Strg+S → v1 auf v3, und der getippte Text steht im heruntergeladenen ODT.
+  - **Ein Adapter für beide Anbieter.** Collabora und OnlyOffice sprechen dieselbe Schnittstelle; umgeschaltet wird über `OFFICE_PROVIDER`. Zwei Integrationen wären dieselbe Sache zweimal gepflegt – und die zweite immer die schlechter getestete.
+  - **Drei Adressen für drei Richtungen.** Das war der Teil, der beim Aufbau dreimal gescheitert ist: `OFFICE_URL` (Backend → Office), `OFFICE_PUBLIC_URL` (Browser → Office) und `OFFICE_WOPI_URL` (Office → Aether). Sie sind selten gleich: Im Compose-Netz heißt der Server `collabora`, der Browser braucht einen auflösbaren Namen, und aus dem Office-Container heraus ist „localhost" er selbst. Der veröffentlichte Port `127.0.0.1:8090` taugt dafür ausdrücklich **nicht** – er ist auf loopback gebunden (gemessen als `ECONNREFUSED` in Collaboras Log).
+  - **Die eigene Sicherheitsrichtlinie war der erste Stolperstein.** `frame-src` fällt auf `default-src 'self'` zurück; der Browser blockte den Rahmen, bevor irgendeine Anfrage hinausging. Die Ausnahme entsteht jetzt aus der Konfiguration und nennt genau einen Ursprung – kein Platzhalter, die Ausnahme soll so schmal sein wie der Anlass.
+  - **Das Token ist an genau eine Datei gebunden** und HMAC-signiert (abgeleiteter Schlüssel, nicht derselbe wie für die Sitzungscookies). Zwölf Stunden Laufzeit: Das ist die Zeit, die ein Dokument offen stehen darf, bevor das Speichern scheitert – kürzer hieße, dass eine Mittagspause die Änderungen kostet.
+  - **Die Rechte werden bei jedem WOPI-Aufruf neu aufgelöst**, nicht aus dem Token übernommen. Eine zurückgezogene Freigabe wirkt damit sofort und nicht erst, wenn das Token abläuft.
+  - **Ein Office-Server ist kein Sonderweg an der Datenintegrität vorbei.** Das Zurückschreiben läuft über `files.ReplaceContent` und hält dieselben vier Regeln wie jeder Upload: atomar schreiben, Prüfsumme neu berechnen, Kontingent beachten, bei eingeschalteter Versionierung die alte Fassung aufheben.
+  - **Der Rahmen bekommt das Token per Formular, nicht in der Adresse.** Eine URL landet im Verlauf des Browsers, im Log des Proxys und im Referrer; ein POST-Rumpf nicht.
+  - Weitere Fallen, alle beim Testen gefunden und im README festgehalten: `ssl.termination=true` ohne HTTPS davor lässt Collabora eine `wss://`-Verbindung verlangen, die es nicht gibt (Editor lädt, Dokument bleibt weiß); eine unkodierte `WOPISrc` weist Collabora zurück; `coolmount` braucht `CAP_SYS_ADMIN`, gelöst über `--o:mount_jail_tree=false` statt zusätzlicher Rechte.
+  - Der Container läuft nur mit `--profile office`. Wer kein Office will, soll nicht 1 GB Arbeitsspeicher dafür abgeben, nur weil die Zeilen im Compose stehen.
+
+WOPI-Host im Backend + `OfficeProvider`-Interface. Collabora **und** OnlyOffice als Provider, per `.env` umschaltbar. Optional: nativer OnlyOffice-Adapter für maximale Treue.
+
+**Phase 8 – Härtung & Extension-Points**
+Security-Audit, vollständige Tests, Observability (strukturiertes Logging, Metriken), 2FA, definierte Plugin-/Hook-Schnittstellen.
+
+---
+
+## 6. Sicherheits-Checkliste
+
+**Allgemein**
+- Passwort-Hashing **Argon2id** (kein MD5/SHA).
+- **Path-Traversal**-Schutz bei jedem Dateipfad (kanonisieren, gegen Root prüfen).
+- Session-Cookies: `httpOnly`, `Secure`, `SameSite=Lax/Strict`; CSRF-Schutz.
+- Rate-Limiting auf Login & API; Brute-Force-Schutz (Verzögerung/Lockout nach Fehlversuchen).
+- Security-Header (CSP, X-Content-Type-Options, X-Frame-Options) setzt die App selbst;
+  **HSTS gehört auf den externen Proxy**, nicht in die Anwendung.
+- Autorisierung pro Request (RBAC: User/Gruppe/Owner), nicht nur Authentifizierung. Jede Aktion serverseitig prüfen, nie dem Frontend vertrauen.
+- Upload-Validierung: Größenlimits, MIME-Prüfung, kein Ausführen; Uploads außerhalb des Webroots, mit nicht-ausführbaren Rechten.
+- Secrets nur via `.env`/Compose, nie im Image/Repo.
+- Optional: Verschlüsselung at-rest.
+- Abhängigkeiten scannen (`govulncheck`, `npm audit`).
+
+**Admin-Konto besonders härten**
+- Admin-Routen mit eigener AuthZ-Schicht; Admin-Status serverseitig bei JEDER Admin-Aktion prüfen (keine reine UI-Verschleierung).
+- Kein Default-/Standardpasswort. Erst-Admin per Seed/CLI mit erzwungenem starken Passwort.
+- Strengeres Rate-Limit + Lockout auf Admin-Login; Admin-Aktionen ins Audit-Log (wer, was, wann).
+- Privilege-Escalation aktiv verhindern: ein normaler User darf sich niemals selbst zum Admin machen (Rollen nur durch bestehenden Admin änderbar, serverseitig erzwungen).
+- 2FA für Admin (Phase 8) fest vorgesehen.
+
+**Gegen gängige Angriffsmethoden prüfen (OWASP Top 10)**
+- SQL-Injection → ausschließlich parametrisierte Queries / Prepared Statements.
+- XSS → Output-Encoding, strikte CSP, kein `dangerouslySetInnerHTML` mit User-Input.
+- CSRF → Token + SameSite-Cookies.
+- IDOR/Broken Access Control → Objektzugriffe immer gegen den Eigentümer/Rechte prüfen.
+- SSRF (relevant bei OIDC/WOPI-Callbacks) → ausgehende Ziele auf Allowlist beschränken.
+- Insecure Deserialization, Open Redirects, Header-Injection → bewusst testen.
+- Vor jedem Phasen-Abschluss: kurzer Security-Pass gegen diese Liste, plus `govulncheck`/`npm audit`.
+
+---
+
+## 7. Test-Strategie
+
+- **Backend**: Unit-Tests pro Domänen-Paket; Integrationstests mit Test-Postgres (testcontainers); WebDAV-Endpoint mit echtem Client testen.
+- **Frontend**: Komponenten-Tests (Vitest + Testing Library); kritische Flows als E2E (Playwright): Login, Upload, Share, Suche.
+- **Sicherheit**: Path-Traversal-, AuthZ- und Rate-Limit-Tests explizit.
+- CI: Tests + Lint + Build bei jedem Commit.
+
+---
+
+## 8. Plugin-/Extension-Strategie (bewusst spät)
+
+Nicht von Anfang an. Wenn der Core steht:
+- **Server-Seite**: Event-Bus mit Hooks (`onFileUploaded`, `onUserCreated`, …); Plugins registrieren Handler. Keine Plugin-DB-Schreibrechte ohne API.
+- **Frontend-Seite**: definierte Slots (z. B. Datei-Kontextmenü, Sidebar) zum Einhängen.
+- **Grenze**: Kernfeatures (Dateien, Auth, Sharing, Dokumente) bleiben im Core und schnell – Plugins nur für „extra".
+
+---
+
+## 9. CLAUDE-CODE MASTER-PROMPT (kopierbar)
+
+> Lege diesen Text als ersten Auftrag in Claude Code ein. Er ist bewusst so gebaut,
+> dass Claude Code **phasenweise** arbeitet und nicht versucht, alles auf einmal zu bauen.
+
+```
+Du baust mit mir zusammen eine self-hosted Cloud-Lösung (schlanke, schnelle
+Alternative zu Nextcloud). Lies zuerst die Datei cloud-projekt-plan.md im Repo
+vollständig – sie enthält Stack, Architektur und die Phasen-Roadmap. Halte dich daran.
+
+STACK (verbindlich):
+- Backend: Go (net/http + chi Router), modularer Monolith.
+- Frontend: React + TypeScript + Vite + Tailwind, gebaut als PWA.
+- DB: PostgreSQL mit Migrations (z. B. golang-migrate).
+- Storage: Interface mit LocalFS-Implementierung (S3-ready, aber jetzt nur LocalFS).
+- Auth: Session-Cookies (KEINE JWTs). Username + Passwort, Argon2id.
+- Deployment: Docker Compose, Multi-Stage-Build. Secrets nur über .env.
+
+GETROFFENE ENTSCHEIDUNGEN (nicht in Frage stellen):
+- KEINE E-Mail-Adressen. Dies ist eine private, nicht öffentliche Cloud. Kein E-Mail-Feld,
+  keine E-Mail-Verifizierung, kein Passwort-Reset per Mail. User identifizieren sich per Username.
+- Passwort-Reset NUR durch den Admin (Admin kann User anlegen/bearbeiten/löschen + Passwort setzen).
+- DATENINTEGRITÄT IST OBERSTE PRIORITÄT (ab Phase 1, nicht verhandelbar): Dateien dürfen durch
+  die Cloud niemals beschädigt werden oder verloren gehen. Verbindlich:
+  * Atomare Schreibvorgänge: in Temp schreiben -> fsync -> atomares rename. Nie in-place überschreiben.
+  * SHA-256-Prüfsumme pro Datei: beim Upload speichern, beim Download verifizieren.
+  * Nie hart löschen / nie blind überschreiben: Soft-Delete (Papierkorb) + Versionen; echtes
+    Löschen der Bytes nur verzögert per Garbage-Collection.
+  * DB-Metadaten erst nach erfolgreichem Blob-Write committen, sonst sauber zurückrollen.
+  * Pflicht-Tests: Upload-Abbruch/Crash-Simulation, Checksum-Verifikation, Soft-Delete-Recovery.
+- THEMING: Der Admin kann global das Branding setzen (Logo, Cloud-Name, freie Farbpaletten:
+  main/akzent/… frei wählbar, Styling). Ein normaler User darf NUR seine EIGENE Farbpalette für sich
+  selbst wählen, sonst keine Theming-Rechte. Umsetzung über CSS-Variablen / Design-Tokens
+  (global vom Admin, pro-User-Override nur fürs eigene Konto). Feature gehört in Phase 4.
+- ADMIN-SICHERHEIT: Das Admin-Konto und alle Admin-Funktionen müssen besonders gehärtet sein.
+  Admin-Status serverseitig bei JEDER Admin-Aktion prüfen (nicht nur UI). Kein Default-Passwort,
+  strengeres Rate-Limit/Lockout am Admin-Login, Privilege-Escalation verhindern (User kann sich
+  nie selbst zum Admin machen), Admin-Aktionen ins Audit-Log. Details in Abschnitt 6 des Plans.
+- Office (in späterer Phase): Backend wird WOPI-Host; sowohl Collabora als auch OnlyOffice
+  müssen als Provider funktionieren, per .env umschaltbar (OFFICE_PROVIDER). 2FA und OCR/Paperless
+  ebenfalls erst NACH dem Grundgerüst (spätere Phasen).
+  Jetzt zählt: stabiles Gerüst + Grundfunktionen zuerst, Features danach.
+
+ARBEITSWEISE:
+- Arbeite STRIKT phasenweise nach der Roadmap. Baue NICHT alles auf einmal. Erst Gerüst + Core, dann Features.
+- Lege zu Beginn eine CLAUDE.md mit Projektkonventionen an (Code-Stil, Ordnerstruktur,
+  Commit-Regeln, wie Tests laufen).
+- Schreibe zu jeder nicht-trivialen Funktion Tests (Backend: go test; Frontend: Vitest).
+- Committe in kleinen, sinnvollen Schritten mit klaren Messages.
+- Wenn eine Architektur-Entscheidung mehrere sinnvolle Optionen hat, FRAG MICH kurz,
+  statt einfach zu wählen.
+- Sicherheit durchgängig: Path-Traversal, AuthZ pro Request, Argon2id, CSRF, Rate-Limiting,
+  und vor jedem Phasen-Abschluss ein kurzer Security-Pass gegen die OWASP-Top-10-Liste im Plan
+  (SQL-Injection, XSS, CSRF, IDOR/Access-Control, SSRF) plus govulncheck/npm audit.
+
+JETZT STARTEN MIT PHASE 0 + PHASE 1, DANN STOPPEN:
+1. Monorepo-Struktur anlegen: /backend, /frontend, /deploy.
+2. docker-compose.yml mit Services app + postgres + caddy. .env.example anlegen.
+3. Postgres-Migrations-Setup + erste Tabellen (users [ohne email], sessions, files, folders).
+4. Backend-Grundgerüst: chi Router, Health-Endpoint, Config aus .env, strukturiertes Logging.
+5. Lokale Auth: Login mit Username + Argon2id, Session-Cookies (httpOnly/secure/SameSite), CSRF.
+   (Erst-Admin per Seed/CLI anlegen, da keine öffentliche Registrierung nötig.)
+6. Storage-Interface + LocalFS-Implementierung mit Path-Traversal-Schutz, ATOMAREN Schreibvorgängen
+   (Temp -> fsync -> rename), SHA-256-Prüfsummen und Soft-Delete (kein hartes Löschen).
+7. Datei-API: Upload, Download (mit Checksum-Verifikation), Liste, Rename, Move, Delete (Soft),
+   Ordner anlegen. DB-Commit erst nach erfolgreichem Blob-Write.
+8. Frontend: Vite+React+TS+Tailwind-Setup, Login-Seite, Datei-Browser mit Upload-Queue,
+   spricht die Datei-API an. Als PWA konfigurieren. Theming über CSS-Variablen vorbereiten
+   (Tokens für main/akzent etc.), damit Admin-/User-Theming in Phase 4 leicht andockt.
+9. Tests für Auth, Storage (inkl. Traversal-Test, Upload-Abbruch-Simulation, Checksum-Verifikation,
+   Soft-Delete-Recovery) und Datei-API.
+10. README mit Setup-Anleitung (docker compose up).
+
+Wenn Phase 0+1 lauffähig und getestet sind: STOPP. Gib mir eine kurze Zusammenfassung,
+wie ich es lokal starte und teste, und schlage Phase 2 vor. Erst nach meinem OK weitermachen.
+```
+
+---
+
+## 10. Getroffene Entscheidungen
+
+- **Auth:** Session-Cookies (keine JWTs). ✅
+- **Office:** WOPI-Host → Collabora **und** OnlyOffice als Provider, per `.env` umschaltbar. OnlyOffice für beste MS-Office-Treue, Collabora als unabhängige Alternative. ✅
+- **E-Mail:** wird nicht verwendet (private Cloud). ✅
+- **2FA:** später (Phase 8). ✅
+- **OCR/Paperless:** erst nach Grundgerüst (Phase 6). ✅
+- **Reihenfolge:** Gerüst + Grundfunktionen zuerst, Features danach. ✅
+- **Datenintegrität:** atomare Writes + SHA-256 + Soft-Delete ab Phase 1, nicht verhandelbar. ✅
+- **Theming:** Admin = volles Branding (Logo, Name, freie Farbpaletten); User = nur eigene Farbpalette. ✅
+- **Admin-Sicherheit:** Admin-Konto/-Funktionen besonders gehärtet, OWASP-Top-10-Pass je Phase. ✅
+
+- **Reverse Proxy:** extern (Bring Your Own), kein interner Proxy-Container; App proxy-aware (HTTP intern, X-Forwarded-* von TRUSTED_PROXIES, PUBLIC_URL). ✅
+
+Noch offen:
+- Suche: ab wann Meilisearch statt Postgres FTS? (Empfehlung: erst Postgres FTS, Meilisearch wenn die Doku-Menge groß wird.)
+- Sidebar-Customizing (Phase 2.5): Favoriten/Pins als DB-Tabelle pro User (serverseitig gespeichert). Reihenfolge per Drag & Drop änderbar. Custom-Links: vorerst nur interne Ordner pinnen.
diff --git a/deploy/.env.example b/deploy/.env.example
new file mode 100644
index 0000000..710133e
--- /dev/null
+++ b/deploy/.env.example
@@ -0,0 +1,160 @@
+# Aether – Environment Variables
+# Copy to .env and fill in values. Never commit .env!
+
+# ── App ──────────────────────────────────────────────────────────────────────
+APP_ENV=production              # development | production
+
+# Internal listen address. Your external reverse proxy forwards here.
+APP_LISTEN_ADDR=:8080
+
+# Public-facing URL (used for OIDC redirects, WOPI callbacks, share links).
+# Must match what the browser sees — include scheme + domain, no trailing slash.
+PUBLIC_URL=https://cloud.example.com
+
+# Comma-separated IPs or CIDRs of reverse proxies allowed to set
+# X-Forwarded-For / X-Forwarded-Proto. Everyone else is untrusted.
+# Example: 172.18.0.1,10.0.0.0/8
+TRUSTED_PROXIES=172.18.0.1
+
+# ── Database ─────────────────────────────────────────────────────────────────
+DB_HOST=postgres
+DB_PORT=5432
+DB_NAME=aether
+DB_USER=aether
+DB_PASSWORD=changeme_strong_password
+
+# ── Session ───────────────────────────────────────────────────────────────────
+# Generate with: openssl rand -hex 32
+SESSION_SECRET=changeme_generate_with_openssl_rand_hex_32
+SESSION_MAX_AGE=86400           # seconds (24h)
+
+# ── Storage ───────────────────────────────────────────────────────────────────
+STORAGE_PATH=/data
+TMP_PATH=/data/tmp
+
+# ── Admin seed ────────────────────────────────────────────────────────────────
+# Used only on first startup to create the initial admin account.
+# Remove or leave blank after first start.
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=changeme_strong_admin_password
+
+# ── OIDC (optional, Phase 4) ─────────────────────────────────────────────────
+# Wenn OIDC_ISSUER leer ist, ist OIDC-Login deaktiviert (kein SSO-Button).
+# OIDC_REDIRECT_URL muss exakt <PUBLIC_URL>/api/v1/auth/oidc/callback sein
+# und beim IdP als erlaubte Redirect-URI registriert werden.
+# OIDC_ISSUER=https://your-idp.example.com
+# OIDC_CLIENT_ID=aether
+# OIDC_CLIENT_SECRET=
+# OIDC_REDIRECT_URL=https://cloud.example.com/api/v1/auth/oidc/callback
+
+# ── WebDAV ────────────────────────────────────────────────────────────────────
+# Erreichbar unter /dav/ (Basic Auth, Username + Passwort). Kein Setting nötig.
+# Reverse Proxy muss PROPFIND/MKCOL/MOVE/COPY durchreichen.
+
+# ── Office / WOPI ─────────────────────────────────────────────────────────────
+# Steht weiter unten, mit allen Adressen. (Hier stand bis zum 24.08.2026 ein
+# Rest aus der Planung mit OFFICE_SERVER_URL – den Schlüssel gibt es nicht.)
+
+# ── Features ─────────────────────────────────────────────────────────────────
+# MEILISEARCH_URL=http://meilisearch:7700
+# MEILISEARCH_KEY=
+
+# ── App-Umschalter ────────────────────────────────────────────────────────────
+# Andere selbst gehostete Apps, die im Menü oben in der Seitenleiste erscheinen.
+# Format:  Name|URL|Emoji  – mehrere durch Komma getrennt. Leer = kein Menü.
+# Beispiel: EXTERNAL_APPS=InkNote|https://notes.honeyy.duckdns.org|📓
+EXTERNAL_APPS=
+
+# ── OIDC: bestehendes Konto verbinden ───────────────────────────────────────
+# Es gibt schon ein Konto mit demselben Benutzernamen, aber ohne Bindung an den
+# Identitätsanbieter – was soll passieren?
+#
+#   false (Voreinstellung): Es entsteht ein ZWEITES Konto. Da der Name vergeben
+#     ist, heißt es "name2" – leer, ohne Adminrechte, ohne deine Dateien.
+#   true:  Das bestehende Konto wird mit der Identität verbunden. Dateien,
+#     Adminrecht und Freigaben bleiben; ab dann meldest du dich darüber an.
+#
+# Auf "true" nur, wenn du dem Anbieter glaubst, dass "marc" bei ihm derselbe
+# "marc" ist wie hier – also bei einem eigenen Anbieter (PocketID, Authentik),
+# dessen Konten du selbst anlegst. Bei einem Anbieter mit freier Registrierung
+# wäre es die Übernahme fremder Konten.
+#
+# Verbunden wird nur, was noch KEINE Bindung hat – ein Konto, das schon zu einer
+# anderen Identität gehört, wird nie überschrieben.
+# OIDC_LINK_BY_USERNAME=true
+
+# ── Wo die Dateien liegen ────────────────────────────────────────────────────
+# Ein gewöhnliches Verzeichnis auf dem Wirt, kein Docker-Volume. Damit kommst
+# du per SFTP, rsync oder im Dateimanager an deine Dateien – sie liegen dort
+# als echte Ordner mit echten Namen (users/<name>/home/…).
+#
+# Nur lesend benutzen: Wer von Hand hineinschreibt, hat eine Datei, die die
+# Cloud nicht kennt. Zum Hineinlegen ist WebDAV der Weg.
+DATA_PATH=/pfad/zu/aether-data
+
+# Der Container läuft unter dieser Kennung, damit die Dateien im Verzeichnis
+# oben **dir** gehören und nicht einem Container-Nutzer. `id -u` und `id -g`
+# verraten deine.
+APP_UID=1000
+APP_GID=1000
+
+# Port auf dem Wirt – gebunden auf **loopback**, davor gehört dein Reverse
+# Proxy. Im Container bleibt es immer 8080; hier steht nur, unter welchem Port
+# der Wirt ihn anbietet.
+APP_PORT=8080
+
+# ── Volltextsuche über den Inhalt (OCR) ──────────────────────────────────────
+# Holt den Text aus PDFs und Bildern, damit auch ein Scan namens
+# "scan_0042.pdf" über seinen Inhalt auffindbar ist. Das Original wird dabei
+# nicht verändert – der Text landet daneben in der Datenbank.
+#
+# Standardmäßig an. Fehlen ocrmypdf/tesseract im Image, schaltet sich der
+# Arbeiter beim Start von selbst ab und die Cloud läuft ohne Volltext weiter.
+# OCR_ENABLED=false
+
+# Sprachmodelle für tesseract. Im Image liegen deu und eng; weitere brauchen
+# ein zusätzliches apk-Paket (tesseract-ocr-data-<sprache>) im Dockerfile.
+# OCR_LANGUAGES=deu+eng
+
+# Höchstzahl erkannter Seiten je Datei. OCR kostet rund eine Minute je
+# gescannter Seite – ohne Grenze blockiert ein dickes Handbuch die
+# Warteschlange für alles andere. 0 = unbegrenzt.
+# OCR_MAX_PAGES=50
+
+# Notbremse je Datei, falls eine einzelne Seite entgleist.
+# OCR_TIMEOUT=10m
+
+# ── Office (optional) ────────────────────────────────────────────────────────
+# Leer = aus. Die Anwendung ist ohne Office vollständig.
+#
+# Beide Anbieter sprechen WOPI, es gibt also nur einen Adapter:
+#   collabora   – LibreOffice-Kern, ~1 GB Arbeitsspeicher, ODF nativ
+#   onlyoffice  – beste .docx/.xlsx-Treue, 2 GB Minimum / 4 GB empfohlen
+OFFICE_PROVIDER=
+OFFICE_URL=
+# Adresse, unter der der **Browser** den Office-Server erreicht. Leer = dieselbe
+# wie OFFICE_URL. Die beiden sind selten gleich: Im Compose-Netz heisst der
+# Server `collabora`, im Browser muss dort ein aufloesbarer Name stehen.
+OFFICE_PUBLIC_URL=
+# Adresse, unter der der **Office-Server** Aether erreicht. Leer = PUBLIC_URL.
+# Der am leichtesten uebersehene Weg: Der Office-Server holt die Datei selbst
+# ab, und aus seinem Container heraus ist „localhost" er selbst.
+# Laufen beide im selben Compose-Projekt, ist das der Dienstname: http://app:8080
+# Der veroeffentlichte Port (127.0.0.1:8090) taugt **nicht** – auf loopback
+# gebunden, aus einem Container also nicht erreichbar (ECONNREFUSED).
+OFFICE_WOPI_URL=
+# Adressen, die das Backend anfragen darf – gegen SSRF. Der Host aus OFFICE_URL
+# zählt immer dazu; hier kommt nur hinein, was zusätzlich erlaubt sein soll.
+OFFICE_ALLOWED_HOSTS=
+# Nur für den Testaufbau mit selbstsigniertem Zertifikat auf demselben Rechner.
+OFFICE_INSECURE_TLS=false
+# Für den mitgelieferten Collabora-Container (docker compose --profile office):
+# unter welcher Adresse er Aether erreicht. Punkte maskieren – Collabora liest
+# den Wert als regulären Ausdruck.
+OFFICE_ALIASGROUP=http://app:8080
+OFFICE_SSL=false
+# Endet HTTPS an deinem Reverse Proxy? Produktiv true, im reinen HTTP-Test
+# false – sonst verlangt Collabora vom Browser eine wss://-Verbindung, die es
+# nicht gibt, und der Editor bleibt leer.
+OFFICE_SSL_TERMINATION=false
+OFFICE_PORT=9980
diff --git a/deploy/Dockerfile b/deploy/Dockerfile
new file mode 100644
index 0000000..b88139e
--- /dev/null
+++ b/deploy/Dockerfile
@@ -0,0 +1,58 @@
+# ── Stage 1: Frontend build ───────────────────────────────────────────────────
+FROM node:20-alpine AS frontend-builder
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm ci
+COPY frontend/ ./
+RUN npm run build
+
+# ── Stage 2: Backend build ────────────────────────────────────────────────────
+FROM golang:1.25-alpine AS backend-builder
+WORKDIR /app
+RUN apk add --no-cache git
+COPY backend/go.mod backend/go.sum ./
+RUN go mod download
+COPY backend/ ./
+RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o aether ./cmd/aether
+
+# ── Stage 3: Final image ──────────────────────────────────────────────────────
+FROM alpine:3.20
+# ocrmypdf, tesseract und poppler machen den Inhalt von PDFs und Scans
+# durchsuchbar (internal/documents). Sie wiegen zusammen rund 330 MB – der
+# Löwenanteil des Images. Wer das nicht braucht, kann die zweite apk-Zeile
+# streichen und OCR_ENABLED=false setzen; der Server prüft beim Start selbst,
+# ob die Programme da sind, und läuft sonst ohne Volltextsuche weiter.
+#
+# tesseract-ocr-data-deu/-eng sind die Sprachmodelle. Ohne sie startet
+# tesseract zwar, erkennt aber nichts – das Paket tesseract-ocr allein bringt
+# keine mit.
+RUN apk add --no-cache ca-certificates tzdata && \
+    apk add --no-cache ocrmypdf tesseract-ocr tesseract-ocr-data-deu \
+                       tesseract-ocr-data-eng poppler-utils && \
+    addgroup -S aether && adduser -S aether -G aether && \
+    mkdir -p /data/users /data/thumbs /data/tmp && \
+    chown -R aether:aether /data
+WORKDIR /app
+
+# Tesseract vermisst beim allerersten Aufruf die OpenCL-Geräte und schreibt
+# dabei einen langen Diagnoseblock nach stderr. ocrmypdf ruft davor
+# `tesseract --list-langs` auf und liest die Antwort – der Block bringt seinen
+# Parser aus dem Tritt, und der Aufruf endet mit „Tesseract failed to report
+# available languages" (Exit 3).
+#
+# Das Ergebnis der Vermessung landet als .dat im Arbeitsverzeichnis; ab dann ist
+# die Ausgabe kurz genug. Ohne diese Zeile scheitert deshalb genau das erste
+# Dokument nach jedem Neustart eines frischen Containers – gemessen, nicht
+# vermutet: Versuch 1 Exit 3, Versuch 2 erfolgreich. Der Wiederholungszähler
+# fängt es zwar auf, aber ein Fehlschlag, den man einbauen kann, gehört nicht
+# in den Log.
+RUN tesseract --list-langs >/dev/null 2>&1 || true
+
+COPY --from=backend-builder /app/aether ./aether
+COPY --from=frontend-builder /app/frontend/dist ./static
+
+RUN chown -R aether:aether /app
+USER aether
+
+EXPOSE 8080
+ENTRYPOINT ["./aether"]
diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml
new file mode 100644
index 0000000..93c7422
--- /dev/null
+++ b/deploy/docker-compose.yml
@@ -0,0 +1,137 @@
+services:
+  app:
+    container_name: aether-app
+    # Fertiges Abbild aus der eigenen Gitea-Registry.
+    #
+    # Ein Tag mit Datum **und** `latest`: Zum Aufbauen nimmt man `latest`, zum
+    # Zurückrollen den datierten. Wer nur `latest` fährt, hat im Fehlerfall
+    # nichts, worauf er zurück kann – der Name zeigt dann schon auf die
+    # Fassung, die gerade Ärger macht.
+    #
+    # Anmelden vor dem ersten Zug:
+    #   docker login gitea.honeyy.duckdns.org
+    #
+    # Aktualisieren:
+    #   docker compose pull app && docker compose up -d app
+    image: gitea.honeyy.duckdns.org/honey/aether:latest
+    # Selbst bauen statt ziehen? Dann die Zeile darüber auskommentieren und
+    # diese drei einkommentieren. Der Kontext ist das **Wurzelverzeichnis** des
+    # Projekts, nicht dieser Ordner – das Abbild braucht backend/ und frontend/.
+    #
+    #   docker compose build app
+    #
+    # build:
+    #   context: ..
+    #   dockerfile: deploy/Dockerfile
+    restart: unless-stopped
+    env_file: .env
+    # Als der Nutzer laufen, dem das Datenverzeichnis auf dem Wirt gehört.
+    # Ohne das legt der Container seine Dateien als uid 100 an, und du kämst
+    # per SFTP nur als root daran.
+    user: "${APP_UID:-1000}:${APP_GID:-1000}"
+    # ocrmypdf und ghostscript legen Arbeitsdateien unter $HOME ab. Bei einem
+    # abweichenden Nutzer ist das Heimverzeichnis aus dem Image nicht mehr
+    # beschreibbar – /tmp im Container ist es immer.
+    environment:
+      HOME: /tmp
+    depends_on:
+      postgres:
+        condition: service_healthy
+    volumes:
+      # Bind-Mount statt eines benannten Volumes: Deine Dateien liegen damit in
+      # einem gewöhnlichen Verzeichnis auf dem Wirt, mit echten Ordnern und
+      # echten Namen (users/<name>/home/…). Du kommst per SFTP, rsync oder
+      # einfach im Dateimanager daran – auch dann noch, wenn diese Anwendung
+      # nie wieder startet. Bei einem benannten Volume läge alles unter
+      # /var/lib/docker/volumes/ und gehörte root.
+      #
+      # Nur lesen. Wer hier hineinschreibt, hat eine Datei auf der Platte, die
+      # in der Datenbank nicht existiert – die Cloud sieht sie nicht, und der
+      # GC räumt sie irgendwann weg. Zum Hineinlegen ist WebDAV der Weg.
+      - ${DATA_PATH:-./data}:/data
+    networks:
+      - internal
+    ports:
+      # Expose on loopback only — your external reverse proxy connects here.
+      # Host port via APP_PORT in .env (default 8080), container port stays 8080.
+      - "127.0.0.1:${APP_PORT:-8080}:8080"
+
+  postgres:
+    container_name: aether-db
+    image: postgres:16-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: ${DB_NAME}
+      POSTGRES_USER: ${DB_USER}
+      POSTGRES_PASSWORD: ${DB_PASSWORD}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - internal
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  # ── Office (optional) ──────────────────────────────────────────────────────
+  # Laeuft nur mit `--profile office`. Ohne das Profil startet der Container
+  # nicht – wer kein Office will, soll nicht 1 GB Arbeitsspeicher dafuer
+  # abgeben, nur weil die Zeilen hier stehen.
+  #
+  #   docker compose --profile office up -d
+  #
+  # Der Office-Server holt die Datei **selbst** beim Backend ab. Er muss Aether
+  # also unter PUBLIC_URL erreichen, nicht unter localhost. Im selben
+  # Compose-Netz erreicht er es unter `app:8080` – dafuer steht `extra_hosts`
+  # bzw. ein PUBLIC_URL, das auf den Wirt zeigt.
+  collabora:
+    container_name: aether-collabora
+    image: collabora/code:latest
+    profiles: ["office"]
+    restart: unless-stopped
+    environment:
+      # Welche Hosts ihre Dateien hier oeffnen duerfen. Punkte maskiert, weil
+      # Collabora den Wert als regulaeren Ausdruck liest.
+      aliasgroup1: ${OFFICE_ALIASGROUP:-http://host.docker.internal:8090}
+      # Zwei getrennte Schalter, und beide zaehlen:
+      #
+      #   ssl.enable       – spricht Collabora selbst HTTPS?
+      #   ssl.termination  – endet HTTPS davor, an einem Reverse Proxy?
+      #
+      # Steht termination auf true, sagt Collabora dem Browser „verbinde dich
+      # per wss://" – auch dann, wenn davor gar kein HTTPS liegt. Im reinen
+      # HTTP-Testaufbau scheitert damit die WebSocket-Verbindung, und der
+      # Editor bleibt leer stehen, obwohl alles andere laedt (gemessen).
+      #
+      # Produktiv hinter deinem Reverse Proxy: OFFICE_SSL_TERMINATION=true.
+      #
+      # mount_jail_tree=false: Collabora sperrt jedes Dokument sonst in einen
+      # eigenen Einhaengepunkt und braucht dafuer CAP_SYS_ADMIN. Die Rechte
+      # dem Container zu geben waere der teurere Weg – ohne den Schalter
+      # scheitert der Start eines Dokuments mit „Failed to exec coolmount".
+      extra_params: >-
+        --o:ssl.enable=${OFFICE_SSL:-false}
+        --o:ssl.termination=${OFFICE_SSL_TERMINATION:-false}
+        --o:mount_jail_tree=false
+      dictionaries: de_DE en_US
+    cap_add:
+      - MKNOD
+    extra_hosts:
+      # Damit der Container den Wirt erreicht – dort haengt der Reverse Proxy
+      # bzw. der veroeffentlichte Port von Aether.
+      - "host.docker.internal:host-gateway"
+    networks:
+      - internal
+    ports:
+      - "127.0.0.1:${OFFICE_PORT:-9980}:9980"
+
+volumes:
+  postgres_data:
+  # "data" ist bewusst weg – die Dateien liegen jetzt unter DATA_PATH auf dem
+  # Wirt (siehe oben). Die Datenbank bleibt ein benanntes Volume: An ihre
+  # Dateien geht man nicht von Hand, und Postgres mag fremde Besitzer nicht.
+
+networks:
+  internal:
+    driver: bridge
diff --git a/frontend/index.html b/frontend/index.html
new file mode 100644
index 0000000..1f48554
--- /dev/null
+++ b/frontend/index.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8" />
+    <!-- viewport-fit=cover: Als installierte App soll der Inhalt den ganzen
+         Schirm nutzen und nicht neben der Kamera-Aussparung eingerahmt stehen.
+         Der Preis ist, dass er dann *unter* Statusleiste und Wischbalken laufen
+         kann – dagegen die safe-area-Abstände in index.css. -->
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+    <link rel="icon" type="image/svg+xml" href="/icon.svg" />
+    <link rel="apple-touch-icon" href="/icon-192.png" />
+    <!-- Das Plugin fuegt keinen Link mehr ein (manifest: false) – der Server
+         erzeugt das Manifest aus den Einstellungen. -->
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <meta name="theme-color" content="#6366f1" />
+    <title>Aether</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
new file mode 100644
index 0000000..92e64ac
--- /dev/null
+++ b/frontend/package-lock.json
@@ -0,0 +1,6522 @@
+{
+  "name": "aether-frontend",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "aether-frontend",
+      "version": "0.1.0",
+      "dependencies": {
+        "@vitejs/plugin-react": "^6.0.2",
+        "pdfjs-dist": "^6.2.108",
+        "react": "^19.2.7",
+        "react-dom": "^19.2.7",
+        "vite": "^8.0.16",
+        "vite-plugin-pwa": "^1.3.0"
+      },
+      "devDependencies": {
+        "@tailwindcss/vite": "^4.3.1",
+        "@testing-library/react": "^16.3.2",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/react": "^19.2.17",
+        "@types/react-dom": "^19.2.3",
+        "tailwindcss": "^4.3.1",
+        "typescript": "^6.0.3",
+        "vitest": "^4.1.9"
+      }
+    },
+    "node_modules/@apideck/better-ajv-errors": {
+      "version": "0.3.7",
+      "resolved": "https://registry.npmjs.org/@apideck/better-ajv-errors/-/better-ajv-errors-0.3.7.tgz",
+      "integrity": "sha512-TajUJwGWbDwkCx/CZi7tRE8PVB7simCvKJfHUsSdvps+aTM/PDPP4gkLmKnc+x3CE//y9i/nj74GqdL/hwk7Iw==",
+      "dependencies": {
+        "jsonpointer": "^5.0.1",
+        "leven": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "peerDependencies": {
+        "ajv": ">=8"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-annotate-as-pure": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.29.7.tgz",
+      "integrity": "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-create-class-features-plugin": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.29.7.tgz",
+      "integrity": "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-create-regexp-features-plugin": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.29.7.tgz",
+      "integrity": "sha512-907Uymvqgg1dwUA+7IGwFAOSYzQOuzPXKNJ1yxzwPffzkYFg2q2eHi1fIOs6sXkG9NbIUMunnUlkYsfRFNvomg==",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "regexpu-core": "^6.3.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-define-polyfill-provider": {
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz",
+      "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==",
+      "dependencies": {
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-plugin-utils": "^7.28.6",
+        "debug": "^4.4.3",
+        "lodash.debounce": "^4.0.8",
+        "resolve": "^1.22.11"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-member-expression-to-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.29.7.tgz",
+      "integrity": "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-optimise-call-expression": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.29.7.tgz",
+      "integrity": "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-remap-async-to-generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.29.7.tgz",
+      "integrity": "sha512-16AMiW26DbXWBbr3B8wNozKM0ydMLB892vaOaJW/fPJdnT8vJk5sdkQcU/isqUxyCE0cEoa8wZOcbgDuC4b6Og==",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-wrap-function": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-replace-supers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.29.7.tgz",
+      "integrity": "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==",
+      "dependencies": {
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.29.7.tgz",
+      "integrity": "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-wrap-function": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.29.7.tgz",
+      "integrity": "sha512-iES0Skag9ERIF68aXadpO6dbXa03mNWK3sEqJaMnLNs/eC3l0lkImdfoy6Y09/SfkpawdAB4RjQ7PVA7TcVGdw==",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.29.7.tgz",
+      "integrity": "sha512-j8SrR0zLZrRsC09DlszEx8FpMiwukKffYXMK0d5LmOglO7vGG6sz/BR/20yHqWH+Lnn31JTt2PE3hIWNgM2J6w==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.29.7.tgz",
+      "integrity": "sha512-r8j8escF+U2FUHo0KOhPUdMzUO+jp9fInva6+ACVAF3Y97Ev+5iNZwiqTghmzNeWwDkOPlYuTcfb1vDaoZKmAQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.29.7.tgz",
+      "integrity": "sha512-GE1TFSiuFeGsCxmYXZl8HwoPrVlwe4rHPFE8weieGKZqnDORK+Ar3vgWMgW+AOxQ6/2TgLSKx9p6W7O4rC6qgQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array/-/plugin-bugfix-safari-rest-destructuring-rhs-array-7.29.7.tgz",
+      "integrity": "sha512-oBNVCvnO5tND+xSopWvV8WNGfpTfgP4Zr/YXXSj8zfmcPktp5Ku/aZlsIowgSD4fjmgHn6sGmB9APVsU5zOdhA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.29.7.tgz",
+      "integrity": "sha512-QQt9qKHZ2sg/kivaLr7lnQr8HVrQDdBNSfCsTjiDxRuX/K5ORyKq+Bu8Xr0cDE3Dfkv0cw28Ve0EKyKMvulkOw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/plugin-transform-optional-chaining": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.13.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.29.7.tgz",
+      "integrity": "sha512-pn6QacGLgvCcwc+syUhKE/qSjV2D1IHDB84RNxWYSt1mW3K/SCtjinZ2p0cETJxAWBjPy3K/1lHwG5BjjPxNlw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-proposal-private-property-in-object": {
+      "version": "7.21.0-placeholder-for-preset-env.2",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz",
+      "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==",
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-import-assertions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.29.7.tgz",
+      "integrity": "sha512-/An1OCBN93thpBAGyfsK2pcf0jvju1SAtKkL2Ny++B5Sy6sqgzXDQH1cZxWbF96Wuk+bn41MDA9bLd4VVAw6rw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-import-attributes": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.29.7.tgz",
+      "integrity": "sha512-zGYcYfq/WmZ4V+kBIXQon9dSSc8ircGZqw9ZaNhhGj9nZkeBu1jHLBDQqYYi5WA9uawvA2sIMbry2nCFhf5Djg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-unicode-sets-regex": {
+      "version": "7.18.6",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz",
+      "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.18.6",
+        "@babel/helper-plugin-utils": "^7.18.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-arrow-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.29.7.tgz",
+      "integrity": "sha512-N7zArUXWzAMzm+/N0uPBeVB3Fam5lMxtUwMmDK5f/IBBS7a7p1qeUoxd/6CckXoxUdgsntq1Dh8xNW06maZbDQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-async-generator-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.7.tgz",
+      "integrity": "sha512-d98gXZkgswvkyohMBABkhm3GeXhYj8psWfwQ2C7gtfrKGTykQa/iOIi+JJhwMjPlZ6Vm2XN+DCf3Es1EoG4ZLA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-remap-async-to-generator": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-async-to-generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.29.7.tgz",
+      "integrity": "sha512-pcUb2SS+RMo9TWVBwKGI5ShtoG7R+zBsFmCKDa6fe8c+hPr3XJlZgoE5j6i8W7gDjhyvy+85vmYexanvXh3d1w==",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-remap-async-to-generator": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-block-scoped-functions": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.29.7.tgz",
+      "integrity": "sha512-cUSmjh72N+rN4PrkFlN1dJwNCwjVp5d38/CQrEsFggkD10UiFlBFgdH3tv5dNsLuHY+3S8db2xCHjhZcv5WgvA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-block-scoping": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.29.7.tgz",
+      "integrity": "sha512-ONyr4+AZhKh8yKWInVxU9AXA9EbsyeLcL6V0dJy6M2/62vuvpGm29zzuymbTpdc451GEpDIdAyPLP3r+P61yKQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-class-properties": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.29.7.tgz",
+      "integrity": "sha512-GtcpjFvanPfzNQi3eTitsCqtRRmmqzpy/A+yhTR1HaZo1Ly3EA8ZXxlPyHdR8/IuRMYc3E4wdGBewB2QKQjAaA==",
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-class-static-block": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.29.7.tgz",
+      "integrity": "sha512-kibJgmEdX2iMwsHY2tSZNDgj8PwIlCQz7FK9KuGKO8zsuoUwSEhoNnNVp/emKWrbY4HeO6kkXfdMqRKKKXBm2A==",
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.12.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-classes": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.29.7.tgz",
+      "integrity": "sha512-qV0OGGBVacduzQHE649JyCneOFI/maT+YKsO+K4Yi3xv2wTPNjM/W2o2gdzMwEAZz7fXNTHAe0NcSg30bIN69g==",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-computed-properties": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.29.7.tgz",
+      "integrity": "sha512-RK7/IyU5phpuCdBAuig5VkzG/EnbDaui5SQGdU9BFrHdV+mV4cUjLMQ9lJDjLNtWHsqtiefpGZUXQP2BiTYMsA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/template": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-destructuring": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.29.7.tgz",
+      "integrity": "sha512-iPX8aD6H9zV5s7ZsqTdNocPN/MGQ5sSMnElKrktxjJRMnB2jN/1p2+R7GkfD6CAYoVFqy5A4XnSIUeGgJzIWpg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-dotall-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.29.7.tgz",
+      "integrity": "sha512-3qc18hsD2RdZiyJNDNc7HQpv6xbncwh8FYtxNFFzclSyh/trPD9KkVR9BDECUjDLvb7yJVF15GfYUuC+LMkkiQ==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-duplicate-keys": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.29.7.tgz",
+      "integrity": "sha512-6IvRRriEMqnBwD6chtxdLpMYCHWEzN+oL5cyQtjykya19UgzbmKhxmhZgKC/LHxS2nYr9Q/qYPZ5Lr6jOL9+yQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.7.tgz",
+      "integrity": "sha512-2wiIyo2BjtgU7HufSeDnL9L2O7zr8jmhFKuSr65VpRkUiRKRNpb0mdlk56+XPPKoIrfHqzbMuglDvZun0RISsA==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-dynamic-import": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.29.7.tgz",
+      "integrity": "sha512-giOlEm/EFjfjr+te9NsdjkUo2v4f8rS/SXPumRVHAtbNcyNlvtREkU1dZzaIDclNpnaVhlCqRdFKhJBjBikzLg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-explicit-resource-management": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.29.7.tgz",
+      "integrity": "sha512-Rstj7coNz8sE+7Ju7ihpHLI564lsK5pUpNNlvptCIC/16E/S5hbl6n3kESPKdNRmqEWlpn5xpS5Q2dvXBsySLw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-exponentiation-operator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.29.7.tgz",
+      "integrity": "sha512-zFpMOTLZBdW5LfObqcSbL6kefg4R4eLdmvS0wbN9M6D5Mym/sKm9toOoWyVOa+xDjvCnuWcHls2YonXwHvH3CQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-export-namespace-from": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.29.7.tgz",
+      "integrity": "sha512-24B2nOy2TeJSMheqwPD4DDQOV/elLSIlKxjZt4i05H5AgdPdWR3n18HnNrcJ+j76WJd9gbwb9jPjNYUy6RautA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-for-of": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.29.7.tgz",
+      "integrity": "sha512-zeSIHh0+E1Um1WJRXCFlHQYu2ieJNdivLLjlBEp+dIBu3S51n+SZZmIXjxnItw6pz56Cn+KvK68BIBVsxq2JiQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-function-name": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.29.7.tgz",
+      "integrity": "sha512-otRWaHXE6fbAGkePvaj/kvs3HsqXfPhlnzwSOlnFgbqCPMd975dW+4wZ00WFBt+/YlBGcJwNrARQTOJOb4ZrIg==",
+      "dependencies": {
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-json-strings": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.29.7.tgz",
+      "integrity": "sha512-RRnE2+eon1rJAq8MnoF1b5kTpY1vU88twHcvcKMrsqP/jxIRqDVs9iJB5fqPuqyeFAW0wJo4MlUIPpQCq/aRsg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.29.7.tgz",
+      "integrity": "sha512-DZ/oLP21ZuWx1vKqnoNv6/tvEK48AQOBRai40CX9dTjGluvT/YZCyY3rryDtyUqCEoyNroy5KKPwX2iQCiRvyw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-logical-assignment-operators": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.29.7.tgz",
+      "integrity": "sha512-A0H91hh6W8MFRkp5TqJmMr39jzGD1A1E1Ysiv2O06Sfbhkapm+XyIzxWCEh5kqwOZ1/8QZ0dY3SeQ7XBqfJd5Q==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-member-expression-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.29.7.tgz",
+      "integrity": "sha512-hl1kwFZCCiDyfH25Xmco9jTrkPgnS9pmOzSG7W5I4SaGbLeqKv417hcU2RKmaxoPEgsoJh7ZPOrnPGq99bHoUg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-modules-amd": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.29.7.tgz",
+      "integrity": "sha512-fxtQoH3m5ywUSIfaH0FGCzWu4McsYon5bD3K4XnskC7f+OyQMj7rsOMi4NvvmJ83WwBAg4UCe+ov4VZlqEvyew==",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-modules-commonjs": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.29.7.tgz",
+      "integrity": "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-modules-systemjs": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.7.tgz",
+      "integrity": "sha512-TM2ZcQLoG2/y4HODiStCo10DibYhWhGWAwVv+EQKmG/7GFl0N+AAmUiXOMKM+aiJ9XBJ9AHVZBvTzMnJ2sM3cQ==",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-modules-umd": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.29.7.tgz",
+      "integrity": "sha512-B4UkaTK3QpgCwJnrxKfMPKdo92CN7OKXAlpAAnM3UPu0Q0lCCk57ylA9AJbRy2v8dDKOPAAWcoR6CMyeoHwRCA==",
+      "dependencies": {
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-named-capturing-groups-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.7.tgz",
+      "integrity": "sha512-vuFoLwr4qnv2xbZ16SQd6uPcH5FNrLHhk/Jzo++0XJFcaDsr4gjJVg6j398oMHiC+83k/GiBzviwF5KBJkPUtQ==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-new-target": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.29.7.tgz",
+      "integrity": "sha512-fEo41GmsOUhOBlw8ioo6zvjX5Xc2Lqkzlyfqbpsk3eB6TReV18uhxZ0esfEokVbY2+PVJAQHNKxER6lGrzNd3A==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-nullish-coalescing-operator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.29.7.tgz",
+      "integrity": "sha512-idmp1dFaekP9GbcMvG24Kvw2BfhFZjHnNJCkV4WuIY4PskJzwI3f1N5OdgYke38T7rftO6ERulFRn2cFeZwRkg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-numeric-separator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.29.7.tgz",
+      "integrity": "sha512-zR7fv/z14OjgHl4AgRtkDBvBMhIzCxqV/qN/2BCRC7LjFwvuzjYe7gDWxC4Wl/SNsLM6SE1IWvRPYMgSJaUvNw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-object-rest-spread": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.29.7.tgz",
+      "integrity": "sha512-Ld98jn4c0smUywL57m7SgsHq3OpThOa6LqZJif3G6jYOovPleoFhVrBJ1WegRApSFB2wu4+RelAj9AC9G08Z4A==",
+      "dependencies": {
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7",
+        "@babel/plugin-transform-parameters": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-object-super": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.29.7.tgz",
+      "integrity": "sha512-Ea/diGcw0twB5IlZPO5sgET6fJsLJqPABqTuFWIR+iMPGPZJkATEIWx0wa+aEQ5UY1CBQyP/gkAiLEqn1vBiQA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-optional-catch-binding": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.29.7.tgz",
+      "integrity": "sha512-sLsyndxK2VwX6yNUOakMb7Sh553ZTe/vVM1XJ+9Z5aW1ytsc8xOIwmyk05NNjN60vkc5/KqoTH6hB4V41LJhng==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-optional-chaining": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.29.7.tgz",
+      "integrity": "sha512-6GM1dhvK3gNODkXcEcMCOLEDCLSoZ/sBbro2Ax8HURyasQ4NshagQixkRFdh5niI6E4gmA/jYI/4aT7rRos3ZQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-parameters": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.29.7.tgz",
+      "integrity": "sha512-ZDOBqV/qLYJI0YElr8DcENEyARsFQeESqWXH6gZlghYXuPPjvweuDhP4VyEi4BlUBlLRFZVjxoZDMjxhLW766g==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-private-methods": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.29.7.tgz",
+      "integrity": "sha512-/6Rz4DK1ETDEM/bWHsPHcaEe7ZaT1EqSXjtSP/L0DijOYuaUhiRiOKcwpZ8P7zR4xXEHc2ITdiCgBm9Tpyv9ug==",
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-private-property-in-object": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.29.7.tgz",
+      "integrity": "sha512-+BNo06dnrzdNNqCm1X6YUaVv0DKk8Q+JYcoZfOkLhYWNCXzlwTSRq8zGWayT1csjcpNXV9CQTBRRbmTLZac5cA==",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-property-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.29.7.tgz",
+      "integrity": "sha512-bOMRLQuI0A5ZqHq3OWJ89/rXpJ/NJrbVhXiP4zwPGMs6kpcVsuTUNjwoE30K0Qm3mf48a/TnRYYD6vPNqcg6jA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-regenerator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.7.tgz",
+      "integrity": "sha512-rNNFV0DBAJp988xW2DOntfDoYn1eR8GGF5AT5vYc+rjyfaQkM242c9tZUHHPe7KYaiJizXPWhQTzzdbXySyhBw==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-regexp-modifiers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.29.7.tgz",
+      "integrity": "sha512-mB5Fs0VWrJ42ZCmc8114v60qetdaUVNkj9PmSZRmanCZM3S9hm0CFRLjRmYIsuXav14l2jvZ+4T8iiCGnhj3nQ==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-reserved-words": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.29.7.tgz",
+      "integrity": "sha512-5+YhdpVgmfSmwZyLMftfaiffLRMHjzIRHFHHLdibcSyJm2pasMrKHrO3Ptrt2DRshjvpgjEJJ1zVW14WPq/6QA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-shorthand-properties": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.29.7.tgz",
+      "integrity": "sha512-I+WYbGBAiCn7nA6xBrlgPH+MB7HWb4u8pv5S0Pv7OtwNvIFvCCb24YlttKEeUFVurfBCEaOTnuhlqsb7f0Z5Dg==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-spread": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.29.7.tgz",
+      "integrity": "sha512-/u5K1QWada7tbYNqTjMh96718g9NTwh9tfPJMsSmVsQwGT447FskV+KcfeXkXq2GWki4EM/MuTdmBec+hOuVTQ==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-sticky-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.29.7.tgz",
+      "integrity": "sha512-BCHzNYJGe9l7EpwwDBN/ztlL2NYFFq8hp9ddjtUEM9f2O7S7kKV/lL6Fwo7IF7NSkYhPK2vO+86nIGltA90MsA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-template-literals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.29.7.tgz",
+      "integrity": "sha512-NCSEJ4sLFU2gqAub45HYh4fus2yQ36rr6ei6vpU7NdoJqCpxvEG8E6eJpscGyXP3VHD2Ny+fSXr04k1hoUrFqA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-typeof-symbol": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.29.7.tgz",
+      "integrity": "sha512-223mNGoTkBiTEWFoK+Q6Go3tueMRclO8vxxxxquNCYuNI4jWOofFKJRRDu6SDrB8Sgo1UEGW9T4GAQ8ZyRso1A==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-escapes": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.29.7.tgz",
+      "integrity": "sha512-jCfXxSjf94lf4E0hKE0AByxF6F3/pVFqRdUUNkDJhsY0m1ZKjnN6ZYyMeHNpzflxb/0q5b7t3p+BE+SLF1WOtA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-property-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.29.7.tgz",
+      "integrity": "sha512-OgZ+zoAJgZLUCunsTRQ5LAjOywDv5zzZ2/hQ5aMw1pGXyY2rtE8/chXYUmu3AlVHKpm10KEdG9aMwbI/K76ZGw==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.29.7.tgz",
+      "integrity": "sha512-7D/x/23/d/3VqZ0QA+LGbZMlGwZjztBygSWWWsfTPoQ1oQ6Q1P6Mr3d0kk42XabyUVw+fha3LqdRsFqeKqvCyA==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-unicode-sets-regex": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.29.7.tgz",
+      "integrity": "sha512-BLOhLht9DOJwIxlmp91wHvkXv1lguuHS3/FwUO8HL1H0u8s4hR1gASVFyilu9iGtcTRYqjTZmlsFFeQletntEg==",
+      "dependencies": {
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/preset-env": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.7.tgz",
+      "integrity": "sha512-GYzX36n1nsciIb0uyH0GHwxwtNwPQIcpxSeiVLDtG/B7jB5xXgchnmL1f/jCX5o+pwnaDBtO60ONSJhEBJfxYA==",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.29.7",
+        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.29.7",
+        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.29.7",
+        "@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": "^7.29.7",
+        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.29.7",
+        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.29.7",
+        "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2",
+        "@babel/plugin-syntax-import-assertions": "^7.29.7",
+        "@babel/plugin-syntax-import-attributes": "^7.29.7",
+        "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6",
+        "@babel/plugin-transform-arrow-functions": "^7.29.7",
+        "@babel/plugin-transform-async-generator-functions": "^7.29.7",
+        "@babel/plugin-transform-async-to-generator": "^7.29.7",
+        "@babel/plugin-transform-block-scoped-functions": "^7.29.7",
+        "@babel/plugin-transform-block-scoping": "^7.29.7",
+        "@babel/plugin-transform-class-properties": "^7.29.7",
+        "@babel/plugin-transform-class-static-block": "^7.29.7",
+        "@babel/plugin-transform-classes": "^7.29.7",
+        "@babel/plugin-transform-computed-properties": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7",
+        "@babel/plugin-transform-dotall-regex": "^7.29.7",
+        "@babel/plugin-transform-duplicate-keys": "^7.29.7",
+        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.7",
+        "@babel/plugin-transform-dynamic-import": "^7.29.7",
+        "@babel/plugin-transform-explicit-resource-management": "^7.29.7",
+        "@babel/plugin-transform-exponentiation-operator": "^7.29.7",
+        "@babel/plugin-transform-export-namespace-from": "^7.29.7",
+        "@babel/plugin-transform-for-of": "^7.29.7",
+        "@babel/plugin-transform-function-name": "^7.29.7",
+        "@babel/plugin-transform-json-strings": "^7.29.7",
+        "@babel/plugin-transform-literals": "^7.29.7",
+        "@babel/plugin-transform-logical-assignment-operators": "^7.29.7",
+        "@babel/plugin-transform-member-expression-literals": "^7.29.7",
+        "@babel/plugin-transform-modules-amd": "^7.29.7",
+        "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+        "@babel/plugin-transform-modules-systemjs": "^7.29.7",
+        "@babel/plugin-transform-modules-umd": "^7.29.7",
+        "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.7",
+        "@babel/plugin-transform-new-target": "^7.29.7",
+        "@babel/plugin-transform-nullish-coalescing-operator": "^7.29.7",
+        "@babel/plugin-transform-numeric-separator": "^7.29.7",
+        "@babel/plugin-transform-object-rest-spread": "^7.29.7",
+        "@babel/plugin-transform-object-super": "^7.29.7",
+        "@babel/plugin-transform-optional-catch-binding": "^7.29.7",
+        "@babel/plugin-transform-optional-chaining": "^7.29.7",
+        "@babel/plugin-transform-parameters": "^7.29.7",
+        "@babel/plugin-transform-private-methods": "^7.29.7",
+        "@babel/plugin-transform-private-property-in-object": "^7.29.7",
+        "@babel/plugin-transform-property-literals": "^7.29.7",
+        "@babel/plugin-transform-regenerator": "^7.29.7",
+        "@babel/plugin-transform-regexp-modifiers": "^7.29.7",
+        "@babel/plugin-transform-reserved-words": "^7.29.7",
+        "@babel/plugin-transform-shorthand-properties": "^7.29.7",
+        "@babel/plugin-transform-spread": "^7.29.7",
+        "@babel/plugin-transform-sticky-regex": "^7.29.7",
+        "@babel/plugin-transform-template-literals": "^7.29.7",
+        "@babel/plugin-transform-typeof-symbol": "^7.29.7",
+        "@babel/plugin-transform-unicode-escapes": "^7.29.7",
+        "@babel/plugin-transform-unicode-property-regex": "^7.29.7",
+        "@babel/plugin-transform-unicode-regex": "^7.29.7",
+        "@babel/plugin-transform-unicode-sets-regex": "^7.29.7",
+        "@babel/preset-modules": "0.1.6-no-external-plugins",
+        "babel-plugin-polyfill-corejs2": "^0.4.15",
+        "babel-plugin-polyfill-corejs3": "^0.14.0",
+        "babel-plugin-polyfill-regenerator": "^0.6.6",
+        "core-js-compat": "^3.48.0",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/preset-modules": {
+      "version": "0.1.6-no-external-plugins",
+      "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz",
+      "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.0.0",
+        "@babel/types": "^7.4.4",
+        "esutils": "^2.0.2"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
+      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
+      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@isaacs/cliui": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-9.0.0.tgz",
+      "integrity": "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.11",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+      "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@napi-rs/canvas": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-1.0.7.tgz",
+      "integrity": "sha512-26wVFEgs6gbe7wmzCrud1pK8q6oOgcUu7OOF24BuazB8ZUCskU9ZSLrCjoWIFVxx09rjAxsXxPleaWowHvdPCA==",
+      "license": "MIT",
+      "optional": true,
+      "workspaces": [
+        "e2e/*"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas-android-arm64": "1.0.7",
+        "@napi-rs/canvas-darwin-arm64": "1.0.7",
+        "@napi-rs/canvas-darwin-x64": "1.0.7",
+        "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.7",
+        "@napi-rs/canvas-linux-arm64-gnu": "1.0.7",
+        "@napi-rs/canvas-linux-arm64-musl": "1.0.7",
+        "@napi-rs/canvas-linux-riscv64-gnu": "1.0.7",
+        "@napi-rs/canvas-linux-x64-gnu": "1.0.7",
+        "@napi-rs/canvas-linux-x64-musl": "1.0.7",
+        "@napi-rs/canvas-win32-arm64-msvc": "1.0.7",
+        "@napi-rs/canvas-win32-x64-msvc": "1.0.7"
+      }
+    },
+    "node_modules/@napi-rs/canvas-android-arm64": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-android-arm64/-/canvas-android-arm64-1.0.7.tgz",
+      "integrity": "sha512-d5p4hHTykc/9PjiBXkvCH/IC5hT5jH7BjQ1u8ITq+G8x4VmvveOHdy/4BWYcC3ebWRmrG9zEc/oCTy+Yf3iZ4A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-arm64": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-arm64/-/canvas-darwin-arm64-1.0.7.tgz",
+      "integrity": "sha512-jKfZl2QDqBr6/Ap/8NKkX0Po9SFfVjUPBJbQQmYGVtQQIazWWIAO60riH3Mz2sOyysa2oJO39sLEfXerypu0vg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-x64": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-x64/-/canvas-darwin-x64-1.0.7.tgz",
+      "integrity": "sha512-v1asrnKBu0tD+sdSD2qVIUfhoXSrr8LFTn7z76pN+8xsiOrmFcAVty57R/5DB8ZNqNLKsUBDXFSrzf4Wt9NaSg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm-gnueabihf": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm-gnueabihf/-/canvas-linux-arm-gnueabihf-1.0.7.tgz",
+      "integrity": "sha512-c4Hcu4L5bXCgLY8jrZ2hy/Avl65MsbfH9DqNWrrd9InbpBZZF/rmrh7XkgmTUmOFcUrt/PaFSBinW2C0moDgcA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-gnu": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-gnu/-/canvas-linux-arm64-gnu-1.0.7.tgz",
+      "integrity": "sha512-OVW6T1x65BTVfWb//xylCoWxbdII+nzHu3L5T035aerBAnZ5e0nmeTMkMEO9qQrVJq4WcWW8hp+T0dF+JvJPUQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-musl": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-musl/-/canvas-linux-arm64-musl-1.0.7.tgz",
+      "integrity": "sha512-KX/k1UO61XdKlXxhtIkq1ZUH8uP+NNK4vSrBcM2/4wWUUCZaG93BU5s0KuE9n+TFn0jEoqLSlXOuH1pYuV5dcQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-riscv64-gnu": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-riscv64-gnu/-/canvas-linux-riscv64-gnu-1.0.7.tgz",
+      "integrity": "sha512-r+0Bg+fK8r2AsrbeT7JwBUAERZSjlyhfAMQfZE/zxYGmbswS92hN0FPjynVWbeuz5fIrLfZ6JA5pH8V6drN6qw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-gnu": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-1.0.7.tgz",
+      "integrity": "sha512-0tT9KzEcTfb6MWdUWIDfy6uq6UNF691r/9NfXxxl8s9+G5QrD7VP1UC+PAwzsCzJTClIKyidNau/grYTL+QmHw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-musl": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-1.0.7.tgz",
+      "integrity": "sha512-rvT0xo1xA+C7e+U/2ngsxWsl9gC5knHU+z8KTT5VK0Zos4AQbWZvtjvegrmzxm4o2yHE32Lexj6CDEJNvuTczA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-arm64-msvc": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-arm64-msvc/-/canvas-win32-arm64-msvc-1.0.7.tgz",
+      "integrity": "sha512-N6s3yoFFPUDkfRpjUiKERVYkli7ex5Sf0Bu/My6D6gOGYxYolC1KvL6x8U0aN+ScCWAzbkIWcMYR9g0OGsFuVw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-x64-msvc": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-x64-msvc/-/canvas-win32-x64-msvc-1.0.7.tgz",
+      "integrity": "sha512-SKTNdBV/ljfhkPsLhXjm4x2PQ0ILpc0PhkBzRHuroJXidZUaF5yh0j3s3dIzB8PrRmW+nEASzyMTaWT3nH1ywQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.5.tgz",
+      "integrity": "sha512-AWPoBRJ9tsnVhor4sjO7rkni+7p+2IAEFj6cx06UgP10jkQHqay/36uRV/bFkgrh18D9vb4cr8Q0Pthskgzy+Q==",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.133.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.133.0.tgz",
+      "integrity": "sha512-KzkdCd6Uxqnf6l3HOw1xfatAlUURA0g14cvBYFyJ5SaNOQbOUvBr9PKArcPcrNIeRsBdgcUzOGrhKveVpvOIGA==",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.3.tgz",
+      "integrity": "sha512-454rs7jHngixp/NMxd5srYD57OnzSlZ/eFTETjORQHLwJG1lRtmNOJcBerZlfu4GjKqeq8aCCIQrMdHyhI51Hw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.3.tgz",
+      "integrity": "sha512-PcAhP+ynjURNyy8SKGl5DQP94aGuB/7JrXJb/t7P+hanXvQVMWzUvRRhBAcg/lNRadBhoUPqSoP4xw5tR/KBEA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.3.tgz",
+      "integrity": "sha512-9YpfeUvSE2RS7wysJ81uOZkXJz7f7Q55H2Gvp3VEw/EsahqDtrphrZ0EwDLK5vvKOzaCrBsjF8JmnMLcUt78Gg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.3.tgz",
+      "integrity": "sha512-yB1IlAsSNHncV6SCTL27/MVGR5htvQsoGxIv5KMGXALp+Ll1wYsn+x98M9MW7qa+NdSbvrrY7ANI4wLJ0n1e6g==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.3.tgz",
+      "integrity": "sha512-Yi30IVAAfLUCy2MseFjbB1jAMDl1VMCAas5StnYp8da9+CKvMd2H2cbEjWcw5NPaPqzvYkVIaF1nNUG+b7u/sw==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.3.tgz",
+      "integrity": "sha512-jsO7R8To+AdlYgUmN5sHSCZbfhtMBkO0WUx8iORQnPcMMdgr7qM2DQmMwgabs3GhNztdmoKkMKQFHD6DTMCIQw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.3.tgz",
+      "integrity": "sha512-VWkUHwWriDciit80wleYwKILoR/KMvxh/IdwS/paX+ZgpuRpCrKLUdadJbc0NpBEiyhpYawsJ73j9aCvOH+f7Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.3.tgz",
+      "integrity": "sha512-5f1laC0SlIR0yDbFCd8acUhvJIag6N3zC5P7oUPN6wX0aOma+uKJ0wBDH5aq7I1PVI2ttTlhJwzwRIBnLiSGEg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.3.tgz",
+      "integrity": "sha512-Iq4ko0r4XsgbrF/LunNgHtAGLRRVE2kXonAXQ/MV0mC6jQpMOhW1SvtZja2EhC/kd05++bP78dsqBeIQyYJ6Yg==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.3.tgz",
+      "integrity": "sha512-B8m6tD5+/N5FeNQFbKlLA/2yVq9ycQP1SeedyEYYKWBNR3ZQbkvIUcNnDNM03lO1l5F2roiiFJGgvoLLyZXtSg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.3.tgz",
+      "integrity": "sha512-pSdpdUJHkuCxun9LE7jvgUB9qsRgaiyNNCX7m/AvHTcq67AiT/Yhoxvw5zPfhrM8k/BfP8ce/hMOpthKDpEUow==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.3.tgz",
+      "integrity": "sha512-OXXS3RKJgX2uLwM+gYyuH5omcH8fL1LJs96pZGgtetVCahON57+d4SJHzTgZiOjxgGkSnpXpOsWuPDGAKAigEg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.3.tgz",
+      "integrity": "sha512-JTtb8BWFynicNSoPrehsCzBtOKjZ6jhMiPFEmOiuXg1Fl8dn2KHQob+GuPSGR0dryQa1PQJbzjF3dqO/whhjLg==",
+      "cpu": [
+        "wasm32"
+      ],
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "1.10.0",
+        "@emnapi/runtime": "1.10.0",
+        "@napi-rs/wasm-runtime": "^1.1.4"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.3.tgz",
+      "integrity": "sha512-gEdFFEN70A/jxb2svrWsN3aDL7OUtmvlOy+6fa2jxG8K0wQ1ZbdeLGnidov6Yu5/733dI5ySfzFlQ/cb0bSz1g==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.3.tgz",
+      "integrity": "sha512-eXB7CHuaQdqmJcc3koCNtNPmT/bj2gc999kUFgBxG8Ac0NdgXc4rkCHhqrgrhN3zddvvvrgzj1e90SuSfmyIXA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="
+    },
+    "node_modules/@rollup/plugin-babel": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.1.0.tgz",
+      "integrity": "sha512-dFZNuFD2YRcoomP4oYf+DvQNSUA9ih+A3vUqopQx5EdtPGo3WBnQcI/S8pwpz91UsGfL0HsMSOlaMld8HrbubA==",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.18.6",
+        "@rollup/pluginutils": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0",
+        "@types/babel__core": "^7.1.9",
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/babel__core": {
+          "optional": true
+        },
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-node-resolve": {
+      "version": "16.0.3",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-16.0.3.tgz",
+      "integrity": "sha512-lUYM3UBGuM93CnMPG1YocWu7X802BrNF3jW2zny5gQyLQgRFJhV1Sq0Zi74+dh/6NBx1DxFC4b4GXg9wUCG5Qg==",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "@types/resolve": "1.20.2",
+        "deepmerge": "^4.2.2",
+        "is-module": "^1.0.0",
+        "resolve": "^1.22.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.78.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-replace": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-6.0.3.tgz",
+      "integrity": "sha512-J4RZarRvQAm5IF0/LwUUg+obsm+xZhYnbMXmXROyoSE1ATJe3oXSb9L5MMppdxP2ylNSjv6zFBwKYjcKMucVfA==",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.0.1",
+        "magic-string": "^0.30.3"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/plugin-terser": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-1.0.0.tgz",
+      "integrity": "sha512-FnCxhTBx6bMOYQrar6C8h3scPt8/JwIzw3+AJ2K++6guogH5fYaIFia+zZuhqv0eo1RN7W1Pz630SyvLbDjhtQ==",
+      "dependencies": {
+        "serialize-javascript": "^7.0.3",
+        "smob": "^1.0.0",
+        "terser": "^5.17.4"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.4.0.tgz",
+      "integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.0.tgz",
+      "integrity": "sha512-IPIQ55ythEHkfEd9jMEi32OQ7SxURsGA43JI22lj01OLZNt2NUbJX8YUHxkVWyQ6daHPNn0truF5nSj3DQp6YQ==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.0.tgz",
+      "integrity": "sha512-M6s9cr10MibETyo8JsOkq+Lo1+lU6hcvb1MApnUql5qte/5hMEgzlN8/ReIKNfRV8rrqX50W1BX9zoUhC192RA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.0.tgz",
+      "integrity": "sha512-BqCoMoIbn0keKys+dEAdBa70EtOwV1bEsQCUgU9FdiZmmMge/Zk7LlkYGqbrdHR+Frnt0E1FOanly+rlwvvQzw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.0.tgz",
+      "integrity": "sha512-SIMzST3VFNXDAbeIWDWiFCNM5qncUBDWaEV7NfE7oZbDt2mgfW4MvbKdbYiGOLoM32gbTv608UMd0XktEYSD7w==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.0.tgz",
+      "integrity": "sha512-ezjfSQMP7ArdUsbBwbQIfwAlhE84I2iVnzQNCFSveqV42q+BmKlzVpf7mxv5EchLcoWU4y6/heFzVg1F+hodUQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.0.tgz",
+      "integrity": "sha512-9+qTWGW9AZRhnUgwtTwzNwcPlL87ngkeN0LA+q1bADvmY9aNvWaF2TFW8BZgnQPYxpDI7+rMVLivcd4V737TAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.0.tgz",
+      "integrity": "sha512-T1dMEQhXA/jkJ/jyMIw9IovK8bSUq7A8kLIlvZTb/6YIVsp2zLavr4F3oyllHWo7eIVJRyE5n3tUjQJEbE1IuQ==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.0.tgz",
+      "integrity": "sha512-2as0LgT7qQpyceQq6VUJYnumUMUrgGQCWIiDIN9DE0/tglsk6o66uCB4f3djRawAltvfCNLyZZrsqbPA6inCsA==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.0.tgz",
+      "integrity": "sha512-bVURMg+6eNN9C/yc0aVjooZcwTTtYF4YW3xta5pP0//r3o1V8gXEHXWCndj47w/HhwsFroZrFhR+6uQP5T0n0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.0.tgz",
+      "integrity": "sha512-Ful8pM/2yYI83PViWdFdpZhdI8HJ5qsXANe5atypbHDf+KIBBDsZsbyy8hbXnULVvW9NsTh5DHwbcBftyLTfiw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.0.tgz",
+      "integrity": "sha512-9Gp/DgrkzfUBmNPVTyPTvay+4xEP7M/clXpj3efXBcm6uTIVIgDg4rqUpqKXvLEuFRVuEpSAOkhgNeecvaZ4Cg==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.0.tgz",
+      "integrity": "sha512-m9tsJz54LUXkSYM8+8PG81B9IKK5r+2T0clMq4QrS16xFosufU7firBDAZEsDheDs7wTlP7h3++S7lMsU955HA==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.0.tgz",
+      "integrity": "sha512-3UvJ5PNVU16aJf6M3tFI24pWzAl2/ynfbyRN3ICyQajK1lSkrnVYNnLz3v04J32qKa0FczJc22zeToc0lr2A3w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.0.tgz",
+      "integrity": "sha512-vRWUAbYLGHBZS6Q8Msb2sfnf1fvJf+47t8l/TwOerM2qArzy+IeNMTHrYLHXh95h8MoatPHI5hhSZNs+mGXKPg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.0.tgz",
+      "integrity": "sha512-c00T5SYENHAt86cfW47URaP3Us5vLC/4QO7GYud1G5VNRffCwwCuBspwqYrriuJB+5m0WFzClCn9wed0FBjKvg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.0.tgz",
+      "integrity": "sha512-krrCDilhXOwFkSkO3Wm9I/f9H0L92XHHwy2fwxjukxIbh0dem8gZqOW5Y8BsHrpJv5qwlRBV+Wl4ZFyRWhUpwg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.0.tgz",
+      "integrity": "sha512-7pfYFSTc4/rUC/FtAI0Qp6QthDBCIi6/AuP1xYqFk5vanI6KnL5dWKP60OM/05LOsbwTmIcvr6eXC4CJuJ75IA==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.0.tgz",
+      "integrity": "sha512-7SDIalKeIpG0Ifogbbdn58HmSotYMlf23K3dCJEmiVd9Fg36Vmni82iPQec27N3wY4Bvbxftkxz6vSx9OcouTg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.0.tgz",
+      "integrity": "sha512-eRZevouTH2i1HeAVLqJuLnt256krQkGY0TN6WsTmsIhuzbh457HuWDMakKwmi0Cjadux983CoSr8Lim2QhUIFw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.0.tgz",
+      "integrity": "sha512-3oVS7FLGa4U1qcvao9ylGxrjXZyUQqR8UwxEcnUEyPX53O/C/mKDZegNXTdHCP+h3e6ta/f1EN38Yif1mmZHYg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.0.tgz",
+      "integrity": "sha512-yTB9TgfWj5wHe5QgktAgXTLLot1gvEjl1NiPPAUiCs4oPrIWFl5V4nC3GrkNdj9LaAU4s94nVrGbGOCqUpyWsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.0.tgz",
+      "integrity": "sha512-5LOhoaesY3doG1c+ac/2JtgREpKoJr5bUHH8tKY0V8di7+uSV6BwLs2PlR0/yzefGOkR+wE7ZolZphHCsyG5Rw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.0.tgz",
+      "integrity": "sha512-yYkWHhmbhRTWTnWos5HC4GcPQfjlzzCNbM9e/+GXrLuaBXYA3qSDR9f0Vgufd5S8yX81U8jPKp7ZnAjZFMtRnw==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.0.tgz",
+      "integrity": "sha512-SoTb6lPg25xZlA2ibwQ++ahCCnH+FP0qmEuafMJ4gznZKOlXioKEAeJLgCrqjM98ACziXM9V1amFjICVL4IFoA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.0.tgz",
+      "integrity": "sha512-5L+T1fMX4RIEBoZzT0+sQ0PhTS36NULFmMXtl1TZo44TMAROIMHbZufSOjVWt/Y622BtxgxtaNOokbTDvfsrZA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true
+    },
+    "node_modules/@tailwindcss/node": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.3.1.tgz",
+      "integrity": "sha512-6NDaqRoAMSXD1mr/RXu0HBvNE9a2n5tHPsxu9XHLws8o4Twes5rBM2205SUUiJ9goAtadrN6xTGX0UDEwp/N4A==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "enhanced-resolve": "5.21.6",
+        "jiti": "^2.7.0",
+        "lightningcss": "1.32.0",
+        "magic-string": "^0.30.21",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.3.1"
+      }
+    },
+    "node_modules/@tailwindcss/oxide": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.3.1.tgz",
+      "integrity": "sha512-yVPyo8RNkabVr3O2EhHEE0Rewu7YKzc1DhIqfL46LKveFrmu9XbDazNOJY7/GRuvw1h6u3utWnR29H/p5JPlgA==",
+      "dev": true,
+      "engines": {
+        "node": ">= 20"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.3.1",
+        "@tailwindcss/oxide-darwin-arm64": "4.3.1",
+        "@tailwindcss/oxide-darwin-x64": "4.3.1",
+        "@tailwindcss/oxide-freebsd-x64": "4.3.1",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.1",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.3.1",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.3.1",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.3.1",
+        "@tailwindcss/oxide-linux-x64-musl": "4.3.1",
+        "@tailwindcss/oxide-wasm32-wasi": "4.3.1",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.3.1",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.3.1"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-android-arm64": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.3.1.tgz",
+      "integrity": "sha512-SVlyf61g374l5cHyg8x9kf5xmLcOaxvOTsbsqDnSsDJaKOEFZ7GCvi84VAVGpxojYOs1+3K6M0UjXfqPU8vmOQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.3.1.tgz",
+      "integrity": "sha512-hVnWLwv+e/l7c4WKyVtHVrIPvYdqWHjRB3MDIqARynzFtnQg85kmQEFCbV9Ja0VVx4xXTIiDWY60Y7iz/iNoDA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-x64": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.3.1.tgz",
+      "integrity": "sha512-Cf7abu0WVgbhU7ANgPUnSAvm7nCvMweusHb8FnaHlLfv/Caq4GYaEZg7ZImzzmjx4lIAfuS8q+eLIS7A7IzxIg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-freebsd-x64": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.3.1.tgz",
+      "integrity": "sha512-ZZqzX2Y+GXtXXfqSfpJhDm60OoZfvLHLCgm+J7NVqgHHJjG/m9ugZI77RwTsVd4fnBJuCFP6Ae6kTJb71UdS8g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.3.1.tgz",
+      "integrity": "sha512-/Ah/xik0LaMYfv9DZ0S/t4pBlBNYOcqtRwusjgovHkvT8ixueWCLyJjsaF5kQIckjb4IT8Q6K6p/iPmZMixYgg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.3.1.tgz",
+      "integrity": "sha512-gqdFoVJlw444GvpnheZLHmvTzSxI/cOUUh2KSNejQjTcYkW062SVD+En0rUgD+QV91bz1XGIGtt1HJd48xUGbQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.3.1.tgz",
+      "integrity": "sha512-Bwv9KwOvE0VKa86xPFif9b9c3Y1NxOV1P0gLti/IYaWEsQYZXDlxfGEtA8mdDZ7SG3wyNXAWYT5SIn3giL57oA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.3.1.tgz",
+      "integrity": "sha512-Ymi8O8T15HYQdOUWUtTI6ldN0neHP85FC+Qz32xTcZ7iJXtem/x8ITev0o1e9e5rkqj4lONZfTRLvkmin1+tKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-musl": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.3.1.tgz",
+      "integrity": "sha512-M+P/91qJ6uILLw4k2G93GMDRAXj61SMvFQYt39AqvUqYgExXpLL5aepfns7sj4HiAQeolirQF9E0lzRvdf4zPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.3.1.tgz",
+      "integrity": "sha512-zsM8uOeqvVGHsAXsJxsT28ttosFahLJKCLOTUBqRAtKnVgGSRitds9T432QiT8b77Yga7JIBkulIRRlJPtYhRA==",
+      "bundleDependencies": [
+        "@napi-rs/wasm-runtime",
+        "@emnapi/core",
+        "@emnapi/runtime",
+        "@tybys/wasm-util",
+        "@emnapi/wasi-threads",
+        "tslib"
+      ],
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.10.0",
+        "@emnapi/runtime": "^1.10.0",
+        "@emnapi/wasi-threads": "^1.2.1",
+        "@napi-rs/wasm-runtime": "^1.1.4",
+        "@tybys/wasm-util": "^0.10.2",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.3.1.tgz",
+      "integrity": "sha512-aiNvSq9BsVk8V513lDKlrCFAgf8qBMPZTpgEhInL+NwQqs97mYmupVMrPrgBBSL8Pv/0zXu9MrMF9rMun1ZeNg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-x64-msvc": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.3.1.tgz",
+      "integrity": "sha512-xDEyu1rg290472FEGaKHnzyDyh5QH+AlWvsU5hMoMtPpzmKlRI0jaYKCgSHDYtaQWZOYbMaduSyCwFwY4n1HmA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/vite": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.3.1.tgz",
+      "integrity": "sha512-hItDHuIIlEV61R+faXu66s1K36aTurO/Qw0e45Vskz57gXl9pWOT6eg3zmcEui6CZXddbN7zd41bwmvag4JGwQ==",
+      "dev": true,
+      "dependencies": {
+        "@tailwindcss/node": "4.3.1",
+        "@tailwindcss/oxide": "4.3.1",
+        "tailwindcss": "4.3.1"
+      },
+      "peerDependencies": {
+        "vite": "^5.2.0 || ^6 || ^7 || ^8"
+      }
+    },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.2",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.2.tgz",
+      "integrity": "sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==",
+      "dev": true,
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
+    "node_modules/@trickfilm400/rollup-plugin-off-main-thread": {
+      "version": "3.0.0-pre1",
+      "resolved": "https://registry.npmjs.org/@trickfilm400/rollup-plugin-off-main-thread/-/rollup-plugin-off-main-thread-3.0.0-pre1.tgz",
+      "integrity": "sha512-/67zpWDBLV+oYAEL682s1ktXL0HgqX76f6gaVGkGnVZlBbm1zd0v4Bz8MFF2GGhoX9rvfq3KSQHubFHwa6w6/Q==",
+      "dependencies": {
+        "ejs": "^3.1.10",
+        "json5": "^2.2.3",
+        "magic-string": "^0.30.21",
+        "string.prototype.matchall": "^4.0.12"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
+      "integrity": "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg=="
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.17",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
+      "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==",
+      "dev": true,
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@types/resolve": {
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz",
+      "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="
+    },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw=="
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.0.2.tgz",
+      "integrity": "sha512-DlSMqo4WhThw4vB8Mpn0Woe9J+Jfq1geJ61AKW0QEgLzGMNwtIMdxbDUzLxcun8W7NbJO0e2Jg/Nxm3cCSVzzg==",
+      "dependencies": {
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
+        "babel-plugin-react-compiler": "^1.0.0",
+        "vite": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@rolldown/plugin-babel": {
+          "optional": true
+        },
+        "babel-plugin-react-compiler": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.9.tgz",
+      "integrity": "sha512-vl/rYsUKcBr3SnQn166+XR5ZQcgMx3DQhFWdfli/cWpLnLUmbxZvyrJZotLFUryib+LtArYMSTJ5RbQ57ZqrlA==",
+      "dev": true,
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.9",
+        "@vitest/utils": "4.1.9",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.9.tgz",
+      "integrity": "sha512-EVkXzBjrPGM+cK8/ANWgBrkUCfJfb38/EfTSO8h7pWvKkyPkpWxvR7BkD2MyItMF62C97zAEoqdpUixwR/e+Rw==",
+      "dev": true,
+      "dependencies": {
+        "@vitest/spy": "4.1.9",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/mocker/node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.9.tgz",
+      "integrity": "sha512-s0iufns3iIFitdgm+YR7g1whCAaGtXz459VS9/PqyKDEEFgYIhsHOQmXgIgDuYCt7DeQmiZT0Qe2OA2p4ZPu5A==",
+      "dev": true,
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.9.tgz",
+      "integrity": "sha512-KXLMDtc7oe70+3mJfGrPUWPesswH+3sTxAMAMl8DG7I8IUQT4XW718dY5ID3vPUcmlu27CcKfY4P3h3I29SLJg==",
+      "dev": true,
+      "dependencies": {
+        "@vitest/utils": "4.1.9",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.9.tgz",
+      "integrity": "sha512-Jc7RKGNBo8Z28WYIm0Niej4xdSPByRf6mU58VpHQkd6Zh05rlnA+twjbK5HyeIGHxrzsc3mJgS43uM0CZKzaIA==",
+      "dev": true,
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.9",
+        "@vitest/utils": "4.1.9",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.9.tgz",
+      "integrity": "sha512-fHpsS6mIi+PiEW+vcRVOMkX1oSaPKne3VOclSFICPcGOmfKgXPU5iAah+wcNcj2xPrCCmfq99IDGf+EojhhvhA==",
+      "dev": true,
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.9.tgz",
+      "integrity": "sha512-A51o8ymO5PpqlWNnBP9ZHPXDIpuMtTLlGSjN7la4US+LJzoUMyhwjA5QXlm39JexgwHKW4Xjs8Z2d3dLCXOeuA==",
+      "dev": true,
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.9",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.17.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz",
+      "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/array-buffer-byte-length": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
+      "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "is-array-buffer": "^3.0.5"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/arraybuffer.prototype.slice": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
+      "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
+      "dependencies": {
+        "array-buffer-byte-length": "^1.0.1",
+        "call-bind": "^1.0.8",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.23.5",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "is-array-buffer": "^3.0.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA=="
+    },
+    "node_modules/async-function": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
+      "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/at-least-node": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+      "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+      "engines": {
+        "node": ">= 4.0.0"
+      }
+    },
+    "node_modules/available-typed-arrays": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
+      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
+      "dependencies": {
+        "possible-typed-array-names": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/babel-plugin-polyfill-corejs2": {
+      "version": "0.4.17",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz",
+      "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "semver": "^6.3.1"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/babel-plugin-polyfill-corejs3": {
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz",
+      "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==",
+      "dependencies": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
+        "core-js-compat": "^3.48.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/babel-plugin-polyfill-regenerator": {
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz",
+      "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==",
+      "dependencies": {
+        "@babel/helper-define-polyfill-provider": "^0.6.8"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.37",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.37.tgz",
+      "integrity": "sha512-girxaJ7WZssDOFhzCGZTDKoTa1gk6A1TbflaYTpykLJ4UU9Fz9kx1aREM8JCuoVHbL8X8T/mJg7w2oYSq72Oig==",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
+    },
+    "node_modules/call-bind": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz",
+      "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "get-intrinsic": "^1.3.0",
+        "set-function-length": "^1.2.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001799",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001799.tgz",
+      "integrity": "sha512-hG1bReV+OUU+MOqK4t/ZWI0tZOyz3rqS9XuhOUz1cIcbwBKjOyJEJuw9ER5JuNyqxNk8u/JUVbGibBOL1yrjFw==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ]
+    },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
+    },
+    "node_modules/common-tags": {
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz",
+      "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="
+    },
+    "node_modules/core-js-compat": {
+      "version": "3.49.0",
+      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.49.0.tgz",
+      "integrity": "sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==",
+      "dependencies": {
+        "browserslist": "^4.28.1"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/core-js"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/crypto-random-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz",
+      "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true
+    },
+    "node_modules/data-view-buffer": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
+      "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-data-view": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/data-view-byte-length": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
+      "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-data-view": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/inspect-js"
+      }
+    },
+    "node_modules/data-view-byte-offset": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
+      "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "is-data-view": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/define-properties": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+      "dependencies": {
+        "define-data-property": "^1.0.1",
+        "has-property-descriptors": "^1.0.0",
+        "object-keys": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ejs": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+      "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+      "dependencies": {
+        "jake": "^10.8.5"
+      },
+      "bin": {
+        "ejs": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.375",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.375.tgz",
+      "integrity": "sha512-ZWP5eB4BVPW/ZYo9252hQZHZ5XavtsTgpbhcmMmRwymavC5AsLWQWBPaKMeNd2LW0KGby5HPXvj7+sr4ta5j/Q=="
+    },
+    "node_modules/enhanced-resolve": {
+      "version": "5.21.6",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.21.6.tgz",
+      "integrity": "sha512-aNnGCvbJ/RIyWo1IuhNdVjnNF+EjH9wpzpNHt+ci/m9He9LJvUN8wrCcXjp9cWsGNAuvSpVFTx/vraAFQ8qGjQ==",
+      "dev": true,
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/es-abstract": {
+      "version": "1.24.2",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz",
+      "integrity": "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==",
+      "dependencies": {
+        "array-buffer-byte-length": "^1.0.2",
+        "arraybuffer.prototype.slice": "^1.0.4",
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.4",
+        "data-view-buffer": "^1.0.2",
+        "data-view-byte-length": "^1.0.2",
+        "data-view-byte-offset": "^1.0.1",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "es-set-tostringtag": "^2.1.0",
+        "es-to-primitive": "^1.3.0",
+        "function.prototype.name": "^1.1.8",
+        "get-intrinsic": "^1.3.0",
+        "get-proto": "^1.0.1",
+        "get-symbol-description": "^1.1.0",
+        "globalthis": "^1.0.4",
+        "gopd": "^1.2.0",
+        "has-property-descriptors": "^1.0.2",
+        "has-proto": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "internal-slot": "^1.1.0",
+        "is-array-buffer": "^3.0.5",
+        "is-callable": "^1.2.7",
+        "is-data-view": "^1.0.2",
+        "is-negative-zero": "^2.0.3",
+        "is-regex": "^1.2.1",
+        "is-set": "^2.0.3",
+        "is-shared-array-buffer": "^1.0.4",
+        "is-string": "^1.1.1",
+        "is-typed-array": "^1.1.15",
+        "is-weakref": "^1.1.1",
+        "math-intrinsics": "^1.1.0",
+        "object-inspect": "^1.13.4",
+        "object-keys": "^1.1.1",
+        "object.assign": "^4.1.7",
+        "own-keys": "^1.0.1",
+        "regexp.prototype.flags": "^1.5.4",
+        "safe-array-concat": "^1.1.3",
+        "safe-push-apply": "^1.0.0",
+        "safe-regex-test": "^1.1.0",
+        "set-proto": "^1.0.0",
+        "stop-iteration-iterator": "^1.1.0",
+        "string.prototype.trim": "^1.2.10",
+        "string.prototype.trimend": "^1.0.9",
+        "string.prototype.trimstart": "^1.0.8",
+        "typed-array-buffer": "^1.0.3",
+        "typed-array-byte-length": "^1.0.3",
+        "typed-array-byte-offset": "^1.0.4",
+        "typed-array-length": "^1.0.7",
+        "unbox-primitive": "^1.1.0",
+        "which-typed-array": "^1.1.19"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/es-abstract-get": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-abstract-get/-/es-abstract-get-1.0.0.tgz",
+      "integrity": "sha512-6PMWXpdhshVvFp+FoWYs1EvG1Nj0tvk0dZM+XcK0xMEM1czRVcP6ohqPWHy6qPagSpC8j4+p89WXlT+xXJs/fg==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.2",
+        "is-callable": "^1.2.7",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.1.0.tgz",
+      "integrity": "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==",
+      "dev": true
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-to-primitive": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.1.tgz",
+      "integrity": "sha512-CxN9N56HYfd2m/acc/NOFrZQsN9kU4eh+2kk6A707Kz1krH8tKmfrs5RnftB8WNX80T0NS7vSQsDOlg23diR2g==",
+      "dependencies": {
+        "es-abstract-get": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "is-callable": "^1.2.7",
+        "is-date-object": "^1.1.0",
+        "is-symbol": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/eta": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/eta/-/eta-4.6.0.tgz",
+      "integrity": "sha512-lW6is4T1NFOYnmqGZIfvixqj7A7sSvScF+DN8EK6K58xI5MZ5UvYe0GjopxOXQtZvUn4eDdVuZ8XSoYWTMEKwA==",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/bgub/eta?sponsor=1"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
+      "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ]
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/filelist": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+      "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+      "dependencies": {
+        "minimatch": "^5.0.1"
+      }
+    },
+    "node_modules/filelist/node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "node_modules/filelist/node_modules/brace-expansion": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.1.tgz",
+      "integrity": "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/filelist/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/for-each": {
+      "version": "0.3.5",
+      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
+      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
+      "dependencies": {
+        "is-callable": "^1.2.7"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/fs-extra": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+      "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+      "dependencies": {
+        "at-least-node": "^1.0.0",
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/function.prototype.name": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.2.0.tgz",
+      "integrity": "sha512-jObKIik1P2QjPHP5nz5BaOtUlfgS0fWo8IUByNXkM+o+02sJOi94em77GwJKQSJ3gfPHdgzLNrHc1uokV4P/ew==",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "functions-have-names": "^1.2.3",
+        "has-property-descriptors": "^1.0.2",
+        "hasown": "^2.0.4",
+        "is-callable": "^1.2.7",
+        "is-document.all": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/functions-have-names": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
+      "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/generator-function": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
+      "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-own-enumerable-property-symbols": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz",
+      "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g=="
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-symbol-description": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
+      "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/glob": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz",
+      "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dependencies": {
+        "foreground-child": "^3.3.1",
+        "jackspeak": "^4.1.1",
+        "minimatch": "^10.1.1",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^2.0.0"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/globalthis": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+      "dependencies": {
+        "define-properties": "^1.2.1",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
+    },
+    "node_modules/has-bigints": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
+      "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-proto": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
+      "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
+      "dependencies": {
+        "dunder-proto": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/idb": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz",
+      "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ=="
+    },
+    "node_modules/internal-slot": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
+      "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "hasown": "^2.0.2",
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/is-array-buffer": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
+      "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-async-function": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
+      "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
+      "dependencies": {
+        "async-function": "^1.0.0",
+        "call-bound": "^1.0.3",
+        "get-proto": "^1.0.1",
+        "has-tostringtag": "^1.0.2",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-bigint": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
+      "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
+      "dependencies": {
+        "has-bigints": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-boolean-object": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
+      "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-callable": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
+      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.2",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz",
+      "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==",
+      "dependencies": {
+        "hasown": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-data-view": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
+      "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "get-intrinsic": "^1.2.6",
+        "is-typed-array": "^1.1.13"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-date-object": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
+      "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-document.all": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-document.all/-/is-document.all-1.0.0.tgz",
+      "integrity": "sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g==",
+      "dependencies": {
+        "call-bound": "^1.0.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-finalizationregistry": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
+      "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
+      "dependencies": {
+        "call-bound": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-generator-function": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz",
+      "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==",
+      "dependencies": {
+        "call-bound": "^1.0.4",
+        "generator-function": "^2.0.0",
+        "get-proto": "^1.0.1",
+        "has-tostringtag": "^1.0.2",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-map": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
+      "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-module": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
+      "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g=="
+    },
+    "node_modules/is-negative-zero": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
+      "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-number-object": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
+      "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-obj": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz",
+      "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-regex": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
+      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "gopd": "^1.2.0",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-regexp": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz",
+      "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-set": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
+      "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-shared-array-buffer": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
+      "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
+      "dependencies": {
+        "call-bound": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-string": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
+      "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-symbol": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
+      "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "has-symbols": "^1.1.0",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-typed-array": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+      "dependencies": {
+        "which-typed-array": "^1.1.16"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-weakmap": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
+      "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-weakref": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
+      "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
+      "dependencies": {
+        "call-bound": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-weakset": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
+      "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
+    },
+    "node_modules/jackspeak": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.2.3.tgz",
+      "integrity": "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==",
+      "dependencies": {
+        "@isaacs/cliui": "^9.0.0"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/jake": {
+      "version": "10.9.4",
+      "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+      "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+      "dependencies": {
+        "async": "^3.2.6",
+        "filelist": "^1.0.4",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "jake": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
+      "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==",
+      "devOptional": true,
+      "bin": {
+        "jiti": "lib/jiti-cli.mjs"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/jsonpointer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
+      "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/leven": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz",
+      "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lodash.debounce": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
+      "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow=="
+    },
+    "node_modules/lodash.sortby": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz",
+      "integrity": "sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA=="
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.47",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz",
+      "integrity": "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/object.assign": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
+      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.0.0",
+        "has-symbols": "^1.1.0",
+        "object-keys": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/obug": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.3.tgz",
+      "integrity": "sha512-9miFgM2OFba7hB+pRgvtV84pYTBaoTHohvmIgiRt6dRIzbwEOIaNaP+dIlGs2fNFoB0SeISs0Jz5WFVRid6Xyg==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/own-keys": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
+      "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==",
+      "dependencies": {
+        "get-intrinsic": "^1.2.6",
+        "object-keys": "^1.1.1",
+        "safe-push-apply": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
+    },
+    "node_modules/path-scurry": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/path-scurry/node_modules/lru-cache": {
+      "version": "11.5.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
+      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true
+    },
+    "node_modules/pdfjs-dist": {
+      "version": "6.2.108",
+      "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-6.2.108.tgz",
+      "integrity": "sha512-YxFb+SQcodN2rnX9Tn3dHYlqfb7NjlzzfONPpJd+AKoKtUjEdevTfbC07d5TcczzOK6261auRkP/M8OBHs9vFQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=22.13.0 || >=24"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas": "^1.0.0"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/possible-typed-array-names": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
+      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/pretty-bytes": {
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-6.1.1.tgz",
+      "integrity": "sha512-mQUvGU6aUFQ+rNvTIAcZuWGRT9a6f6Yrg9bHs4ImKF+HZCEK+plBvnAZYSIQztknZF2qnzNtr6F8s0+IuptdlQ==",
+      "engines": {
+        "node": "^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz",
+      "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.7",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
+      "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.7"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/reflect.getprototypeof": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
+      "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.23.9",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
+        "get-intrinsic": "^1.2.7",
+        "get-proto": "^1.0.1",
+        "which-builtin-type": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/regenerate": {
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz",
+      "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A=="
+    },
+    "node_modules/regenerate-unicode-properties": {
+      "version": "10.2.2",
+      "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz",
+      "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==",
+      "dependencies": {
+        "regenerate": "^1.4.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/regexp.prototype.flags": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
+      "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "define-properties": "^1.2.1",
+        "es-errors": "^1.3.0",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "set-function-name": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/regexpu-core": {
+      "version": "6.4.0",
+      "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz",
+      "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==",
+      "dependencies": {
+        "regenerate": "^1.4.2",
+        "regenerate-unicode-properties": "^10.2.2",
+        "regjsgen": "^0.8.0",
+        "regjsparser": "^0.13.0",
+        "unicode-match-property-ecmascript": "^2.0.0",
+        "unicode-match-property-value-ecmascript": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/regjsgen": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz",
+      "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q=="
+    },
+    "node_modules/regjsparser": {
+      "version": "0.13.2",
+      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.2.tgz",
+      "integrity": "sha512-NgRBy2Nx/bE+9F27nVHnqcN5HjyLmecqsqx2PJHu3/IEtADD4WuxuXIVExD5PoSDFVrl78dOonfcOe5O+5nbzQ==",
+      "dependencies": {
+        "jsesc": "~3.1.0"
+      },
+      "bin": {
+        "regjsparser": "bin/parser"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.12",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/rolldown": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.3.tgz",
+      "integrity": "sha512-i00lAJ2ks1BYr7rjNjKC7BcqAS7nVfiT3QX1SI5aY+AFHblCmaUf9OE9dbdzDvW6dJxbi2ZCZiy9v3CcwOiX3g==",
+      "dependencies": {
+        "@oxc-project/types": "=0.133.0",
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.0.3",
+        "@rolldown/binding-darwin-arm64": "1.0.3",
+        "@rolldown/binding-darwin-x64": "1.0.3",
+        "@rolldown/binding-freebsd-x64": "1.0.3",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.3",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.3",
+        "@rolldown/binding-linux-arm64-musl": "1.0.3",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.3",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.3",
+        "@rolldown/binding-linux-x64-gnu": "1.0.3",
+        "@rolldown/binding-linux-x64-musl": "1.0.3",
+        "@rolldown/binding-openharmony-arm64": "1.0.3",
+        "@rolldown/binding-wasm32-wasi": "1.0.3",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.3",
+        "@rolldown/binding-win32-x64-msvc": "1.0.3"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.0.tgz",
+      "integrity": "sha512-nc72Wgq62I7rtDV4izT5/aaS0zxy3kttkinf9586ApknY3jZO9NYsmtc24fUckA0X7Q2v+ML4a15pdUlV5V/jA==",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.0",
+        "@rollup/rollup-android-arm64": "4.62.0",
+        "@rollup/rollup-darwin-arm64": "4.62.0",
+        "@rollup/rollup-darwin-x64": "4.62.0",
+        "@rollup/rollup-freebsd-arm64": "4.62.0",
+        "@rollup/rollup-freebsd-x64": "4.62.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.0",
+        "@rollup/rollup-linux-arm64-musl": "4.62.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.0",
+        "@rollup/rollup-linux-loong64-musl": "4.62.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.0",
+        "@rollup/rollup-linux-x64-gnu": "4.62.0",
+        "@rollup/rollup-linux-x64-musl": "4.62.0",
+        "@rollup/rollup-openbsd-x64": "4.62.0",
+        "@rollup/rollup-openharmony-arm64": "4.62.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.0",
+        "@rollup/rollup-win32-x64-gnu": "4.62.0",
+        "@rollup/rollup-win32-x64-msvc": "4.62.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/safe-array-concat": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.4.tgz",
+      "integrity": "sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "get-intrinsic": "^1.3.0",
+        "has-symbols": "^1.1.0",
+        "isarray": "^2.0.5"
+      },
+      "engines": {
+        "node": ">=0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/safe-push-apply": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
+      "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "isarray": "^2.0.5"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/safe-regex-test": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
+      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "is-regex": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/serialize-javascript": {
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-7.0.5.tgz",
+      "integrity": "sha512-F4LcB0UqUl1zErq+1nYEEzSHJnIwb3AF2XWB94b+afhrekOUijwooAYqFyRbjYkm2PAKBabx6oYv/xDxNi8IBw==",
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/set-function-length": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
+      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2",
+        "get-intrinsic": "^1.2.4",
+        "gopd": "^1.0.1",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/set-function-name": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
+      "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
+      "dependencies": {
+        "define-data-property": "^1.1.4",
+        "es-errors": "^1.3.0",
+        "functions-have-names": "^1.2.3",
+        "has-property-descriptors": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/set-proto": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
+      "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/smob": {
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/smob/-/smob-1.6.2.tgz",
+      "integrity": "sha512-RQsvleCbF8cVHEv+xuDGaA4pOizFqJ0GgjtMSRo6oP8pnN7WsigHgVGey6aILRBKv4W2YOMHLqbKdnB6hpB9fw==",
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.8.0-beta.0",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz",
+      "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==",
+      "deprecated": "The work that was done in this beta branch won't be included in future versions",
+      "dependencies": {
+        "whatwg-url": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/source-map-support/node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true
+    },
+    "node_modules/std-env": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.1.0.tgz",
+      "integrity": "sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==",
+      "dev": true
+    },
+    "node_modules/stop-iteration-iterator": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
+      "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "internal-slot": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/string.prototype.matchall": {
+      "version": "4.0.12",
+      "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz",
+      "integrity": "sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.23.6",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
+        "get-intrinsic": "^1.2.6",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "internal-slot": "^1.1.0",
+        "regexp.prototype.flags": "^1.5.3",
+        "set-function-name": "^2.0.2",
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/string.prototype.trim": {
+      "version": "1.2.11",
+      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.11.tgz",
+      "integrity": "sha512-PwvK7BU+CMTJGYQCTZb5RWXIML92lftJLhQz1tBzgKiqGxJaMlBAa48POXaNAC2s4y8jr3EFqrkF9+44neS46w==",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "define-data-property": "^1.1.4",
+        "define-properties": "^1.2.1",
+        "es-abstract": "^1.24.2",
+        "es-object-atoms": "^1.1.2",
+        "has-property-descriptors": "^1.0.2",
+        "safe-regex-test": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/string.prototype.trimend": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.10.tgz",
+      "integrity": "sha512-2+3aDAOmPTmuFwjDnmJG2ctEkQKVki7vOSqaxkv42Mowj1V6PnvuwFCRrR5lChUux1TBskPjfkeTOhqczDMxTw==",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/string.prototype.trimstart": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
+      "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
+      "dependencies": {
+        "call-bind": "^1.0.7",
+        "define-properties": "^1.2.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/stringify-object": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz",
+      "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==",
+      "dependencies": {
+        "get-own-enumerable-property-symbols": "^3.0.0",
+        "is-obj": "^1.0.1",
+        "is-regexp": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/strip-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-comments/-/strip-comments-2.0.1.tgz",
+      "integrity": "sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/tailwindcss": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.3.1.tgz",
+      "integrity": "sha512-hk+TB1m+K8CYNrP6rjQaq/Y+4Zylwpa87mLYBKCunwnnQ9p+fHb7kmSfGqyEJoxF/O6CDyABWVFEafNSYKll+Q==",
+      "dev": true
+    },
+    "node_modules/tapable": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz",
+      "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/temp-dir": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz",
+      "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tempy": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/tempy/-/tempy-0.6.0.tgz",
+      "integrity": "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==",
+      "dependencies": {
+        "is-stream": "^2.0.0",
+        "temp-dir": "^2.0.0",
+        "type-fest": "^0.16.0",
+        "unique-string": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/terser": {
+      "version": "5.48.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.48.0.tgz",
+      "integrity": "sha512-J/9An6vs9Us6wKRriSFXBWdRZapREHqFzdNUKk0pmu804EMR6dr6winwo7e5JDxN4xahxQsuysyYFwlwj4XN/Q==",
+      "dependencies": {
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.15.0",
+        "commander": "^2.20.0",
+        "source-map-support": "~0.5.20"
+      },
+      "bin": {
+        "terser": "bin/terser"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true
+    },
+    "node_modules/tinyexec": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
+      "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+      "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
+      "dev": true,
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz",
+      "integrity": "sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "optional": true
+    },
+    "node_modules/type-fest": {
+      "version": "0.16.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz",
+      "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/typed-array-buffer": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
+      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "es-errors": "^1.3.0",
+        "is-typed-array": "^1.1.14"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/typed-array-byte-length": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
+      "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
+      "dependencies": {
+        "call-bind": "^1.0.8",
+        "for-each": "^0.3.3",
+        "gopd": "^1.2.0",
+        "has-proto": "^1.2.0",
+        "is-typed-array": "^1.1.14"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/typed-array-byte-offset": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz",
+      "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==",
+      "dependencies": {
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.8",
+        "for-each": "^0.3.3",
+        "gopd": "^1.2.0",
+        "has-proto": "^1.2.0",
+        "is-typed-array": "^1.1.15",
+        "reflect.getprototypeof": "^1.0.9"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/typed-array-length": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.8.tgz",
+      "integrity": "sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==",
+      "dependencies": {
+        "call-bind": "^1.0.9",
+        "for-each": "^0.3.5",
+        "gopd": "^1.2.0",
+        "is-typed-array": "^1.1.15",
+        "possible-typed-array-names": "^1.1.0",
+        "reflect.getprototypeof": "^1.0.10"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unbox-primitive": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
+      "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
+      "dependencies": {
+        "call-bound": "^1.0.3",
+        "has-bigints": "^1.0.2",
+        "has-symbols": "^1.1.0",
+        "which-boxed-primitive": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/unicode-canonical-property-names-ecmascript": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz",
+      "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/unicode-match-property-ecmascript": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz",
+      "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==",
+      "dependencies": {
+        "unicode-canonical-property-names-ecmascript": "^2.0.0",
+        "unicode-property-aliases-ecmascript": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/unicode-match-property-value-ecmascript": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz",
+      "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/unicode-property-aliases-ecmascript": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz",
+      "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/unique-string": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz",
+      "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==",
+      "dependencies": {
+        "crypto-random-string": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/upath": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz",
+      "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==",
+      "engines": {
+        "node": ">=4",
+        "yarn": "*"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "8.0.16",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.16.tgz",
+      "integrity": "sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==",
+      "dependencies": {
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.4",
+        "postcss": "^8.5.15",
+        "rolldown": "1.0.3",
+        "tinyglobby": "^0.2.17"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.1.18",
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-plugin-pwa": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/vite-plugin-pwa/-/vite-plugin-pwa-1.3.0.tgz",
+      "integrity": "sha512-c5kMgN+ITrOtHXp8PAtk2uOIEea6XjP/unCGxOWWBzQ6qa65qj/awHg0wf+QF9E/2u9vh86LqxPwzEPNbM2r5A==",
+      "dependencies": {
+        "debug": "^4.3.6",
+        "pretty-bytes": "^6.1.1",
+        "tinyglobby": "^0.2.10",
+        "workbox-build": "^7.4.1",
+        "workbox-window": "^7.4.1"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      },
+      "peerDependencies": {
+        "@vite-pwa/assets-generator": "^1.0.0",
+        "vite": "^3.1.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
+        "workbox-build": "^7.4.1",
+        "workbox-window": "^7.4.1"
+      },
+      "peerDependenciesMeta": {
+        "@vite-pwa/assets-generator": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.9.tgz",
+      "integrity": "sha512-nE3/LEyc0z87uHYLZebqCUOaJr2hdtuPp7BQ4BosVFnfltxgAvMG08NyrSGlPpOUWvR27c5flSmYFTNr78L9GQ==",
+      "dev": true,
+      "dependencies": {
+        "@vitest/expect": "4.1.9",
+        "@vitest/mocker": "4.1.9",
+        "@vitest/pretty-format": "4.1.9",
+        "@vitest/runner": "4.1.9",
+        "@vitest/snapshot": "4.1.9",
+        "@vitest/spy": "4.1.9",
+        "@vitest/utils": "4.1.9",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.9",
+        "@vitest/browser-preview": "4.1.9",
+        "@vitest/browser-webdriverio": "4.1.9",
+        "@vitest/coverage-istanbul": "4.1.9",
+        "@vitest/coverage-v8": "4.1.9",
+        "@vitest/ui": "4.1.9",
+        "happy-dom": "*",
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz",
+      "integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg=="
+    },
+    "node_modules/whatwg-url": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz",
+      "integrity": "sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==",
+      "dependencies": {
+        "lodash.sortby": "^4.7.0",
+        "tr46": "^1.0.1",
+        "webidl-conversions": "^4.0.2"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/which-boxed-primitive": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
+      "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
+      "dependencies": {
+        "is-bigint": "^1.1.0",
+        "is-boolean-object": "^1.2.1",
+        "is-number-object": "^1.1.1",
+        "is-string": "^1.1.1",
+        "is-symbol": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/which-builtin-type": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
+      "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "function.prototype.name": "^1.1.6",
+        "has-tostringtag": "^1.0.2",
+        "is-async-function": "^2.0.0",
+        "is-date-object": "^1.1.0",
+        "is-finalizationregistry": "^1.1.0",
+        "is-generator-function": "^1.0.10",
+        "is-regex": "^1.2.1",
+        "is-weakref": "^1.0.2",
+        "isarray": "^2.0.5",
+        "which-boxed-primitive": "^1.1.0",
+        "which-collection": "^1.0.2",
+        "which-typed-array": "^1.1.16"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/which-collection": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
+      "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
+      "dependencies": {
+        "is-map": "^2.0.3",
+        "is-set": "^2.0.3",
+        "is-weakmap": "^2.0.2",
+        "is-weakset": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/which-typed-array": {
+      "version": "1.1.22",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.22.tgz",
+      "integrity": "sha512-fvO4ExWMFsqyhG3AiPAObMuY1lxaqgYcxbc49CNdWDDECOJNgQyvsOWVwbZc+qf3rzRtxojBK+CMEv0Ld5CYpw==",
+      "dependencies": {
+        "available-typed-arrays": "^1.0.7",
+        "call-bind": "^1.0.9",
+        "call-bound": "^1.0.4",
+        "for-each": "^0.3.5",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-tostringtag": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/workbox-background-sync": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-background-sync/-/workbox-background-sync-7.4.1.tgz",
+      "integrity": "sha512-HhT7KE8tOWDm02wRNshXUnUPofMlhenF2DBdUnDPOubhizzPeItkYTmAB6td1Z2cjYPa98vzEiPLEuzn5hN66g==",
+      "dependencies": {
+        "idb": "^7.0.1",
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-broadcast-update": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-7.4.1.tgz",
+      "integrity": "sha512-uAlgslKLvbQY+suirIdnBCSYrcgBhjp81Nj4l1lj/Jmj0MJO2CJERnCJjT0GFVwmReV0N+zs78K6gqd5gr9/+A==",
+      "dependencies": {
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-build": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-build/-/workbox-build-7.4.1.tgz",
+      "integrity": "sha512-SDhxIvEAde9Gy/5w4Yo1Jh/M49Z0qE3q0oteyE8zGq0DScxFqVBcCtIXFuLtmtxRQZCMbf0prco4VyEu3KBQuw==",
+      "dependencies": {
+        "@apideck/better-ajv-errors": "^0.3.1",
+        "@babel/core": "^7.24.4",
+        "@babel/preset-env": "^7.11.0",
+        "@babel/runtime": "^7.11.2",
+        "@rollup/plugin-babel": "^6.1.0",
+        "@rollup/plugin-node-resolve": "^16.0.3",
+        "@rollup/plugin-replace": "^6.0.3",
+        "@rollup/plugin-terser": "^1.0.0",
+        "@trickfilm400/rollup-plugin-off-main-thread": "^3.0.0-pre1",
+        "ajv": "^8.6.0",
+        "common-tags": "^1.8.0",
+        "eta": "^4.5.1",
+        "fast-json-stable-stringify": "^2.1.0",
+        "fs-extra": "^9.0.1",
+        "glob": "^11.0.1",
+        "pretty-bytes": "^5.3.0",
+        "rollup": "^4.53.3",
+        "source-map": "^0.8.0-beta.0",
+        "stringify-object": "^3.3.0",
+        "strip-comments": "^2.0.1",
+        "tempy": "^0.6.0",
+        "upath": "^1.2.0",
+        "workbox-background-sync": "7.4.1",
+        "workbox-broadcast-update": "7.4.1",
+        "workbox-cacheable-response": "7.4.1",
+        "workbox-core": "7.4.1",
+        "workbox-expiration": "7.4.1",
+        "workbox-google-analytics": "7.4.1",
+        "workbox-navigation-preload": "7.4.1",
+        "workbox-precaching": "7.4.1",
+        "workbox-range-requests": "7.4.1",
+        "workbox-recipes": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1",
+        "workbox-streams": "7.4.1",
+        "workbox-sw": "7.4.1",
+        "workbox-window": "7.4.1"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/workbox-build/node_modules/pretty-bytes": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz",
+      "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/workbox-cacheable-response": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-cacheable-response/-/workbox-cacheable-response-7.4.1.tgz",
+      "integrity": "sha512-8xaFoJdDc2OjrlbbL3gEeBO1WKcMwRqwLRupgqahYXu75yXajPLuwrbXMrIGZuWYXrQwk0xDjOxZ/ujCy/oJYw==",
+      "dependencies": {
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-core": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-core/-/workbox-core-7.4.1.tgz",
+      "integrity": "sha512-DT+vu46eh/2vRsSHTY4Xmc32Z1rr9PRlQUXr1Dx30ZuXRWwOsvZgGgcwxcasubQLQmbTNYZjv44LkBAQ4tT5tQ=="
+    },
+    "node_modules/workbox-expiration": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-expiration/-/workbox-expiration-7.4.1.tgz",
+      "integrity": "sha512-lRKUF7b+OGbeXkQk1s6MHXOa3d7Xxf7Of31W6c6hCfipfIyrtdWZ89stq21AHZMaoG7VNFoHply4Ox+rU31TWg==",
+      "dependencies": {
+        "idb": "^7.0.1",
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-google-analytics": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-google-analytics/-/workbox-google-analytics-7.4.1.tgz",
+      "integrity": "sha512-Mks1JwLEt++ZAkF6sS1OpSh9RtAMIsiDgRpK+codiHGIPXeaUOgi4cPc3GFadUl8V5QPeypEk8Oxgl3HlwVzHw==",
+      "dependencies": {
+        "workbox-background-sync": "7.4.1",
+        "workbox-core": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1"
+      }
+    },
+    "node_modules/workbox-navigation-preload": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-navigation-preload/-/workbox-navigation-preload-7.4.1.tgz",
+      "integrity": "sha512-C4KVsjPcYKJOhr631AxR9XoG2rLF3QiTk5aMv36MXOjtWvm8axwNFAtKUPGsWUwLXXAMgYM1En7fsvndaXeXRQ==",
+      "dependencies": {
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-precaching": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-precaching/-/workbox-precaching-7.4.1.tgz",
+      "integrity": "sha512-cdr/9qByww7yzEp7zg/qI4ukUrrNjQLgN+ONQRpjy/VqGQXwkgHwr00KksGJK8v0VifwDXBb8a4cWNZH71jn3Q==",
+      "dependencies": {
+        "workbox-core": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1"
+      }
+    },
+    "node_modules/workbox-range-requests": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-range-requests/-/workbox-range-requests-7.4.1.tgz",
+      "integrity": "sha512-7i2oxAUE82gHdAJBCAQ04JzNOdRPqzuOzGfoUyJpFSmeqBNYGPrAH8GPoPjUQTfp+NycwrD2H68VtuF8qxv0vQ==",
+      "dependencies": {
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-recipes": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-recipes/-/workbox-recipes-7.4.1.tgz",
+      "integrity": "sha512-gnbVfmV4/TtmQaM4x9AtuXhcdstJsep3XMVeztOrQVPT+R6+6DeBjGTCQ7fFCXm+4GEHUA5VEBTyi5+4gWGeog==",
+      "dependencies": {
+        "workbox-cacheable-response": "7.4.1",
+        "workbox-core": "7.4.1",
+        "workbox-expiration": "7.4.1",
+        "workbox-precaching": "7.4.1",
+        "workbox-routing": "7.4.1",
+        "workbox-strategies": "7.4.1"
+      }
+    },
+    "node_modules/workbox-routing": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-routing/-/workbox-routing-7.4.1.tgz",
+      "integrity": "sha512-yubJGErZOusuidAenaL5ypfhQOa7urxP/f8E0ws7FPb4039RiWXUWBAyUkmUoOL/BcQGen3h0J8872d51IYxtA==",
+      "dependencies": {
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-strategies": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-7.4.1.tgz",
+      "integrity": "sha512-GZxpaw9NbmOelj7667uZ2kpk5BFpOGbO4X0qjwh5ls8XQ8C+Lha5LQchTiUzsTFSS+NlUpftYAyOVXvQUrcqOQ==",
+      "dependencies": {
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/workbox-streams": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-7.4.1.tgz",
+      "integrity": "sha512-HWWtraKUbJknd9kgqGcpQ3G114HOPYvqs8HaJMDs2ebLNAimDkVDaWfAXE6Ybl+m8U6KsCE6pWyLYuigWmnAXw==",
+      "dependencies": {
+        "workbox-core": "7.4.1",
+        "workbox-routing": "7.4.1"
+      }
+    },
+    "node_modules/workbox-sw": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-sw/-/workbox-sw-7.4.1.tgz",
+      "integrity": "sha512-fez5f2DUlDJWTFYkCWQpY10N8gtztd849NswCbVFk0QlcSM4HT5A8x4g4ii650yem4I8tHY0R7JZahwp3ltIPw=="
+    },
+    "node_modules/workbox-window": {
+      "version": "7.4.1",
+      "resolved": "https://registry.npmjs.org/workbox-window/-/workbox-window-7.4.1.tgz",
+      "integrity": "sha512-notZDH2u8VXaqyuD7xaqIfEFi6SRM4SUSd7ewe9PDsVqADuepxX2ZMY3uvuZGxzY5ZOsGC/vD3A/3smFtJt4/A==",
+      "dependencies": {
+        "@types/trusted-types": "^2.0.2",
+        "workbox-core": "7.4.1"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="
+    }
+  }
+}
diff --git a/frontend/package.json b/frontend/package.json
new file mode 100644
index 0000000..76d44b0
--- /dev/null
+++ b/frontend/package.json
@@ -0,0 +1,31 @@
+{
+  "name": "aether-frontend",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@vitejs/plugin-react": "^6.0.2",
+    "pdfjs-dist": "^6.2.108",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "vite": "^8.0.16",
+    "vite-plugin-pwa": "^1.3.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.3.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "tailwindcss": "^4.3.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}
diff --git a/frontend/public/icon-192.png b/frontend/public/icon-192.png
new file mode 100644
index 0000000000000000000000000000000000000000..b3b0157ad9087ac8f41ab53de158dfaa4238e4c1
GIT binary patch
literal 6372
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
I)*|?S0A^5?zW@LL

literal 0
HcmV?d00001

diff --git a/frontend/public/icon-512.png b/frontend/public/icon-512.png
new file mode 100644
index 0000000000000000000000000000000000000000..714a0e87e73aee60de8ba19048975dbc933522ef
GIT binary patch
literal 13418
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
Sl;jSmfKa+dI^~xfWBv#C_NL+h

literal 0
HcmV?d00001

diff --git a/frontend/public/icon-maskable-512.png b/frontend/public/icon-maskable-512.png
new file mode 100644
index 0000000000000000000000000000000000000000..ee12ae3e23dd3db206c7070af07c13624942166c
GIT binary patch
literal 36793
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
W&@1fkpFu5PFP_Og&6Ut{|GxnG)F<iy

literal 0
HcmV?d00001

diff --git a/frontend/public/icon.svg b/frontend/public/icon.svg
new file mode 100644
index 0000000..8a84d4b
--- /dev/null
+++ b/frontend/public/icon.svg
@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" role="img" aria-label="Aether">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0" stop-color="#6366f1"/>
+      <stop offset="1" stop-color="#4f46e5"/>
+    </linearGradient>
+  </defs>
+  <rect width="512" height="512" rx="114" fill="url(#bg)"/>
+  <!-- Wolke: zwei Kuppen auf einer Grundfläche, bewusst flächig statt Kontur,
+       damit das Motiv auch bei 48 px noch als Wolke lesbar bleibt. -->
+  <path fill="#ffffff" d="M170 356q-46 0-78-32t-32-78q0-42 27-73t68-37q19-36 54-58t77-22q54 0 93 36t44 89q35 4 58 30t23 61q0 38-27 66t-66 28z"/>
+</svg>
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
new file mode 100644
index 0000000..64d3bba
--- /dev/null
+++ b/frontend/src/App.tsx
@@ -0,0 +1,63 @@
+import { useEffect } from 'react'
+import { useAuth } from './hooks/useAuth'
+import { AppSettingsProvider, useAppSettings } from './hooks/useAppSettings'
+import { applyTheme } from './theme'
+import LoginPage from './pages/LoginPage'
+import Shell from './components/Shell'
+import SharePage from './pages/SharePage'
+
+// Simple path-based routing without react-router
+function getShareToken(): string | null {
+  const match = window.location.pathname.match(/^\/s\/([^/]+)/)
+  return match ? match[1] : null
+}
+
+export default function App() {
+  const shareToken = getShareToken()
+
+  // Name und Farben umschliessen auch die Share-Seite: sie ist die einzige
+  // Ansicht, die Fremde zu Gesicht bekommen.
+  return (
+    <AppSettingsProvider>
+      {shareToken ? <SharePage token={shareToken} /> : <AuthedApp />}
+    </AppSettingsProvider>
+  )
+}
+
+function AuthedApp() {
+  const { user, loading, login, logout, refreshUser } = useAuth()
+  const { globalColors } = useAppSettings()
+
+  // Die persönliche Palette gilt nur, wenn der Nutzer sie eingeschaltet hat –
+  // sonst die des Administrators. Läuft bei jeder Änderung am Nutzer erneut,
+  // damit ein Umschalten im Profil sofort überall greift.
+  useEffect(() => {
+    if (!user) return
+    if (user.use_custom_theme) {
+      applyTheme(
+        user.primary_color || globalColors.primary,
+        user.accent_color || globalColors.accent,
+      )
+    } else {
+      applyTheme(globalColors.primary, globalColors.accent)
+    }
+  }, [user, globalColors])
+
+  if (loading) {
+    return (
+      <div style={{ minHeight: '100vh', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+        <div style={{
+          width: 32, height: 32,
+          border: '2px solid var(--color-primary)',
+          borderTopColor: 'transparent',
+          borderRadius: '50%',
+          animation: 'spin 0.7s linear infinite',
+        }} />
+        <style>{`@keyframes spin { to { transform: rotate(360deg); } }`}</style>
+      </div>
+    )
+  }
+
+  if (!user) return <LoginPage onLogin={login} />
+  return <Shell user={user} onLogout={logout} onUserChanged={refreshUser} />
+}
diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts
new file mode 100644
index 0000000..8da5a2c
--- /dev/null
+++ b/frontend/src/api/client.ts
@@ -0,0 +1,813 @@
+// Typed API client. All fetch calls go through here — never use fetch directly in components.
+
+export interface User {
+  id: string
+  username: string
+  display_name: string
+  is_admin: boolean
+  quota_bytes: number
+  used_bytes: number
+  /** Persönliche Palette – bleibt erhalten, auch wenn sie gerade nicht
+   *  angewendet wird (siehe use_custom_theme). */
+  primary_color: string
+  accent_color: string
+  use_custom_theme: boolean
+  /** Konto meldet sich über den Identitätsanbieter an und hat hier kein
+   *  Passwort – die Passwortänderung wird dann ausgeblendet. */
+  is_oidc?: boolean
+  created_at: string
+}
+
+export interface FileItem {
+  id: string
+  /** Datum auf dem Beleg (YYYY-MM-DD) – nicht das des Uploads. */
+  document_date?: string
+  owner_id: string | null
+  group_id: string | null
+  folder_id: string | null
+  name: string
+  mime_type: string
+  size: number
+  checksum: string
+  has_thumbnail: boolean
+  version: number
+  versioning_enabled: boolean
+  created_at: string
+  updated_at: string
+}
+
+export interface FolderItem {
+  id: string
+  /** Genau eines von beiden ist gesetzt: persönlicher Ordner oder Gruppenordner. */
+  owner_id: string | null
+  group_id: string | null
+  parent_id: string | null
+  name: string
+  created_at: string
+}
+
+export interface ListResponse {
+  files: FileItem[]
+  folders: FolderItem[]
+  /** Etiketten je Datei-ID. Kommen mit der Liste in einer Abfrage mit – bei
+   *  fuenfzig Kacheln waeren fuenfzig Einzelabfragen der falsche Weg. */
+  tags?: Record<string, Tag[]>
+  /** Absender je Datei-ID – auf demselben Weg wie die Etiketten. */
+  correspondents?: Record<string, Correspondent>
+}
+
+export interface AuthResponse {
+  user: User
+  csrf_token: string
+}
+
+export interface ShareLink {
+  id: string
+  file_id: string
+  owner_id: string
+  token: string
+  has_password: boolean
+  expires_at: string | null
+  download_count: number
+  created_at: string
+}
+
+export interface CreateShareRequest {
+  password?: string
+  expires_in_hours?: number
+}
+
+export interface PublicShareInfo {
+  link: ShareLink
+  file_name: string
+  file_size: number
+  mime_type: string
+}
+
+export interface FileVersion {
+  id: string
+  file_id: string
+  version: number
+  size: number
+  checksum: string
+  created_at: string
+}
+
+export interface UploadProgress {
+  loaded: number
+  total: number
+  percent: number
+}
+
+class APIError extends Error {
+  constructor(public status: number, message: string) {
+    super(message)
+    this.name = 'APIError'
+  }
+}
+
+let csrfToken = ''
+
+export function setCSRFToken(token: string) {
+  csrfToken = token
+}
+
+async function request<T>(
+  method: string,
+  path: string,
+  body?: unknown,
+  isFormData = false,
+  /** Abbruchsignal – die Suche verwirft damit überholte Anfragen. */
+  signal?: AbortSignal,
+): Promise<T> {
+  const headers: Record<string, string> = {}
+  if (csrfToken) headers['X-CSRF-Token'] = csrfToken
+  if (body && !isFormData) headers['Content-Type'] = 'application/json'
+
+  const res = await fetch(`/api/v1${path}`, {
+    method,
+    headers,
+    credentials: 'include',
+    signal,
+    body: isFormData ? (body as FormData) : body ? JSON.stringify(body) : undefined,
+  })
+
+  if (res.status === 204) return undefined as T
+
+  const json = await res.json().catch(() => ({ error: res.statusText }))
+  if (!res.ok) throw new APIError(res.status, json.error ?? 'Unknown error')
+  return json.data ?? json as T
+}
+
+// XHR-based upload with real progress reporting.
+export function uploadWithProgress(
+  file: File,
+  folderId: string | undefined,
+  onProgress: (p: UploadProgress) => void
+): Promise<FileItem> {
+  return new Promise((resolve, reject) => {
+    const form = new FormData()
+    // folder_id MUST come before the file so the server can stream the file
+    // straight to storage without buffering the whole body first.
+    if (folderId) form.append('folder_id', folderId)
+    form.append('file', file)
+
+    const xhr = new XMLHttpRequest()
+    xhr.open('POST', '/api/v1/files')
+    xhr.withCredentials = true
+    if (csrfToken) xhr.setRequestHeader('X-CSRF-Token', csrfToken)
+
+    xhr.upload.addEventListener('progress', (e) => {
+      if (e.lengthComputable) {
+        onProgress({ loaded: e.loaded, total: e.total, percent: Math.round((e.loaded / e.total) * 100) })
+      }
+    })
+
+    xhr.addEventListener('load', () => {
+      if (xhr.status === 201) {
+        try {
+          const json = JSON.parse(xhr.responseText)
+          resolve(json.data ?? json)
+        } catch {
+          reject(new APIError(xhr.status, 'Invalid response'))
+        }
+      } else {
+        let msg = 'Upload failed'
+        try {
+          msg = JSON.parse(xhr.responseText).error ?? msg
+        } catch { /* kein JSON – Standardtext behalten */ }
+        // 413 kommt hier nur vom Quota-Check; der rohe Servertext sagt einem
+        // Nutzer vor dem Upload-Fenster wenig.
+        if (xhr.status === 413) msg = 'Storage full – your quota is not sufficient'
+        reject(new APIError(xhr.status, msg))
+      }
+    })
+
+    xhr.addEventListener('error', () => reject(new APIError(0, 'Network error')))
+    xhr.addEventListener('abort', () => reject(new APIError(0, 'Upload aborted')))
+
+    xhr.send(form)
+  })
+}
+
+// ── Auth ─────────────────────────────────────────────────────────────────────
+
+export interface ExternalApp {
+  name: string
+  url: string
+  icon: string
+}
+
+export interface PublicConfig {
+  oidc_enabled: boolean
+  cloud_name: string
+  /** Leer, wenn kein Logo hinterlegt ist. Enthält einen Versionsanteil, der
+   *  sich bei jedem Austausch ändert – damit Browser nicht das alte zeigen. */
+  logo_url?: string
+  /** Tab-Symbol (64 px) aus dem hochgeladenen App-Symbol. Leer, wenn keins
+   *  hinterlegt ist. Ebenfalls mit Versionsanteil. */
+  favicon_url?: string
+  /** Dasselbe Symbol in 192 px – für den Startbildschirm von iOS. */
+  apple_touch_icon_url?: string
+  /** Gibt es einen Office-Server? Sonst bietet das Menue das Bearbeiten gar
+   *  nicht erst an – ein Punkt, der immer scheitert, ist schlimmer als keiner. */
+  office_enabled?: boolean
+  primary_color?: string
+  accent_color?: string
+  external_apps: ExternalApp[]
+}
+
+export const publicApi = {
+  config: (): Promise<PublicConfig> =>
+    fetch('/api/v1/public/config').then(r => r.json()).then(j => j.data ?? j),
+}
+
+export const authApi = {
+  login: (username: string, password: string) =>
+    request<AuthResponse>('POST', '/auth/login', { username, password }),
+
+  logout: () => request<void>('POST', '/auth/logout'),
+
+  me: () => request<AuthResponse>('GET', '/auth/me'),
+
+  updateProfile: (displayName: string) =>
+    request<User>('PATCH', '/auth/profile', { display_name: displayName }),
+
+  updateColors: (primaryColor: string, accentColor: string) =>
+    request<User>('PATCH', '/auth/profile', {
+      primary_color: primaryColor,
+      accent_color: accentColor,
+    }),
+
+  setUseCustomTheme: (enabled: boolean) =>
+    request<User>('PATCH', '/auth/profile', { use_custom_theme: enabled }),
+
+  changePassword: (currentPassword: string, newPassword: string) =>
+    request<void>('POST', '/auth/change-password', { current_password: currentPassword, new_password: newPassword }),
+}
+
+// ── Internal shares (people and groups) ───────────────────────────────────────
+
+export type SharePermission = 'read' | 'write'
+
+export interface AclEntry {
+  id: string
+  subject_type: 'user' | 'group'
+  subject_id: string
+  subject_name: string
+  permission: SharePermission
+  created_at: string
+}
+
+export interface ShareRecipient {
+  id: string
+  name: string
+  type: 'user' | 'group'
+}
+
+export interface SharedResource {
+  type: 'folder' | 'file'
+  id: string
+  name: string
+  owner_id: string
+  owner_name: string
+  permission: SharePermission
+  size: number
+  mime_type: string
+  shared_at: string
+  /** Gesetzt, wenn der Zugriff über eine Gruppe kommt statt persönlich. */
+  via_group: string
+}
+
+export const aclApi = {
+  recipients: () => request<ShareRecipient[]>('GET', '/share-recipients'),
+
+  sharedWithMe: () => request<SharedResource[]>('GET', '/shared-with-me'),
+
+  listForFolder: (id: string) => request<AclEntry[]>('GET', `/folders/${id}/acl`),
+  listForFile: (id: string) => request<AclEntry[]>('GET', `/files/${id}/acl`),
+
+  grantFolder: (id: string, subjectId: string, subjectType: 'user' | 'group', permission: SharePermission) =>
+    request<AclEntry>('POST', `/folders/${id}/acl`, { subject_id: subjectId, subject_type: subjectType, permission }),
+  grantFile: (id: string, subjectId: string, subjectType: 'user' | 'group', permission: SharePermission) =>
+    request<AclEntry>('POST', `/files/${id}/acl`, { subject_id: subjectId, subject_type: subjectType, permission }),
+
+  revoke: (entryId: string) => request<void>('DELETE', `/acl/${entryId}`),
+}
+
+// ── App passwords (WebDAV / sync clients) ─────────────────────────────────────
+
+export interface AppPassword {
+  id: string
+  name: string
+  last_used_at: string | null
+  created_at: string
+}
+
+// The plaintext password is returned exactly once, on creation.
+export interface AppPasswordCreated extends AppPassword {
+  password: string
+}
+
+export const appPasswordsApi = {
+  list: () => request<AppPassword[]>('GET', '/app-passwords'),
+
+  create: (name: string) =>
+    request<AppPasswordCreated>('POST', '/app-passwords', { name }),
+
+  revoke: (id: string) => request<void>('DELETE', `/app-passwords/${id}`),
+}
+
+// ── Files ─────────────────────────────────────────────────────────────────────
+
+// ── Suche ────────────────────────────────────────────────────────────────────
+
+export interface SearchHit {
+  kind: 'folder' | 'file'
+  id: string
+  name: string
+  /** Ordner, in dem der Treffer liegt – null heisst Wurzel. */
+  folder_id: string | null
+  folder_name: string
+  mime_type?: string
+  size: number
+  has_thumbnail: boolean
+  updated_at: string
+  /** true, wenn nicht der Name passte, sondern der erkannte Text im Dokument. */
+  matched_content?: boolean
+  /** Fundstelle im Text; Treffer in <b>…</b>. Nur bei matched_content. */
+  snippet?: string
+}
+
+export interface OcrStatus {
+  enabled: boolean
+  /** Fehlen alle, wenn enabled false ist. */
+  pending?: number
+  running?: number
+  done?: number
+  failed?: number
+  /** Dateien mit gespeichertem Text. */
+  indexed?: number
+}
+
+export interface SearchResponse {
+  hits: SearchHit[]
+  query: string
+  /** true, wenn die Liste bei der Obergrenze abgeschnitten wurde. */
+  truncated?: boolean
+}
+
+export interface Tag {
+  id: string
+  name: string
+  /** Leer heisst: die Oberflaeche leitet eine Farbe aus dem Namen ab. */
+  color: string
+  /** Emoji oder leer. Steht **neben** der Farbe: Die Farbe traegt die
+   *  Wiedererkennung im Augenwinkel, das Symbol die Bedeutung. Ab etwa fuenf
+   *  Etiketten reicht Farbe allein nicht mehr – dann fragt man sich, ob Blau
+   *  nun „Uni" oder „Versicherung" war. */
+  icon: string
+  /** Gesetzt, wenn das Etikett einer Gruppe gehoert – dann sehen es alle
+   *  Mitglieder, und es gilt nur fuer Dateien in deren Gruppenordner. */
+  group_id?: string
+  group_name?: string
+  file_count: number
+  created_at: string
+}
+
+/**
+ * Absender („Korrespondent") – von wem ein Dokument kommt.
+ *
+ * Der Unterschied zum Etikett ist die Anzahl: Etiketten sagen, *wofür* ein
+ * Dokument gebraucht wird, davon trägt eine Datei beliebig viele. Der Absender
+ * sagt, *von wem* es kommt – davon hat eine Datei genau einen. Deshalb ein
+ * Feld und keine Mehrfachauswahl, und deshalb eine eigene Liste: Sonst stünde
+ * „Stadtwerke" neben „absetzbar" in derselben Aufzählung.
+ */
+export interface Correspondent {
+  id: string
+  name: string
+  /** Emoji oder leer – dieselbe Regel wie beim Etikett. */
+  icon: string
+  group_id?: string
+  group_name?: string
+  file_count: number
+  created_at: string
+}
+
+/** Datei-Treffer beim Filtern nach einem Etikett. */
+export interface TaggedFile {
+  id: string
+  name: string
+  folder_id: string | null
+  folder_name: string
+  mime_type: string
+  size: number
+  has_thumbnail: boolean
+  /** Datum auf dem Beleg – nicht das des Uploads. */
+  document_date?: string
+  updated_at: string
+}
+
+/**
+ * Meldet, dass sich an den Etiketten etwas geändert hat.
+ *
+ * Die Seitenleiste zeigt Zählstände, die sich ändern, sobald irgendwo
+ * etikettiert wird – und sie steht neben dem Dialog, in dem das passiert. Eine
+ * Zahl, die daneben stehenbleibt, während man sie gerade verändert hat, sieht
+ * nach einem Fehler aus.
+ *
+ * Ein Ereignis statt Zustand durch drei Ebenen zu reichen: Der Dialog steckt
+ * tief im Dateibrowser, die Seitenleiste hängt am Shell – ein gemeinsamer
+ * Zustand nur für einen Zählstand wäre viel Verkabelung für wenig.
+ */
+export const tagsChangedEvent = 'aether:tags-changed'
+
+export function notifyTagsChanged() {
+  window.dispatchEvent(new Event(tagsChangedEvent))
+}
+
+/**
+ * Startet einen Archiv-Download.
+ *
+ * Über ein abgeschicktes Formular, nicht über fetch(): Nur eine **Navigation**
+ * behandelt der Browser als Download. Ein fetch() müsste die Antwort erst
+ * vollständig in den Speicher holen – bei einem 5-GB-Ordner also 5 GB im
+ * Arbeitsspeicher, und der Nutzer sähe bis dahin nichts.
+ *
+ * POST statt GET, weil eine Auswahl beliebig lang sein kann: Fünfzig
+ * Kennungen sind schon knapp 1900 Zeichen, und Adressen haben eine Grenze.
+ */
+export function downloadZip(opts: { fileIds?: string[]; folderId?: string; name?: string }) {
+  const form = document.createElement('form')
+  form.method = 'POST'
+  form.action = '/api/v1/download/zip'
+  // Das CSRF-Token als Feld – ein Formular kann keine Header setzen. Der
+  // Server vergleicht es weiterhin gegen das Cookie (Double-Submit).
+  const add = (name: string, value: string) => {
+    const input = document.createElement('input')
+    input.type = 'hidden'
+    input.name = name
+    input.value = value
+    form.appendChild(input)
+  }
+  add('csrf_token', csrfToken)
+  if (opts.folderId) add('folder_id', opts.folderId)
+  if (opts.name) add('name', opts.name)
+  for (const id of opts.fileIds ?? []) add('file_ids', id)
+  document.body.appendChild(form)
+  form.submit()
+  form.remove()
+}
+
+export const tagsApi = {
+  list: () => request<Tag[]>('GET', '/tags'),
+  create: (name: string, color = '', groupId?: string, icon = '') =>
+    request<Tag>('POST', '/tags', { name, color, icon, group_id: groupId ?? '' }),
+  update: (id: string, name: string, color: string, icon = '') =>
+    request<Tag>('PATCH', `/tags/${id}`, { name, color, icon }),
+  remove: (id: string) => request<void>('DELETE', `/tags/${id}`),
+  files: (id: string) => request<TaggedFile[]>('GET', `/tags/${id}/files`),
+  /**
+   * Setzt Etiketten, Belegdatum und Absender einer Datei in **einem** Vorgang.
+   *
+   * Alles drei steht im selben Dialog, also geht es auch zusammen zum Server –
+   * sonst gäbe es einen Zustand, in dem die Etiketten sitzen und der Absender
+   * nicht.
+   *
+   * Weglassen heisst jeweils „unveraendert", leerer String heisst „loeschen".
+   * `correspondentName` legt den Absender bei Bedarf an; das ist der Normalfall
+   * beim Tippen.
+   */
+  setForFile: (fileId: string, tagIds: string[], documentDate?: string,
+               correspondent?: { id?: string; name?: string }) =>
+    request<Tag[]>('PUT', `/files/${fileId}/tags`, {
+      tag_ids: tagIds,
+      ...(documentDate === undefined ? {} : { document_date: documentDate }),
+      ...(correspondent?.name ? { correspondent_name: correspondent.name }
+          : correspondent?.id === undefined ? {} : { correspondent_id: correspondent.id }),
+    }),
+}
+
+export const correspondentsApi = {
+  list: () => request<Correspondent[]>('GET', '/correspondents'),
+  create: (name: string, groupId?: string, icon = '') =>
+    request<Correspondent>('POST', '/correspondents', { name, icon, group_id: groupId ?? '' }),
+  update: (id: string, name: string, icon = '') =>
+    request<Correspondent>('PATCH', `/correspondents/${id}`, { name, icon }),
+  remove: (id: string) => request<void>('DELETE', `/correspondents/${id}`),
+  files: (id: string) => request<TaggedFile[]>('GET', `/correspondents/${id}/files`),
+}
+
+/** Was der Server über eine Office-Sitzung mitteilt. */
+export interface OfficeSession {
+  enabled: boolean
+  provider?: string
+  /** Adresse der Bedienoberflaeche beim Office-Server, samt WOPISrc. */
+  url: string
+  /** Kurzlebiges Zugriffstoken – gilt fuer **genau diese** Datei. */
+  token: string
+  token_ttl: number
+  can_write: boolean
+  file_name: string
+}
+
+/**
+ * Endungen, die ein Office-Server bearbeiten kann.
+ *
+ * Dieselbe Positivliste wie im Backend (internal/office). Hier steht sie nur,
+ * damit das Kontextmenue den Punkt gar nicht erst anbietet, wo er nicht ginge –
+ * entschieden wird serverseitig.
+ */
+const officeExtensions = new Set([
+  'odt', 'docx', 'doc', 'rtf', 'txt',
+  'ods', 'xlsx', 'xls', 'csv',
+  'odp', 'pptx', 'ppt',
+  'odg',
+])
+
+export function isOfficeFile(name: string): boolean {
+  const i = name.lastIndexOf('.')
+  return i >= 0 && officeExtensions.has(name.slice(i + 1).toLowerCase())
+}
+
+export const officeApi = {
+  session: (fileId: string) =>
+    request<OfficeSession>('GET', `/office/session/${fileId}`),
+}
+
+export const ocrApi = {
+  /** Stand der Texterkennung für die **eigenen** Dateien. Braucht keine
+   *  Adminrechte – anders als adminApi.ocrStatus, das den ganzen Server zählt. */
+  myStatus: () => request<OcrStatus>('GET', '/ocr'),
+}
+
+export const searchApi = {
+  query: (q: string, signal?: AbortSignal) =>
+    request<SearchResponse>('GET', `/search?q=${encodeURIComponent(q)}`, undefined, false, signal),
+}
+
+export const filesApi = {
+  list: (folderId?: string) => {
+    const qs = folderId ? `?folder_id=${folderId}` : ''
+    return request<ListResponse>('GET', `/files${qs}`)
+  },
+
+  upload: (file: File, folderId?: string) => {
+    const form = new FormData()
+    // folder_id before file – see uploadWithProgress note (streaming upload).
+    if (folderId) form.append('folder_id', folderId)
+    form.append('file', file)
+    return request<FileItem>('POST', '/files', form, true)
+  },
+
+  download: (id: string) => `/api/v1/files/${id}/download`,
+
+  /** Dieselbe Datei, aber zum Anzeigen im Browser statt zum Speichern. Der
+   *  Server liefert das nur für eine feste Liste harmloser Typen inline aus. */
+  inline: (id: string) => `/api/v1/files/${id}/download?inline=1`,
+
+  thumbnail: (id: string) => `/api/v1/files/${id}/thumbnail`,
+
+  /**
+   * Der erkannte Text einer Datei, in Seiten zerlegt.
+   *
+   * Für die Suche im PDF-Betrachter: Bei einem Scan steht im PDF selbst kein
+   * Wort, nur ein Bild – ohne diesen Weg fände die Suche im Dokument nichts.
+   * `source` sagt, woher der Text stammt ('layer' aus dem PDF, 'ocr' erkannt).
+   */
+  textPages: (id: string) =>
+    request<{ pages: string[]; source: string }>('GET', `/files/${id}/text`),
+
+  delete: (id: string) => request<void>('DELETE', `/files/${id}`),
+
+  rename: (id: string, name: string) =>
+    request<FileItem>('PATCH', `/files/${id}/rename`, { name }),
+
+  move: (id: string, folderId: string | null) =>
+    request<FileItem>('PATCH', `/files/${id}/move`, { folder_id: folderId }),
+}
+
+// ── Folders ───────────────────────────────────────────────────────────────────
+
+export const foldersApi = {
+  list: async (parentId?: string): Promise<FolderItem[]> => {
+    const data = await filesApi.list(parentId)
+    return data.folders ?? []
+  },
+  create: (name: string, parentId?: string) =>
+    request<FolderItem>('POST', '/folders', { name, parent_id: parentId }),
+  rename: (id: string, name: string) =>
+    request<FolderItem>('PATCH', `/folders/${id}/rename`, { name }),
+  move: (id: string, parentId: string | null) =>
+    request<FolderItem>('PATCH', `/folders/${id}/move`, { parent_id: parentId }),
+  delete: (id: string) =>
+    request<void>('DELETE', `/folders/${id}`),
+}
+
+// ── Favorites ─────────────────────────────────────────────────────────────────
+
+export interface FavoriteItem {
+  id: string
+  folder_id: string
+  folder_name: string
+  folder_parent_id: string | null
+  position: number
+  is_expanded: boolean
+}
+
+export const favoritesApi = {
+  list: () => request<FavoriteItem[]>('GET', '/favorites'),
+  add: (folderId: string) => request<FavoriteItem>('POST', '/favorites', { folder_id: folderId }),
+  remove: (folderId: string) => request<void>('DELETE', `/favorites/${folderId}`),
+  setExpanded: (folderId: string, expanded: boolean) =>
+    request<void>('PATCH', `/favorites/${folderId}/expand`, { expanded }),
+  reorder: (folderIds: string[]) =>
+    request<void>('PATCH', '/favorites/reorder', { folder_ids: folderIds }),
+}
+
+// ── Trash ─────────────────────────────────────────────────────────────────────
+
+export interface TrashItem extends FileItem {
+  folder_path: string | null
+}
+
+export const trashApi = {
+  list: () => request<TrashItem[]>('GET', '/trash'),
+
+  restore: (id: string) => request<FileItem>('POST', `/trash/${id}/restore`),
+
+  deletePermanently: (id: string) => request<void>('DELETE', `/trash/${id}`),
+
+  emptyAll: () => request<void>('DELETE', '/trash'),
+}
+
+// ── Shares ────────────────────────────────────────────────────────────────────
+
+export const sharesApi = {
+  create: (fileId: string, opts: CreateShareRequest) =>
+    request<ShareLink>('POST', `/files/${fileId}/share`, opts),
+
+  list: () => request<ShareLink[]>('GET', '/shares'),
+
+  delete: (id: string) => request<void>('DELETE', `/shares/${id}`),
+
+  // Public endpoints (no auth) – /share/ prefix avoids chi /api/v1 middleware conflict
+  getInfo: (token: string) =>
+    fetch(`/share/${token}`)
+      .then(r => r.json())
+      .then(j => (j.data ?? j) as PublicShareInfo),
+
+  download: (token: string, password?: string) =>
+    fetch(`/share/${token}/download`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ password }),
+    }),
+}
+
+// ── Versions ──────────────────────────────────────────────────────────────────
+
+export const versionsApi = {
+  list: (fileId: string) =>
+    request<FileVersion[]>('GET', `/files/${fileId}/versions`),
+
+  download: (fileId: string, versionId: string) =>
+    `/api/v1/files/${fileId}/versions/${versionId}/download`,
+
+  restore: (fileId: string, versionId: string) =>
+    request<FileItem>('POST', `/files/${fileId}/versions/${versionId}/restore`),
+
+  setEnabled: (fileId: string, enabled: boolean) =>
+    request<FileItem>('PATCH', `/files/${fileId}/versioning`, { enabled }),
+}
+
+// ── Admin ─────────────────────────────────────────────────────────────────────
+
+export interface AdminUser {
+  id: string
+  username: string
+  display_name: string
+  is_admin: boolean
+  quota_bytes: number
+  used_bytes: number
+  groups: string[]
+  created_at: string
+}
+
+export interface AdminGroup {
+  id: string
+  name: string
+  description: string
+  member_count: number
+  created_at: string
+}
+
+export interface GroupMember {
+  user_id: string
+  username: string
+  display_name: string
+  joined_at: string
+}
+
+export interface AppSettings {
+  cloud_name: string
+  primary_color: string
+  accent_color: string
+  logo_storage_key: string
+  app_icon_storage_key: string
+}
+
+export interface AuditEntry {
+  id: string
+  actor_id: string | null
+  actor_name: string
+  action: string
+  target_type: string | null
+  target_id: string | null
+  target_name: string | null
+  ip: string | null
+  detail: string | null
+  created_at: string
+}
+
+export interface GroupFolder {
+  id: string
+  name: string
+  group_id: string
+  group_name: string
+  members: number
+  used_bytes: number
+  quota_bytes: number
+}
+
+function uploadBranding(kind: 'logo' | 'icon', file: File) {
+  const form = new FormData()
+  form.append('file', file)
+  return request<{ url: string }>('POST', `/admin/branding/${kind}`, form, true)
+}
+
+export const adminApi = {
+  // Branding
+  uploadLogo: (file: File) => uploadBranding('logo', file),
+  deleteLogo: () => request<void>('DELETE', '/admin/branding/logo'),
+  uploadAppIcon: (file: File) => uploadBranding('icon', file),
+  deleteAppIcon: () => request<void>('DELETE', '/admin/branding/icon'),
+
+  // Group folders
+  listGroupFolders: () => request<GroupFolder[]>('GET', '/admin/group-folders'),
+  createGroupFolder: (groupId: string, name: string) =>
+    request<FolderItem>('POST', '/admin/group-folders', { group_id: groupId, name }),
+  deleteGroupFolder: (id: string) => request<void>('DELETE', `/admin/group-folders/${id}`),
+
+  // Audit log
+  listAudit: (params: { action?: string; actorId?: string; limit?: number; offset?: number } = {}) => {
+    const qs = new URLSearchParams()
+    if (params.action) qs.set('action', params.action)
+    if (params.actorId) qs.set('actor_id', params.actorId)
+    if (params.limit != null) qs.set('limit', String(params.limit))
+    if (params.offset != null) qs.set('offset', String(params.offset))
+    const suffix = qs.toString() ? `?${qs}` : ''
+    return request<{ entries: AuditEntry[]; total: number }>('GET', `/admin/audit${suffix}`)
+  },
+  listAuditActions: () => request<string[]>('GET', '/admin/audit/actions'),
+  runCleanup: () => request<{
+    scanned: number; orphans: number; deleted: number
+    freed_bytes: number; skipped_young: number
+  }>('POST', '/admin/gc'),
+
+  /** Stand der Texterkennung. `enabled: false` heißt: abgeschaltet oder die
+   *  Programme fehlen im Image – kein Fehler, sondern eine Auskunft. */
+  ocrStatus: () => request<OcrStatus>('GET', '/admin/ocr'),
+
+  // Users
+  listUsers: () => request<AdminUser[]>('GET', '/admin/users'),
+  createUser: (data: { username: string; display_name: string; password: string; is_admin: boolean; quota_bytes: number }) =>
+    request<AdminUser>('POST', '/admin/users', data),
+  updateUser: (id: string, data: { display_name: string; is_admin: boolean; quota_bytes: number }) =>
+    request<AdminUser>('PATCH', `/admin/users/${id}`, data),
+  resetPassword: (id: string, password?: string) =>
+    request<{ new_password: string }>('POST', `/admin/users/${id}/reset-password`, password ? { password } : {}),
+  deleteUser: (id: string) => request<void>('DELETE', `/admin/users/${id}`),
+
+  // Groups
+  listGroups: () => request<AdminGroup[]>('GET', '/admin/groups'),
+  createGroup: (name: string, description: string) =>
+    request<AdminGroup>('POST', '/admin/groups', { name, description }),
+  updateGroup: (id: string, name: string, description: string) =>
+    request<AdminGroup>('PATCH', `/admin/groups/${id}`, { name, description }),
+
+  deleteGroup: (id: string) => request<void>('DELETE', `/admin/groups/${id}`),
+  listMembers: (groupId: string) => request<GroupMember[]>('GET', `/admin/groups/${groupId}/members`),
+  addMember: (groupId: string, userId: string) =>
+    request<void>('POST', `/admin/groups/${groupId}/members`, { user_id: userId }),
+  removeMember: (groupId: string, userId: string) =>
+    request<void>('DELETE', `/admin/groups/${groupId}/members/${userId}`),
+
+  // Settings
+  getSettings: () => request<AppSettings>('GET', '/admin/settings'),
+  updateSettings: (data: Partial<AppSettings>) =>
+    request<AppSettings>('PATCH', '/admin/settings', data),
+}
+
+export { APIError }
diff --git a/frontend/src/components/AppPasswords.tsx b/frontend/src/components/AppPasswords.tsx
new file mode 100644
index 0000000..57b2d4a
--- /dev/null
+++ b/frontend/src/components/AppPasswords.tsx
@@ -0,0 +1,217 @@
+import { useState, useEffect } from 'react'
+import { appPasswordsApi, type AppPassword } from '../api/client'
+import ConfirmDialog from './ConfirmDialog'
+
+/** Zugangsdaten für WebDAV-Clients, die das Hauptpasswort ersetzen: Geht ein
+ *  Gerät verloren, widerruft man dieses eine Token statt das Konto neu
+ *  abzusichern. */
+export default function AppPasswords({ username }: { username: string }) {
+  const [list, setList] = useState<AppPassword[]>([])
+  const [loading, setLoading] = useState(true)
+  const [name, setName] = useState('')
+  const [creating, setCreating] = useState(false)
+  const [error, setError] = useState('')
+  const [revoking, setRevoking] = useState<AppPassword | null>(null)
+
+  // Nur einmal im Klartext vorhanden – danach kennt der Server nur den Hash.
+  const [freshToken, setFreshToken] = useState<string | null>(null)
+  const [copied, setCopied] = useState(false)
+
+  useEffect(() => { load() }, [])
+
+  async function load() {
+    try {
+      setList(await appPasswordsApi.list() ?? [])
+    } catch {
+      setError('Could not load app passwords')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function create() {
+    const trimmed = name.trim()
+    if (!trimmed) return
+    setCreating(true)
+    setError('')
+    try {
+      const created = await appPasswordsApi.create(trimmed)
+      setFreshToken(created.password)
+      setCopied(false)
+      setName('')
+      await load()
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Could not create app password')
+    } finally {
+      setCreating(false)
+    }
+  }
+
+  async function revoke(item: AppPassword) {
+    setRevoking(null)
+    try {
+      await appPasswordsApi.revoke(item.id)
+      await load()
+    } catch {
+      setError('Could not revoke app password')
+    }
+  }
+
+  function copyToken() {
+    if (!freshToken) return
+    navigator.clipboard?.writeText(freshToken).then(
+      () => { setCopied(true); setTimeout(() => setCopied(false), 2000) },
+      () => setError('Copying failed – please select the password manually'),
+    )
+  }
+
+  return (
+    <>
+      <p style={{ margin: '-8px 0 16px', fontSize: 12, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+        WebDAV and sync clients need an app password — your account password does
+        not work there. Each one can be revoked on its own, so a lost device costs
+        you one password, not your account.
+      </p>
+
+      {/* Der Klartext erscheint genau einmal; deshalb prominent und mit
+          deutlicher Ansage statt als beiläufige Zeile in der Liste. */}
+      {freshToken && (
+        <div style={{
+          padding: 14, borderRadius: 10, marginBottom: 16,
+          border: '1px solid var(--color-primary)',
+          background: 'rgba(var(--color-primary-rgb), 0.08)',
+        }}>
+          <div style={{ fontSize: 12, fontWeight: 700, color: 'var(--color-text)', marginBottom: 8 }}>
+            Copy this password now — it is shown only once
+          </div>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 10 }}>
+            <code style={{
+              flex: 1, padding: '9px 11px', borderRadius: 8,
+              background: 'var(--color-surface-2)', color: 'var(--color-text)',
+              fontSize: 14, fontFamily: 'monospace', letterSpacing: 0.5,
+              userSelect: 'all', overflowX: 'auto', whiteSpace: 'nowrap',
+            }}>
+              {freshToken}
+            </code>
+            <button
+              onClick={copyToken}
+              style={{
+                padding: '9px 14px', borderRadius: 8, border: 'none', flexShrink: 0,
+                background: 'var(--color-primary)', color: '#fff',
+                fontSize: 12, fontWeight: 600, cursor: 'pointer',
+              }}
+            >
+              {copied ? 'Copied' : 'Copy'}
+            </button>
+          </div>
+          <div style={{ fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.6 }}>
+            In your WebDAV client use username <strong style={{ color: 'var(--color-text)' }}>{username}</strong> and
+            this password — not your account password.
+          </div>
+          <button
+            onClick={() => setFreshToken(null)}
+            style={{
+              marginTop: 10, padding: '5px 12px', borderRadius: 7,
+              border: '1px solid var(--color-border)', background: 'transparent',
+              color: 'var(--color-text-muted)', fontSize: 11, cursor: 'pointer',
+            }}
+          >
+            I've saved it
+          </button>
+        </div>
+      )}
+
+      {/* Create */}
+      <div style={{ display: 'flex', gap: 8, marginBottom: 16 }}>
+        <input
+          value={name}
+          onChange={e => setName(e.target.value)}
+          onKeyDown={e => { if (e.key === 'Enter') create() }}
+          placeholder="Device name, e.g. Phone"
+          style={{
+            flex: 1, padding: '8px 10px', borderRadius: 8,
+            border: '1px solid var(--color-border)',
+            background: 'var(--color-surface-2)', color: 'var(--color-text)',
+            fontSize: 13, outline: 'none',
+          }}
+        />
+        <button
+          onClick={create}
+          disabled={creating || !name.trim()}
+          style={{
+            padding: '8px 18px', borderRadius: 8, border: 'none',
+            background: 'var(--color-primary)', color: '#fff',
+            fontSize: 13, fontWeight: 600,
+            cursor: creating || !name.trim() ? 'default' : 'pointer',
+            opacity: creating || !name.trim() ? 0.6 : 1, flexShrink: 0,
+          }}
+        >
+          {creating ? 'Creating…' : 'Create'}
+        </button>
+      </div>
+
+      {error && (
+        <p style={{ margin: '0 0 12px', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>
+      )}
+
+      {/* List */}
+      {loading ? (
+        <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)' }}>Loading…</p>
+      ) : list.length === 0 ? (
+        <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)' }}>
+          No app passwords yet — you need one before a WebDAV client can connect.
+        </p>
+      ) : (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
+          {list.map(item => (
+            <div
+              key={item.id}
+              style={{
+                display: 'flex', alignItems: 'center', gap: 12,
+                padding: '10px 12px', borderRadius: 9,
+                border: '1px solid var(--color-border)',
+              }}
+            >
+              <div style={{ flex: 1, minWidth: 0 }}>
+                <div style={{
+                  fontSize: 13, fontWeight: 600, color: 'var(--color-text)',
+                  overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                }}>
+                  {item.name}
+                </div>
+                <div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginTop: 2 }}>
+                  {item.last_used_at
+                    ? `Last used ${new Date(item.last_used_at).toLocaleDateString()}`
+                    : 'Never used'}
+                  {' · '}
+                  Created {new Date(item.created_at).toLocaleDateString()}
+                </div>
+              </div>
+              <button
+                onClick={() => setRevoking(item)}
+                style={{
+                  padding: '5px 12px', borderRadius: 7, flexShrink: 0,
+                  border: '1px solid var(--color-danger)', background: 'transparent',
+                  color: 'var(--color-danger)', fontSize: 12, cursor: 'pointer',
+                }}
+              >
+                Revoke
+              </button>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {revoking && (
+        <ConfirmDialog
+          title="Revoke app password"
+          message={`"${revoking.name}" will stop working immediately. Any device using it has to be set up again with a new password.`}
+          confirmLabel="Revoke"
+          danger
+          onConfirm={() => revoke(revoking)}
+          onCancel={() => setRevoking(null)}
+        />
+      )}
+    </>
+  )
+}
diff --git a/frontend/src/components/AppSwitcher.tsx b/frontend/src/components/AppSwitcher.tsx
new file mode 100644
index 0000000..881b5e7
--- /dev/null
+++ b/frontend/src/components/AppSwitcher.tsx
@@ -0,0 +1,114 @@
+import { useEffect, useRef, useState } from 'react'
+import { publicApi, type ExternalApp } from '../api/client'
+
+/**
+ * DERZEIT NICHT EINGEHÄNGT (Stand 2026-07-30).
+ *
+ * Auf Wunsch wieder aus der Seitenleiste entfernt – erst soll Aether für sich
+ * fertig werden. Die Komponente bleibt liegen, weil eine gemeinsame Leiste für
+ * alle Apps noch überlegt wird. Wird sie nirgends importiert, landet sie auch
+ * nicht im Bundle. Zum Reaktivieren: in `Sidebar.tsx` neben dem Markenschriftzug
+ * einsetzen und EXTERNAL_APPS in `deploy/.env` füllen.
+ *
+ * Umschalter zu den anderen selbst gehosteten Apps.
+ *
+ * Die Einträge kommen aus EXTERNAL_APPS in der .env des Servers – so lassen
+ * sich Apps ergänzen, ohne das Frontend neu zu bauen. Ist nichts gesetzt,
+ * rendert die Komponente nichts.
+ *
+ * Die Ziele liegen auf anderen Ursprüngen (eigene Subdomain je App). Deshalb
+ * `target="_blank"`: Ist die andere App als PWA installiert, übernimmt das
+ * Betriebssystem sie als eigene App; sonst öffnet sie in einem neuen Tab.
+ * Eine Navigation im selben Fenster würde die installierte Aether-App
+ * verlassen und in einer Browserleiste landen.
+ */
+export default function AppSwitcher() {
+  const [apps, setApps] = useState<ExternalApp[]>([])
+  const [open, setOpen] = useState(false)
+  const boxRef = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    publicApi.config()
+      .then(c => setApps(c.external_apps ?? []))
+      .catch(() => {})
+  }, [])
+
+  useEffect(() => {
+    if (!open) return
+    function onDown(e: MouseEvent) {
+      if (boxRef.current && !boxRef.current.contains(e.target as Node)) setOpen(false)
+    }
+    function onEsc(e: KeyboardEvent) {
+      if (e.key === 'Escape') setOpen(false)
+    }
+    document.addEventListener('mousedown', onDown)
+    document.addEventListener('keydown', onEsc)
+    return () => {
+      document.removeEventListener('mousedown', onDown)
+      document.removeEventListener('keydown', onEsc)
+    }
+  }, [open])
+
+  if (apps.length === 0) return null
+
+  return (
+    <div ref={boxRef} style={{ position: 'relative', marginLeft: 'auto' }}>
+      <button
+        onClick={() => setOpen(o => !o)}
+        aria-label="Other apps"
+        aria-expanded={open}
+        style={{
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+          width: 28, height: 28, borderRadius: 8, cursor: 'pointer',
+          background: open ? 'var(--color-surface-2)' : 'transparent',
+          border: 'none', color: 'var(--color-text-muted)', padding: 0,
+        }}
+      >
+        {/* Raster aus neun Punkten – das übliche Zeichen für einen App-Wechsel */}
+        <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor">
+          {[5, 12, 19].map(y => [5, 12, 19].map(x => (
+            <circle key={`${x}-${y}`} cx={x} cy={y} r="1.8" />
+          )))}
+        </svg>
+      </button>
+
+      {open && (
+        <div style={{
+          position: 'absolute', top: 34, right: 0, zIndex: 60, minWidth: 190,
+          background: 'var(--color-surface)',
+          border: '1px solid var(--color-border)',
+          borderRadius: 'var(--radius)',
+          boxShadow: '0 10px 30px rgba(0,0,0,0.4)',
+          padding: 4,
+        }}>
+          <div style={{
+            padding: '6px 10px 4px', fontSize: 11, fontWeight: 600,
+            color: 'var(--color-text-muted)', textTransform: 'uppercase',
+            letterSpacing: '0.04em',
+          }}>
+            My apps
+          </div>
+          {apps.map(app => (
+            <a
+              key={app.url}
+              href={app.url}
+              target="_blank"
+              rel="noopener noreferrer"
+              onClick={() => setOpen(false)}
+              style={{
+                display: 'flex', alignItems: 'center', gap: 10,
+                padding: '8px 10px', borderRadius: 8,
+                fontSize: 13, color: 'var(--color-text)', textDecoration: 'none',
+              }}
+              onMouseEnter={e => (e.currentTarget.style.background = 'var(--color-surface-2)')}
+              onMouseLeave={e => (e.currentTarget.style.background = 'transparent')}
+            >
+              <span style={{ fontSize: 16, width: 20, textAlign: 'center' }}>{app.icon || '🔗'}</span>
+              {app.name}
+            </a>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/components/Breadcrumb.tsx b/frontend/src/components/Breadcrumb.tsx
new file mode 100644
index 0000000..1b1024a
--- /dev/null
+++ b/frontend/src/components/Breadcrumb.tsx
@@ -0,0 +1,87 @@
+import type { FolderItem } from '../api/client'
+
+interface Props {
+  path: FolderItem[]
+  onNavigate: (folderId: string | undefined) => void
+}
+
+/**
+ * Der Pfad in der Kopfleiste.
+ *
+ * Schriftgröße und -stärke sind dieselben wie bei den Titeln der anderen
+ * Ansichten („Trash", „Shared links"): 15 px, 600 für den aktuellen Ort. Bis
+ * zum 23.08.2026 lief das über Tailwind-Klassen (`text-sm`, `font-medium`) und
+ * war damit 14 px bei Stärke 500 – nebeneinander sieht man den Unterschied
+ * sofort, auch ohne ihn benennen zu können.
+ *
+ * Auch das Symbol war kleiner (15 statt 18). Es ist jetzt Zeichen für Zeichen
+ * dasselbe wie in der Seitenleiste.
+ */
+const rootLabel = 'Home'
+
+export default function Breadcrumb({ path, onNavigate }: Props) {
+  const atRoot = path.length === 0
+
+  const segment = (active: boolean) => ({
+    flexShrink: 0,
+    display: 'flex',
+    alignItems: 'center',
+    // 10 wie in PageHeader zwischen Symbol und Titel – bei 7 stand „Home"
+    // drei Pixel weiter links als „Trash". Gemessen: 265 statt 268.
+    gap: 10,
+    padding: '2px 6px',
+    borderRadius: 6,
+    border: 'none',
+    background: 'none',
+    cursor: 'pointer',
+    // Gleiche Schrift wie die Seitentitel – sonst wirkt die Dateiansicht wie
+    // eine andere Anwendung.
+    fontSize: 15,
+    fontWeight: 600,
+    lineHeight: 1.3,
+    color: active ? 'var(--color-text)' : 'var(--color-text-muted)',
+  })
+
+  return (
+    <nav style={{
+      display: 'flex', alignItems: 'center', gap: 2,
+      minWidth: 0, overflowX: 'auto',
+      // Der Wurzel-Knopf hat innen 6 px Rand, damit sein Hover-Feld nicht am
+      // Text klebt. Ohne diesen Ausgleich begänne das Haus-Symbol 6 px weiter
+      // rechts als das Symbol in Papierkorb und Co. – beim Umschalten sieht man
+      // genau diesen Sprung. Gemessen: 246 statt 240.
+      marginLeft: -6,
+    }}>
+      <button onClick={() => onNavigate(undefined)} style={segment(atRoot)} title={rootLabel}>
+        {/* Das Symbol bleibt gedämpft, auch wenn der Titel hell ist – genau so
+            steht es im Papierkorb und bei den Freigabe-Links. Vorher erbte es
+            die Textfarbe und leuchtete auf der Startebene heller als dort. */}
+        <span style={{ display: 'flex', color: 'var(--color-text-muted)' }}>
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+               strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <path d="M3 10.5L12 3l9 7.5" />
+            <path d="M5.5 9.5V20a1 1 0 001 1h11a1 1 0 001-1V9.5" />
+          </svg>
+        </span>
+        {rootLabel}
+      </button>
+
+      {path.map((folder, i) => (
+        <span key={folder.id} style={{ display: 'flex', alignItems: 'center', gap: 2, minWidth: 0 }}>
+          <span style={{ color: 'var(--color-text-muted)', fontSize: 15, opacity: 0.6 }}>/</span>
+          <button
+            onClick={() => onNavigate(folder.id)}
+            style={{
+              ...segment(i === path.length - 1),
+              overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+              display: 'block', maxWidth: 220,
+            }}
+            title={folder.name}
+          >
+            {folder.name}
+          </button>
+        </span>
+      ))}
+    </nav>
+  )
+}
diff --git a/frontend/src/components/ConfirmDialog.tsx b/frontend/src/components/ConfirmDialog.tsx
new file mode 100644
index 0000000..31250f3
--- /dev/null
+++ b/frontend/src/components/ConfirmDialog.tsx
@@ -0,0 +1,55 @@
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+
+interface Props {
+  title: string
+  message: string
+  confirmLabel?: string
+  danger?: boolean
+  onConfirm: () => void
+  onCancel: () => void
+}
+
+export default function ConfirmDialog({ title, message, confirmLabel = 'Confirm', danger = false, onConfirm, onCancel }: Props) {
+  const overlay = useOverlayDismiss(onCancel)
+  return (
+    <div
+      style={{ position: 'fixed', inset: 0, zIndex: 200, display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'rgba(0,0,0,0.6)' }}
+      {...overlay}
+    >
+      <div style={{
+        background: 'var(--color-surface)',
+        border: '1px solid var(--color-border)',
+        borderRadius: 14,
+        padding: 24,
+        width: 360,
+        maxWidth: '90vw',
+      }}>
+        <h2 style={{ margin: '0 0 8px', fontSize: 16, fontWeight: 600, color: 'var(--color-text)' }}>{title}</h2>
+        <p style={{ margin: '0 0 24px', fontSize: 14, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>{message}</p>
+        <div style={{ display: 'flex', gap: 8, justifyContent: 'flex-end' }}>
+          <button
+            onClick={onCancel}
+            style={{
+              padding: '8px 16px', borderRadius: 8,
+              border: '1px solid var(--color-border)',
+              background: 'transparent', color: 'var(--color-text-muted)',
+              fontSize: 13, cursor: 'pointer',
+            }}
+          >
+            Cancel
+          </button>
+          <button
+            onClick={onConfirm}
+            style={{
+              padding: '8px 16px', borderRadius: 8, border: 'none',
+              background: danger ? 'var(--color-danger)' : 'var(--color-primary)',
+              color: '#fff', fontSize: 13, fontWeight: 600, cursor: 'pointer',
+            }}
+          >
+            {confirmLabel}
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/ContextMenu.tsx b/frontend/src/components/ContextMenu.tsx
new file mode 100644
index 0000000..f30c80c
--- /dev/null
+++ b/frontend/src/components/ContextMenu.tsx
@@ -0,0 +1,110 @@
+import { useEffect, useRef, type ReactNode } from 'react'
+import { CheckIcon } from './icons'
+
+export interface MenuAction {
+  label: string
+  icon?: ReactNode
+  danger?: boolean
+  /** Setzt einen Haken rechts – für Einträge, die einen Zustand umschalten. */
+  checked?: boolean
+  onClick: () => void
+}
+
+/** Eine Trennlinie gruppiert zusammengehörende Einträge. */
+export type MenuItem = MenuAction | { separator: true }
+
+function isSeparator(item: MenuItem): item is { separator: true } {
+  return 'separator' in item
+}
+
+interface Props {
+  x: number
+  y: number
+  items: MenuItem[]
+  onClose: () => void
+}
+
+const ITEM_HEIGHT = 32
+const SEPARATOR_HEIGHT = 9
+const MENU_WIDTH = 190
+
+export default function ContextMenu({ x, y, items, onClose }: Props) {
+  const ref = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    const handler = (e: MouseEvent) => {
+      if (ref.current && !ref.current.contains(e.target as Node)) onClose()
+    }
+    const esc = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose() }
+    document.addEventListener('mousedown', handler)
+    document.addEventListener('keydown', esc)
+    return () => {
+      document.removeEventListener('mousedown', handler)
+      document.removeEventListener('keydown', esc)
+    }
+  }, [onClose])
+
+  // Höhe aus dem Inhalt schätzen, statt eine feste Zahl anzunehmen: sonst
+  // klappt ein langes Menü am unteren Rand aus dem Bild heraus.
+  const height =
+    items.reduce((h, i) => h + (isSeparator(i) ? SEPARATOR_HEIGHT : ITEM_HEIGHT), 0) + 8
+
+  const style: React.CSSProperties = {
+    position: 'fixed',
+    top: Math.max(8, Math.min(y, window.innerHeight - height - 8)),
+    left: Math.max(8, Math.min(x, window.innerWidth - MENU_WIDTH - 8)),
+    zIndex: 50,
+    minWidth: MENU_WIDTH,
+    background: 'var(--color-surface)',
+    border: '1px solid var(--color-border)',
+    borderRadius: 'var(--radius)',
+    boxShadow: '0 10px 30px rgba(0,0,0,0.4)',
+    padding: '4px',
+  }
+
+  return (
+    <div ref={ref} style={style}>
+      {items.map((item, i) =>
+        isSeparator(item) ? (
+          <div
+            key={`sep-${i}`}
+            style={{ height: 1, background: 'var(--color-border)', margin: '4px 6px' }}
+          />
+        ) : (
+          <button
+            key={item.label}
+            onClick={() => { item.onClick(); onClose() }}
+            style={{
+              width: '100%', height: ITEM_HEIGHT,
+              display: 'flex', alignItems: 'center', gap: 10,
+              padding: '0 10px', borderRadius: 6,
+              border: 'none', background: 'transparent', cursor: 'pointer',
+              fontSize: 13, textAlign: 'left',
+              color: item.danger ? 'var(--color-danger)' : 'var(--color-text)',
+              transition: 'background 0.12s',
+            }}
+            onMouseEnter={e => (e.currentTarget.style.background = item.danger
+              ? 'rgba(239,68,68,0.12)'
+              : 'var(--color-surface-2)')}
+            onMouseLeave={e => (e.currentTarget.style.background = 'transparent')}
+          >
+            {/* Feste Spalte für das Icon – so stehen alle Beschriftungen bündig,
+                auch bei Einträgen ohne Icon. */}
+            <span style={{
+              width: 15, display: 'flex', alignItems: 'center', justifyContent: 'center',
+              color: item.danger ? 'var(--color-danger)' : 'var(--color-text-muted)',
+            }}>
+              {item.icon}
+            </span>
+            <span style={{ flex: 1 }}>{item.label}</span>
+            {item.checked && (
+              <span style={{ color: 'var(--color-primary)', display: 'flex' }}>
+                <CheckIcon size={14} />
+              </span>
+            )}
+          </button>
+        )
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/components/Dialog.tsx b/frontend/src/components/Dialog.tsx
new file mode 100644
index 0000000..5ad42e4
--- /dev/null
+++ b/frontend/src/components/Dialog.tsx
@@ -0,0 +1,66 @@
+import { type FormEvent, useEffect, useRef } from 'react'
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+
+interface Props {
+  title: string
+  defaultValue?: string
+  placeholder?: string
+  confirmLabel?: string
+  onConfirm: (value: string) => void
+  onCancel: () => void
+}
+
+export default function InputDialog({ title, defaultValue = '', placeholder, confirmLabel = 'OK', onConfirm, onCancel }: Props) {
+  const inputRef = useRef<HTMLInputElement>(null)
+  const overlay = useOverlayDismiss(onCancel)
+
+  useEffect(() => {
+    inputRef.current?.focus()
+    inputRef.current?.select()
+  }, [])
+
+  function handleSubmit(e: FormEvent) {
+    e.preventDefault()
+    const val = inputRef.current?.value.trim()
+    if (val) onConfirm(val)
+  }
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4"
+         style={{ background: 'rgba(0,0,0,0.6)' }}
+         {...overlay}>
+      <div className="w-full max-w-sm rounded-xl p-5 shadow-2xl border"
+           style={{ background: 'var(--color-surface)', borderColor: 'var(--color-border)' }}>
+        <h2 className="font-semibold mb-4" style={{ color: 'var(--color-text)' }}>{title}</h2>
+        <form onSubmit={handleSubmit} className="space-y-3">
+          <input
+            ref={inputRef}
+            type="text"
+            defaultValue={defaultValue}
+            placeholder={placeholder}
+            className="w-full rounded-lg px-3 py-2.5 text-sm outline-none"
+            style={{
+              background: 'var(--color-surface-2)',
+              border: '1px solid var(--color-border)',
+              color: 'var(--color-text)',
+            }}
+            onFocus={e => e.currentTarget.style.borderColor = 'var(--color-primary)'}
+            onBlur={e => e.currentTarget.style.borderColor = 'var(--color-border)'}
+          />
+          <div className="flex justify-end gap-2">
+            <button type="button" onClick={onCancel}
+                    className="px-4 py-2 text-sm rounded-lg transition-opacity hover:opacity-70"
+                    style={{ color: 'var(--color-text-muted)' }}>
+              Cancel
+            </button>
+            <button type="submit"
+                    className="px-4 py-2 text-sm rounded-lg font-medium"
+                    style={{ background: 'var(--color-primary)', color: 'var(--color-primary-fg)' }}>
+              {confirmLabel}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/FileCover.tsx b/frontend/src/components/FileCover.tsx
new file mode 100644
index 0000000..36671ea
--- /dev/null
+++ b/frontend/src/components/FileCover.tsx
@@ -0,0 +1,144 @@
+import { useState } from 'react'
+import { filesApi, type FileItem, type FolderItem } from '../api/client'
+import { FileTypeIcon, FolderGlyph } from './icons'
+import { fileKind, kindColors, extensionOf } from './filetypes'
+
+/**
+ * Das Bild auf einer Kachel.
+ *
+ * Bilder zeigen ihr Vorschaubild. Alles andere bekam vorher dieselbe blasse
+ * Fläche mit einem kleinen Symbol – eine MP3, ein Archiv und eine Tabelle sahen
+ * damit fast gleich aus. Jetzt trägt jede Art ihre eigene Farbe, ein
+ * passendes Symbol und die Endung als Aufkleber: Man erkennt den Typ, bevor man
+ * den Namen gelesen hat.
+ */
+export default function FileCover({ file }: { file: FileItem }) {
+  const [failed, setFailed] = useState(false)
+  const kind = fileKind(file.mime_type, file.name)
+  const color = kindColors[kind]
+  const ext = extensionOf(file.name).toUpperCase()
+
+  if (file.has_thumbnail && !failed) {
+    return (
+      <>
+        <img
+          src={filesApi.thumbnail(file.id)}
+          alt=""
+          onError={() => setFailed(true)}
+          style={{
+            width: '100%', height: '100%',
+            objectFit: 'cover',
+            position: 'absolute', inset: 0,
+          }}
+        />
+        {/* Auch über dem Vorschaubild: Sonst sieht man einem Bild nicht an, ob
+            es ein PNG mit Transparenz, ein JPG oder ein GIF ist – und beim
+            Weitergeben macht das einen Unterschied.
+            In der Farbe der Art wie überall sonst; ein dunkler Kasten hätte die
+            eine Kachel aus der Reihe fallen lassen. Damit er auf einem hellen
+            Motiv nicht verschwimmt, bekommt er einen dunklen Saum. */}
+        {ext && <Badge text={ext} background={color} ring />}
+      </>
+    )
+  }
+
+  return (
+    <div style={{
+      position: 'absolute', inset: 0,
+      display: 'flex', alignItems: 'center', justifyContent: 'center',
+      // Verlauf statt einer flachen Fläche: Der Unterschied zwischen zwei
+      // Arten ist bei 12 % Deckkraft sonst kaum zu sehen.
+      background: `linear-gradient(135deg, ${color}2e 0%, ${color}12 55%, transparent 100%)`,
+    }}>
+      <FileTypeIcon mime={file.mime_type} name={file.name} size={34} />
+
+      {ext && <Badge text={ext} background={color} />}
+
+      {/* Bei Ton und Video verrät ein Abspielzeichen sofort, dass hier ein
+          Doppelklick etwas abspielt. */}
+      {(kind === 'video' || kind === 'audio') && (
+        <span style={{
+          position: 'absolute', right: 7, bottom: 6,
+          width: 18, height: 18, borderRadius: '50%',
+          background: `${color}33`,
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+        }}>
+          <svg width="9" height="9" viewBox="0 0 24 24" fill={color}>
+            <polygon points="6 4 20 12 6 20" />
+          </svg>
+        </span>
+      )}
+    </div>
+  )
+}
+
+/** Der Aufkleber unten links. Eine Stelle, damit er über einem Vorschaubild
+ *  und über einer Farbfläche gleich sitzt. */
+function Badge({ text, background, ring }: { text: string; background: string; ring?: boolean }) {
+  return (
+    <span style={{
+      position: 'absolute', left: 8, bottom: 7,
+      padding: '1px 5px', borderRadius: 4,
+      background, color: '#fff',
+      // Nur über einem Vorschaubild nötig – auf der ruhigen Farbfläche wäre
+      // der Saum bloß Unruhe.
+      boxShadow: ring ? '0 0 0 1px rgba(0,0,0,0.45), 0 1px 3px rgba(0,0,0,0.5)' : 'none',
+      fontSize: 9, fontWeight: 700, letterSpacing: 0.4,
+      textTransform: 'uppercase',
+      maxWidth: 'calc(100% - 16px)', overflow: 'hidden',
+      textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+    }}>
+      {text}
+    </span>
+  )
+}
+
+/**
+ * Das Gegenstück für Ordner.
+ *
+ * Vorher ein flaches Symbol auf blasser Fläche – neben den neuen Dateikacheln
+ * sah der Ordner damit aus wie vergessen. Jetzt zwei Lagen mit Reiter, die
+ * Tiefe andeuten, dazu derselbe Verlauf wie bei den Dateien.
+ *
+ * Ein Gruppenordner trägt die Primärfarbe statt Bernstein und ein
+ * Personen-Zeichen: Er gehört nicht dir allein, und das soll man sehen, bevor
+ * man etwas hineinlegt.
+ */
+export function FolderCover({ folder, highlight }: { folder: FolderItem; highlight?: boolean }) {
+  const isGroup = folder.group_id !== null
+  // Der Gruppenfall über die Token-Variable, damit er der eingestellten
+  // Palette folgt; Bernstein ist fest, weil es die Ordnerfarbe der App ist.
+  const tint = isGroup ? 'rgba(var(--color-primary-rgb), ALPHA)' : 'rgba(245, 158, 11, ALPHA)'
+  const at = (a: number) => tint.replace('ALPHA', String(a))
+  const solid = isGroup ? 'rgb(var(--color-primary-rgb))' : '#f59e0b'
+
+  return (
+    <div style={{
+      position: 'absolute', inset: 0,
+      display: 'flex', alignItems: 'center', justifyContent: 'center',
+      background: highlight
+        ? 'rgba(var(--color-primary-rgb), 0.16)'
+        : `linear-gradient(135deg, ${at(0.3)} 0%, ${at(0.12)} 55%, transparent 100%)`,
+      transition: 'background 0.12s',
+    }}>
+      <FolderGlyph size={48} color={solid} />
+
+      {isGroup && (
+        <span style={{
+          position: 'absolute', left: 8, bottom: 7,
+          display: 'flex', alignItems: 'center', gap: 3,
+          padding: '1px 5px', borderRadius: 4,
+          background: solid, color: '#fff',
+          fontSize: 9, fontWeight: 700, letterSpacing: 0.4,
+        }}>
+          <svg width="9" height="9" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.4">
+            <circle cx="9" cy="8" r="3.5" />
+            <path d="M2 21v-1a7 7 0 0114 0v1" />
+            <path d="M17 11a3 3 0 100-6M19 21v-1a6 6 0 00-3-5.2" />
+          </svg>
+          GROUP
+        </span>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/components/FileInfoDialog.tsx b/frontend/src/components/FileInfoDialog.tsx
new file mode 100644
index 0000000..f8fe621
--- /dev/null
+++ b/frontend/src/components/FileInfoDialog.tsx
@@ -0,0 +1,185 @@
+import { useEffect, useState } from 'react'
+import { filesApi, type Correspondent, type FileItem, type Tag } from '../api/client'
+import { formatBytes } from '../pages/FileBrowser'
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+import TagChip from './TagChip'
+
+/**
+ * „Properties" einer Datei – das, was Dateimanager unter Windows und Linux
+ * im Rechtsklickmenü anbieten.
+ *
+ * Anlass war eine Lücke, die man erst beim Benutzen merkt: Bei einem Bild
+ * stand nirgends, **wie groß** es ist. Nicht in Byte – in Pixeln. Die Kachel
+ * zeigt eine Vorschau, die Liste zeigt Kilobyte, und ob das Foto 800 oder
+ * 4000 Punkte breit ist, war der Anwendung schlicht nicht zu entlocken.
+ *
+ * Die Maße kommen **hier im Browser** zustande, nicht vom Server: Er
+ * speichert sie nicht, und für eine Angabe in einem Dialog lohnt weder eine
+ * Spalte in der Datenbank noch ein Durchlauf über alle bestehenden Dateien.
+ * Der Browser kann jedes Bild, das er anzeigen kann, auch ausmessen.
+ */
+interface Props {
+  file: FileItem
+  tags: Tag[]
+  correspondent?: Correspondent
+  onClose: () => void
+}
+
+function formatDate(iso: string): string {
+  return new Date(iso).toLocaleString(undefined, {
+    day: '2-digit', month: 'short', year: 'numeric',
+    hour: '2-digit', minute: '2-digit',
+  })
+}
+
+/** Der Teil hinter dem letzten Punkt, in Großbuchstaben. Leer, wenn keiner. */
+function extensionOf(name: string): string {
+  const at = name.lastIndexOf('.')
+  return at > 0 && at < name.length - 1 ? name.slice(at + 1).toUpperCase() : ''
+}
+
+function Row({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div style={{ display: 'flex', gap: 12, padding: '5px 0', alignItems: 'baseline' }}>
+      <div style={{
+        width: 104, flexShrink: 0, fontSize: 12,
+        color: 'var(--color-text-muted)',
+      }}>{label}</div>
+      <div style={{ flex: 1, minWidth: 0, fontSize: 13, color: 'var(--color-text)' }}>
+        {children}
+      </div>
+    </div>
+  )
+}
+
+export default function FileInfoDialog({ file, tags, correspondent, onClose }: Props) {
+  const overlay = useOverlayDismiss(onClose)
+  const [dims, setDims] = useState<{ w: number; h: number } | null>(null)
+  const [copied, setCopied] = useState(false)
+
+  const isImage = file.mime_type.startsWith('image/')
+
+  useEffect(() => {
+    if (!isImage) return
+    let alive = true
+    const img = new Image()
+    // Dieselbe Adresse, die auch die Vorschau nimmt – das Bild liegt danach
+    // ohnehin im Zwischenspeicher des Browsers.
+    img.src = filesApi.inline(file.id)
+    img.onload = () => {
+      if (alive) setDims({ w: img.naturalWidth, h: img.naturalHeight })
+    }
+    // Kein onerror-Zweig: Kann der Browser das Bild nicht lesen (etwa ein
+    // Format, das er nicht kennt), bleibt die Zeile einfach weg. Eine
+    // Fehlermeldung über ein Maß, das niemand angefordert hat, wäre nur Lärm.
+    return () => { alive = false; img.src = '' }
+  }, [file.id, isImage])
+
+  async function copyChecksum() {
+    try {
+      await navigator.clipboard.writeText(file.checksum)
+      setCopied(true)
+      setTimeout(() => setCopied(false), 1500)
+    } catch {
+      /* Ohne sicheren Kontext gibt es keine Zwischenablage – dann bleibt der
+         Wert zum Markieren stehen, er ist ja vollständig zu sehen. */
+    }
+  }
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4"
+         style={{ background: 'rgba(0,0,0,0.6)' }}
+         {...overlay}>
+      <div className="w-full max-w-md rounded-xl p-5 shadow-2xl border"
+           style={{ background: 'var(--color-surface)', borderColor: 'var(--color-border)' }}>
+        <h2 className="font-semibold mb-1" style={{ color: 'var(--color-text)' }}>Properties</h2>
+        <p className="mb-3" style={{
+          fontSize: 13, color: 'var(--color-text-muted)',
+          overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+        }} title={file.name}>{file.name}</p>
+
+        <div style={{ borderTop: '1px solid var(--color-border)', paddingTop: 6 }}>
+          <Row label="Type">
+            {extensionOf(file.name) && <strong style={{ fontWeight: 600 }}>{extensionOf(file.name)} </strong>}
+            <span style={{ color: 'var(--color-text-muted)' }}>{file.mime_type}</span>
+          </Row>
+
+          <Row label="Size">
+            {formatBytes(file.size)}
+            {/* Die genaue Zahl daneben: Beim Vergleich zweier Fassungen sind
+                „1,2 MB" und „1,2 MB" dasselbe, 1 261 «und» 1 264 Kilobyte
+                nicht. */}
+            <span style={{ color: 'var(--color-text-muted)' }}>
+              {' '}({file.size.toLocaleString()} bytes)
+            </span>
+          </Row>
+
+          {isImage && (
+            <Row label="Dimensions">
+              {dims
+                ? <>{dims.w} × {dims.h} px
+                    <span style={{ color: 'var(--color-text-muted)' }}>
+                      {' '}({(dims.w * dims.h / 1e6).toFixed(1)} MP)
+                    </span>
+                  </>
+                : <span style={{ color: 'var(--color-text-muted)' }}>measuring…</span>}
+            </Row>
+          )}
+
+          {file.document_date && <Row label="Document date">{file.document_date}</Row>}
+
+          {correspondent && (
+            <Row label="From">
+              {correspondent.icon ? `${correspondent.icon} ${correspondent.name}` : correspondent.name}
+            </Row>
+          )}
+
+          {tags.length > 0 && (
+            <Row label="Tags">
+              <span style={{ display: 'flex', flexWrap: 'wrap', gap: 4 }}>
+                {tags.map(t => <TagChip key={t.id} tag={t} size="sm" />)}
+              </span>
+            </Row>
+          )}
+
+          <Row label="Uploaded">{formatDate(file.created_at)}</Row>
+          <Row label="Modified">{formatDate(file.updated_at)}</Row>
+
+          <Row label="Version">
+            {file.version}
+            <span style={{ color: 'var(--color-text-muted)' }}>
+              {' '}({file.versioning_enabled ? 'history kept' : 'history off'})
+            </span>
+          </Row>
+
+          {/* Die Prüfsumme steht schon in der Datenbank und wird bei jedem
+              Download nachgerechnet. Sie hier zu zeigen kostet nichts und
+              beantwortet die eine Frage, für die es sonst keinen Weg gibt:
+              „Ist das dieselbe Datei wie die auf meiner Platte?" */}
+          <Row label="SHA-256">
+            <button
+              onClick={copyChecksum}
+              title="Copy"
+              style={{
+                fontFamily: 'ui-monospace, monospace', fontSize: 11, lineHeight: 1.4,
+                wordBreak: 'break-all', textAlign: 'left', cursor: 'pointer',
+                background: 'none', border: 'none', padding: 0,
+                color: copied ? 'var(--color-primary)' : 'var(--color-text-muted)',
+              }}
+            >
+              {copied ? 'copied' : file.checksum}
+            </button>
+          </Row>
+        </div>
+
+        <div className="flex justify-end mt-4">
+          <button onClick={onClose}
+                  className="px-4 py-2 text-sm rounded-lg font-medium"
+                  style={{ background: 'var(--color-primary)', color: 'var(--color-primary-fg)' }}>
+            Close
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/FilePreview.tsx b/frontend/src/components/FilePreview.tsx
new file mode 100644
index 0000000..395f432
--- /dev/null
+++ b/frontend/src/components/FilePreview.tsx
@@ -0,0 +1,373 @@
+import { lazy, Suspense, useEffect, useState, useSyncExternalStore } from 'react'
+import { filesApi, APIError, type FileItem } from '../api/client'
+import { fileKind } from './filetypes'
+
+/**
+ * Nachgeladen, nicht mitgeliefert: PDF.js wiegt rund eine halbe Megabyte im
+ * Hauptbündel und noch einmal 1,3 MB im Arbeiter. Wer nur Bilder ansieht,
+ * soll das nicht bei jedem Besuch herunterladen – geholt wird es erst beim
+ * ersten PDF und liegt danach im Cache des Browsers.
+ */
+const PdfViewer = lazy(() => import('./PdfViewer'))
+
+interface Props {
+  file: FileItem
+  /** Blättern innerhalb des Ordners – null, wenn es nichts zu blättern gibt. */
+  onPrev?: () => void
+  onNext?: () => void
+  onClose: () => void
+  /** Nach dem Speichern: Liste neu holen, damit Größe und Datum stimmen. */
+  onSaved?: () => void
+  /**
+   * Suchwort, mit dem die Datei gefunden wurde. Der PDF-Betrachter springt
+   * damit zur Fundstelle, statt auf Seite 1 zu beginnen – der Grund, aus dem
+   * es überhaupt ein eigener Betrachter geworden ist.
+   */
+  searchTerm?: string
+}
+
+/**
+ * Was der Browser selbst anzeigen kann, zeigt er: Bilder, PDF, Text, Video,
+ * Ton. Der Server liefert diese Typen mit `inline`, alles andere bleibt ein
+ * Download – die Liste steht in internal/files/handler.go und ist eine
+ * Positivliste, damit eine hochgeladene HTML-Datei nie im Ursprung der
+ * Anwendung läuft.
+ */
+type Kind = 'image' | 'pdf' | 'text' | 'video' | 'audio' | 'none'
+
+/**
+ * Der Name zählt mit, nicht nur der MIME-Typ: Ältere Dateien liegen als
+ * application/octet-stream in der Datenbank, weil der Server bis zum
+ * 23.08.2026 die Endungen .mp3 und .mp4 nicht kannte. Ohne den Namen ließe
+ * sich eine vorhandene MP3 also nie abspielen.
+ */
+function kindOf(mime: string, name = ''): Kind {
+  const m = (mime || '').toLowerCase()
+  // SVG bleibt draußen: Der Server liefert sie nie inline aus, weil eine
+  // SVG-Datei Skripte enthalten darf.
+  if (m.includes('svg')) return 'none'
+
+  switch (fileKind(mime, name)) {
+    case 'image': return 'image'
+    case 'pdf': return 'pdf'
+    case 'video': return 'video'
+    case 'audio': return 'audio'
+    case 'text':
+    case 'code': return 'text'
+    case 'doc':
+      // Nur echte Textdateien, kein .docx – das ist ein ZIP-Archiv.
+      return m.startsWith('text/') || /\.(txt|md|log)$/i.test(name) ? 'text' : 'none'
+    default: return 'none'
+  }
+}
+
+/**
+ * Unterhalb dieser Breite ist der Bildschirm ein Telefon.
+ *
+ * Dort zählt jeder Pixel: Ein PDF, das nach Rand und Blätterpfeilen nur noch
+ * die halbe Breite hat, wird bei 51 % dargestellt – lesbar ist das nicht mehr.
+ */
+const narrowQuery = '(max-width: 640px)'
+
+function useNarrow(): boolean {
+  return useSyncExternalStore(
+    cb => {
+      const m = window.matchMedia(narrowQuery)
+      m.addEventListener('change', cb)
+      return () => m.removeEventListener('change', cb)
+    },
+    () => window.matchMedia(narrowQuery).matches,
+    () => false,
+  )
+}
+
+/** Grenze fürs Nachladen von Text. Darüber wird nicht angezeigt, sondern
+ *  heruntergeladen – ein 200-MB-Protokoll bringt jeden Browser ins Stocken. */
+const maxTextBytes = 2 * 1024 * 1024
+
+export function canPreview(file: FileItem): boolean {
+  return kindOf(file.mime_type, file.name) !== 'none'
+}
+
+export default function FilePreview({ file, onPrev, onNext, onClose, onSaved, searchTerm }: Props) {
+  const kind = kindOf(file.mime_type, file.name)
+  const narrow = useNarrow()
+  const src = filesApi.inline(file.id)
+  const [text, setText] = useState<string | null>(null)
+  const [tooBig, setTooBig] = useState(false)
+  const [editing, setEditing] = useState(false)
+  const [draft, setDraft] = useState('')
+  const [saving, setSaving] = useState(false)
+  const [saveError, setSaveError] = useState('')
+  const dirty = editing && draft !== (text ?? '')
+
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      // Im Textfeld gehören die Pfeiltasten dem Schreiben, nicht dem Blättern.
+      if (editing) {
+        if (e.key === 'Escape') tryClose()
+        return
+      }
+      if (e.key === 'Escape') { onClose(); return }
+      // Die Pfeiltasten blättern zwischen Dateien – aber nicht, während
+      // jemand in einem Feld schreibt. Der PDF-Betrachter hat eine eigene
+      // Suche; dort setzte ein Pfeil sonst mitten im Wort die nächste Datei
+      // vor.
+      const el = document.activeElement
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) return
+      if (e.key === 'ArrowLeft') onPrev?.()
+      else if (e.key === 'ArrowRight') onNext?.()
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [onClose, onPrev, onNext, editing, dirty])
+
+  useEffect(() => {
+    if (kind !== 'text') return
+    setText(null); setTooBig(false)
+    if (file.size > maxTextBytes) { setTooBig(true); return }
+    setEditing(false); setSaveError('')
+    let alive = true
+    fetch(src, { credentials: 'include' })
+      .then(r => r.text())
+      .then(t => { if (alive) { setText(t); setDraft(t) } })
+      .catch(() => { if (alive) setText('(could not load this file)') })
+    return () => { alive = false }
+  }, [src, kind, file.size])
+
+  /**
+   * Gespeichert wird über denselben Weg wie ein Upload: gleicher Name, gleicher
+   * Ordner. Der Server ersetzt die Datei damit und legt – wenn Versionierung
+   * für sie eingeschaltet ist – die alte Fassung in die Historie. Ein eigener
+   * Endpunkt zum Schreiben bräuchte dieselben Prüfungen noch einmal.
+   */
+  async function save() {
+    setSaving(true); setSaveError('')
+    try {
+      const blob = new File([draft], file.name, { type: file.mime_type || 'text/plain' })
+      await filesApi.upload(blob, file.folder_id ?? undefined)
+      setText(draft)
+      setEditing(false)
+      onSaved?.()
+    } catch (err) {
+      // Nur-Lese-Zugriff auf eine geliehene Datei ist der häufigste Fall –
+      // deshalb hier ausgeschrieben statt "403".
+      setSaveError(
+        err instanceof APIError && err.status === 403
+          ? 'You only have read access to this file.'
+          : err instanceof Error ? err.message : 'Could not save',
+      )
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  function tryClose() {
+    if (dirty && !confirm('Discard your changes?')) return
+    onClose()
+  }
+
+  return (
+    <div
+      onClick={tryClose}
+      style={{
+        position: 'fixed', inset: 0, zIndex: 100,
+        background: 'rgba(0,0,0,0.82)',
+        display: 'flex', flexDirection: 'column',
+      }}
+    >
+      {/* Kopfzeile */}
+      <div
+        onClick={e => e.stopPropagation()}
+        style={{
+          display: 'flex', alignItems: 'center', gap: 12,
+          padding: '10px 14px', flexShrink: 0,
+          background: 'var(--color-surface)',
+          borderBottom: '1px solid var(--color-border)',
+        }}
+      >
+        <span style={{
+          flex: 1, minWidth: 0, fontSize: 14, color: 'var(--color-text)',
+          overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+        }}>
+          {file.name}
+        </span>
+
+        {kind === 'text' && !tooBig && text !== null && (
+          editing ? (
+            <>
+              {saveError && (
+                <span style={{ fontSize: 12, color: 'var(--color-danger)' }}>{saveError}</span>
+              )}
+              <button
+                onClick={() => { setDraft(text ?? ''); setEditing(false); setSaveError('') }}
+                disabled={saving}
+                style={{
+                  padding: '6px 12px', borderRadius: 8, fontSize: 12,
+                  border: '1px solid var(--color-border)', background: 'transparent',
+                  color: 'var(--color-text-muted)', cursor: 'pointer',
+                }}
+              >
+                Cancel
+              </button>
+              <button
+                onClick={save}
+                disabled={saving || !dirty}
+                style={{
+                  padding: '6px 12px', borderRadius: 8, fontSize: 12, fontWeight: 600,
+                  border: 'none', background: 'var(--color-primary)', color: '#fff',
+                  cursor: saving || !dirty ? 'default' : 'pointer',
+                  opacity: saving || !dirty ? 0.6 : 1,
+                }}
+              >
+                {saving ? 'Saving…' : 'Save'}
+              </button>
+            </>
+          ) : (
+            <button
+              onClick={() => setEditing(true)}
+              style={{
+                padding: '6px 12px', borderRadius: 8, fontSize: 12,
+                border: '1px solid var(--color-border)', background: 'transparent',
+                color: 'var(--color-text-muted)', cursor: 'pointer',
+              }}
+            >
+              Edit
+            </button>
+          )
+        )}
+
+        <a
+          href={filesApi.download(file.id)}
+          download={file.name}
+          style={{
+            padding: '6px 12px', borderRadius: 8, fontSize: 12, fontWeight: 600,
+            background: 'var(--color-primary)', color: '#fff', textDecoration: 'none',
+          }}
+        >
+          Download
+        </a>
+        <button
+          onClick={tryClose}
+          title="Close (Esc)"
+          style={{
+            padding: 6, borderRadius: 8, border: 'none', background: 'none',
+            color: 'var(--color-text-muted)', cursor: 'pointer', display: 'flex',
+          }}
+        >
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <line x1="18" y1="6" x2="6" y2="18" /><line x1="6" y1="6" x2="18" y2="18" />
+          </svg>
+        </button>
+      </div>
+
+      {/* Inhalt */}
+      <div
+        onClick={e => e.stopPropagation()}
+        style={{
+          flex: 1, minHeight: 0, display: 'flex',
+          alignItems: 'center', justifyContent: 'center',
+          // Ein PDF bekommt fast den ganzen Platz: Es bringt seinen eigenen
+          // weißen Rand mit, ein zweiter darum herum verschenkt nur Breite.
+          padding: kind === 'pdf' ? (narrow ? 2 : 8) : 16,
+        }}
+      >
+        {/* Am Telefon blättert man nicht per Pfeil zur nächsten Datei, während
+            man ein Dokument liest – dort lägen die Knöpfe mitten auf dem Text
+            und würden beim Wischen getroffen. */}
+        {onPrev && !(kind === 'pdf' && narrow) && <PagerButton dir="prev" onClick={onPrev} />}
+
+        {kind === 'image' && (
+          <img src={src} alt={file.name}
+               style={{ maxWidth: '100%', maxHeight: '100%', objectFit: 'contain' }} />
+        )}
+
+        {kind === 'pdf' && (
+          // Eigener Betrachter statt des eingebauten im <iframe>: Chrome auf
+          // Android zeigte darin gar nichts an, und ein Suchtreffer ließ sich
+          // ihm nicht mitteilen. Siehe PdfViewer.tsx.
+          <Suspense fallback={
+            <span style={{ color: 'var(--color-text-muted)', fontSize: 13 }}>Loading…</span>
+          }>
+            <PdfViewer url={src} fileId={file.id} searchTerm={searchTerm} />
+          </Suspense>
+        )}
+
+        {kind === 'video' && (
+          <video src={src} controls autoPlay
+                 style={{ maxWidth: '100%', maxHeight: '100%', borderRadius: 8 }} />
+        )}
+
+        {kind === 'audio' && (
+          <audio src={src} controls style={{ width: 'min(520px, 90%)' }} />
+        )}
+
+        {/* Text bekommt die Form eines Blattes statt der ganzen Fläche: über
+            die volle Breite gelesen springt das Auge beim Zeilenwechsel, und
+            eine kurze Notiz auf einem riesigen Feld wirkt erschlagend. */}
+        {kind === 'text' && (
+          <div style={{
+            width: '100%', maxWidth: 820, height: '100%', maxHeight: 680,
+            display: 'flex', flexDirection: 'column',
+            borderRadius: 10, overflow: 'hidden',
+            border: `1px solid ${editing ? 'var(--color-primary)' : 'var(--color-border)'}`,
+            background: 'var(--color-surface)',
+            boxShadow: '0 12px 40px rgba(0,0,0,0.35)',
+          }}>
+            {editing ? (
+              <textarea
+                value={draft}
+                onChange={e => setDraft(e.target.value)}
+                spellCheck={false}
+                autoFocus
+                style={{
+                  flex: 1, resize: 'none', width: '100%',
+                  padding: '18px 20px', border: 'none',
+                  background: 'transparent', color: 'var(--color-text)',
+                  fontFamily: 'ui-monospace, monospace',
+                  fontSize: 13, lineHeight: 1.65, outline: 'none',
+                }}
+              />
+            ) : (
+              <pre style={{
+                flex: 1, margin: 0, overflow: 'auto',
+                padding: '18px 20px',
+                color: 'var(--color-text)',
+                fontFamily: 'ui-monospace, monospace',
+                fontSize: 13, lineHeight: 1.65,
+                whiteSpace: 'pre-wrap', wordBreak: 'break-word',
+              }}>
+                {tooBig
+                  ? 'This file is too large to show here – use Download.'
+                  : text ?? 'Loading…'}
+              </pre>
+            )}
+          </div>
+        )}
+
+        {onNext && !(kind === 'pdf' && narrow) && <PagerButton dir="next" onClick={onNext} />}
+      </div>
+    </div>
+  )
+}
+
+function PagerButton({ dir, onClick }: { dir: 'prev' | 'next'; onClick: () => void }) {
+  return (
+    <button
+      onClick={onClick}
+      title={dir === 'prev' ? 'Previous (←)' : 'Next (→)'}
+      style={{
+        position: 'absolute', [dir === 'prev' ? 'left' : 'right']: 12,
+        top: '50%', transform: 'translateY(-50%)',
+        width: 40, height: 40, borderRadius: '50%',
+        border: 'none', background: 'rgba(0,0,0,0.5)', color: '#fff',
+        cursor: 'pointer', display: 'flex', alignItems: 'center', justifyContent: 'center',
+      }}
+    >
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <polyline points={dir === 'prev' ? '15 18 9 12 15 6' : '9 18 15 12 9 6'} />
+      </svg>
+    </button>
+  )
+}
diff --git a/frontend/src/components/FileViews.tsx b/frontend/src/components/FileViews.tsx
new file mode 100644
index 0000000..aa73765
--- /dev/null
+++ b/frontend/src/components/FileViews.tsx
@@ -0,0 +1,511 @@
+import { useEffect, useRef, useState } from 'react'
+import { type Correspondent, type FileItem, type FolderItem, type Tag } from '../api/client'
+import { TagRow } from './TagDialog'
+import TagChip from './TagChip'
+import { FileTypeIcon, FolderGlyph } from './icons'
+import FileCover, { FolderCover } from './FileCover'
+import { formatBytes } from '../pages/FileBrowser'
+
+/**
+ * Die beiden Darstellungen einer Ordnerliste: Kacheln und Zeilen.
+ *
+ * Lagen bis zum 23.08.2026 unten in FileBrowser.tsx und machten die Seite über
+ * 1100 Zeilen lang. Sie hängen nur an ihren Eigenschaften, nicht am Zustand der
+ * Seite – hier stehen sie für sich.
+ */
+
+/** Klein in der Liste – dieselbe Form wie auf der Kachel. 24 statt 22 Pixel,
+ *  weil 48/24 glatt aufgeht und die Kanten damit scharf bleiben. */
+function FolderIcon({ size = 24, group = false }: { size?: number; group?: boolean }) {
+  return <FolderGlyph size={size} color={group ? 'rgb(var(--color-primary-rgb))' : '#f59e0b'} />
+}
+
+/**
+ * Zeigt der Nutzer mit dem Finger oder mit einer Maus?
+ *
+ * `pointer: coarse` ist die Frage nach der Genauigkeit des Zeigegeräts, nicht
+ * nach der Bildschirmbreite – ein schmales Fenster auf dem Schreibtisch bleibt
+ * damit richtig eine Maus, ein Tablet im Querformat richtig ein Finger.
+ *
+ * Der Anlass: **Auf dem Handy öffnete gar nichts.** Ordner und Dateien hingen
+ * an `onDoubleClick`, und den doppelten Klick gibt es auf einem Touchscreen
+ * praktisch nicht – der Browser meldet zwei einzelne Berührungen, weil man
+ * nicht zweimal auf denselben Pixel tippt. Der Doppelklick ist eine
+ * Mausgeste; am Finger ist er nie angekommen.
+ */
+function useCoarsePointer(): boolean {
+  const [coarse, setCoarse] = useState(
+    () => typeof matchMedia === 'function' && matchMedia('(pointer: coarse)').matches,
+  )
+  useEffect(() => {
+    if (typeof matchMedia !== 'function') return
+    const mq = matchMedia('(pointer: coarse)')
+    const on = () => setCoarse(mq.matches)
+    mq.addEventListener('change', on)
+    return () => mq.removeEventListener('change', on)
+  }, [])
+  return coarse
+}
+
+/**
+ * Die Öffnen-Geste, je nach Zeigegerät.
+ *
+ * Maus: Doppelklick – der einfache Klick bleibt zum Auswählen frei.
+ * Finger: **einfacher Tipp**. So macht es jede Dateiverwaltung am Telefon,
+ * und etwas anderes wäre dort nicht zu erraten.
+ *
+ * Nur für **Ordner**: Die haben keine Auswahl und keinen zweiten Klick-
+ * Handler, deshalb genügt hier das Umschalten der Eigenschaft. Dateien
+ * schreiben ihren Handler selbst aus – warum, steht dort.
+ */
+function openGesture(coarse: boolean, open: () => void) {
+  return coarse ? { onClick: open } : { onDoubleClick: open }
+}
+
+interface ViewProps {
+  folders: FolderItem[]
+  files: FileItem[]
+  onFolderOpen: (f: FolderItem) => void
+  onFolderMenu: (e: React.MouseEvent, f: FolderItem) => void
+  onFileMenu: (e: React.MouseEvent, f: FileItem) => void
+  /** Öffnen (Doppelklick bzw. Tipp): Vorschau, wenn möglich – sonst Download. */
+  onFileOpen: (file: FileItem) => void
+  onFileDownload: (file: FileItem) => void
+  onFolderDrop: (e: React.DragEvent, folder: FolderItem) => void
+  dragOverFolder: string | null
+  onFolderDragOver: (id: string | null) => void
+  /**
+   * Datei, zu der gerade aus der Suche gesprungen wurde. Sie wird kurz
+   * umrandet und in den sichtbaren Bereich geholt.
+   *
+   * Ohne das wäre der Sprung in einen Ordner mit fünfzig Dateien wertlos: Man
+   * landet am richtigen Ort und sucht dann von vorn.
+   */
+  highlightId?: string | null
+  /** Etiketten je Datei-ID – kommen mit der Ordnerliste in einer Abfrage mit. */
+  fileTags?: Record<string, Tag[]>
+  /** Absender je Datei-ID. Anders als die Etiketten höchstens einer. */
+  fileCorrespondents?: Record<string, Correspondent>
+  /** Ausgewählte Dateien für den Sammel-Download. */
+  selected?: Set<string>
+  /** Umschalten; `range` bei gedrückter Umschalttaste. */
+  onToggleSelect?: (id: string, range: boolean) => void
+}
+
+/** Umrandung der eben angesprungenen Datei. */
+const highlightRing = '0 0 0 2px var(--color-primary)'
+
+/**
+ * Holt die markierte Datei in den sichtbaren Bereich.
+ *
+ * In einem eigenen Haken, weil Kachel- und Listenansicht ihn beide brauchen –
+ * und weil es in einem Callback-Ref bei jedem Neuzeichnen erneut scrollen
+ * würde, auch wenn sich gar nichts geändert hat.
+ */
+function useScrollToHighlight(highlightId?: string | null) {
+  const ref = useRef<HTMLDivElement | null>(null)
+  useEffect(() => {
+    if (!highlightId || !ref.current) return
+    ref.current.scrollIntoView({ block: 'center', behavior: 'smooth' })
+  }, [highlightId])
+  return ref
+}
+
+export default function GridView({ folders, files, onFolderOpen, onFolderMenu, onFileMenu, onFileOpen, onFolderDrop, dragOverFolder, onFolderDragOver, highlightId, fileTags, fileCorrespondents, selected, onToggleSelect }: ViewProps) {
+  const highlightRef = useScrollToHighlight(highlightId)
+  const coarse = useCoarsePointer()
+  return (
+    <div style={{
+      display: 'grid',
+      gridTemplateColumns: 'repeat(auto-fill, minmax(160px, 1fr))',
+      gap: 12,
+    }}>
+      {folders.map(folder => {
+        const isOver = dragOverFolder === folder.id
+        // Ein Gruppenordner lässt sich nicht verschieben – ihn ziehbar zu
+        // machen, würde eine Bewegung anbieten, die der Server ablehnt.
+        const isGroupFolder = folder.group_id !== null
+        return (
+          <div
+            key={folder.id}
+            draggable={!isGroupFolder}
+            onDragStart={e => {
+              if (isGroupFolder) { e.preventDefault(); return }
+              e.dataTransfer.setData('aether-folder-id', folder.id)
+              e.dataTransfer.effectAllowed = 'move'
+            }}
+            style={{
+              background: 'var(--color-surface)',
+              border: `1px solid ${isOver ? 'var(--color-primary)' : 'var(--color-border)'}`,
+              borderRadius: 12, overflow: 'hidden', cursor: 'grab',
+              transition: 'border-color 0.15s, transform 0.1s, background 0.1s',
+              display: 'flex', flexDirection: 'column',
+              transform: isOver ? 'scale(1.03)' : 'none',
+              boxShadow: isOver ? '0 0 0 3px rgba(var(--color-primary-rgb), 0.2)' : 'none',
+            }}
+            {...openGesture(coarse, () => onFolderOpen(folder))}
+            onContextMenu={e => onFolderMenu(e, folder)}
+            onMouseEnter={e => { if (!isOver) { e.currentTarget.style.borderColor = 'var(--color-primary)'; e.currentTarget.style.transform = 'translateY(-1px)' } }}
+            onMouseLeave={e => { if (!isOver) { e.currentTarget.style.borderColor = 'var(--color-border)'; e.currentTarget.style.transform = 'none' } }}
+            onDragOver={e => { e.preventDefault(); e.stopPropagation(); onFolderDragOver(folder.id) }}
+            onDragLeave={e => { e.stopPropagation(); onFolderDragOver(null) }}
+            onDrop={e => onFolderDrop(e, folder)}
+          >
+            <div style={{ height: 100, position: 'relative', overflow: 'hidden' }}>
+              <FolderCover folder={folder} highlight={isOver} />
+            </div>
+            <div style={{ padding: '8px 10px 10px' }}>
+              <p style={{ margin: 0, fontSize: 12, fontWeight: 500, color: 'var(--color-text)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                {folder.name}
+              </p>
+              <p style={{
+                margin: '2px 0 0', fontSize: 11,
+                color: isGroupFolder ? 'var(--color-primary)' : 'var(--color-text-muted)',
+                display: 'flex', alignItems: 'center', gap: 4,
+              }}>
+                {isGroupFolder && (
+                  <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.2">
+                    <circle cx="9" cy="8" r="3.5" />
+                    <path d="M2 21v-1a7 7 0 0114 0v1" />
+                    <path d="M17 11a3 3 0 100-6M19 21v-1a6 6 0 00-3-5.2" />
+                  </svg>
+                )}
+                {isGroupFolder ? 'Group folder' : 'Folder'}
+              </p>
+            </div>
+          </div>
+        )
+      })}
+
+      {files.map(file => (
+        <div
+          key={file.id}
+          draggable
+          onDragStart={e => {
+            e.dataTransfer.setData('aether-file-id', file.id)
+            e.dataTransfer.effectAllowed = 'move'
+          }}
+          ref={file.id === highlightId ? highlightRef : undefined}
+          onDoubleClick={() => { if (!coarse) onFileOpen(file) }}
+          onClick={e => {
+            // Am Finger öffnet der Tipp – bzw. schaltet die Auswahl um,
+            // solange eine läuft. Ohne Strg- und Umschalttaste wäre eine
+            // Mehrfachauswahl am Telefon sonst gar nicht zu bedienen.
+            //
+            // Das steht **hier** und nicht als eigener Handler daneben: In
+            // JSX gewinnt das zuletzt notierte `onClick`. Ein zweites, per
+            // Spread eingesetztes wurde von diesem hier stillschweigend
+            // überschrieben – gemessen: der Tipp auf ein PDF tat nichts,
+            // während der auf einen Ordner funktionierte.
+            if (coarse) {
+              if ((selected?.size ?? 0) > 0) { onToggleSelect?.(file.id, false); return }
+              onFileOpen(file)
+              return
+            }
+            // **Nur** mit Zusatztaste – der einfache Klick bleibt frei.
+            //
+            // Der erste Entwurf wählte auch einfach aus, sobald schon etwas
+            // markiert war. Das kollidiert mit dem Doppelklick: Dessen erster
+            // Klick löst dann eine Auswahl aus, und statt die Vorschau zu
+            // öffnen ändert sich die Markierung. Beim Testen gemessen – aus
+            // drei Ausgewählten wurden vier, und die Vorschau blieb zu.
+            //
+            // Zum Auswählen bleiben das Kästchen und Strg/Umschalt. Das ist
+            // eindeutig, und der Doppelklick tut wieder genau eine Sache.
+            if (!onToggleSelect) return
+            if (e.metaKey || e.ctrlKey || e.shiftKey) {
+              e.preventDefault()
+              onToggleSelect(file.id, e.shiftKey)
+            }
+          }}
+          style={{
+            background: 'var(--color-surface)',
+            border: '1px solid var(--color-border)',
+            borderRadius: 12, overflow: 'hidden', cursor: 'grab',
+            // boxShadow statt border: Ein dickerer Rahmen würde die Kachel um
+            // einen Pixel wachsen lassen und die ganze Reihe verschieben.
+            boxShadow: selected?.has(file.id)
+              ? '0 0 0 2px var(--color-primary)'
+              : file.id === highlightId ? highlightRing : undefined,
+            transition: 'border-color 0.15s, transform 0.1s, box-shadow 0.3s',
+            display: 'flex', flexDirection: 'column',
+          }}
+          onContextMenu={e => onFileMenu(e, file)}
+          onMouseEnter={e => {
+            e.currentTarget.style.borderColor = 'var(--color-primary)'
+            e.currentTarget.style.transform = 'translateY(-1px)'
+            const pick = e.currentTarget.querySelector<HTMLElement>('.aether-pick')
+            if (pick) pick.style.opacity = '1'
+          }}
+          onMouseLeave={e => {
+            e.currentTarget.style.borderColor = 'var(--color-border)'
+            e.currentTarget.style.transform = 'none'
+            const pick = e.currentTarget.querySelector<HTMLElement>('.aether-pick')
+            if (pick && !selected?.has(file.id) && (selected?.size ?? 0) === 0) pick.style.opacity = '0'
+          }}
+        >
+          <div style={{ height: 100, position: 'relative', background: 'var(--color-surface-2)' }}>
+            <FileCover file={file} />
+            {/* Kästchen oben links. Erscheint beim Überfahren oder sobald
+                irgendetwas ausgewählt ist – dauerhaft sichtbar wäre es an
+                fünfzig Kacheln nur Unruhe, und die meisten Besuche wählen
+                nichts aus. */}
+            {onToggleSelect && (
+              <button
+                className="aether-pick"
+                onClick={e => { e.stopPropagation(); onToggleSelect(file.id, e.shiftKey) }}
+                title="Select"
+                style={{
+                  position: 'absolute', top: 6, left: 6,
+                  width: 20, height: 20, borderRadius: 6, cursor: 'pointer',
+                  display: 'flex', alignItems: 'center', justifyContent: 'center',
+                  background: selected?.has(file.id) ? 'var(--color-primary)' : 'rgba(15,23,42,0.65)',
+                  border: `1px solid ${selected?.has(file.id) ? 'var(--color-primary)' : 'rgba(255,255,255,0.35)'}`,
+                  opacity: selected?.has(file.id) || (selected?.size ?? 0) > 0 ? 1 : 0,
+                  transition: 'opacity 0.12s',
+                }}
+              >
+                {selected?.has(file.id) && (
+                  <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="#fff"
+                       strokeWidth="3.5" strokeLinecap="round" strokeLinejoin="round">
+                    <polyline points="4 12 10 18 20 6" />
+                  </svg>
+                )}
+              </button>
+            )}
+          </div>
+          <div style={{ padding: '8px 10px 10px' }}>
+            <p style={{ margin: 0, fontSize: 12, fontWeight: 500, color: 'var(--color-text)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }} title={file.name}>
+              {file.name}
+            </p>
+            {/* Eine Zeile unter dem Namen, zwei Zonen: links **wer**, rechts
+                **was**. Vorher standen Absender, Größe und Aufkleber
+                nebeneinander in derselben Reihe – drei Angaben in drei
+                Schriftgraden auf 130 Pixeln, und jede Kachel brach an einer
+                anderen Stelle um. Genau das machte das Raster unruhig.
+
+                Die Größe weicht dabei nach hinten: Sie steht nur noch da, wo
+                kein Absender steht (Bilder, Downloads), und sonst in der
+                Listenansicht und unter „Properties". Beim Überfliegen eines
+                Rasters sucht man den Absender, nicht die Kilobyte. */}
+            <div style={{
+              display: 'flex', alignItems: 'center', gap: 6,
+              margin: '3px 0 0', minWidth: 0, height: 18,
+            }}>
+              {fileCorrespondents?.[file.id] ? (
+                <span
+                  title={fileCorrespondents[file.id].name}
+                  style={{
+                    fontSize: 11, color: 'var(--color-text-muted)', minWidth: 0,
+                    display: 'flex', alignItems: 'center', gap: 4,
+                    overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                  }}
+                >
+                  {fileCorrespondents[file.id].icon && (
+                    <span style={{ flexShrink: 0 }}>{fileCorrespondents[file.id].icon}</span>
+                  )}
+                  <span style={{ overflow: 'hidden', textOverflow: 'ellipsis' }}>
+                    {fileCorrespondents[file.id].name}
+                  </span>
+                </span>
+              ) : (
+                <span style={{ fontSize: 11, color: 'var(--color-text-muted)', flexShrink: 0 }}>
+                  {formatBytes(file.size)}
+                </span>
+              )}
+              {(fileTags?.[file.id]?.length ?? 0) > 0 && (
+                <span style={{
+                  marginLeft: 'auto', minWidth: 0, display: 'flex',
+                  justifyContent: 'flex-end', flexShrink: 0,
+                }}>
+                  {/* Nur eins, der Rest als „+n": Bei zweien schrumpfen beide
+                      auf „gar…" und „steue…" – zwei unlesbare Aufkleber sagen
+                      weniger als einer lesbarer. Gemessen im Bildschirmfoto. */}
+                  <TagRow tags={fileTags?.[file.id] ?? []} max={1} />
+                </span>
+              )}
+            </div>
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+// ── List View ────────────────────────────────────────────────────────────────
+
+export function ListView({ folders, files, onFolderOpen, onFolderMenu, onFileMenu, onFileOpen, onFileDownload, onFolderDrop, dragOverFolder, onFolderDragOver, highlightId, fileTags, fileCorrespondents, selected, onToggleSelect }: ViewProps) {
+  const highlightRef = useScrollToHighlight(highlightId)
+  const coarse = useCoarsePointer()
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+      {/* Header */}
+      <div style={{ display: 'flex', alignItems: 'center', gap: 12, padding: '4px 12px', marginBottom: 4 }}>
+        <div style={{ width: 32 }} />
+        <div style={{ flex: 1, fontSize: 11, fontWeight: 600, color: 'var(--color-text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>Name</div>
+        <div style={{ width: 80, fontSize: 11, fontWeight: 600, color: 'var(--color-text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em', textAlign: 'right' }}>Size</div>
+        <div style={{ width: 100, fontSize: 11, fontWeight: 600, color: 'var(--color-text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em', textAlign: 'right' }}>Modified</div>
+        <div style={{ width: 32 }} />
+      </div>
+
+      {folders.map(folder => {
+        const isOver = dragOverFolder === folder.id
+        return (
+          <div
+            key={folder.id}
+            draggable
+            onDragStart={e => {
+              e.dataTransfer.setData('aether-folder-id', folder.id)
+              e.dataTransfer.effectAllowed = 'move'
+            }}
+            style={{
+              display: 'flex', alignItems: 'center', gap: 12,
+              padding: '8px 12px', borderRadius: 8, cursor: 'grab',
+              background: isOver ? 'rgba(var(--color-primary-rgb), 0.1)' : 'transparent',
+              outline: isOver ? '2px solid var(--color-primary)' : 'none',
+              transition: 'background 0.1s',
+            }}
+            {...openGesture(coarse, () => onFolderOpen(folder))}
+            onContextMenu={e => onFolderMenu(e, folder)}
+            onMouseEnter={e => { if (!isOver) e.currentTarget.style.background = 'var(--color-surface)' }}
+            onMouseLeave={e => { if (!isOver) e.currentTarget.style.background = 'transparent' }}
+            onDragOver={e => { e.preventDefault(); e.stopPropagation(); onFolderDragOver(folder.id) }}
+            onDragLeave={e => { e.stopPropagation(); onFolderDragOver(null) }}
+            onDrop={e => onFolderDrop(e, folder)}
+          >
+            <div style={{ width: 32, display: 'flex', justifyContent: 'center' }}>
+              <FolderIcon size={24} group={folder.group_id !== null} />
+            </div>
+            <div style={{ flex: 1, fontSize: 13, fontWeight: 500, color: 'var(--color-text)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+              {folder.name}
+            </div>
+            <div style={{ width: 80, fontSize: 12, color: 'var(--color-text-muted)', textAlign: 'right' }}>—</div>
+            <div style={{ width: 100, fontSize: 12, color: 'var(--color-text-muted)', textAlign: 'right' }}>
+              {new Date(folder.created_at).toLocaleDateString()}
+            </div>
+            <div style={{ width: 32 }} />
+          </div>
+        )
+      })}
+
+      {files.map(file => (
+        <div
+          key={file.id}
+          draggable
+          onDragStart={e => {
+            e.dataTransfer.setData('aether-file-id', file.id)
+            e.dataTransfer.effectAllowed = 'move'
+          }}
+          ref={file.id === highlightId ? highlightRef : undefined}
+          style={{
+            display: 'flex', alignItems: 'center', gap: 12,
+            padding: '8px 12px', borderRadius: 8,
+            cursor: 'grab', transition: 'background 0.1s, box-shadow 0.3s',
+            boxShadow: selected?.has(file.id)
+              ? '0 0 0 2px var(--color-primary)'
+              : file.id === highlightId ? highlightRing : undefined,
+          }}
+          onDoubleClick={() => { if (!coarse) onFileOpen(file) }}
+          onClick={e => {
+            // Siehe Kachelansicht – ein einziger Handler für beide Geräte.
+            if (coarse) {
+              if ((selected?.size ?? 0) > 0) { onToggleSelect?.(file.id, false); return }
+              onFileOpen(file)
+              return
+            }
+            if (!onToggleSelect) return
+            if (e.metaKey || e.ctrlKey || e.shiftKey) {
+              e.preventDefault()
+              onToggleSelect(file.id, e.shiftKey)
+            }
+          }}
+          onContextMenu={e => onFileMenu(e, file)}
+          onMouseEnter={e => e.currentTarget.style.background = 'var(--color-surface)'}
+          onMouseLeave={e => e.currentTarget.style.background = 'transparent'}
+        >
+          <div
+            style={{ width: 32, display: 'flex', justifyContent: 'center', flexShrink: 0 }}
+            onClick={e => {
+              if (!onToggleSelect) return
+              e.stopPropagation()
+              onToggleSelect(file.id, e.shiftKey)
+            }}
+            title={onToggleSelect ? 'Select' : undefined}
+          >
+            {/* In der Liste ersetzt das Kästchen das Symbol, sobald etwas
+                ausgewählt ist – in einer Zeile ist kein Platz für beides, und
+                zwei Spalten nur für den seltenen Fall wären Verschwendung. */}
+            {onToggleSelect && (selected?.has(file.id) || (selected?.size ?? 0) > 0) ? (
+              <span style={{
+                width: 18, height: 18, borderRadius: 5,
+                display: 'flex', alignItems: 'center', justifyContent: 'center',
+                background: selected?.has(file.id) ? 'var(--color-primary)' : 'transparent',
+                border: `1px solid ${selected?.has(file.id) ? 'var(--color-primary)' : 'var(--color-border)'}`,
+                cursor: 'pointer',
+              }}>
+                {selected?.has(file.id) && (
+                  <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="#fff"
+                       strokeWidth="3.5" strokeLinecap="round" strokeLinejoin="round">
+                    <polyline points="4 12 10 18 20 6" />
+                  </svg>
+                )}
+              </span>
+            ) : (
+              <FileTypeIcon mime={file.mime_type} name={file.name} size={22} />
+            )}
+          </div>
+          {/* Name und Aufkleber teilen sich die Spalte: In einer Zeile ist
+              kein Platz für eine zweite Zeile darunter, und eine eigene Spalte
+              stünde bei den meisten Dateien leer. */}
+          <div style={{ flex: 1, minWidth: 0, display: 'flex', alignItems: 'center', gap: 8 }}>
+            <span style={{
+              fontSize: 13, color: 'var(--color-text)', minWidth: 0,
+              overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+            }} title={file.name}>
+              {file.name}
+            </span>
+            {(fileTags?.[file.id]?.length ?? 0) > 0 && (
+              <span style={{ display: 'flex', gap: 4, flexShrink: 0 }}>
+                {(fileTags?.[file.id] ?? []).slice(0, 2).map(t => (
+                  <TagChip key={t.id} tag={t} size="sm" />
+                ))}
+              </span>
+            )}
+          </div>
+          {/* Eigene Spalte statt einer zweiten Zeile: In einer Tabelle gibt
+              es die Spalte ohnehin schon, und eine leere Zelle ändert die
+              Zeilenhöhe nicht. */}
+          <div
+            className="aether-from-col"
+            title={fileCorrespondents?.[file.id]?.name}
+            style={{
+              width: 130, fontSize: 12, color: 'var(--color-text-muted)',
+              overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+            }}
+          >
+            {fileCorrespondents?.[file.id]
+              ? `${fileCorrespondents[file.id].icon} ${fileCorrespondents[file.id].name}`.trim()
+              : ''}
+          </div>
+          <div style={{ width: 80, fontSize: 12, color: 'var(--color-text-muted)', textAlign: 'right' }}>
+            {formatBytes(file.size)}
+          </div>
+          <div style={{ width: 100, fontSize: 12, color: 'var(--color-text-muted)', textAlign: 'right' }}>
+            {new Date(file.updated_at).toLocaleDateString()}
+          </div>
+          <button
+            onClick={e => { e.stopPropagation(); onFileDownload(file) }}
+            style={{ width: 32, height: 28, border: 'none', background: 'none', cursor: 'pointer', color: 'var(--color-text-muted)', borderRadius: 6, display: 'flex', alignItems: 'center', justifyContent: 'center' }}
+            title="Download"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+              <polyline points="7 10 12 15 17 10" />
+              <line x1="12" y1="15" x2="12" y2="3" />
+            </svg>
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}
diff --git a/frontend/src/components/MoveTo.tsx b/frontend/src/components/MoveTo.tsx
new file mode 100644
index 0000000..fb6c3f5
--- /dev/null
+++ b/frontend/src/components/MoveTo.tsx
@@ -0,0 +1,320 @@
+import { useState, useEffect } from 'react'
+import { foldersApi, type FolderItem } from '../api/client'
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+import { FolderGlyph } from './icons'
+
+interface Props {
+  excludeId?: string
+  onConfirm: (targetFolderId: string | null) => void
+  onCancel: () => void
+  title?: string
+}
+
+interface TreeNode {
+  folder: FolderItem
+  children: TreeNode[] | null
+  expanded: boolean
+}
+
+function buildNode(folder: FolderItem): TreeNode {
+  return { folder, children: null, expanded: false }
+}
+
+function deepClone(nodes: TreeNode[]): TreeNode[] {
+  return nodes.map(n => ({
+    ...n,
+    children: n.children ? deepClone(n.children) : n.children,
+  }))
+}
+
+function getNode(nodes: TreeNode[], path: number[]): TreeNode | null {
+  let current: TreeNode | null = null
+  let list = nodes
+  for (const idx of path) {
+    current = list[idx] ?? null
+    if (!current) return null
+    list = current.children ?? []
+  }
+  return current
+}
+
+function findLabel(nodes: TreeNode[], id: string): string {
+  for (const n of nodes) {
+    if (n.folder.id === id) return n.folder.name
+    if (n.children) {
+      const found = findLabel(n.children, id)
+      if (found) return found
+    }
+  }
+  return ''
+}
+
+export default function MoveTo({ excludeId, onConfirm, onCancel, title = 'Move to…' }: Props) {
+  const overlay = useOverlayDismiss(onCancel)
+  const [roots, setRoots] = useState<TreeNode[]>([])
+  const [selected, setSelected] = useState<string | null | undefined>(undefined)
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    foldersApi.list(undefined)
+      .then(folders => setRoots(folders.filter(f => f.id !== excludeId).map(buildNode)))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [excludeId])
+
+  async function toggleExpand(path: number[]) {
+    const node = getNode(roots, path)
+    if (!node) return
+
+    // Load children on first expand
+    if (node.children === null) {
+      const children = await foldersApi.list(node.folder.id)
+      setRoots(prev => {
+        const next = deepClone(prev)
+        const n = getNode(next, path)
+        if (!n) return prev
+        n.children = children.filter(f => f.id !== excludeId).map(buildNode)
+        n.expanded = true
+        return next
+      })
+    } else {
+      setRoots(prev => {
+        const next = deepClone(prev)
+        const n = getNode(next, path)
+        if (!n) return prev
+        n.expanded = !n.expanded
+        return next
+      })
+    }
+  }
+
+  const selectedLabel = selected === undefined ? null
+    : selected === null ? 'Home'
+    : findLabel(roots, selected)
+
+  return (
+    <div
+      style={{
+        position: 'fixed', inset: 0, zIndex: 300,
+        background: 'rgba(0,0,0,0.55)',
+        display: 'flex', alignItems: 'center', justifyContent: 'center',
+        padding: 24,
+      }}
+      {...overlay}
+    >
+      <div style={{
+        background: 'var(--color-surface)',
+        border: '1px solid var(--color-border)',
+        borderRadius: 16,
+        width: '100%', maxWidth: 520,
+        boxShadow: '0 12px 40px rgba(0,0,0,0.3)',
+        display: 'flex', flexDirection: 'column',
+        maxHeight: '82vh',
+      }}>
+        {/* Header */}
+        <div style={{ padding: '18px 22px 14px', borderBottom: '1px solid var(--color-border)', flexShrink: 0 }}>
+          <h3 style={{ margin: 0, fontSize: 17, fontWeight: 700, color: 'var(--color-text)' }}>{title}</h3>
+          <p style={{ margin: '4px 0 0', fontSize: 12, color: 'var(--color-text-muted)' }}>
+            Choose destination
+          </p>
+        </div>
+
+        {/* Tree */}
+        <div style={{ flex: 1, overflowY: 'auto', padding: '8px 0' }}>
+          {/* Home row */}
+          <LocationRow
+            label="Home"
+            depth={0}
+            selected={selected === null}
+            onSelect={() => setSelected(null)}
+            icon={
+              // Dasselbe Haus wie in der Brotkrume und der Seitenleiste.
+              <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                <path d="M3 10.5L12 3l9 7.5" />
+                <path d="M5.5 9.5V20a1 1 0 001 1h11a1 1 0 001-1V9.5" />
+              </svg>
+            }
+          />
+
+          {loading && (
+            <p style={{ margin: '10px 22px', fontSize: 13, color: 'var(--color-text-muted)' }}>Loading…</p>
+          )}
+
+          {!loading && roots.length === 0 && (
+            <p style={{ margin: '10px 22px', fontSize: 13, color: 'var(--color-text-muted)' }}>No folders yet</p>
+          )}
+
+          {!loading && roots.map((node, i) => (
+            <TreeRow
+              key={node.folder.id}
+              node={node}
+              path={[i]}
+              depth={1}
+              selected={selected}
+              onSelect={setSelected}
+              onToggle={toggleExpand}
+            />
+          ))}
+        </div>
+
+        {/* Footer */}
+        <div style={{
+          padding: '14px 22px',
+          borderTop: '1px solid var(--color-border)',
+          display: 'flex', gap: 10, alignItems: 'center', flexShrink: 0,
+        }}>
+          {selectedLabel !== null ? (
+            <div style={{ flex: 1, display: 'flex', alignItems: 'center', gap: 6, minWidth: 0 }}>
+              <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="var(--color-primary)" strokeWidth="2.5">
+                <polyline points="9 18 15 12 9 6" />
+              </svg>
+              <span style={{ fontSize: 13, color: 'var(--color-text-muted)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                {selectedLabel}
+              </span>
+            </div>
+          ) : <div style={{ flex: 1 }} />}
+
+          <button
+            onClick={onCancel}
+            style={{
+              padding: '8px 18px', borderRadius: 9, border: '1px solid var(--color-border)',
+              background: 'transparent', color: 'var(--color-text-muted)', fontSize: 13, cursor: 'pointer',
+            }}
+          >
+            Cancel
+          </button>
+          <button
+            disabled={selected === undefined}
+            onClick={() => selected !== undefined && onConfirm(selected)}
+            style={{
+              padding: '8px 20px', borderRadius: 9, border: 'none',
+              background: selected !== undefined ? 'var(--color-primary)' : 'var(--color-surface-2)',
+              color: selected !== undefined ? '#fff' : 'var(--color-text-muted)',
+              fontSize: 13, fontWeight: 600,
+              cursor: selected !== undefined ? 'pointer' : 'default',
+              transition: 'background 0.15s',
+            }}
+          >
+            Move here
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+// ── Row components ────────────────────────────────────────────────────────────
+
+interface LocationRowProps {
+  label: string
+  depth: number
+  selected: boolean
+  onSelect: () => void
+  icon: React.ReactNode
+}
+
+function LocationRow({ label, depth, selected, onSelect, icon }: LocationRowProps) {
+  return (
+    <button
+      onClick={onSelect}
+      style={{
+        width: '100%', display: 'flex', alignItems: 'center', gap: 8,
+        padding: `9px 22px 9px ${22 + depth * 20}px`,
+        border: 'none', cursor: 'pointer', textAlign: 'left',
+        background: selected ? 'rgba(var(--color-primary-rgb), 0.12)' : 'transparent',
+        color: selected ? 'var(--color-primary)' : 'var(--color-text)',
+        fontSize: 14, fontWeight: selected ? 600 : 400,
+        borderLeft: selected ? '3px solid var(--color-primary)' : '3px solid transparent',
+        transition: 'background 0.1s',
+      }}
+      onMouseEnter={e => { if (!selected) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+      onMouseLeave={e => { if (!selected) e.currentTarget.style.background = 'transparent' }}
+    >
+      <span style={{ color: selected ? 'var(--color-primary)' : 'var(--color-text-muted)', flexShrink: 0, display: 'flex' }}>
+        {icon}
+      </span>
+      <span style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{label}</span>
+    </button>
+  )
+}
+
+interface TreeRowProps {
+  node: TreeNode
+  path: number[]
+  depth: number
+  selected: string | null | undefined
+  onSelect: (id: string) => void
+  onToggle: (path: number[]) => void
+}
+
+function TreeRow({ node, path, depth, selected, onSelect, onToggle }: TreeRowProps) {
+  const isSelected = selected === node.folder.id
+  const hasChildren = node.children === null || node.children.length > 0
+
+  return (
+    <>
+      <div style={{ display: 'flex', alignItems: 'center' }}>
+        {/* Chevron toggle */}
+        <button
+          onClick={() => onToggle(path)}
+          style={{
+            width: 28, height: 36, flexShrink: 0,
+            marginLeft: 22 + (depth - 1) * 20,
+            background: 'none', border: 'none',
+            cursor: hasChildren ? 'pointer' : 'default',
+            color: 'var(--color-text-muted)',
+            display: 'flex', alignItems: 'center', justifyContent: 'center',
+            opacity: hasChildren ? 1 : 0,
+          }}
+        >
+          <svg
+            width="11" height="11" viewBox="0 0 24 24"
+            fill="none" stroke="currentColor" strokeWidth="2.5"
+            style={{ transform: node.expanded ? 'rotate(90deg)' : 'none', transition: 'transform 0.15s' }}
+          >
+            <polyline points="9 18 15 12 9 6" />
+          </svg>
+        </button>
+
+        {/* Folder name */}
+        <button
+          onClick={() => onSelect(node.folder.id)}
+          style={{
+            flex: 1, display: 'flex', alignItems: 'center', gap: 8,
+            padding: '9px 22px 9px 6px',
+            border: 'none', cursor: 'pointer', textAlign: 'left',
+            background: isSelected ? 'rgba(var(--color-primary-rgb), 0.12)' : 'transparent',
+            color: isSelected ? 'var(--color-primary)' : 'var(--color-text)',
+            fontSize: 14, fontWeight: isSelected ? 600 : 400,
+            borderLeft: isSelected ? '3px solid var(--color-primary)' : '3px solid transparent',
+            transition: 'background 0.1s',
+          }}
+          onMouseEnter={e => { if (!isSelected) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+          onMouseLeave={e => { if (!isSelected) e.currentTarget.style.background = 'transparent' }}
+        >
+          <span style={{ flexShrink: 0, display: 'flex' }}>
+            <FolderGlyph
+              size={20}
+              color={node.folder.group_id !== null ? 'rgb(var(--color-primary-rgb))' : '#f59e0b'}
+            />
+          </span>
+          <span style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+            {node.folder.name}
+          </span>
+        </button>
+      </div>
+
+      {node.expanded && node.children && node.children.map((child, i) => (
+        <TreeRow
+          key={child.folder.id}
+          node={child}
+          path={[...path, i]}
+          depth={depth + 1}
+          selected={selected}
+          onSelect={onSelect}
+          onToggle={onToggle}
+        />
+      ))}
+    </>
+  )
+}
diff --git a/frontend/src/components/OfficeEditor.tsx b/frontend/src/components/OfficeEditor.tsx
new file mode 100644
index 0000000..73b880c
--- /dev/null
+++ b/frontend/src/components/OfficeEditor.tsx
@@ -0,0 +1,137 @@
+import { useEffect, useRef, useState } from 'react'
+import { officeApi, type FileItem, type OfficeSession } from '../api/client'
+
+/**
+ * Ein Dokument im Office-Server bearbeiten.
+ *
+ * Die Bedienoberfläche kommt vom Office-Server und läuft in einem Rahmen. Wir
+ * schicken sie **per Formular** dorthin, nicht über die Adresszeile: Das
+ * Zugriffstoken gehört in den Rumpf einer POST-Anfrage und nicht in eine URL,
+ * die im Verlauf des Browsers, im Log des Proxys und im Referrer landet.
+ *
+ * Gespeichert wird nicht hier. Der Office-Server holt die Datei selbst beim
+ * Backend ab und schreibt sie ebenso zurück (siehe internal/office). Dieser
+ * Rahmen weiß davon nichts – er zeigt nur an.
+ */
+export default function OfficeEditor({ file, onClose }: {
+  file: FileItem
+  onClose: () => void
+}) {
+  const [session, setSession] = useState<OfficeSession | null>(null)
+  const [error, setError] = useState('')
+  const formRef = useRef<HTMLFormElement>(null)
+
+  useEffect(() => {
+    let alive = true
+    officeApi.session(file.id)
+      .then(s => {
+        if (!alive) return
+        if (!s.enabled) { setError('Office editing is switched off on this server.'); return }
+        setSession(s)
+      })
+      .catch(err => {
+        if (!alive) return
+        setError(err instanceof Error ? err.message : 'Could not open the editor')
+      })
+    return () => { alive = false }
+  }, [file.id])
+
+  // Das Formular abschicken, sobald es steht. Ein useEffect statt eines
+  // autoSubmit-Attributs: HTML kennt keines, und ein Klick des Nutzers wäre
+  // ein Schritt, der nichts entscheidet.
+  useEffect(() => { if (session) formRef.current?.submit() }, [session])
+
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      // Escape schließt nur, solange der Rahmen nicht den Tastendruck hat –
+      // sonst nähme man dem Editor seine eigene Escape-Taste weg.
+      if (e.key === 'Escape' && document.activeElement?.tagName !== 'IFRAME') onClose()
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [onClose])
+
+  return (
+    <div style={{
+      position: 'fixed', inset: 0, zIndex: 120,
+      background: 'var(--color-background)', display: 'flex', flexDirection: 'column',
+    }}>
+      <div style={{
+        display: 'flex', alignItems: 'center', gap: 12,
+        padding: '10px 14px', flexShrink: 0,
+        background: 'var(--color-surface)',
+        borderBottom: '1px solid var(--color-border)',
+      }}>
+        <span style={{
+          flex: 1, minWidth: 0, fontSize: 14, color: 'var(--color-text)',
+          overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+        }}>
+          {file.name}
+        </span>
+        {session && !session.can_write && (
+          <span style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>read only</span>
+        )}
+        {/* Kein eigener Speichern-Knopf: Der Office-Server speichert selbst,
+            und zwei Knöpfe für dieselbe Sache – von denen einer nichts weiß –
+            wären schlimmer als keiner. */}
+        <button
+          onClick={onClose}
+          title="Close (Esc)"
+          style={{
+            padding: 6, borderRadius: 8, border: 'none', background: 'none',
+            color: 'var(--color-text-muted)', cursor: 'pointer', display: 'flex',
+          }}
+        >
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <line x1="18" y1="6" x2="6" y2="18" /><line x1="6" y1="6" x2="18" y2="18" />
+          </svg>
+        </button>
+      </div>
+
+      <div style={{ flex: 1, minHeight: 0, position: 'relative' }}>
+        {error && (
+          <div style={{
+            position: 'absolute', inset: 0, display: 'flex',
+            alignItems: 'center', justifyContent: 'center', padding: 24,
+            color: 'var(--color-text-muted)', fontSize: 13, textAlign: 'center',
+          }}>
+            {error}
+          </div>
+        )}
+        {!error && !session && (
+          <div style={{
+            position: 'absolute', inset: 0, display: 'flex',
+            alignItems: 'center', justifyContent: 'center',
+            color: 'var(--color-text-muted)', fontSize: 13,
+          }}>
+            Starting the editor…
+          </div>
+        )}
+        {session && (
+          <>
+            <form
+              ref={formRef}
+              action={session.url}
+              method="post"
+              target="aether-office"
+              style={{ display: 'none' }}
+            >
+              <input type="hidden" name="access_token" value={session.token} />
+              <input type="hidden" name="access_token_ttl" value={String(session.token_ttl)} />
+            </form>
+            <iframe
+              name="aether-office"
+              title={file.name}
+              style={{ width: '100%', height: '100%', border: 'none', background: '#fff' }}
+              // Der Office-Server braucht Skripte, Formulare und eigene
+              // Fenster (Druckvorschau). „allow-same-origin" ist nötig, damit
+              // er seine eigene Sitzung halten kann – er läuft ohnehin in
+              // einem fremden Ursprung, also nicht in unserem.
+              sandbox="allow-scripts allow-forms allow-same-origin allow-popups allow-downloads allow-modals"
+            />
+          </>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/PageHeader.tsx b/frontend/src/components/PageHeader.tsx
new file mode 100644
index 0000000..4ec9c1b
--- /dev/null
+++ b/frontend/src/components/PageHeader.tsx
@@ -0,0 +1,193 @@
+import type { ReactNode } from 'react'
+import UserMenu, { useSidebarToggle } from './UserMenu'
+
+/**
+ * Die Kopfleiste jeder Ansicht.
+ *
+ * Vorher gab es zwei Muster nebeneinander: Dateien, Papierkorb und
+ * Freigabe-Links hatten eine feste Leiste, „Geteilt mit mir", Admin und Profil
+ * dagegen eine große Überschrift im Scrollbereich. Beim Umschalten sprang
+ * dadurch der Inhalt – und schon zwischen den drei Leisten war die Höhe
+ * unterschiedlich, weil sie sich aus dem jeweils höchsten Bedienelement ergab.
+ *
+ * Deshalb hier eine feste Höhe statt einer gewachsenen: Die Leiste ist überall
+ * gleich hoch, egal was darin steht.
+ */
+export const headerHeight = 57
+
+/**
+ * Ab dieser Breite passt alles in eine Zeile.
+ *
+ * Darunter wird umgebrochen statt gequetscht: Auf 390 px stand die Brotkrume
+ * als einzelner Strich da, das Suchfeld schob sich über die Sortierauswahl, der
+ * Ansichts-Umschalter war ganz verschwunden und der Nutzerbereich am rechten
+ * Rand abgeschnitten. Eine Zeile, die nicht umbrechen kann, quetscht – und
+ * ausgerechnet auf dem Gerät, mit dem man unterwegs einen Beleg sucht.
+ */
+export const wideEnough = '(min-width: 720px)'
+
+interface Props {
+  /** Strichsymbol, 18 × 18 – dasselbe wie in der Seitenleiste. */
+  icon?: ReactNode
+  title?: string
+  /** Nebenangabe in gedämpfter Schrift, etwa „12 items". */
+  meta?: ReactNode
+  /** Statt Symbol und Titel: eigener Inhalt links, z. B. die Brotkrumen. */
+  left?: ReactNode
+  /** Bedienelemente – sitzen rechts. */
+  children?: ReactNode
+}
+
+export default function PageHeader({ icon, title, meta, left, children }: Props) {
+  const openSidebar = useSidebarToggle()
+  return (
+    <div className="aether-header" style={{
+      // Feste Höhe nur auf breiten Schirmen (siehe CSS unten). Auf dem Handy
+      // wächst die Leiste auf zwei Zeilen, statt ihren Inhalt zu verstecken.
+      padding: '0 14px',
+      // Statusleiste der installierten App. Die Kopfleiste ist jetzt die
+      // oberste Zeile der Anwendung – vorher lag darüber noch eine zweite.
+      paddingTop: 'var(--safe-top)',
+      background: 'var(--color-surface)',
+      borderBottom: '1px solid var(--color-border)',
+      display: 'flex', alignItems: 'center', gap: 10,
+      flexShrink: 0,
+      minWidth: 0,
+      flexWrap: 'wrap',
+    }}>
+      {/* Die Seitenleiste wird auf dem Handy von hier geöffnet.
+          Vorher stand dafür eine **zweite** Leiste darüber, die nichts weiter
+          enthielt als dieses Symbol und den Namen der Cloud. Gemessen kostete
+          sie 57 der 915 Pixel Höhe – und der Name stand ohnehin schon in der
+          Seitenleiste, die sie öffnete. */}
+      {openSidebar && (
+        <button
+          className="aether-header-menu"
+          onClick={openSidebar}
+          title="Menu"
+          aria-label="Menu"
+          style={{
+            // Kein `display` hier: Das schaltet die Breite unten um, und ein
+            // Inline-Stil schlägt jede Klasse. Genau daran war der Knopf schon
+            // auf dem Desktop zu sehen, obwohl die Regel ihn ausblendet.
+            padding: 6, marginLeft: -6, borderRadius: 8, flexShrink: 0,
+            color: 'var(--color-text-muted)', background: 'none',
+            border: 'none', cursor: 'pointer',
+          }}
+        >
+          <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
+            <line x1="3" y1="6" x2="21" y2="6" />
+            <line x1="3" y1="12" x2="21" y2="12" />
+            <line x1="3" y1="18" x2="21" y2="18" />
+          </svg>
+        </button>
+      )}
+
+      {left ?? (
+        <>
+          {icon && (
+            // strokeLinecap/-join hier statt an jedem Symbol: Beide Eigenschaften
+            // vererben sich, und ein Symbol ohne eigene Angabe übernimmt sie
+            // damit. Vorher hatten Papierkorb und Freigabe-Links eckige Enden,
+            // „Geteilt mit mir" runde – nebeneinander wirkt das unruhig.
+            <span style={{
+              display: 'flex', color: 'var(--color-text-muted)', flexShrink: 0,
+              strokeLinecap: 'round', strokeLinejoin: 'round',
+            }}>
+              {icon}
+            </span>
+          )}
+          {title && (
+            <span style={{ fontSize: 15, fontWeight: 600, color: 'var(--color-text)', flexShrink: 0 }}>
+              {title}
+            </span>
+          )}
+        </>
+      )}
+
+      {meta && (
+        <span style={{
+          fontSize: 12, color: 'var(--color-text-muted)', minWidth: 0,
+          overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+        }}>
+          {meta}
+        </span>
+      )}
+
+      {/* Rechte Gruppe: erst die Bedienelemente der Ansicht, dann – durch eine
+          Trennlinie abgesetzt – der Nutzerbereich. Er steht bewusst in *jeder*
+          Ansicht an derselben Stelle; ein Zugang, den man je nach Seite
+          woanders sucht, ist keiner. */}
+      <div className="aether-header-actions" style={{
+        display: 'flex', alignItems: 'center', gap: 8, minWidth: 0,
+      }}>
+        {children}
+      </div>
+
+      {/* Der Nutzerbereich steht **außerhalb** der Bedienelemente.
+          Auf dem Handy gehört er in die Titelzeile nach rechts – dorthin, wo
+          man den eigenen Zugang sucht. Vorher stand er in der Reihe mit
+          „+ Folder" und „Upload" und sah dort aus wie ein weiterer Knopf für
+          eine Handlung, die er nicht ist.
+
+          Umgestellt wird über `order`, nicht über einen zweiten Baum: Zwei
+          Nutzermenüs nebeneinander hießen zwei Klappmenüs, von denen eines
+          immer versteckt ist. */}
+      <div className="aether-header-user" style={{
+        display: 'flex', alignItems: 'center', gap: 8, flexShrink: 0,
+      }}>
+        {children && (
+          <span className="aether-header-divider" style={{
+            width: 1, height: 22, background: 'var(--color-border)',
+            margin: '0 2px', flexShrink: 0,
+          }} />
+        )}
+        <UserMenu />
+      </div>
+
+      <style>{`
+        .aether-header { min-height: ${headerHeight - 1}px; }
+
+        /* Breit: erst die Bedienelemente der Ansicht, dann – durch eine
+           Trennlinie abgesetzt – der Nutzerbereich, ganz rechts. */
+        @media ${wideEnough} {
+          .aether-header-menu { display: none; }
+          .aether-header-actions { order: 2; margin-left: auto; }
+          .aether-header-user { order: 3; }
+        }
+
+        @media not all and ${wideEnough} {
+          .aether-header {
+            padding-top: calc(8px + var(--safe-top));
+            padding-bottom: 8px;
+          }
+          /* Schmal: Nutzerbereich noch in der Titelzeile ganz rechts, die
+             Bedienelemente darunter über die volle Breite.
+
+             Die Umstellung per order ist hier nicht Zierde: Im Baum steht der Nutzerbereich
+             **hinter** den Bedienelementen, und die nehmen sich schmal die
+             volle Breite. Ohne die Umstellung landete er dahinter – also in
+             einer dritten Zeile, allein und rechts. Genau so sah es aus. */
+          .aether-header-menu { display: flex; }
+          .aether-header-user { order: 1; margin-left: auto; }
+          .aether-header-divider { display: none; }
+          /* Nichts wird versteckt – man kommt an alles heran, es steht nur
+             untereinander. */
+          .aether-header-actions {
+            order: 2;
+            width: 100%;
+            flex-wrap: wrap;
+          }
+          /* Das Suchfeld nimmt die Zeile für sich – 220px feste Breite waren
+             der Grund, warum daneben nichts mehr passte. */
+          .aether-header-actions input[type="text"],
+          .aether-header-actions input:not([type]) { width: 100% !important; }
+        }
+
+        @media ${wideEnough} {
+          .aether-header { height: ${headerHeight - 1}px; padding-left: 20px; padding-right: 20px; }
+        }
+      `}</style>
+    </div>
+  )
+}
diff --git a/frontend/src/components/PdfViewer.tsx b/frontend/src/components/PdfViewer.tsx
new file mode 100644
index 0000000..1b49f07
--- /dev/null
+++ b/frontend/src/components/PdfViewer.tsx
@@ -0,0 +1,957 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { filesApi } from '../api/client'
+import * as pdfjs from 'pdfjs-dist'
+import type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist'
+import workerUrl from 'pdfjs-dist/build/pdf.worker.min.mjs?url'
+import './pdf.css'
+
+/**
+ * Eigener PDF-Betrachter.
+ *
+ * Vorher stand hier ein <iframe> mit dem eingebauten Betrachter des Browsers.
+ * Der ist gut, aber er gehört uns nicht – wir können ihm nichts sagen und
+ * nichts von ihm erfahren. Zwei Gründe haben den Wechsel getragen:
+ *
+ *  1. **Am Handy.** Chrome auf Android zeigt ein PDF in einem <iframe> nicht
+ *     an, sondern bietet es zum Herunterladen an. Für ein Archiv, in das man
+ *     beim Reklamieren im Laden hineinsieht, war die Vorschau dort also
+ *     schlicht nicht vorhanden.
+ *  2. **Der Suchtreffer.** Die Volltextsuche findet ein Wort auf Seite 7 eines
+ *     Scans – der fremde Betrachter beginnt trotzdem auf Seite 1, und man
+ *     sucht von Hand weiter. Ihm lässt sich kein Suchwort vorgeben.
+ *
+ * Was er absichtlich *nicht* kann: Anmerkungen, Formulare, Unterschriften.
+ * Das Original wird in dieser Anwendung nie verändert – ein Betrachter, der
+ * schreiben kann, wäre ein Widerspruch dazu.
+ */
+
+// Der Arbeiter kommt gebündelt aus node_modules und wird vom eigenen Server
+// ausgeliefert. Kein CDN: Die Sicherheitsrichtlinie erlaubt nur 'self', und
+// eine Cloud für private Unterlagen soll beim Öffnen eines Dokuments keine
+// fremde Adresse anfragen.
+pdfjs.GlobalWorkerOptions.workerSrc = workerUrl
+
+/**
+ * Die 14 Standardschriften (Helvetica, Times, Courier …). Ältere PDFs betten
+ * sie nicht ein, sondern setzen sie voraus. Fehlen sie, malt PDF.js mit einer
+ * Ersatzschrift – die Seite ist lesbar, aber Zeilen brechen an anderer Stelle.
+ * Kopiert wird der Ordner beim Bauen, siehe vite.config.ts.
+ */
+const standardFontDataUrl = '/pdfjs/standard_fonts/'
+
+/** Zoomstufen des Knopfes. „Fit" liegt außerhalb und wird gerechnet. */
+const zoomSteps = [0.5, 0.75, 1, 1.25, 1.5, 2, 3]
+
+/**
+ * Innenabstand der Seitenliste. Am Telefon fast keiner: Dort ist die Breite
+ * das knappe Gut, und ein 16-Pixel-Rand links und rechts kostet zusammen mehr
+ * als ein Zehntel der Darstellungsgröße.
+ */
+function padOf(width: number): number {
+  return width < 560 ? 4 : 16
+}
+
+/**
+ * Ab welcher Breite die Leiste als Dreispaltenraster taugt.
+ *
+ * Gerechnet, nicht geschätzt: Die Steuerung links braucht 275 Pixel
+ * (zwei Knöpfe, Seitenzahl, Trenner, Zoom), die Suche in der Mitte 492 – und
+ * die rechte Spalte ist genauso breit wie die linke, sonst säße die Suche
+ * nicht mittig. Macht 2 × 275 + 492.
+ *
+ * **Vorher stand hier 720, und dazwischen war die Leiste kaputt:** Das Raster
+ * gab der linken Spalte weniger, als ihr Inhalt braucht, und die Knöpfe
+ * schrumpften mit. Gemessen bei 980 Pixeln Fensterbreite – erster Knopf 16
+ * statt 28 Pixel, bei 760 die ganze Gruppe auf 108 statt 275. Am Ende war von
+ * der Steuerung nichts mehr zu sehen.
+ */
+const minGridWidth = 2 * 275 + 492
+
+/**
+ * Breiten rechts vom Suchfeld – und damit das Maß für das Gegengewicht links.
+ * Beide Seiten gleich breit heißt: Das Feld sitzt in der Mitte der Leiste.
+ */
+const counterWidth = 54
+const hitButtonsWidth = 60
+/** Zähler + Knöpfe + die beiden Abstände dazwischen. */
+const hitsWidth = counterWidth + hitButtonsWidth + 6
+
+/** Abstand zwischen zwei Seiten, in Pixeln. Auch der Wert, mit dem gerechnet
+ *  wird, wenn die sichtbare Seite bestimmt wird. */
+const pageGap = 12
+
+interface Props {
+  /** Adresse der Datei – dieselbe, die auch das <iframe> bekam. */
+  url: string
+  /** ID derselben Datei – für den erkannten Text vom Server. */
+  fileId: string
+  /**
+   * Suchwort aus der Volltextsuche. Ist es gesetzt, springt der Betrachter
+   * beim Öffnen zur ersten Fundstelle, statt auf Seite 1 zu beginnen.
+   */
+  searchTerm?: string
+}
+
+/**
+ * Eine Fundstelle: Seite und die wievielte auf dieser Seite.
+ *
+ * `exact` unterscheidet die beiden Quellen. Bringt das PDF eigenen Text mit,
+ * steht die Stelle im Dokument und lässt sich einfärben. Bei einem **Scan**
+ * steht dort nur ein Bild; der Text kommt dann aus der Erkennung auf dem
+ * Server, und der weiß zwar die Seite, aber nicht den Ort auf dem Blatt –
+ * dafür müssten die Koordinaten der Erkennung aufbewahrt werden.
+ */
+interface Hit { page: number; nth: number; exact: boolean }
+
+export default function PdfViewer({ url, fileId, searchTerm }: Props) {
+  const [doc, setDoc] = useState<PDFDocumentProxy | null>(null)
+  const [error, setError] = useState('')
+  const [sizes, setSizes] = useState<{ w: number; h: number }[]>([])
+  const [scale, setScale] = useState<number | 'fit'>('fit')
+  const [fitScale, setFitScale] = useState(1)
+  const [current, setCurrent] = useState(1)
+
+  const [query, setQuery] = useState(searchTerm ?? '')
+  const [hits, setHits] = useState<Hit[]>([])
+  const [hitIndex, setHitIndex] = useState(0)
+  const [searching, setSearching] = useState(false)
+
+  /** Erkannter Text vom Server, einmal je Datei geholt. Ohne den Zwischen-
+   *  speicher fragte jeder Tastendruck im Suchfeld erneut an. */
+  const serverText = useRef<string[] | null>(null)
+  useEffect(() => { serverText.current = null }, [fileId])
+
+  const scrollRef = useRef<HTMLDivElement>(null)
+  const pageRefs = useRef<(HTMLDivElement | null)[]>([])
+
+  const effScale = scale === 'fit' ? fitScale : scale
+
+  // ---------------------------------------------------------------- Laden
+
+  useEffect(() => {
+    let alive = true
+    let task: ReturnType<typeof pdfjs.getDocument> | null = null
+    setDoc(null); setSizes([]); setError(''); setCurrent(1)
+
+    task = pdfjs.getDocument({
+      url,
+      // Same-Origin, die Sitzung steckt im Cookie – ohne das käme 401.
+      withCredentials: true,
+      standardFontDataUrl,
+    })
+    task.promise.then(
+      async d => {
+        // Beim Verlassen raeumt die Aufraeumfunktion die Ladeaufgabe ab; die
+        // nimmt Arbeiter und Dokument mit. Hier genuegt es, nichts mehr zu
+        // setzen.
+        if (!alive) return
+        // Die Maße *aller* Seiten vorab: Sonst müsste die Liste mit einer
+        // geschätzten Höhe beginnen und beim Zeichnen springen. Ein Dokument
+        // mit gemischtem Hoch- und Querformat ist bei Scans der Normalfall.
+        const s: { w: number; h: number }[] = []
+        for (let i = 1; i <= d.numPages; i++) {
+          const v = (await d.getPage(i)).getViewport({ scale: 1 })
+          s.push({ w: v.width, h: v.height })
+        }
+        if (!alive) return
+        setSizes(s)
+        setDoc(d)
+      },
+      (err: unknown) => {
+        if (!alive) return
+        setError(
+          err instanceof Error && /password/i.test(err.message)
+            ? 'This PDF is password protected.'
+            : 'Could not open this PDF.',
+        )
+      },
+    )
+    return () => {
+      alive = false
+      task?.destroy()
+    }
+  }, [url])
+
+  // ------------------------------------------------------- Breite einpassen
+
+  /**
+   * „Fit" heißt: **auf die Breite, aber nie größer als das Original.**
+   *
+   * Zwei Anläufe, beide falsch, beide erst am echten Dokument sichtbar:
+   *
+   *  1. *Nur auf die Breite.* Die Vorschau ist fast bildschirmbreit, ein
+   *     A4-Blatt füllte sie bei 199 % – man sah das obere Drittel.
+   *  2. *Auf die ganze Seite, also gegen beide Kanten.* Klingt richtig und
+   *     ist es für A4 auch. Bei einem **langen** Blatt – ein Merkzettel, eine
+   *     Rechnung mit vierzig Posten auf einer Seite – kam dabei **10 %**
+   *     heraus: Schriftgröße 1,4 Pixel. Gemessen an einem echten Dokument.
+   *
+   * Die Höhe taugt also nicht als Grenze, weil eine Seite beliebig lang sein
+   * darf. Die Breite taugt, denn sie ist bei jedem Papier ähnlich. Bleibt das
+   * Aufblähen zu verhindern: Über 100 % wird nichts vergrößert – das Original
+   * ist so gesetzt, dass man es lesen kann.
+   *
+   * Am Telefon greift die Grenze von selbst nicht: Dort ist der Bildschirm
+   * schmaler als das Blatt, die Breite also unter 100 %.
+   *
+   * Gerechnet wird gegen die **häufigste** Seitenbreite, nicht gegen die
+   * breiteste – warum, steht bei `commonWidth`.
+   */
+  const recomputeFit = useCallback(() => {
+    const el = scrollRef.current
+    if (!el || sizes.length === 0) return
+    // Eine Messung von (fast) null ist keine Messung, sondern ein Zeitpunkt:
+    // Der Beobachter meldet sich auch, während die Vorschau noch aufgeht und
+    // der Bereich keine Breite hat. Früher lieferte das die Untergrenze von
+    // 10 % – und weil danach keine Größenänderung mehr kam, blieb das Dokument
+    // dabei stehen. Gemessen an einem Dokument, das mal mit 96 %, mal mit
+    // 10 % aufging, je nachdem wie schnell der Rechner gerade war.
+    if (el.clientWidth < 50) return
+    // 16 für die Bildlaufleiste, die je nach Browser Breite wegnimmt.
+    const byWidth = (el.clientWidth - 2 * padOf(el.clientWidth) - 16) / commonWidth(sizes)
+    setFitScale(Math.max(0.1, Math.min(1, byWidth)))
+  }, [sizes])
+
+  useEffect(() => {
+    recomputeFit()
+    const el = scrollRef.current
+    if (!el) return
+    const ro = new ResizeObserver(recomputeFit)
+    ro.observe(el)
+    return () => ro.disconnect()
+  }, [recomputeFit])
+
+  // ------------------------------------------------------------- Zeichnen
+
+  /**
+   * Gezeichnet wird nur, was in die Nähe des Sichtfelds kommt.
+   *
+   * Ein 200-seitiger Scan hätte sonst 200 Leinwände im Speicher – bei A4 und
+   * doppelter Pixeldichte sind das je rund 8 MB. Der Beobachter meldet
+   * Seiten eine Bildschirmhöhe im Voraus an; wieder verlassene Seiten geben
+   * ihre Leinwand frei.
+   */
+  useEffect(() => {
+    if (!doc || sizes.length === 0) return
+    const root = scrollRef.current
+    if (!root) return
+
+    // Läuft eine Zeichnung noch, wenn sich der Maßstab ändert, muss sie
+    // abgebrochen werden – sonst malt sie in der alten Größe fertig.
+    const running = new Map<number, ReturnType<PDFPageProxy['render']>>()
+    const drawn = new Set<number>()
+
+    async function draw(n: number) {
+      const host = pageRefs.current[n - 1]
+      if (!doc || !host || drawn.has(n)) return
+      drawn.add(n)
+      const page = await doc.getPage(n)
+      const viewport = page.getViewport({ scale: effScale })
+      const dpr = Math.min(window.devicePixelRatio || 1, 2)
+
+      const canvas = document.createElement('canvas')
+      canvas.width = Math.floor(viewport.width * dpr)
+      canvas.height = Math.floor(viewport.height * dpr)
+      canvas.style.width = '100%'
+      canvas.style.height = '100%'
+      canvas.style.display = 'block'
+      const ctx = canvas.getContext('2d')
+      if (!ctx) return
+      ctx.scale(dpr, dpr)
+
+      const task = page.render({ canvas, canvasContext: ctx, viewport })
+      running.set(n, task)
+      try {
+        await task.promise
+      } catch {
+        drawn.delete(n)   // abgebrochen – beim nächsten Mal neu
+        return
+      } finally {
+        running.delete(n)
+      }
+      host.querySelector('canvas')?.remove()
+      host.prepend(canvas)
+
+      // Textebene darüber: unsichtbare, aber markierbare Schrift. Sie ist es
+      // auch, in der die Suche ihre Fundstellen färbt.
+      const layer = host.querySelector<HTMLDivElement>('.pdf-textLayer')
+      if (layer) {
+        layer.replaceChildren()
+        const tl = new pdfjs.TextLayer({
+          textContentSource: await page.getTextContent(),
+          container: layer,
+          viewport,
+        })
+        await tl.render()
+        host.dataset.text = 'ready'
+        host.dispatchEvent(new CustomEvent('pdf-text-ready', { bubbles: true }))
+      }
+    }
+
+    function release(n: number) {
+      running.get(n)?.cancel()
+      running.delete(n)
+      drawn.delete(n)
+      const host = pageRefs.current[n - 1]
+      if (!host) return
+      host.querySelector('canvas')?.remove()
+      host.querySelector('.pdf-textLayer')?.replaceChildren()
+      host.querySelector('.pdf-hitLayer')?.replaceChildren()
+      delete host.dataset.text
+    }
+
+    const io = new IntersectionObserver(entries => {
+      for (const e of entries) {
+        const n = Number((e.target as HTMLElement).dataset.page)
+        if (e.isIntersecting) void draw(n)
+        else release(n)
+      }
+    }, { root, rootMargin: '100% 0px' })
+
+    for (const host of pageRefs.current) if (host) io.observe(host)
+    return () => {
+      io.disconnect()
+      for (const t of running.values()) t.cancel()
+    }
+  }, [doc, sizes, effScale])
+
+  // --------------------------------------------------- Sichtbare Seitenzahl
+
+  useEffect(() => {
+    const root = scrollRef.current
+    if (!root || sizes.length === 0) return
+    function onScroll() {
+      const mid = root!.scrollTop + root!.clientHeight / 2
+      let acc = 0
+      for (let i = 0; i < sizes.length; i++) {
+        const h = sizes[i].h * effScale + pageGap
+        if (mid < acc + h) { setCurrent(i + 1); return }
+        acc += h
+      }
+      setCurrent(sizes.length)
+    }
+    root.addEventListener('scroll', onScroll, { passive: true })
+    onScroll()
+    return () => root.removeEventListener('scroll', onScroll)
+  }, [sizes, effScale])
+
+  /**
+   * Zu einer Seite fahren – **mit** dem Rand darüber.
+   *
+   * Vorher stand hier `scrollIntoView({ block: 'start' })`. Das legt die
+   * Oberkante der Seite genau auf die Oberkante des Rollbereichs und frisst
+   * dabei den Innenabstand auf. Sichtbar wurde das beim Suchen: Man tippt,
+   * und das Blatt rutscht um 16 Pixel nach oben, klebt am Fensterrand – ein
+   * Ruck, für den es keinen Grund gibt.
+   *
+   * Jetzt wird von Hand gerollt und der Rand abgezogen. Die Seite steht dann
+   * dort, wo sie auch beim Öffnen steht.
+   */
+  const goToPage = useCallback((n: number) => {
+    const root = scrollRef.current
+    const host = pageRefs.current[n - 1]
+    if (!root || !host) return
+    const r = root.getBoundingClientRect()
+    const h = host.getBoundingClientRect()
+    root.scrollTo({ top: Math.max(0, root.scrollTop + (h.top - r.top) - padOf(root.clientWidth)) })
+  }, [])
+
+  /**
+   * Zu einer Fundstelle rollen – **nur wenn nötig**.
+   *
+   * Der zweite Teil desselben Rucks: Jeder Tastendruck im Suchfeld ließ die
+   * Anzeige zur Fundstelle springen, auch wenn die längst zu sehen war. Wer
+   * „la" tippt, hat nach dem ersten Buchstaben schon eine andere Trefferliste,
+   * und das Blatt zuckte bei jedem Zeichen.
+   *
+   * Steht der Treffer im mittleren Bereich, passiert jetzt gar nichts.
+   */
+  const revealHit = useCallback((el: Element) => {
+    const root = scrollRef.current
+    if (!root) return
+    const r = root.getBoundingClientRect()
+    const e = el.getBoundingClientRect()
+    const margin = 60
+    if (e.top >= r.top + margin && e.bottom <= r.bottom - margin) return
+    root.scrollTo({ top: Math.max(0, root.scrollTop + (e.top - r.top) - root.clientHeight / 3) })
+  }, [])
+
+  // ----------------------------------------------------------------- Suche
+
+  /**
+   * Gesucht wird im *ganzen* Dokument auf einmal, nicht nur auf der
+   * gezeichneten Seite: Nur so lässt sich „3 von 7" anzeigen und gezielt
+   * weiterspringen. Der Text kommt dabei nicht aus der Datenbank, sondern
+   * aus dem PDF selbst – nur dort steht, an welcher *Stelle* er steht.
+   */
+  useEffect(() => {
+    const q = query.trim().toLowerCase()
+    if (!doc || q.length < 2) { setHits([]); setHitIndex(0); return }
+    let alive = true
+    setSearching(true)
+    ;(async () => {
+      const found: Hit[] = []
+      for (let n = 1; n <= doc.numPages; n++) {
+        if (!alive) return
+        const tc = await doc.getPage(n).then(p => p.getTextContent())
+        // Zusammengesetzt wie in der Anzeige, damit ein über zwei Stücke
+        // getrenntes Wort trotzdem zählt.
+        const text = tc.items
+          .map(it => ('str' in it ? it.str : ''))
+          .join('')
+          .toLowerCase()
+        found.push(...countIn(text, q, n, true))
+      }
+      if (!alive) return
+
+      // Nichts gefunden? Dann liegt hier womöglich ein **Scan**, in dem gar
+      // kein Text steht. Der erkannte Text vom Server ist die einzige Quelle,
+      // die dann etwas weiß – ausgerechnet für den Dateityp, für den die
+      // Texterkennung überhaupt gebaut wurde.
+      //
+      // Nur als Rückfall, nicht immer: Steht der Text im PDF, ist er dort
+      // genauer verortet, und die Fundstelle lässt sich einfärben.
+      if (found.length === 0) {
+        try {
+          if (!serverText.current) {
+            serverText.current = (await filesApi.textPages(fileId)).pages
+          }
+          if (!alive) return
+          serverText.current.forEach((page, i) => {
+            found.push(...countIn(page.toLowerCase(), q, i + 1, false))
+          })
+        } catch {
+          // Kein Text vorhanden oder Erkennung abgeschaltet: dann eben keine
+          // Treffer. Eine Fehlermeldung wäre hier nur im Weg.
+        }
+      }
+
+      if (!alive) return
+      setHits(found)
+      setHitIndex(0)
+      setSearching(false)
+    })()
+    return () => { alive = false; setSearching(false) }
+  }, [doc, query, fileId])
+
+  /**
+   * Färbt die Fundstellen einer Seite.
+   *
+   * **Nicht** im Text selbst, sondern als eigene Ebene aus Kästchen darüber.
+   * Der erste Anlauf setzte ein <mark> mitten in die unsichtbare Schrift –
+   * und genau das war der Grund für die schiefen, oben angeschnittenen
+   * Streifen:
+   *
+   *   Ein <mark> ist ein Textstück. Sein Grund ist so hoch, wie die Schrift
+   *   ihn vorgibt (Oberlänge + Unterlänge der **Ersatz**schrift), nicht so
+   *   hoch wie die Zeile. Gemessen: 23 Pixel Kasten auf 17 Pixel Zeile. Der
+   *   Überstand ragte nach oben aus der Textebene heraus – und die schneidet
+   *   ab (`overflow: clip`). Daher „abgeschnitten und nicht gerade".
+   *
+   * Jetzt kommt die Geometrie **vollständig** aus der Auswahl – genau die
+   * Kästen, die der Browser auch beim Markieren mit der Maus malt. Das darf
+   * er jetzt auch: Unsere Ebene schneidet nichts ab, das war ja allein die
+   * Textebene.
+   *
+   * Und markiert wird das **ganze Wort**, nicht der Buchstabenschnipsel –
+   * warum, steht bei `wordAround` unten.
+   *
+   * Nebenbei bleibt die Schrift unberührt: Markieren und Kopieren gehen
+   * währenddessen weiter, was beim Umbauen des Textes nicht mehr sicher war.
+   *
+   * Grenze, die ich in Kauf nehme: Ein Wort, das PDF.js über zwei Stücke
+   * verteilt, wird gezählt, aber nicht eingefärbt. Bei erkanntem Text (OCR)
+   * ist ein Wort praktisch immer ein Stück.
+   */
+  const paint = useCallback((n: number, activeNth: number) => {
+    const host = pageRefs.current[n - 1]
+    const layer = host?.querySelector<HTMLDivElement>('.pdf-hitLayer')
+    if (!host || !layer) return
+    layer.replaceChildren()
+    const q = query.trim().toLowerCase()
+    if (q.length < 2) return
+
+    const base = host.getBoundingClientRect()
+    let nth = 0
+    /** Zuletzt gezeichnetes Wort – gegen doppelte Kästen (siehe unten). */
+    let last: { at: number; to: number; boxes: HTMLElement[] } | null = null
+
+    for (const span of host.querySelectorAll<HTMLElement>('.pdf-textLayer span')) {
+      const text = span.textContent ?? ''
+      const low = text.toLowerCase()
+      if (!low.includes(q)) continue
+      const node = span.firstChild
+      if (!node || node.nodeType !== Node.TEXT_NODE) continue
+
+      last = null
+      let from = 0
+      for (;;) {
+        const at = low.indexOf(q, from)
+        if (at < 0) break
+        const [ws, we] = wordAround(text, at, at + q.length)
+        const cur = nth === activeNth
+        from = at + q.length
+        nth++
+
+        // „la" findet in einem Wort wie „Salatlöffel" zweimal dieselbe Stelle
+        // zum Malen. Statt zwei deckungsgleicher Kästen: den vorhandenen
+        // behalten und höchstens zum aktuellen Treffer aufwerten.
+        if (last && last.at === ws && last.to === we) {
+          if (cur) last.boxes.forEach(b => b.classList.add('pdf-hit-current'))
+          continue
+        }
+
+        const range = document.createRange()
+        range.setStart(node, ws)
+        range.setEnd(node, we)
+        const boxes: HTMLElement[] = []
+        for (const r of range.getClientRects()) {
+          const box = document.createElement('div')
+          box.className = 'pdf-hit' + (cur ? ' pdf-hit-current' : '')
+          box.style.left = `${r.left - base.left}px`
+          box.style.top = `${r.top - base.top}px`
+          box.style.width = `${r.width}px`
+          box.style.height = `${r.height}px`
+          layer.append(box)
+          boxes.push(box)
+        }
+        last = { at: ws, to: we, boxes }
+      }
+    }
+  }, [query])
+
+  /**
+   * Leerräumen, sobald das Suchfeld leer ist.
+   *
+   * Ohne das blieb die letzte Färbung stehen: `paint` stieg bei kurzem
+   * Suchwort vorne aus und kam nie zum Aufräumen, und ohne Treffer läuft es
+   * gar nicht erst. Auf dem Blatt lagen dann Streifen zu einem Wort, das im
+   * Feld längst nicht mehr stand.
+   *
+   * Steht vor den beiden Effekten, die färben – innerhalb einer Änderung
+   * laufen Effekte in der Reihenfolge ihrer Notierung ab, also erst räumen,
+   * dann neu färben.
+   */
+  useEffect(() => {
+    for (const host of pageRefs.current) {
+      host?.querySelector('.pdf-hitLayer')?.replaceChildren()
+    }
+  }, [query, hits])
+
+  // Zur aktuellen Fundstelle springen und sie färben. Ist die Seite noch
+  // nicht gezeichnet, wartet das auf ihre Textebene – deshalb das Ereignis.
+  const target = hits[hitIndex]
+  useEffect(() => {
+    if (!target) return
+    const host = pageRefs.current[target.page - 1]
+    if (!host) return
+    // Nur zur Seite fahren, wenn sie **noch nicht gezeichnet** ist. Ist sie da,
+    // übernimmt revealHit weiter unten – und das rollt nur, wenn der Treffer
+    // wirklich außerhalb liegt. Ein `goToPage` an dieser Stelle sprang bei
+    // jedem Tastendruck an den Seitenanfang, obwohl der Treffer schon zu
+    // sehen war.
+    if (host.dataset.text !== 'ready' || !target.exact) goToPage(target.page)
+    // Gescrollt wird **hier**, nicht in paint(): Die Färbung läuft auch dann,
+    // wenn eine Seite bloß neu gezeichnet wurde – etwa nach dem Zoomen. Stand
+    // das Scrollen darin, sprang die Anzeige bei jedem Zoomschritt zurück zur
+    // Fundstelle, obwohl man längst woanders las. (Gemessen: von Seite 4
+    // zurück auf Seite 3.)
+    const show = () => {
+      // Ein Treffer aus dem erkannten Text kennt nur die Seite. Dann bleibt
+      // es beim Sprung an den Seitenanfang – ein Wort einzufärben, das wir
+      // nicht verorten können, hieße raten.
+      if (!target.exact) return
+      paint(target.page, target.nth)
+      const el = host.querySelector('.pdf-hit-current')
+      if (el) revealHit(el)
+    }
+    if (host.dataset.text === 'ready') { show(); return }
+    host.addEventListener('pdf-text-ready', show, { once: true })
+    return () => host.removeEventListener('pdf-text-ready', show)
+  }, [target, goToPage, revealHit, paint])
+
+  // Frisch gezeichnete Seiten bekommen ihre Färbung nach – sonst wären beim
+  // Blättern nur die Treffer der Seite markiert, auf der man gelandet ist.
+  useEffect(() => {
+    const root = scrollRef.current
+    if (!root || hits.length === 0) return
+    function onReady(e: Event) {
+      const host = (e.target as HTMLElement)
+      const n = Number(host.dataset.page)
+      paint(n, target && target.page === n ? target.nth : -1)
+    }
+    root.addEventListener('pdf-text-ready', onReady)
+    return () => root.removeEventListener('pdf-text-ready', onReady)
+  }, [hits.length, target, paint])
+
+  // Kommt der Betrachter aus einem Suchtreffer, steht das Wort schon da.
+  useEffect(() => { setQuery(searchTerm ?? '') }, [searchTerm, url])
+
+  // ------------------------------------------------------------------ Zoom
+
+  /**
+   * Beim Zoomen ändern sich alle Seitenhöhen – die Bildlaufposition zeigt
+   * danach irgendwohin. Gemerkt wird deshalb die Seite, auf der man gerade
+   * war, und nach dem Umbau wieder angesteuert. Ohne das landet man nach
+   * einem Zoomschritt am Anfang eines fremden Blattes.
+   */
+  const keepPage = useRef<number | null>(null)
+  useEffect(() => {
+    const n = keepPage.current
+    if (n === null) return
+    keepPage.current = null
+    goToPage(n)
+  }, [effScale, goToPage])
+
+  function zoom(dir: 1 | -1) {
+    const now = effScale
+    const next = dir > 0
+      ? zoomSteps.find(s => s > now + 0.001)
+      : [...zoomSteps].reverse().find(s => s < now - 0.001)
+    if (next) { keepPage.current = current; setScale(next) }
+  }
+
+  const pages = useMemo(() => sizes.map((_, i) => i + 1), [sizes])
+  /**
+   * Reicht die Breite für drei Spalten? Unterhalb bricht die Leiste um, und
+   * ein Raster ergäbe eine gequetschte Suche neben gequetschten Knöpfen.
+   */
+  const barRef = useRef<HTMLDivElement>(null)
+  const [barNarrow, setBarNarrow] = useState(false)
+  useEffect(() => {
+    const el = barRef.current
+    if (!el) return
+    // Dieselbe Vorsicht wie bei der Einpassung: Breite null heißt „noch nicht
+    // sichtbar", nicht „schmal". Ohne die Prüfung stand die Leiste beim
+    // Aufgehen der Vorschau im Umbruch-Zustand und blieb dort.
+    const set = () => { if (el.clientWidth >= 50) setBarNarrow(el.clientWidth < minGridWidth) }
+    set()
+    const ro = new ResizeObserver(set)
+    ro.observe(el)
+    return () => ro.disconnect()
+  }, [])
+
+  const [pad, setPad] = useState(16)
+  useEffect(() => {
+    const el = scrollRef.current
+    if (!el) return
+    const set = () => { if (el.clientWidth >= 50) setPad(padOf(el.clientWidth)) }
+    set()
+    const ro = new ResizeObserver(set)
+    ro.observe(el)
+    return () => ro.disconnect()
+  }, [doc])
+
+  // ----------------------------------------------------------------- Anzeige
+
+  if (error) {
+    return (
+      <div style={{ color: 'var(--color-text-muted)', fontSize: 14, textAlign: 'center' }}>
+        {error}
+      </div>
+    )
+  }
+
+  return (
+    <div style={{
+      width: '100%', height: '100%', display: 'flex', flexDirection: 'column',
+      borderRadius: 8, overflow: 'hidden', background: 'var(--color-surface)',
+    }}>
+      {/*
+        Werkzeugleiste.
+
+        Am Schreibtisch ein **Dreispaltenraster**: Steuerung links, Suche in
+        der Mitte, rechts eine leere Spalte gleicher Breite. Erst dadurch sitzt
+        die Suche wirklich mittig – mit zwei Abstandhaltern in einer Reihe
+        teilen sich diese nur den *Rest* neben der Steuerung, und das Feld
+        landete gemessen 79 bzw. 142 Pixel daneben.
+
+        Am Telefon reicht die Breite für drei Spalten nicht; dort bleibt es
+        beim Umbruch, und die Suche steht in der zweiten Zeile.
+      */}
+      <div
+        ref={barRef}
+        style={{
+          display: barNarrow ? 'flex' : 'grid',
+          gridTemplateColumns: barNarrow ? undefined : 'minmax(0, 1fr) auto minmax(0, 1fr)',
+          alignItems: 'center', gap: 8, flexWrap: 'wrap',
+          padding: '6px 10px', flexShrink: 0,
+          borderBottom: '1px solid var(--color-border)',
+          background: 'var(--color-surface)',
+        }}
+      >
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8, minWidth: 0 }}>
+        <ToolButton label="Previous page" disabled={current <= 1}
+                    onClick={() => goToPage(current - 1)} glyph="up" />
+        <span style={{
+          fontSize: 12, color: 'var(--color-text-muted)',
+          minWidth: 62, flexShrink: 0,
+          textAlign: 'center', fontVariantNumeric: 'tabular-nums',
+        }}>
+          {doc ? `${current} / ${doc.numPages}` : '…'}
+        </span>
+        <ToolButton label="Next page" disabled={!doc || current >= doc.numPages}
+                    onClick={() => goToPage(current + 1)} glyph="down" />
+
+        <span style={{ width: 1, height: 20, flexShrink: 0, background: 'var(--color-border)' }} />
+
+        <ToolButton label="Zoom out" onClick={() => zoom(-1)} glyph="minus" />
+        {/* Zurück zur eingepassten Größe. Bewusst kein Umschalter zwischen
+            „Breite" und „100 %": Seit die Einpassung bei 100 % gedeckelt ist,
+            sind das am Schreibtisch oft dieselbe Zahl – ein Knopf, der nichts
+            tut, ist schlimmer als keiner. */}
+        <button
+          onClick={() => { keepPage.current = current; setScale('fit') }}
+          disabled={scale === 'fit'}
+          title="Fit width"
+          style={{
+            fontSize: 12, color: 'var(--color-text-muted)', minWidth: 52, flexShrink: 0,
+            border: 'none', background: 'none',
+            cursor: scale === 'fit' ? 'default' : 'pointer',
+            fontVariantNumeric: 'tabular-nums',
+          }}
+        >
+          {Math.round(effScale * 100)}%
+        </button>
+        <ToolButton label="Zoom in" onClick={() => zoom(1)} glyph="plus" />
+        </div>
+
+        {/* Suche im Dokument – die mittlere Spalte. Sie ist der Grund, aus dem
+            es diesen Betrachter gibt; rechts an den Rand gedrängt sah sie aus
+            wie ein Zusatz, der nicht recht dazugehört. */}
+        <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+          {/* Gegengewicht. Rechts vom Feld stehen Zähler und Sprungknöpfe;
+              ohne diesen Ausgleich säße die Gruppe zwar mittig, das **Feld**
+              aber 79 Pixel daneben – gemessen. Mittig soll das sein, was man
+              ansieht, nicht der Kasten drumherum.
+
+              Am Telefon fällt es weg: Dort gibt es nichts zu zentrieren, und
+              120 Pixel Leere hätten ein Drittel der Zeile gekostet – während
+              rechts der zweite Sprungknopf aus dem Bild fiel. */}
+          {!barNarrow && <span style={{ width: hitsWidth, flexShrink: 0 }} />}
+          <input
+            value={query}
+            onChange={e => setQuery(e.target.value)}
+            onKeyDown={e => {
+              if (e.key === 'Enter') {
+                e.preventDefault()
+                if (hits.length) setHitIndex(i => (i + (e.shiftKey ? -1 : 1) + hits.length) % hits.length)
+              }
+              // Escape gehört hier dem Feld, nicht dem Schließen der Vorschau.
+              if (e.key === 'Escape' && query) { e.stopPropagation(); setQuery('') }
+            }}
+            placeholder="Find in document"
+            style={{
+              // Breiter als die 150 vom Anfang: In der Mitte einer 1440 Pixel
+              // breiten Leiste sah ein Feld in Knopfbreite aus wie ein
+              // Restposten. Ein Suchbegriff wie „Zahlungsbedingungen" passt
+              // jetzt auch hinein, ohne zu wandern.
+              width: 240, minWidth: 0,
+              padding: '5px 8px', borderRadius: 8, fontSize: 12,
+              border: '1px solid var(--color-border)',
+              background: 'var(--color-background)', color: 'var(--color-text)',
+              outline: 'none',
+            }}
+          />
+          <span style={{
+            fontSize: 11, color: 'var(--color-text-muted)',
+            // Feste Breite, nicht Mindestbreite: Sonst wüchse die rechte Seite
+            // mit „Searching…" und das Feld rutschte beim Tippen hin und her.
+            width: counterWidth, flexShrink: 0,
+            overflow: 'hidden', whiteSpace: 'nowrap',
+            fontVariantNumeric: 'tabular-nums',
+          }}>
+            {searching ? 'Searching…'
+              : query.trim().length < 2 ? ''
+              : hits.length === 0 ? 'No hits'
+              : `${hitIndex + 1} / ${hits.length}${hits[0] && !hits[0].exact ? ' · page' : ''}`}
+          </span>
+          {/* Erst zeigen, wenn es etwas zu springen gibt. Ohne Suche stand
+              hier ein zweites Paar Winkel neben dem zum Blättern – zwei
+              gleich aussehende Knopfpaare für zwei ganz verschiedene Dinge. */}
+          {/* Der Platz für die beiden Knöpfe steht immer bereit, auch wenn
+              sie fehlen. Sonst rückte das Suchfeld beim ersten Treffer um
+              knapp dreißig Pixel zur Seite – ausgerechnet während man darin
+              tippt. Leerer Raum fällt niemandem auf, ein wanderndes Feld
+              schon. */}
+          <span style={{ width: hitButtonsWidth, flexShrink: 0, display: 'flex', gap: 4 }}>
+            {hits.length > 0 && (
+              <>
+                <ToolButton label="Previous hit" glyph="hitUp"
+                            onClick={() => setHitIndex(i => (i - 1 + hits.length) % hits.length)} />
+                <ToolButton label="Next hit" glyph="hitDown"
+                            onClick={() => setHitIndex(i => (i + 1) % hits.length)} />
+              </>
+            )}
+          </span>
+        </div>
+
+        {/* Die leere dritte Spalte. Sie trägt nichts und ist trotzdem nötig:
+            Ohne sie hätte das Raster nur zwei Spalten, und „Mitte" wäre
+            wieder die Mitte des Restes. */}
+        {!barNarrow && <div />}
+      </div>
+
+      {/* Seiten */}
+      <div
+        ref={scrollRef}
+        style={{
+          flex: 1, minHeight: 0, overflow: 'auto',
+          padding: pad, background: 'var(--color-background)',
+          // Auf dem Handy zieht man das Dokument mit dem Finger; die
+          // Vorschau darunter darf dabei nicht mitwandern.
+          overscrollBehavior: 'contain',
+        }}
+      >
+        {!doc && (
+          <div style={{ color: 'var(--color-text-muted)', fontSize: 13, textAlign: 'center' }}>
+            Loading…
+          </div>
+        )}
+        {pages.map(n => (
+          <div
+            key={n}
+            data-page={n}
+            ref={el => { pageRefs.current[n - 1] = el }}
+            style={{
+              position: 'relative',
+              width: sizes[n - 1].w * effScale,
+              height: sizes[n - 1].h * effScale,
+              margin: `0 auto ${pageGap}px`,
+              background: '#fff',
+              boxShadow: '0 2px 10px rgba(0,0,0,0.4)',
+              // Die Textebene rechnet Schriftgrößen gegen diesen Wert.
+              ['--total-scale-factor' as string]: String(effScale),
+            }}
+          >
+            <div className="pdf-textLayer" />
+            {/* Fundstellen der Suche. Eigene Ebene über der Schrift, damit
+                sie nichts am Text ändert und nichts abgeschnitten wird. */}
+            <div className="pdf-hitLayer" />
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}
+
+/**
+ * Die häufigste Seitenbreite eines Dokuments.
+ *
+ * Vorher stand hier die **breiteste** Seite, mit dem Gedanken: Unterschiedlich
+ * breite Seiten unterschiedlich zu skalieren sieht nach Fehler aus. Das
+ * stimmt – nur ist der Preis höher als der Gewinn.
+ *
+ * Gemessen an einem zehnseitigen Dokument, in dem **eine** Seite quer liegt:
+ * Die neun hochkanten Seiten standen dadurch auf 46 % statt 65 %. Auf einem
+ * 412 Pixel breiten Telefon ist das der Unterschied zwischen lesbar und nicht.
+ * Eine einzelne Querformat-Seite – ein Anhang, eine breite Tabelle – bestimmt
+ * so die Darstellung des ganzen Dokuments.
+ *
+ * Jetzt entscheidet die Mehrheit. Die abweichende Seite ragt dann über den
+ * Rand und lässt sich seitlich schieben; das ist genau das, was man bei ihr
+ * ohnehin tun will.
+ *
+ * Bei Gleichstand gewinnt die breitere – dann ragt lieber nichts heraus.
+ */
+function commonWidth(sizes: { w: number; h: number }[]): number {
+  const count = new Map<number, number>()
+  for (const s of sizes) {
+    const w = Math.round(s.w)
+    count.set(w, (count.get(w) ?? 0) + 1)
+  }
+  let best = 0, bestN = 0
+  for (const [w, n] of count) {
+    if (n > bestN || (n === bestN && w > best)) { best = w; bestN = n }
+  }
+  return best || 1
+}
+
+/**
+ * Weitet eine Fundstelle auf das **ganze Wort** aus.
+ *
+ * Der Grund ist gemessen, nicht Geschmack. Über dem gemalten Bild liegt eine
+ * unsichtbare *Ersatz*schrift – hier `sans-serif 13,5px` für eine
+ * Serifenschrift im PDF. PDF.js dehnt sie über `--scale-x` (gemessen 0,937),
+ * damit die **Zeile insgesamt** stimmt. Die Buchstaben *darin* sitzen deshalb
+ * um ein bis drei Pixel anders als die gemalten.
+ *
+ * Bei einem ganzen Wort fällt das nicht auf. Bei „la" mitten in „Display"
+ * schon: Der Kasten ist zehn Pixel breit, und drei Pixel Versatz sehen aus,
+ * als läge er auf den falschen Buchstaben. Genau das war zu sehen.
+ *
+ * Gegenprobe im Browser: Unser Kasten und die Auswahl, die der Browser beim
+ * Markieren mit der Maus malt, liegen auf demselben Pixel (357,08 / 10,38).
+ * Der Versatz ist also nicht unser Fehler – er lässt sich nur nicht
+ * wegrechnen, ohne die Schrift des Dokuments zu besitzen. Ihn zu *umgehen*
+ * geht: ganze Wörter markieren, deren Ränder an Wortgrenzen liegen.
+ *
+ * Sehr lange „Wörter" (Adressen, Prüfsummen) bleiben ungedehnt – sonst wäre
+ * eine halbe Zeile eingefärbt, weil irgendwo darin zwei Buchstaben passten.
+ */
+const maxWordSnap = 40
+
+function wordAround(text: string, at: number, to: number): [number, number] {
+  const isWord = (c: string) => /[\p{L}\p{N}]/u.test(c)
+  let s = at, e = to
+  while (s > 0 && isWord(text[s - 1])) s--
+  while (e < text.length && isWord(text[e])) e++
+  return e - s > maxWordSnap ? [at, to] : [s, e]
+}
+
+/** Zählt die Fundstellen eines Suchworts in einem Stück Text. */
+function countIn(haystack: string, needle: string, page: number, exact: boolean): Hit[] {
+  const out: Hit[] = []
+  let from = 0, nth = 0
+  for (;;) {
+    const at = haystack.indexOf(needle, from)
+    if (at < 0) break
+    out.push({ page, nth: nth++, exact })
+    from = at + needle.length
+  }
+  return out
+}
+
+/**
+ * Die Knöpfe der Werkzeugleiste steuern **zwei verschiedene** Dinge: links
+ * die Seite, rechts die Fundstelle. Beide bewegen sich nach oben und unten –
+ * und mit demselben Winkel-Zeichen sahen beide Paare gleich aus. Wer die
+ * Leiste zum ersten Mal sieht, kann nicht wissen, welches welches ist.
+ *
+ * Deshalb zwei Formen: der schlanke Winkel blättert Seiten, der Pfeil mit
+ * Schaft springt zur nächsten Fundstelle. Der Pfeil erscheint ohnehin erst,
+ * wenn es Fundstellen gibt.
+ */
+const glyphs: Record<string, string> = {
+  up: '18 15 12 9 6 15',
+  down: '6 9 12 15 18 9',
+}
+
+function ToolButton({ label, onClick, disabled, glyph }: {
+  label: string; onClick: () => void; disabled?: boolean
+  glyph: 'up' | 'down' | 'plus' | 'minus' | 'hitUp' | 'hitDown'
+}) {
+  return (
+    <button
+      onClick={onClick}
+      disabled={disabled}
+      title={label}
+      aria-label={label}
+      style={{
+        width: 28, height: 28, flexShrink: 0, borderRadius: 8, border: 'none',
+        background: 'none', color: 'var(--color-text-muted)',
+        cursor: disabled ? 'default' : 'pointer', opacity: disabled ? 0.35 : 1,
+        display: 'flex', alignItems: 'center', justifyContent: 'center', padding: 0,
+      }}
+    >
+      <svg width="16" height="16" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" strokeWidth="2" strokeLinecap="round">
+        {glyph === 'plus' && <><line x1="12" y1="5" x2="12" y2="19" /><line x1="5" y1="12" x2="19" y2="12" /></>}
+        {glyph === 'minus' && <line x1="5" y1="12" x2="19" y2="12" />}
+        {(glyph === 'up' || glyph === 'down') && <polyline points={glyphs[glyph]} />}
+        {glyph === 'hitUp' && <><line x1="12" y1="19" x2="12" y2="6" /><polyline points="6 12 12 6 18 12" /></>}
+        {glyph === 'hitDown' && <><line x1="12" y1="5" x2="12" y2="18" /><polyline points="6 12 12 18 18 12" /></>}
+      </svg>
+    </button>
+  )
+}
diff --git a/frontend/src/components/SearchBox.tsx b/frontend/src/components/SearchBox.tsx
new file mode 100644
index 0000000..0a47ba0
--- /dev/null
+++ b/frontend/src/components/SearchBox.tsx
@@ -0,0 +1,258 @@
+import { useEffect, useRef, useState } from 'react'
+import { searchApi, filesApi, type SearchHit } from '../api/client'
+import { FileTypeIcon, FolderGlyph } from './icons'
+
+/**
+ * Zerlegt die Fundstelle an den Marken aus ts_headline.
+ *
+ * Bewusst kein dangerouslySetInnerHTML: Der Text kommt aus einem hochgeladenen
+ * Dokument, das jeder freigegebene Nutzer beisteuern kann. Als HTML eingesetzt
+ * wäre ein <script> darin eine Lücke; als Textknoten ist es einfach Text.
+ * Deshalb markiert die Datenbank mit [[hl]] statt mit <b>.
+ */
+function highlight(snippet: string) {
+  return snippet.split(/\[\[\/?hl\]\]/).map((part, i) =>
+    // Jedes zweite Stück lag zwischen den Marken – das ist der Treffer.
+    i % 2 === 1
+      ? <mark key={i} style={{
+          background: 'transparent', color: 'var(--color-primary)', fontWeight: 600,
+        }}>{part}</mark>
+      : <span key={i}>{part}</span>
+  )
+}
+
+interface Props {
+  /** Treffer geöffnet: Ordner betreten bzw. zum Ordner der Datei springen. */
+  onOpenFolder: (folderId: string | null, folderName: string) => void
+  /** Zweiter Wert ist das Suchwort – der PDF-Betrachter springt damit zur
+   *  Fundstelle im Dokument. */
+  onOpenFile: (hit: SearchHit, term: string) => void
+}
+
+/** Erst ab zwei Zeichen suchen – ein einzelnes trifft fast alles. Der Server
+ *  hält dieselbe Grenze ein, das hier spart nur die Anfrage. */
+const minChars = 2
+
+/** Wartezeit nach dem letzten Tastendruck. Kurz genug, dass es beim Tippen
+ *  mitläuft; lang genug, dass nicht jeder Buchstabe eine Anfrage auslöst. */
+const debounceMs = 250
+
+export default function SearchBox({ onOpenFolder, onOpenFile }: Props) {
+  const [query, setQuery] = useState('')
+  const [hits, setHits] = useState<SearchHit[]>([])
+  const [truncated, setTruncated] = useState(false)
+  const [open, setOpen] = useState(false)
+  const [busy, setBusy] = useState(false)
+  const [active, setActive] = useState(0)
+  const boxRef = useRef<HTMLDivElement>(null)
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  // Jede Anfrage bricht die vorige ab. Ohne das kann eine langsame frühere
+  // Antwort eine neuere überschreiben – man tippt weiter und sieht plötzlich
+  // wieder die Treffer von vor zwei Buchstaben.
+  useEffect(() => {
+    const q = query.trim()
+    if (q.length < minChars) {
+      setHits([]); setTruncated(false); setBusy(false)
+      return
+    }
+    const ctrl = new AbortController()
+    setBusy(true)
+    const timer = setTimeout(async () => {
+      try {
+        const res = await searchApi.query(q, ctrl.signal)
+        setHits(res.hits ?? [])
+        setTruncated(res.truncated ?? false)
+        setActive(0)
+        setOpen(true)
+      } catch {
+        // Abgebrochen oder fehlgeschlagen – ein leeres Feld ist hier die
+        // ehrlichste Anzeige, eine Fehlermeldung beim Tippen nur im Weg.
+      } finally {
+        setBusy(false)
+      }
+    }, debounceMs)
+
+    return () => { clearTimeout(timer); ctrl.abort() }
+  }, [query])
+
+  // Klick daneben schließt die Liste.
+  useEffect(() => {
+    function onDown(e: MouseEvent) {
+      if (!boxRef.current?.contains(e.target as Node)) setOpen(false)
+    }
+    document.addEventListener('mousedown', onDown)
+    return () => document.removeEventListener('mousedown', onDown)
+  }, [])
+
+  function choose(hit: SearchHit) {
+    const term = query.trim()
+    setOpen(false)
+    setQuery('')
+    if (hit.kind === 'folder') onOpenFolder(hit.id, hit.name)
+    else onOpenFile(hit, term)
+  }
+
+  function onKeyDown(e: React.KeyboardEvent) {
+    if (e.key === 'Escape') { setOpen(false); inputRef.current?.blur(); return }
+    if (!open || hits.length === 0) return
+    if (e.key === 'ArrowDown') { e.preventDefault(); setActive(i => (i + 1) % hits.length) }
+    else if (e.key === 'ArrowUp') { e.preventDefault(); setActive(i => (i - 1 + hits.length) % hits.length) }
+    else if (e.key === 'Enter') { e.preventDefault(); choose(hits[active]) }
+  }
+
+  const showPanel = open && query.trim().length >= minChars
+
+  return (
+    <div ref={boxRef} style={{ position: 'relative', flex: '1 1 180px', minWidth: 0, maxWidth: 220 }}>
+      <div style={{ position: 'relative', display: 'flex', alignItems: 'center' }}>
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"
+             style={{ position: 'absolute', left: 9, color: 'var(--color-text-muted)', pointerEvents: 'none' }}>
+          <circle cx="11" cy="11" r="7" /><line x1="16.5" y1="16.5" x2="21" y2="21" />
+        </svg>
+        <input
+          ref={inputRef}
+          value={query}
+          onChange={e => setQuery(e.target.value)}
+          onFocus={() => { if (hits.length) setOpen(true) }}
+          onKeyDown={onKeyDown}
+          placeholder="Search files and folders"
+          style={{
+            // Auf breiten Schirmen 220, auf schmalen so breit wie der Platz:
+            // Die feste Breite war der Grund, warum daneben nichts mehr passte.
+            width: 220, maxWidth: '100%', minWidth: 0,
+            padding: '6px 10px 6px 28px',
+            borderRadius: 8,
+            border: '1px solid var(--color-border)',
+            background: 'var(--color-surface-2)',
+            color: 'var(--color-text)',
+            fontSize: 13, outline: 'none',
+          }}
+        />
+        {busy && (
+          <div style={{
+            position: 'absolute', right: 8, width: 12, height: 12,
+            border: '2px solid var(--color-primary)', borderTopColor: 'transparent',
+            borderRadius: '50%', animation: 'spin 0.7s linear infinite',
+          }} />
+        )}
+      </div>
+
+      {showPanel && (
+        <div style={{
+          position: 'absolute', top: 'calc(100% + 6px)', left: 0,
+          // Breiter als die 380 von vorher: Eine Fundstelle braucht Platz,
+          // sonst bringen auch zwei Zeilen kaum mehr Wörter unter.
+          // Auf dem Handy passen keine 460px – dort so breit wie der Schirm
+          // hergibt, damit die Fundstelle nicht auf drei Wörter schrumpft.
+          width: 460, maxWidth: 'min(85vw, calc(100vw - 32px))', maxHeight: 420, overflowY: 'auto',
+          background: 'var(--color-surface)',
+          border: '1px solid var(--color-border)',
+          borderRadius: 10, boxShadow: '0 12px 32px rgba(0,0,0,0.45)',
+          zIndex: 60, padding: 4,
+        }}>
+          {hits.length === 0 && !busy && (
+            <div style={{ padding: '14px 12px', fontSize: 13, color: 'var(--color-text-muted)' }}>
+              Nothing found for “{query.trim()}”
+            </div>
+          )}
+
+          {hits.map((hit, i) => (
+            <button
+              key={hit.kind + hit.id}
+              onClick={() => choose(hit)}
+              onMouseEnter={() => setActive(i)}
+              style={{
+                // Oben ausrichten statt mittig: Ein Treffer mit Fundstelle ist
+                // drei Zeilen hoch, einer ohne zwei – mittig zentriert wandert
+                // das Symbol dann von Zeile zu Zeile.
+                display: 'flex', alignItems: 'flex-start', gap: 10, width: '100%',
+                padding: '8px 9px', borderRadius: 7, border: 'none', textAlign: 'left',
+                background: i === active ? 'var(--color-surface-2)' : 'transparent',
+                cursor: 'pointer',
+              }}
+            >
+              {/* Fester Platz fürs Symbol, egal wie breit es ist. Der Ordner
+                  ist 24 Pixel breit, die Dateisymbole 18 – ohne diese Spalte
+                  begännen Ordnernamen weiter rechts als Dateinamen, und in
+                  einer gemischten Trefferliste steht der Text dann in zwei
+                  Spalten. Gemessen: 107 gegen 95. */}
+              <span style={{
+                width: 24, flexShrink: 0, display: 'flex',
+                alignItems: 'center', justifyContent: 'center',
+                // Auf Höhe der ersten Zeile, nicht der Mitte des Blocks.
+                height: 20, marginTop: 1,
+              }}>
+                {hit.kind === 'folder' ? (
+                  <FolderGlyph size={24} />
+                ) : hit.has_thumbnail ? (
+                  <img src={filesApi.thumbnail(hit.id)} alt="" style={{
+                    width: 18, height: 18, borderRadius: 3, objectFit: 'cover',
+                  }} />
+                ) : (
+                  <FileTypeIcon mime={hit.mime_type ?? ''} name={hit.name} size={18} />
+                )}
+              </span>
+
+              <span style={{ minWidth: 0, flex: 1 }}>
+                <span style={{
+                  display: 'block', fontSize: 13, color: 'var(--color-text)',
+                  overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                }}>
+                  {hit.name}
+                </span>
+                {/* Ohne den Ordner darunter sind drei Dateien namens
+                    „Rechnung.pdf" nicht auseinanderzuhalten. */}
+                <span style={{
+                  display: 'block', fontSize: 11, color: 'var(--color-text-muted)',
+                  overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                }}>
+                  in {hit.folder_name || 'Home'}
+                </span>
+                {/* Bei einem Inhaltstreffer passt der Name gerade *nicht* –
+                    ohne die Fundstelle sähe „scan_0042.pdf" wie ein Fehler der
+                    Suche aus.
+
+                    Zwei Zeilen statt einer abgeschnittenen: Eine Fundstelle,
+                    die nach zehn Wörtern in „…" endet, zeigt oft gerade noch
+                    nicht, worum es geht – und das Suchwort selbst kann darin
+                    fehlen. Gekappt wird jetzt am Ende der zweiten Zeile
+                    (line-clamp), nicht am Ende der ersten.
+
+                    Die Linie links trennt die Fundstelle vom Ordnernamen
+                    darüber: Beides ist kleine, gedämpfte Schrift, und ohne
+                    Trennung liest es sich als ein Block. */}
+                {hit.matched_content && hit.snippet && (
+                  <span style={{
+                    display: '-webkit-box',
+                    WebkitBoxOrient: 'vertical',
+                    WebkitLineClamp: 2,
+                    lineClamp: 2,
+                    overflow: 'hidden',
+                    fontSize: 11, lineHeight: 1.45,
+                    color: 'var(--color-text-muted)',
+                    marginTop: 3, paddingLeft: 8,
+                    // In der Farbe des Treffers, nur blass: --color-border war
+                    // gegen die hervorgehobene Zeile praktisch unsichtbar
+                    // (gemessen rgb(51,65,85) auf fast demselben Grund). So ist
+                    // die Linie auf beiden Untergründen zu sehen und gehört
+                    // sichtbar zum hervorgehobenen Wort.
+                    borderLeft: '2px solid rgba(var(--color-primary-rgb), 0.4)',
+                  }}>
+                    {highlight(hit.snippet)}
+                  </span>
+                )}
+              </span>
+            </button>
+          ))}
+
+          {truncated && (
+            <div style={{ padding: '8px 10px', fontSize: 11, color: 'var(--color-text-muted)' }}>
+              Only the first {hits.length} matches are shown – narrow the search.
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/components/ShareDialog.tsx b/frontend/src/components/ShareDialog.tsx
new file mode 100644
index 0000000..984cb6b
--- /dev/null
+++ b/frontend/src/components/ShareDialog.tsx
@@ -0,0 +1,190 @@
+import { useState } from 'react'
+import { sharesApi, type FileItem, type ShareLink } from '../api/client'
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+
+interface Props {
+  file: FileItem
+  onClose: () => void
+}
+
+export default function ShareDialog({ file, onClose }: Props) {
+  const [password, setPassword] = useState('')
+  const [expiresIn, setExpiresIn] = useState('')
+  const [link, setLink] = useState<ShareLink | null>(null)
+  const [creating, setCreating] = useState(false)
+  const [error, setError] = useState('')
+  const [copied, setCopied] = useState(false)
+  const overlay = useOverlayDismiss(onClose)
+
+  async function createLink() {
+    setCreating(true)
+    setError('')
+    try {
+      const created = await sharesApi.create(file.id, {
+        password: password || undefined,
+        expires_in_hours: expiresIn ? parseInt(expiresIn) : undefined,
+      })
+      setLink(created)
+    } catch (e: any) {
+      setError(e.message ?? 'Failed to create link')
+    } finally {
+      setCreating(false)
+    }
+  }
+
+  function shareURL(token: string) {
+    return `${window.location.origin}/s/${token}`
+  }
+
+  function copyLink() {
+    if (!link) return
+    navigator.clipboard.writeText(shareURL(link.token))
+    setCopied(true)
+    setTimeout(() => setCopied(false), 2000)
+  }
+
+  return (
+    <div
+      style={{ position: 'fixed', inset: 0, zIndex: 200, display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'rgba(0,0,0,0.6)' }}
+      {...overlay}
+    >
+      <div style={{
+        background: 'var(--color-surface)',
+        border: '1px solid var(--color-border)',
+        borderRadius: 14,
+        padding: 24,
+        width: 400,
+        maxWidth: '90vw',
+      }}>
+        <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: 20 }}>
+          <h2 style={{ margin: 0, fontSize: 16, fontWeight: 600, color: 'var(--color-text)' }}>Share "{file.name}"</h2>
+          <button onClick={onClose} style={{ background: 'none', border: 'none', cursor: 'pointer', color: 'var(--color-text-muted)', padding: 4, borderRadius: 6 }}>
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <line x1="18" y1="6" x2="6" y2="18" /><line x1="6" y1="6" x2="18" y2="18" />
+            </svg>
+          </button>
+        </div>
+
+        {!link ? (
+          <>
+            <div style={{ marginBottom: 14 }}>
+              <label style={{ display: 'block', fontSize: 12, fontWeight: 500, color: 'var(--color-text-muted)', marginBottom: 6 }}>
+                Password (optional)
+              </label>
+              <input
+                type="password"
+                placeholder="Leave empty for no password"
+                value={password}
+                onChange={e => setPassword(e.target.value)}
+                style={{
+                  width: '100%', padding: '8px 12px', borderRadius: 8,
+                  border: '1px solid var(--color-border)',
+                  background: 'var(--color-surface-2)',
+                  color: 'var(--color-text)', fontSize: 13,
+                  outline: 'none',
+                }}
+              />
+            </div>
+
+            <div style={{ marginBottom: 20 }}>
+              <label style={{ display: 'block', fontSize: 12, fontWeight: 500, color: 'var(--color-text-muted)', marginBottom: 6 }}>
+                Expires in
+              </label>
+              <select
+                value={expiresIn}
+                onChange={e => setExpiresIn(e.target.value)}
+                style={{
+                  width: '100%', padding: '8px 12px', borderRadius: 8,
+                  border: '1px solid var(--color-border)',
+                  background: 'var(--color-surface-2)',
+                  color: 'var(--color-text)', fontSize: 13,
+                  outline: 'none',
+                }}
+              >
+                <option value="">Never</option>
+                <option value="1">1 hour</option>
+                <option value="24">24 hours</option>
+                <option value="168">7 days</option>
+                <option value="720">30 days</option>
+              </select>
+            </div>
+
+            {error && (
+              <p style={{ color: 'var(--color-danger)', fontSize: 13, marginBottom: 14 }}>{error}</p>
+            )}
+
+            <div style={{ display: 'flex', gap: 8, justifyContent: 'flex-end' }}>
+              <button
+                onClick={onClose}
+                style={{
+                  padding: '8px 16px', borderRadius: 8, border: '1px solid var(--color-border)',
+                  background: 'transparent', color: 'var(--color-text-muted)', fontSize: 13, cursor: 'pointer',
+                }}
+              >
+                Cancel
+              </button>
+              <button
+                onClick={createLink}
+                disabled={creating}
+                style={{
+                  padding: '8px 16px', borderRadius: 8, border: 'none',
+                  background: 'var(--color-primary)', color: '#fff', fontSize: 13, fontWeight: 600,
+                  cursor: creating ? 'not-allowed' : 'pointer', opacity: creating ? 0.7 : 1,
+                }}
+              >
+                {creating ? 'Creating…' : 'Create link'}
+              </button>
+            </div>
+          </>
+        ) : (
+          <>
+            <div style={{
+              background: 'var(--color-surface-2)',
+              borderRadius: 8, padding: '12px 14px', marginBottom: 16,
+              display: 'flex', alignItems: 'center', gap: 10,
+            }}>
+              <span style={{ flex: 1, fontSize: 12, color: 'var(--color-text)', wordBreak: 'break-all' }}>
+                {shareURL(link.token)}
+              </span>
+              <button
+                onClick={copyLink}
+                style={{
+                  padding: '5px 10px', borderRadius: 6, border: '1px solid var(--color-border)',
+                  background: copied ? 'var(--color-success)' : 'transparent',
+                  color: copied ? '#fff' : 'var(--color-text)', fontSize: 12, cursor: 'pointer',
+                  whiteSpace: 'nowrap', flexShrink: 0,
+                  transition: 'background 0.2s',
+                }}
+              >
+                {copied ? '✓ Copied' : 'Copy'}
+              </button>
+            </div>
+
+            {link.has_password && (
+              <p style={{ fontSize: 12, color: 'var(--color-text-muted)', marginBottom: 8, display: 'flex', alignItems: 'center', gap: 6 }}>
+                <span>🔒</span> Password protected
+              </p>
+            )}
+            {link.expires_at && (
+              <p style={{ fontSize: 12, color: 'var(--color-text-muted)', marginBottom: 16, display: 'flex', alignItems: 'center', gap: 6 }}>
+                <span>⏰</span> Expires {new Date(link.expires_at).toLocaleString()}
+              </p>
+            )}
+
+            <div style={{ display: 'flex', justifyContent: 'flex-end' }}>
+              <button
+                onClick={onClose}
+                style={{
+                  padding: '8px 16px', borderRadius: 8, border: 'none',
+                  background: 'var(--color-primary)', color: '#fff', fontSize: 13, fontWeight: 600, cursor: 'pointer',
+                }}
+              >
+                Done
+              </button>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/ShareWithDialog.tsx b/frontend/src/components/ShareWithDialog.tsx
new file mode 100644
index 0000000..0d100b1
--- /dev/null
+++ b/frontend/src/components/ShareWithDialog.tsx
@@ -0,0 +1,272 @@
+import { useState, useEffect } from 'react'
+import {
+  aclApi,
+  type AclEntry, type ShareRecipient, type SharePermission,
+} from '../api/client'
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+
+interface Props {
+  /** Was freigegeben wird – Ordner oder einzelne Datei. */
+  resource: { type: 'folder' | 'file'; id: string; name: string }
+  onClose: () => void
+}
+
+/** Freigabe an Personen und Gruppen innerhalb der Cloud.
+ *
+ *  Bewusst getrennt vom öffentlichen Freigabelink: Der eine gibt einen
+ *  anonymen Zugang ins Internet, der andere benennt Personen, die sich
+ *  ohnehin anmelden. Ein Dialog für beides würde die Frage „wer kann das
+ *  sehen?" verwischen – und genau die muss beim Teilen eindeutig sein. */
+export default function ShareWithDialog({ resource, onClose }: Props) {
+  const overlay = useOverlayDismiss(onClose)
+
+  const [entries, setEntries] = useState<AclEntry[]>([])
+  const [recipients, setRecipients] = useState<ShareRecipient[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState('')
+
+  const [subject, setSubject] = useState('')
+  const [permission, setPermission] = useState<SharePermission>('read')
+  const [saving, setSaving] = useState(false)
+
+  useEffect(() => { load() }, [resource.id])
+
+  async function load() {
+    setLoading(true)
+    try {
+      const [list, people] = await Promise.all([
+        resource.type === 'folder'
+          ? aclApi.listForFolder(resource.id)
+          : aclApi.listForFile(resource.id),
+        aclApi.recipients(),
+      ])
+      setEntries(list ?? [])
+      setRecipients(people ?? [])
+    } catch {
+      setError('Could not load sharing settings')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function grant() {
+    const chosen = recipients.find(r => r.id === subject)
+    if (!chosen) return
+    setSaving(true)
+    setError('')
+    try {
+      if (resource.type === 'folder') {
+        await aclApi.grantFolder(resource.id, chosen.id, chosen.type, permission)
+      } else {
+        await aclApi.grantFile(resource.id, chosen.id, chosen.type, permission)
+      }
+      setSubject('')
+      await load()
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Could not share')
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  async function revoke(entry: AclEntry) {
+    try {
+      await aclApi.revoke(entry.id)
+      setEntries(list => list.filter(e => e.id !== entry.id))
+    } catch {
+      setError('Could not remove access')
+    }
+  }
+
+  // Wer schon Zugriff hat, gehört nicht noch einmal in die Auswahlliste.
+  const alreadyShared = new Set(entries.map(e => e.subject_id))
+  const available = recipients.filter(r => !alreadyShared.has(r.id))
+
+  return (
+    <div style={{
+      position: 'fixed', inset: 0, zIndex: 300,
+      background: 'rgba(0,0,0,0.55)',
+      display: 'flex', alignItems: 'center', justifyContent: 'center', padding: 20,
+    }} {...overlay}>
+      <div style={{
+        background: 'var(--color-surface)',
+        border: '1px solid var(--color-border)',
+        borderRadius: 16, width: 480, maxWidth: '100%', maxHeight: '85vh',
+        display: 'flex', flexDirection: 'column', overflow: 'hidden',
+        boxShadow: '0 12px 40px rgba(0,0,0,0.3)',
+      }}>
+        {/* Kopf */}
+        <div style={{ padding: '18px 22px 14px', borderBottom: '1px solid var(--color-border)' }}>
+          <h3 style={{ margin: 0, fontSize: 16, fontWeight: 700, color: 'var(--color-text)' }}>
+            Share with people
+          </h3>
+          <p style={{
+            margin: '3px 0 0', fontSize: 12, color: 'var(--color-text-muted)',
+            overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+          }}>
+            {resource.name}
+          </p>
+        </div>
+
+        {/* Hinzufügen */}
+        <div style={{ padding: '14px 22px', borderBottom: '1px solid var(--color-border)' }}>
+          <div style={{ display: 'flex', gap: 8 }}>
+            <select
+              value={subject}
+              onChange={e => setSubject(e.target.value)}
+              style={{
+                flex: 1, minWidth: 0, padding: '8px 10px', borderRadius: 8,
+                border: '1px solid var(--color-border)',
+                background: 'var(--color-surface-2)', color: 'var(--color-text)',
+                fontSize: 13, outline: 'none',
+              }}
+            >
+              <option value="">Choose a person or group…</option>
+              {available.filter(r => r.type === 'user').length > 0 && (
+                <optgroup label="People">
+                  {available.filter(r => r.type === 'user').map(r => (
+                    <option key={r.id} value={r.id}>{r.name}</option>
+                  ))}
+                </optgroup>
+              )}
+              {available.filter(r => r.type === 'group').length > 0 && (
+                <optgroup label="Groups">
+                  {available.filter(r => r.type === 'group').map(r => (
+                    <option key={r.id} value={r.id}>{r.name}</option>
+                  ))}
+                </optgroup>
+              )}
+            </select>
+
+            <select
+              value={permission}
+              onChange={e => setPermission(e.target.value as SharePermission)}
+              style={{
+                padding: '8px 10px', borderRadius: 8, flexShrink: 0,
+                border: '1px solid var(--color-border)',
+                background: 'var(--color-surface-2)', color: 'var(--color-text)',
+                fontSize: 13, outline: 'none',
+              }}
+            >
+              <option value="read">Can view</option>
+              <option value="write">Can edit</option>
+            </select>
+
+            <button
+              onClick={grant}
+              disabled={!subject || saving}
+              style={{
+                padding: '8px 16px', borderRadius: 8, border: 'none', flexShrink: 0,
+                background: 'var(--color-primary)', color: '#fff',
+                fontSize: 13, fontWeight: 600,
+                cursor: !subject || saving ? 'default' : 'pointer',
+                opacity: !subject || saving ? 0.5 : 1,
+              }}
+            >
+              {saving ? '…' : 'Share'}
+            </button>
+          </div>
+
+          {resource.type === 'folder' && (
+            <p style={{ margin: '10px 0 0', fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+              Everything inside this folder is shared too, including anything added later.
+              Files stay in your storage and count towards your quota.
+            </p>
+          )}
+          {error && (
+            <p style={{ margin: '10px 0 0', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>
+          )}
+        </div>
+
+        {/* Wer hat Zugriff */}
+        <div style={{ flex: 1, overflowY: 'auto', padding: '14px 22px' }}>
+          <div style={{
+            fontSize: 11, fontWeight: 700, color: 'var(--color-text-muted)',
+            textTransform: 'uppercase', letterSpacing: 0.4, marginBottom: 10,
+          }}>
+            Who has access
+          </div>
+
+          {loading ? (
+            <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)' }}>Loading…</p>
+          ) : entries.length === 0 ? (
+            <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)' }}>
+              Only you. Nobody else can see this.
+            </p>
+          ) : (
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
+              {entries.map(e => (
+                <div key={e.id} style={{
+                  display: 'flex', alignItems: 'center', gap: 10,
+                  padding: '9px 11px', borderRadius: 9,
+                  border: '1px solid var(--color-border)',
+                }}>
+                  <span style={{ color: 'var(--color-text-muted)', display: 'flex', flexShrink: 0 }}>
+                    {e.subject_type === 'group' ? <GroupIcon /> : <PersonIcon />}
+                  </span>
+                  <div style={{ flex: 1, minWidth: 0 }}>
+                    <div style={{
+                      fontSize: 13, color: 'var(--color-text)',
+                      overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                    }}>
+                      {e.subject_name}
+                    </div>
+                    <div style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>
+                      {e.subject_type === 'group' ? 'Group' : 'Person'} ·{' '}
+                      {e.permission === 'write' ? 'Can edit' : 'Can view'}
+                    </div>
+                  </div>
+                  <button
+                    onClick={() => revoke(e)}
+                    style={{
+                      padding: '4px 11px', borderRadius: 7, flexShrink: 0,
+                      border: '1px solid var(--color-border)', background: 'transparent',
+                      color: 'var(--color-text-muted)', fontSize: 11, cursor: 'pointer',
+                    }}
+                  >
+                    Remove
+                  </button>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+
+        <div style={{
+          padding: '12px 22px', borderTop: '1px solid var(--color-border)',
+          display: 'flex', justifyContent: 'flex-end',
+        }}>
+          <button
+            onClick={onClose}
+            style={{
+              padding: '8px 18px', borderRadius: 9,
+              border: '1px solid var(--color-border)', background: 'transparent',
+              color: 'var(--color-text)', fontSize: 13, cursor: 'pointer',
+            }}
+          >
+            Done
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function PersonIcon() {
+  return (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+      <circle cx="12" cy="8" r="4" />
+      <path d="M4 21v-1a7 7 0 0114 0v1" />
+    </svg>
+  )
+}
+
+function GroupIcon() {
+  return (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+      <circle cx="9" cy="8" r="3.5" />
+      <path d="M2 21v-1a7 7 0 0114 0v1" />
+      <path d="M17 11a3 3 0 100-6M19 21v-1a6 6 0 00-3-5.2" />
+    </svg>
+  )
+}
diff --git a/frontend/src/components/Shell.tsx b/frontend/src/components/Shell.tsx
new file mode 100644
index 0000000..37810b1
--- /dev/null
+++ b/frontend/src/components/Shell.tsx
@@ -0,0 +1,101 @@
+import { useState } from 'react'
+import type { FolderItem, User } from '../api/client'
+import { useNavHistory, type View } from '../hooks/useNavHistory'
+import Sidebar from './Sidebar'
+import FileBrowser from '../pages/FileBrowser'
+import TrashPage from '../pages/TrashPage'
+import SharedPage from '../pages/SharedPage'
+import SharedWithMePage from '../pages/SharedWithMePage'
+import AdminPage from '../pages/AdminPage'
+import ProfilePage from '../pages/ProfilePage'
+import TagsPage from '../pages/TagsPage'
+import { UserMenuProvider } from './UserMenu'
+
+export type { View }
+
+interface Props {
+  user: User
+  onLogout: () => Promise<void>
+  /** Lädt den Nutzer neu – für Speicherverbrauch und Anzeigename. */
+  onUserChanged: () => Promise<void>
+}
+
+export default function Shell({ user, onLogout, onUserChanged }: Props) {
+  const nav = useNavHistory()
+  const { view, folderPath } = nav
+  const [sidebarOpen, setSidebarOpen] = useState(false)
+
+  // Aus der Seitenleiste kennen wir nur Kennung und Name – die Kette darueber
+  // holt die Liste nicht mit, also faengt der Pfad hier beim Ordner selbst an.
+  function navigateToFolder(folderId: string, folderName: string) {
+    setSidebarOpen(false)
+    const stub: FolderItem = {
+      id: folderId, owner_id: null, group_id: null, parent_id: null,
+      name: folderName, created_at: '',
+    }
+    nav.setFolderPath([stub])
+  }
+
+  return (
+    <UserMenuProvider value={{
+      user,
+      onNavigate: (v) => { nav.setView(v); setSidebarOpen(false) },
+      onLogout,
+      onOpenSidebar: () => setSidebarOpen(true),
+    }}>
+    <div style={{ display: 'flex', height: '100vh', overflow: 'hidden' }}>
+      {/* Mobile overlay */}
+      {sidebarOpen && (
+        <div
+          style={{ position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.5)', zIndex: 40 }}
+          onClick={() => setSidebarOpen(false)}
+        />
+      )}
+
+      <Sidebar
+        user={user}
+        view={view}
+        activeTagId={nav.tagId}
+        onOpenTag={nav.setTag}
+        activeCorrespondentId={nav.correspondentId}
+        onOpenCorrespondent={nav.setCorrespondent}
+        onNavigate={(v) => { nav.setView(v); setSidebarOpen(false) }}
+        onNavigateToFolder={navigateToFolder}
+        open={sidebarOpen}
+      />
+
+      {/* Main content */}
+      <div style={{ flex: 1, display: 'flex', flexDirection: 'column', minWidth: 0, overflow: 'hidden' }}>
+        {view === 'files' && (
+          <FileBrowser
+            user={user}
+            folderPath={folderPath}
+            onNavigate={nav.setFolderPath}
+            onUserChanged={onUserChanged}
+          />
+        )}
+        {view === 'trash' && <TrashPage onUserChanged={onUserChanged} />}
+        {view === 'incoming' && <SharedWithMePage onOpenFolder={navigateToFolder} />}
+        {view === 'shared' && <SharedPage />}
+        {view === 'admin' && <AdminPage />}
+        {view === 'profile' && <ProfilePage user={user} onUserChanged={onUserChanged} />}
+        {/* Etikett und Absender teilen sich die Seite – es ist dieselbe Frage
+            („alles mit diesem Merkmal"), nur ein anderes Merkmal. */}
+        {(view === 'tags' || view === 'from') && (
+          <TagsPage
+            tagId={view === 'tags' ? nav.tagId : undefined}
+            correspondentId={view === 'from' ? nav.correspondentId : undefined}
+            onOpenFolder={(id, name) => {
+              // Klick auf einen Treffer springt zum Ordner – dieselbe Regel wie
+              // in der Suche: Geöffnet wird per Doppelklick auf die Datei.
+              if (id) navigateToFolder(id, name)
+              else nav.setFolderPath([])
+            }}
+          />
+        )}
+      </div>
+
+    </div>
+    </UserMenuProvider>
+  )
+}
diff --git a/frontend/src/components/Sidebar.tsx b/frontend/src/components/Sidebar.tsx
new file mode 100644
index 0000000..744ab86
--- /dev/null
+++ b/frontend/src/components/Sidebar.tsx
@@ -0,0 +1,745 @@
+import { useState, useEffect, useRef } from 'react'
+import { favoritesApi, foldersApi, tagsApi, correspondentsApi, tagsChangedEvent, notifyTagsChanged, type Correspondent, type FavoriteItem, type FolderItem, type Tag } from '../api/client'
+import { tagColor } from './TagChip'
+import TagEditDialog, { CorrespondentRenameDialog } from './TagEditDialog'
+import ContextMenu from './ContextMenu'
+import ConfirmDialog from './ConfirmDialog'
+import { RenameIcon, TrashIcon } from './icons'
+import type { User } from '../api/client'
+import type { View } from './Shell'
+import { useAppSettings } from '../hooks/useAppSettings'
+
+interface Props {
+  user: User
+  /** Gerade angezeigtes Etikett – für die Hervorhebung in der Liste. */
+  activeTagId?: string
+  onOpenTag: (tagId: string) => void
+  activeCorrespondentId?: string
+  onOpenCorrespondent: (id: string) => void
+  view: View
+  onNavigate: (v: View) => void
+  onNavigateToFolder: (folderId: string, folderName: string) => void
+  open: boolean
+}
+
+const nav: { id: View; label: string; icon: React.ReactNode }[] = [
+  {
+    id: 'files',
+    label: 'Home',
+    icon: (
+      <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+           strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <path d="M3 10.5L12 3l9 7.5" />
+        <path d="M5.5 9.5V20a1 1 0 001 1h11a1 1 0 001-1V9.5" />
+      </svg>
+    ),
+  },
+  {
+    id: 'trash',
+    label: 'Trash',
+    icon: (
+      <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <polyline points="3 6 5 6 21 6" />
+        <path d="M19 6l-1 14H6L5 6" />
+        <path d="M10 11v6M14 11v6M9 6V4h6v2" />
+      </svg>
+    ),
+  },
+  {
+    id: 'incoming',
+    label: 'Shared with me',
+    icon: (
+      <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+        <path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2z" />
+        <circle cx="12" cy="13" r="2" />
+        <path d="M8.5 18a3.5 3.5 0 017 0" />
+      </svg>
+    ),
+  },
+  {
+    id: 'shared',
+    label: 'Shared links',
+    icon: (
+      <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+        <circle cx="18" cy="5" r="3" />
+        <circle cx="6" cy="12" r="3" />
+        <circle cx="18" cy="19" r="3" />
+        <line x1="8.59" y1="13.51" x2="15.42" y2="17.49" />
+        <line x1="15.41" y1="6.51" x2="8.59" y2="10.49" />
+      </svg>
+    ),
+  },
+  // „Admin" stand hier bis zum 23.08.2026. Der Eintrag ist ins Nutzermenü oben
+  // rechts gewandert: Diese Leiste zeigt *Orte, an denen Dateien liegen* –
+  // Home, Papierkorb, Geteiltes. Die Verwaltung ist keiner davon, und mit einem
+  // Stern-Symbol zwischen Ordnersymbolen sah sie auch nicht danach aus.
+]
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`
+  return `${(n / 1024 ** 3).toFixed(1)} GB`
+}
+
+function ChevronIcon({ expanded }: { expanded: boolean }) {
+  return (
+    <svg
+      width="12" height="12" viewBox="0 0 24 24"
+      fill="none" stroke="currentColor" strokeWidth="2.5"
+      style={{ transform: expanded ? 'rotate(90deg)' : 'rotate(0deg)', transition: 'transform 0.15s', flexShrink: 0 }}
+    >
+      <polyline points="9 18 15 12 9 6" />
+    </svg>
+  )
+}
+
+function FolderIcon({ size = 14 }: { size?: number }) {
+  return (
+    <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" style={{ flexShrink: 0 }}>
+      <path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2z" />
+    </svg>
+  )
+}
+
+interface SubfolderRowProps {
+  folder: FolderItem
+  onNavigate: (id: string, name: string) => void
+}
+
+function SubfolderRow({ folder, onNavigate }: SubfolderRowProps) {
+  return (
+    <button
+      onClick={() => onNavigate(folder.id, folder.name)}
+      style={{
+        width: '100%', display: 'flex', alignItems: 'center', gap: 6,
+        padding: '5px 10px 5px 28px', borderRadius: 6,
+        border: 'none', cursor: 'pointer', background: 'transparent',
+        color: 'var(--color-text-muted)', fontSize: 12, textAlign: 'left',
+      }}
+      onMouseEnter={e => e.currentTarget.style.background = 'var(--color-surface-2)'}
+      onMouseLeave={e => e.currentTarget.style.background = 'transparent'}
+    >
+      <FolderIcon size={12} />
+      <span style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{folder.name}</span>
+    </button>
+  )
+}
+
+interface FavoriteRowProps {
+  fav: FavoriteItem
+  onNavigate: (id: string, name: string) => void
+  onRemove: (fav: FavoriteItem) => void
+  onToggleExpand: (fav: FavoriteItem) => void
+  onDragStart: (e: React.DragEvent, fav: FavoriteItem) => void
+  onDragOver: (e: React.DragEvent, fav: FavoriteItem) => void
+  onDrop: (e: React.DragEvent, fav: FavoriteItem) => void
+  dragOverId: string | null
+}
+
+function FavoriteRow({ fav, onNavigate, onRemove, onToggleExpand, onDragStart, onDragOver, onDrop, dragOverId }: FavoriteRowProps) {
+  const [subfolders, setSubfolders] = useState<FolderItem[] | null>(null)
+  const [showCtx, setShowCtx] = useState(false)
+  const loaded = useRef(false)
+
+  useEffect(() => {
+    if (fav.is_expanded && !loaded.current) {
+      loaded.current = true
+      foldersApi.list(fav.folder_id)
+        .then(data => setSubfolders(data ?? []))
+        .catch(() => setSubfolders([]))
+    }
+  }, [fav.is_expanded, fav.folder_id])
+
+  function handleToggle() {
+    if (!loaded.current && !fav.is_expanded) {
+      loaded.current = true
+      foldersApi.list(fav.folder_id)
+        .then(data => setSubfolders(data ?? []))
+        .catch(() => setSubfolders([]))
+    }
+    onToggleExpand(fav)
+  }
+
+  const isOver = dragOverId === fav.folder_id
+
+  return (
+    <div>
+      <div
+        draggable
+        onDragStart={e => onDragStart(e, fav)}
+        onDragOver={e => onDragOver(e, fav)}
+        onDrop={e => onDrop(e, fav)}
+        onDragEnd={() => {}}
+        style={{
+          display: 'flex', alignItems: 'center', gap: 4,
+          padding: '6px 6px 6px 8px', borderRadius: 7,
+          background: isOver ? 'rgba(var(--color-primary-rgb), 0.12)' : 'transparent',
+          cursor: 'grab',
+          position: 'relative',
+        }}
+        onMouseEnter={e => { if (!isOver) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+        onMouseLeave={e => { if (!isOver) e.currentTarget.style.background = 'transparent' }}
+      >
+        {/* Expand toggle */}
+        <button
+          onClick={handleToggle}
+          style={{ background: 'none', border: 'none', cursor: 'pointer', padding: 2, color: 'var(--color-text-muted)', display: 'flex', alignItems: 'center' }}
+        >
+          <ChevronIcon expanded={fav.is_expanded} />
+        </button>
+
+        <FolderIcon size={14} />
+
+        {/* Name — click navigates */}
+        <button
+          onClick={() => onNavigate(fav.folder_id, fav.folder_name)}
+          style={{
+            flex: 1, background: 'none', border: 'none', cursor: 'pointer',
+            color: 'var(--color-text)', fontSize: 13, textAlign: 'left',
+            overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+            padding: '0 4px',
+          }}
+        >
+          {fav.folder_name}
+        </button>
+
+        {/* Context: remove */}
+        <div style={{ position: 'relative' }}>
+          <button
+            onClick={() => setShowCtx(v => !v)}
+            style={{ background: 'none', border: 'none', cursor: 'pointer', padding: 2, color: 'var(--color-text-muted)', opacity: 0.6, display: 'flex' }}
+          >
+            <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <circle cx="12" cy="5" r="1" fill="currentColor" />
+              <circle cx="12" cy="12" r="1" fill="currentColor" />
+              <circle cx="12" cy="19" r="1" fill="currentColor" />
+            </svg>
+          </button>
+          {showCtx && (
+            <div
+              style={{
+                position: 'absolute', right: 0, top: '100%', zIndex: 200,
+                background: 'var(--color-surface)',
+                border: '1px solid var(--color-border)',
+                borderRadius: 8, padding: 4, minWidth: 140,
+                boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
+              }}
+            >
+              <button
+                onClick={() => { setShowCtx(false); onRemove(fav) }}
+                style={{
+                  width: '100%', padding: '6px 10px', background: 'none',
+                  border: 'none', cursor: 'pointer', textAlign: 'left',
+                  fontSize: 12, color: 'var(--color-danger)', borderRadius: 6,
+                }}
+              >
+                Remove from favourites
+              </button>
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Subfolders */}
+      {fav.is_expanded && subfolders && subfolders.length > 0 && (
+        <div>
+          {subfolders.map(sf => (
+            <SubfolderRow key={sf.id} folder={sf} onNavigate={onNavigate} />
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default function Sidebar({ user, view, activeTagId, onOpenTag,
+                                  activeCorrespondentId, onOpenCorrespondent,
+                                  onNavigate, onNavigateToFolder, open }: Props) {
+  const { cloudName, logoUrl } = useAppSettings()
+  // Der Anzeigename ist optional – ohne ihn bleibt der Anmeldename stehen.
+  /**
+   * Etiketten in der Seitenleiste – die zweite Art, an Dateien zu kommen.
+   *
+   * Bewusst neben den Favoriten und nicht in der Hauptnavigation: Favoriten
+   * sind Orte, Etiketten sind Sichten quer über alle Orte. Beides gehört in
+   * den unteren, persönlichen Teil der Leiste, nicht zu Home und Papierkorb.
+   *
+   * Neu geladen wird bei jedem Ansichtswechsel: Die Zählstände ändern sich,
+   * sobald irgendwo etikettiert wird, und eine Zahl, die tagelang falsch
+   * stehenbleibt, ist schlimmer als keine.
+   */
+  const [tags, setTags] = useState<Tag[]>([])
+  /**
+   * Rechtsklick auf ein Etikett öffnet erst ein kleines Menü, nicht sofort den
+   * Bearbeiten-Dialog. Ein Fenster, das ungefragt aufspringt, überrumpelt –
+   * und bei Dateien und Ordnern verhält sich der Rechtsklick genauso.
+   */
+  const [tagMenu, setTagMenu] = useState<{ x: number; y: number; tag: Tag } | null>(null)
+  const [editTag, setEditTag] = useState<Tag | null>(null)
+  const [deleteTag, setDeleteTag] = useState<Tag | null>(null)
+
+  /**
+   * Absender als **eigene** Liste, nicht unter den Etiketten.
+   *
+   * Das ist der ganze Punkt des Feldes: „Stadtwerke" und „absetzbar" in einer
+   * Aufzählung wäre Absender und Verwendungszweck durcheinander – bei zwanzig
+   * Einträgen unauffällig, bei achtzig unbenutzbar.
+   */
+  const [correspondents, setCorrespondents] = useState<Correspondent[]>([])
+  const [corrMenu, setCorrMenu] = useState<{ x: number; y: number; c: Correspondent } | null>(null)
+  const [renameCorr, setRenameCorr] = useState<Correspondent | null>(null)
+  const [deleteCorr, setDeleteCorr] = useState<Correspondent | null>(null)
+
+  useEffect(() => {
+    const reload = () => {
+      tagsApi.list().then(setTags).catch(() => { /* ohne Etiketten geht es auch */ })
+      correspondentsApi.list().then(setCorrespondents).catch(() => { /* ebenso */ })
+    }
+    reload()
+    // Sofort nachziehen, wenn irgendwo etikettiert wird – nicht erst beim
+    // nächsten Ansichtswechsel. Der Absender hängt am selben Dialog und am
+    // selben Ereignis.
+    window.addEventListener(tagsChangedEvent, reload)
+    return () => window.removeEventListener(tagsChangedEvent, reload)
+  }, [view, activeTagId, activeCorrespondentId])
+
+  const usedBytes = user.used_bytes || 0
+  const totalBytes = user.quota_bytes || 0
+  const quotaPct = totalBytes > 0 ? Math.min((usedBytes / totalBytes) * 100, 100) : 0
+
+  const [favorites, setFavorites] = useState<FavoriteItem[]>([])
+  const [dragOverId, setDragOverId] = useState<string | null>(null)
+  const dragItem = useRef<FavoriteItem | null>(null)
+
+  useEffect(() => {
+    favoritesApi.list()
+      .then(data => setFavorites(data ?? []))
+      .catch(() => {})
+  }, [])
+
+  function handleToggleExpand(fav: FavoriteItem) {
+    const next = !fav.is_expanded
+    setFavorites(fs => fs.map(f => f.folder_id === fav.folder_id ? { ...f, is_expanded: next } : f))
+    favoritesApi.setExpanded(fav.folder_id, next).catch(() => {})
+  }
+
+  function handleRemove(fav: FavoriteItem) {
+    setFavorites(fs => fs.filter(f => f.folder_id !== fav.folder_id))
+    favoritesApi.remove(fav.folder_id).catch(() => {})
+  }
+
+  function handleDragStart(e: React.DragEvent, fav: FavoriteItem) {
+    dragItem.current = fav
+    e.dataTransfer.setData('aether-favorite-id', fav.folder_id)
+    e.dataTransfer.effectAllowed = 'move'
+  }
+
+  function handleDragOver(e: React.DragEvent, fav: FavoriteItem) {
+    if (!e.dataTransfer.types.includes('aether-favorite-id')) return
+    e.preventDefault()
+    setDragOverId(fav.folder_id)
+  }
+
+  function handleDrop(e: React.DragEvent, target: FavoriteItem) {
+    e.preventDefault()
+    setDragOverId(null)
+    const src = dragItem.current
+    if (!src || src.folder_id === target.folder_id) return
+    dragItem.current = null
+
+    // Reorder locally
+    const next = [...favorites]
+    const srcIdx = next.findIndex(f => f.folder_id === src.folder_id)
+    const tgtIdx = next.findIndex(f => f.folder_id === target.folder_id)
+    next.splice(srcIdx, 1)
+    next.splice(tgtIdx, 0, src)
+    setFavorites(next)
+    favoritesApi.reorder(next.map(f => f.folder_id)).catch(() => {})
+  }
+
+  // Expose addFavorite so FileBrowser context menu can call it
+  ;(window as any).__aetherAddFavorite = async (folder: FolderItem) => {
+    try {
+      const fav = await favoritesApi.add(folder.id)
+      setFavorites(fs => [...fs, fav])
+    } catch { /* already favorite */ }
+  }
+  ;(window as any).__aetherRemoveFavorite = async (folderId: string) => {
+    setFavorites(fs => fs.filter(f => f.folder_id !== folderId))
+    await favoritesApi.remove(folderId).catch(() => {})
+  }
+  ;(window as any).__aetherIsFavorite = (folderId: string) =>
+    favorites.some(f => f.folder_id === folderId)
+
+  return (
+    <>
+      <aside className={`aether-sidebar${open ? ' aether-sidebar--open' : ''}`}>
+        {/* Brand */}
+        <div style={{ padding: '20px 16px 16px', display: 'flex', alignItems: 'center', gap: 10 }}>
+          {logoUrl ? (
+            <img
+              src={logoUrl}
+              alt=""
+              style={{ height: 30, maxWidth: 120, objectFit: 'contain', flexShrink: 0 }}
+            />
+          ) : (
+            <div style={{
+              width: 30, height: 30, borderRadius: 8,
+              background: 'var(--color-primary)',
+              display: 'flex', alignItems: 'center', justifyContent: 'center', flexShrink: 0,
+            }}>
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="white" strokeWidth="1.5">
+                <path strokeLinecap="round" strokeLinejoin="round"
+                  d="M2.25 15a4.5 4.5 0 004.5 4.5H18a3.75 3.75 0 001.332-7.257 3 3 0 00-3.758-3.848 5.25 5.25 0 00-10.233 2.33A4.502 4.502 0 002.25 15z" />
+              </svg>
+            </div>
+          )}
+          <span style={{ fontWeight: 700, fontSize: 16, color: 'var(--color-text)', letterSpacing: '-0.01em' }}>
+            {cloudName}
+          </span>
+        </div>
+
+        {/* Nav */}
+        <nav style={{ padding: '4px 8px' }}>
+          {nav.map(item => {
+            const active = view === item.id
+            return (
+              <button
+                key={item.id}
+                onClick={() => onNavigate(item.id)}
+                style={{
+                  width: '100%', display: 'flex', alignItems: 'center', gap: 10,
+                  padding: '8px 10px', borderRadius: 8,
+                  border: 'none', cursor: 'pointer',
+                  background: active ? 'rgba(var(--color-primary-rgb), 0.15)' : 'transparent',
+                  // Streifen links in der Akzentfarbe – die zweite Farbe braucht
+                  // eine Stelle, an der man sie tatsächlich sieht.
+                  boxShadow: active ? 'inset 3px 0 0 var(--color-accent)' : 'none',
+                  color: active ? 'var(--color-primary)' : 'var(--color-text-muted)',
+                  fontWeight: active ? 600 : 400, fontSize: 14, textAlign: 'left',
+                  transition: 'background 0.15s, color 0.15s', marginBottom: 2,
+                }}
+                onMouseEnter={e => { if (!active) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+                onMouseLeave={e => { if (!active) e.currentTarget.style.background = 'transparent' }}
+              >
+                {item.icon}
+                {item.label}
+              </button>
+            )
+          })}
+        </nav>
+
+        {/* Favourites */}
+        {favorites.length > 0 && (
+          <div style={{ padding: '8px 8px 0' }}>
+            <div style={{
+              fontSize: 10, fontWeight: 600, letterSpacing: '0.08em',
+              color: 'var(--color-text-muted)', padding: '4px 10px 6px',
+              textTransform: 'uppercase',
+            }}>
+              Favourites
+            </div>
+            <div onDragLeave={() => setDragOverId(null)}>
+              {favorites.map(fav => (
+                <FavoriteRow
+                  key={fav.folder_id}
+                  fav={fav}
+                  onNavigate={(id, name) => { onNavigate('files'); onNavigateToFolder(id, name) }}
+                  onRemove={handleRemove}
+                  onToggleExpand={handleToggleExpand}
+                  onDragStart={handleDragStart}
+                  onDragOver={handleDragOver}
+                  onDrop={handleDrop}
+                  dragOverId={dragOverId}
+                />
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* Etiketten */}
+        {tags.length > 0 && (
+          <div style={{ padding: '8px 8px 0' }}>
+            <div style={{
+              fontSize: 10, fontWeight: 600, letterSpacing: '0.08em',
+              color: 'var(--color-text-muted)', padding: '4px 10px 6px',
+              textTransform: 'uppercase',
+            }}>
+              Tags
+            </div>
+            {tags.map(tag => {
+              const active = view === 'tags' && activeTagId === tag.id
+              const color = tagColor(tag)
+              return (
+                <button
+                  key={tag.id}
+                  onClick={() => onOpenTag(tag.id)}
+                  // Rechtsklick öffnet Umbenennen/Farbe/Löschen – dieselbe
+                  // Geste wie bei Dateien und Ordnern.
+                  onContextMenu={e => {
+                    e.preventDefault()
+                    setTagMenu({ x: e.clientX, y: e.clientY, tag })
+                  }}
+                  title={(tag.group_id ? `${tag.name} — shared with ${tag.group_name}` : tag.name) + ' · right-click to edit'}
+                  style={{
+                    width: '100%', display: 'flex', alignItems: 'center', gap: 9,
+                    padding: '6px 10px', borderRadius: 8, border: 'none', cursor: 'pointer',
+                    background: active ? 'rgba(var(--color-primary-rgb), 0.15)' : 'transparent',
+                    color: active ? 'var(--color-text)' : 'var(--color-text-muted)',
+                    fontSize: 13, textAlign: 'left', marginBottom: 1,
+                  }}
+                  onMouseEnter={e => { if (!active) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+                  onMouseLeave={e => { if (!active) e.currentTarget.style.background = 'transparent' }}
+                >
+                  {/* Symbol, wenn eins gewählt ist – sonst der Farbpunkt.
+                      Nicht beides: Zwei Zeichen nebeneinander machen die
+                      Zeile unruhig, und das Symbol sagt ohnehin mehr. Ohne
+                      Symbol bleibt die Farbe die Wiedererkennung. */}
+                  {tag.icon ? (
+                    <span style={{
+                      width: 14, flexShrink: 0, fontSize: 13, lineHeight: 1,
+                      textAlign: 'center',
+                    }}>{tag.icon}</span>
+                  ) : (
+                    <span style={{
+                      width: 8, height: 8, marginLeft: 3, marginRight: 3,
+                      borderRadius: '50%', background: color, flexShrink: 0,
+                    }} />
+                  )}
+                  <span style={{
+                    flex: 1, minWidth: 0, overflow: 'hidden',
+                    textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                  }}>
+                    {tag.name}
+                  </span>
+                  <span style={{ fontSize: 11, color: 'var(--color-text-muted)', flexShrink: 0 }}>
+                    {tag.file_count}
+                  </span>
+                </button>
+              )
+            })}
+          </div>
+        )}
+
+        {/* Absender */}
+        {correspondents.length > 0 && (
+          <div style={{ padding: '8px 8px 0' }}>
+            <div style={{
+              fontSize: 10, fontWeight: 600, letterSpacing: '0.08em',
+              color: 'var(--color-text-muted)', padding: '4px 10px 6px',
+              textTransform: 'uppercase',
+            }}>
+              From
+            </div>
+            {correspondents.map(c => {
+              const active = view === 'from' && activeCorrespondentId === c.id
+              return (
+                <button
+                  key={c.id}
+                  onClick={() => onOpenCorrespondent(c.id)}
+                  onContextMenu={e => {
+                    e.preventDefault()
+                    setCorrMenu({ x: e.clientX, y: e.clientY, c })
+                  }}
+                  title={(c.group_id ? `${c.name} — shared with ${c.group_name}` : c.name) + ' · right-click to edit'}
+                  style={{
+                    width: '100%', display: 'flex', alignItems: 'center', gap: 9,
+                    padding: '6px 10px', borderRadius: 8, border: 'none', cursor: 'pointer',
+                    background: active ? 'rgba(var(--color-primary-rgb), 0.15)' : 'transparent',
+                    color: active ? 'var(--color-text)' : 'var(--color-text-muted)',
+                    fontSize: 13, textAlign: 'left', marginBottom: 1,
+                  }}
+                  onMouseEnter={e => { if (!active) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+                  onMouseLeave={e => { if (!active) e.currentTarget.style.background = 'transparent' }}
+                >
+                  {/* Gewähltes Symbol, sonst der Umschlag. Kein Farbpunkt wie
+                      beim Etikett: Ein Absender hat keine Farbe, und ein grauer
+                      Punkt wäre ein Etikett, das nichts bedeutet. */}
+                  {c.icon ? (
+                    <span style={{
+                      width: 14, flexShrink: 0, fontSize: 13, lineHeight: 1,
+                      textAlign: 'center',
+                    }}>{c.icon}</span>
+                  ) : (
+                    <span style={{ display: 'flex', flexShrink: 0, opacity: 0.75, width: 14, justifyContent: 'center' }}>
+                      <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+                           strokeWidth="2.2" strokeLinecap="round" strokeLinejoin="round">
+                        <rect x="2" y="5" width="20" height="14" rx="2" />
+                        <polyline points="2.5 6.5 12 13 21.5 6.5" />
+                      </svg>
+                    </span>
+                  )}
+                  <span style={{
+                    flex: 1, minWidth: 0, overflow: 'hidden',
+                    textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                  }}>
+                    {c.name}
+                  </span>
+                  <span style={{ fontSize: 11, color: 'var(--color-text-muted)', flexShrink: 0 }}>
+                    {c.file_count}
+                  </span>
+                </button>
+              )
+            })}
+          </div>
+        )}
+
+        <div style={{ flex: 1 }} />
+
+        {/* Unten links steht nur noch, was zum *Ort* gehört: wie voll er ist.
+            Der Nutzerbereich sitzt seit dem 23.08.2026 oben rechts in der
+            Kopfleiste (components/UserMenu.tsx) – dort suchen Menschen den
+            eigenen Zugang, und das Abmelden liegt nicht mehr einen Fehlklick
+            neben dem Weg zu den Einstellungen. */}
+        {totalBytes > 0 && (
+          <div style={{
+            // Unterer Abstand plus Wischbalken – sonst läge der Balken in der
+            // installierten App hinter der Systemleiste.
+            padding: '12px 16px calc(16px + var(--safe-bottom))',
+            borderTop: '1px solid var(--color-border)',
+          }}>
+            <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 4 }}>
+              <span style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>Storage</span>
+              <span style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>
+                {formatBytes(usedBytes)} / {formatBytes(totalBytes)}
+              </span>
+            </div>
+            <div style={{ height: 4, background: 'var(--color-surface-2)', borderRadius: 999 }}>
+              <div style={{
+                width: `${quotaPct}%`, height: '100%', borderRadius: 999,
+                background: quotaPct > 90 ? 'var(--color-danger)' : 'var(--color-primary)',
+                transition: 'width 0.3s',
+              }} />
+            </div>
+          </div>
+        )}
+
+      </aside>
+
+      {tagMenu && (
+        <ContextMenu
+          x={tagMenu.x}
+          y={tagMenu.y}
+          onClose={() => setTagMenu(null)}
+          items={[
+            { label: 'Edit…', icon: <RenameIcon />, onClick: () => setEditTag(tagMenu.tag) },
+            { separator: true },
+            { label: 'Delete', icon: <TrashIcon />, danger: true, onClick: () => setDeleteTag(tagMenu.tag) },
+          ]}
+        />
+      )}
+
+      {corrMenu && (
+        <ContextMenu
+          x={corrMenu.x}
+          y={corrMenu.y}
+          onClose={() => setCorrMenu(null)}
+          items={[
+            { label: 'Rename…', icon: <RenameIcon />, onClick: () => setRenameCorr(corrMenu.c) },
+            { separator: true },
+            { label: 'Delete', icon: <TrashIcon />, danger: true, onClick: () => setDeleteCorr(corrMenu.c) },
+          ]}
+        />
+      )}
+
+      {renameCorr && (
+        <CorrespondentRenameDialog
+          correspondent={renameCorr}
+          onClose={() => setRenameCorr(null)}
+          onChanged={updated => {
+            setCorrespondents(prev => prev.map(c => (c.id === updated.id ? { ...c, ...updated } : c)))
+          }}
+        />
+      )}
+
+      {deleteCorr && (
+        <ConfirmDialog
+          title={`Delete “${deleteCorr.name}”?`}
+          // Die wichtigste Zeile hier: Der Absender verschwindet, die
+          // Rechnungen bleiben. Ohne diesen Satz klingt „Delete" nach dem
+          // Gegenteil, und niemand traut sich, aufzuräumen.
+          message={
+            deleteCorr.file_count > 0
+              ? `${deleteCorr.file_count} ${deleteCorr.file_count === 1 ? 'document loses' : 'documents lose'} this sender. The documents themselves stay where they are — nothing is deleted.`
+              : 'Nothing is from this sender yet.'
+          }
+          confirmLabel="Delete"
+          danger
+          onCancel={() => setDeleteCorr(null)}
+          onConfirm={async () => {
+            try {
+              await correspondentsApi.remove(deleteCorr.id)
+              setCorrespondents(prev => prev.filter(c => c.id !== deleteCorr.id))
+              notifyTagsChanged()
+            } finally {
+              setDeleteCorr(null)
+            }
+          }}
+        />
+      )}
+
+      {editTag && (
+        <TagEditDialog
+          tag={editTag}
+          onClose={() => setEditTag(null)}
+          onChanged={updated => setTags(prev => prev.map(t => t.id === updated.id ? { ...t, ...updated } : t))}
+        />
+      )}
+
+      {deleteTag && (
+        <ConfirmDialog
+          title={`Delete “${deleteTag.name}”?`}
+          // Ausdrücklich sagen, was *nicht* passiert. Ein Etikett zu löschen
+          // ist eine Aussage über die Ordnung, nicht über den Bestand – aber
+          // das weiß man in dem Moment nicht, und dann klickt man lieber ab.
+          message={
+            deleteTag.file_count > 0
+              ? `The tag is removed from ${deleteTag.file_count} ${deleteTag.file_count === 1 ? 'file' : 'files'}. The files themselves stay where they are — nothing is deleted.`
+              : 'No file carries this tag. Nothing else changes.'
+          }
+          confirmLabel="Delete tag"
+          danger
+          onCancel={() => setDeleteTag(null)}
+          onConfirm={async () => {
+            try {
+              await tagsApi.remove(deleteTag.id)
+              notifyTagsChanged()
+              setTags(prev => prev.filter(t => t.id !== deleteTag.id))
+            } catch { /* bleibt stehen, dann sieht man es beim nächsten Laden */ }
+            setDeleteTag(null)
+          }}
+        />
+      )}
+
+      <style>{`
+        .aether-sidebar {
+          width: 220px;
+          /* Statusleiste oben, Aussparung links (Querformat). */
+          padding-top: var(--safe-top);
+          padding-left: var(--safe-left);
+          flex-shrink: 0;
+          display: flex;
+          flex-direction: column;
+          background: var(--color-surface);
+          border-right: 1px solid var(--color-border);
+          height: 100vh;
+          overflow-y: auto;
+          overflow-x: hidden;
+        }
+        @media (max-width: 767px) {
+          .aether-sidebar {
+            position: fixed;
+            top: 0; left: 0;
+            z-index: 50;
+            transform: translateX(-100%);
+            transition: transform 0.2s ease;
+          }
+          .aether-sidebar--open {
+            transform: translateX(0);
+          }
+        }
+      `}</style>
+    </>
+  )
+}
diff --git a/frontend/src/components/Tabs.tsx b/frontend/src/components/Tabs.tsx
new file mode 100644
index 0000000..36da44f
--- /dev/null
+++ b/frontend/src/components/Tabs.tsx
@@ -0,0 +1,45 @@
+/**
+ * Die Reiterleiste – eine Definition für Admin-Bereich und Einstellungen.
+ *
+ * Beide hatten sie zunächst eigen im Code stehen. Zwei Kopien derselben Leiste
+ * laufen mit der Zeit auseinander: Die eine bekommt eine andere Schriftstärke,
+ * die andere einen anderen Abstand, und beim Umschalten merkt man den
+ * Unterschied, ohne ihn benennen zu können. Genau das ist bei den Kopfleisten
+ * schon einmal passiert (siehe components/PageHeader.tsx).
+ */
+interface Props<T extends string> {
+  tabs: { id: T; label: string }[]
+  active: T
+  onChange: (id: T) => void
+}
+
+export default function Tabs<T extends string>({ tabs, active, onChange }: Props<T>) {
+  return (
+    <div style={{
+      display: 'flex', gap: 4, marginBottom: 24,
+      borderBottom: '1px solid var(--color-border)',
+      // Ein Pixel Innenrand, damit die Unterstreichung des aktiven Reiters
+      // genau auf der Trennlinie sitzt statt darunter.
+      paddingBottom: 1,
+      overflowX: 'auto',
+    }}>
+      {tabs.map(t => (
+        <button
+          key={t.id}
+          onClick={() => onChange(t.id)}
+          style={{
+            padding: '8px 18px', border: 'none', cursor: 'pointer', fontSize: 14,
+            background: 'transparent', whiteSpace: 'nowrap', flexShrink: 0,
+            color: active === t.id ? 'var(--color-primary)' : 'var(--color-text-muted)',
+            fontWeight: active === t.id ? 700 : 400,
+            borderBottom: active === t.id ? '2px solid var(--color-primary)' : '2px solid transparent',
+            marginBottom: -1,
+            transition: 'color 0.15s',
+          }}
+        >
+          {t.label}
+        </button>
+      ))}
+    </div>
+  )
+}
diff --git a/frontend/src/components/TagChip.tsx b/frontend/src/components/TagChip.tsx
new file mode 100644
index 0000000..fce9761
--- /dev/null
+++ b/frontend/src/components/TagChip.tsx
@@ -0,0 +1,84 @@
+import type { Tag } from '../api/client'
+
+/**
+ * Die Farbe eines Etiketts.
+ *
+ * Ohne eigene Farbe wird eine aus dem Namen abgeleitet – immer dieselbe für
+ * denselben Namen. Der Grund: Ein frisch angelegtes Etikett soll nicht grau
+ * sein und erst eingefärbt werden müssen, aber zwei verschiedene Etiketten
+ * sollen auch nicht zufällig gleich aussehen.
+ */
+export const tagPalette = [
+  '#8b5cf6', '#ec4899', '#06b6d4', '#ef4444', '#f59e0b',
+  '#22c55e', '#3b82f6', '#14b8a6', '#ea580c', '#6366f1',
+]
+const palette = tagPalette
+
+export function tagColor(tag: { name: string; color?: string }): string {
+  if (tag.color) return tag.color
+  // Einfache Summe über die Zeichen. Keine Streuwertfunktion nötig – es geht
+  // nur darum, dass dieselbe Eingabe stets dieselbe Farbe ergibt.
+  let sum = 0
+  for (const ch of tag.name) sum += ch.codePointAt(0) ?? 0
+  return palette[sum % palette.length]
+}
+
+/** Aufkleber, wie er an Kacheln und in Listen erscheint. */
+export default function TagChip({ tag, size = 'md', onRemove }: {
+  tag: Pick<Tag, 'name' | 'color'> & { icon?: string; group_id?: string }
+  size?: 'sm' | 'md'
+  onRemove?: () => void
+}) {
+  const color = tagColor(tag)
+  const small = size === 'sm'
+  return (
+    <span style={{
+      display: 'inline-flex', alignItems: 'center', gap: 5,
+      padding: small ? '1px 6px' : '3px 9px',
+      borderRadius: 999,
+      fontSize: small ? 10 : 12,
+      fontWeight: 600,
+      lineHeight: 1.5,
+      color,
+      background: `${color}22`,
+      border: `1px solid ${color}55`,
+      maxWidth: '100%',
+      overflow: 'hidden',
+    }}>
+      {/* Gruppen-Etiketten bekommen ein Zeichen davor: Sonst wundert man sich,
+          warum ein Etikett plötzlich bei jemand anderem auftaucht. */}
+      {tag.group_id && (
+        <svg width={small ? 8 : 10} height={small ? 8 : 10} viewBox="0 0 24 24"
+             fill="none" stroke="currentColor" strokeWidth="2.5" style={{ flexShrink: 0 }}>
+          <circle cx="9" cy="8" r="3" /><path d="M3 20v-1a5 5 0 015-5h2a5 5 0 015 5v1" />
+          <path d="M17 11a3 3 0 100-6" /><path d="M20 20v-1a4 4 0 00-2.5-3.7" />
+        </svg>
+      )}
+      {/* Das Symbol steht vor dem Namen und **behält seine eigenen Farben**:
+          Ein Emoji einzufärben ginge nicht, und es soll auch nicht – gerade
+          die Farbigkeit macht es auf einen Blick unterscheidbar. */}
+      {tag.icon && (
+        <span style={{ flexShrink: 0, fontSize: small ? 10 : 12, lineHeight: 1 }}>
+          {tag.icon}
+        </span>
+      )}
+      <span style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+        {tag.name}
+      </span>
+      {onRemove && (
+        <button
+          onClick={e => { e.stopPropagation(); onRemove() }}
+          title={`Remove ${tag.name}`}
+          style={{
+            border: 'none', background: 'none', cursor: 'pointer', padding: 0,
+            color, display: 'flex', flexShrink: 0, opacity: 0.7,
+          }}
+        >
+          <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="3">
+            <line x1="5" y1="5" x2="19" y2="19" /><line x1="19" y1="5" x2="5" y2="19" />
+          </svg>
+        </button>
+      )}
+    </span>
+  )
+}
diff --git a/frontend/src/components/TagDialog.tsx b/frontend/src/components/TagDialog.tsx
new file mode 100644
index 0000000..c8b279d
--- /dev/null
+++ b/frontend/src/components/TagDialog.tsx
@@ -0,0 +1,340 @@
+import { useEffect, useState } from 'react'
+import { tagsApi, correspondentsApi, notifyTagsChanged, APIError, type Correspondent, type FileItem, type Tag } from '../api/client'
+import TagChip, { tagColor, tagPalette } from './TagChip'
+import { ColourPicker, IconPicker } from './TagEditDialog'
+
+/**
+ * Etiketten, Belegdatum und Absender einer Datei setzen.
+ *
+ * Alles drei in einem Dialog und in einem Aufruf: Wer eine Rechnung
+ * einsortiert, setzt „steuer-2026", das Rechnungsdatum und „Stadtwerke" in
+ * derselben Handlung. Der Server schreibt sie in einer Transaktion – entweder
+ * gilt alles oder nichts.
+ */
+interface Props {
+  file: FileItem
+  /** Etiketten, die diese Datei schon trägt. */
+  current: Tag[]
+  /** Absender, den sie schon trägt – oder keiner. */
+  currentCorrespondent?: Correspondent
+  onClose: () => void
+  onSaved: (tags: Tag[]) => void
+}
+
+export default function TagDialog({ file, current, currentCorrespondent, onClose, onSaved }: Props) {
+  const [all, setAll] = useState<Tag[]>([])
+  const [chosen, setChosen] = useState<Set<string>>(() => new Set(current.map(t => t.id)))
+  // Der Server liefert einen vollen Zeitstempel („2026-01-15T00:00:00Z"), ein
+  // <input type="date"> versteht aber nur „2026-01-15" und zeigt sonst
+  // kommentarlos ein leeres Feld – der gesetzte Wert sah damit aus wie keiner.
+  const [date, setDate] = useState((file.document_date ?? '').slice(0, 10))
+  const [newName, setNewName] = useState('')
+  /** Farbe für das nächste neue Etikett. Vorgewählt ist eine aus der Palette,
+   *  damit man nichts wählen *muss* – aber sichtbar, damit man es kann. */
+  const [newColor, setNewColor] = useState(tagPalette[0])
+  /** Symbol für das nächste neue Etikett. Leer ist die Vorgabe – ein Emoji
+   *  ist ein Angebot, keine Pflicht. */
+  const [newIcon, setNewIcon] = useState('')
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  /**
+   * Der Absender steht als **Text** im Feld, nicht als ausgewählte ID.
+   *
+   * Ein Auswahlfeld zwänge dazu, den Absender vorher irgendwo anzulegen –
+   * beim Einsortieren des ersten Belegs von „Stadtwerke" gäbe es ihn aber
+   * noch gar nicht. Ein Textfeld mit Vorschlägen kann beides: das Vorhandene
+   * treffen (Vorschlagsliste) und Neues anlegen (einfach tippen).
+   *
+   * Der Server sucht den Namen und legt ihn nur an, wenn es ihn nicht gibt –
+   * ohne Rücksicht auf Groß-/Kleinschreibung. „stadtwerke" landet also beim
+   * vorhandenen „Stadtwerke" und erzeugt keinen Zwilling.
+   */
+  const [correspondent, setCorrespondent] = useState(currentCorrespondent?.name ?? '')
+  const [knownCorrespondents, setKnownCorrespondents] = useState<Correspondent[]>([])
+
+  useEffect(() => {
+    tagsApi.list().then(setAll).catch(() => setError('Could not load tags'))
+    correspondentsApi.list().then(setKnownCorrespondents).catch(() => {
+      /* ohne Vorschläge geht es auch – tippen kann man trotzdem */
+    })
+  }, [])
+
+  /**
+   * Nur Etiketten desselben Eigentümers sind erlaubt – eine Datei im
+   * Gruppenordner trägt Gruppen-Etiketten, eine eigene die eigenen. Der Server
+   * lehnt alles andere ab; die Liste hier zeigt deshalb gar nicht erst, was
+   * nicht ginge.
+   */
+  const usable = all.filter(t => (file.group_id ? t.group_id === file.group_id : !t.group_id))
+
+  /**
+   * Etikett anlegen – oder das gleichnamige nehmen, wenn es es schon gibt.
+   *
+   * **Warum kein Fehler bei einem vorhandenen Namen:** Die Liste in diesem
+   * Dialog wird beim Öffnen einmal geholt. Legt man anderswo ein Etikett an –
+   * in einem zweiten Fenster, im vorigen Dialog –, kennt sie es nicht. Man
+   * tippt den Namen, bekommt „That name is already taken", sieht das Etikett
+   * aber nirgends und hält die Anwendung für kaputt. Genau das ist Marc am
+   * 24.08.2026 passiert.
+   *
+   * Richtig ist ohnehin, was der Mensch meint: Er will die Datei mit „Finanz"
+   * versehen. Ob das Etikett dafür neu entsteht oder schon existierte, ist
+   * seine Sache nicht.
+   */
+  async function createTag() {
+    const name = newName.trim()
+    if (!name) return
+    setBusy(true); setError(null)
+    try {
+      const tag = await tagsApi.create(name, newColor, file.group_id ?? undefined, newIcon)
+      setAll(prev => [...prev, tag])
+      notifyTagsChanged()
+      setChosen(prev => new Set(prev).add(tag.id))
+      setNewName('')
+      setNewIcon('')
+      // Nächste Farbe vorwählen, damit zwei nacheinander angelegte Etiketten
+      // nicht zufällig gleich aussehen.
+      setNewColor(prev => tagPalette[(tagPalette.indexOf(prev) + 1) % tagPalette.length])
+    } catch (err) {
+      if (err instanceof APIError && err.status === 409) {
+        // Es gibt es schon – Liste neu holen und das gleichnamige anhaken.
+        try {
+          const fresh = await tagsApi.list()
+          setAll(fresh)
+          const hit = fresh.find(t => t.name.toLowerCase() === name.toLowerCase())
+          if (hit) {
+            setChosen(prev => new Set(prev).add(hit.id))
+            setNewName('')
+            return
+          }
+        } catch { /* dann eben die Meldung unten */ }
+      }
+      // Ab hier sagt der Server, was los war – nicht mehr dieser Dialog. Die
+      // frühere feste Meldung „That name is already taken" behauptete eine
+      // Ursache und lag bei jedem anderen Fehler daneben.
+      setError(err instanceof Error ? err.message : 'Could not create the tag')
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  async function save() {
+    setBusy(true); setError(null)
+    try {
+      // Ein geleertes Feld heißt „kein Absender mehr" – deshalb die leere ID
+      // statt des leeren Namens: Ein leerer Name hieße „nicht mitgeschickt".
+      const name = correspondent.trim()
+      const tags = await tagsApi.setForFile(file.id, [...chosen], date,
+        name ? { name } : { id: '' })
+      notifyTagsChanged()
+      onSaved(tags)
+      onClose()
+    } catch (err) {
+      // Auch hier: die Meldung des Servers statt einer geratenen. „check the
+      // date" stand vorher selbst dann da, wenn gar kein Datum im Spiel war.
+      setError(err instanceof Error ? err.message : 'Could not save')
+      setBusy(false)
+    }
+  }
+
+  function toggle(id: string) {
+    setChosen(prev => {
+      const next = new Set(prev)
+      next.has(id) ? next.delete(id) : next.add(id)
+      return next
+    })
+  }
+
+  return (
+    <div
+      onClick={onClose}
+      style={{
+        position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.55)',
+        display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 200, padding: 20,
+      }}
+    >
+      <div
+        onClick={e => e.stopPropagation()}
+        style={{
+          width: 460, maxWidth: '100%', maxHeight: '85vh', overflowY: 'auto',
+          background: 'var(--color-surface)', border: '1px solid var(--color-border)',
+          borderRadius: 14, padding: 22, boxShadow: '0 20px 60px rgba(0,0,0,0.5)',
+        }}
+      >
+        <h3 style={{ margin: '0 0 4px', fontSize: 15, fontWeight: 700, color: 'var(--color-text)' }}>
+          Organise
+        </h3>
+        <p style={{
+          margin: '0 0 18px', fontSize: 12, color: 'var(--color-text-muted)',
+          overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+        }}>
+          {file.name}
+        </p>
+
+        {usable.length > 0 && (
+          <div style={{ display: 'flex', flexWrap: 'wrap', gap: 7, marginBottom: 18 }}>
+            {usable.map(tag => {
+              const on = chosen.has(tag.id)
+              const color = tagColor(tag)
+              return (
+                <button
+                  key={tag.id}
+                  onClick={() => toggle(tag.id)}
+                  style={{
+                    padding: '4px 11px', borderRadius: 999, cursor: 'pointer',
+                    fontSize: 12, fontWeight: 600,
+                    // Gewählt heißt gefüllt, ungewählt nur umrandet. Ein
+                    // Häkchen daneben wäre bei zwanzig Etiketten unruhig.
+                    color: on ? color : 'var(--color-text-muted)',
+                    background: on ? `${color}22` : 'transparent',
+                    border: `1px solid ${on ? `${color}88` : 'var(--color-border)'}`,
+                    transition: 'all 0.12s',
+                  }}
+                >
+                  {tag.name}
+                </button>
+              )
+            })}
+          </div>
+        )}
+
+        {/* Neues Etikett direkt hier anlegen. Ein eigener Verwaltungsdialog
+            wäre ein Umweg: Man merkt beim Einsortieren, dass eins fehlt. */}
+        <div style={{ display: 'flex', gap: 8, marginBottom: 10 }}>
+          <input
+            value={newName}
+            onChange={e => setNewName(e.target.value)}
+            onKeyDown={e => { if (e.key === 'Enter') { e.preventDefault(); void createTag() } }}
+            placeholder={file.group_id ? 'New group tag…' : 'New tag…'}
+            style={{
+              flex: 1, padding: '7px 10px', borderRadius: 8, fontSize: 13,
+              border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+              color: 'var(--color-text)', outline: 'none',
+            }}
+          />
+          <button
+            onClick={() => void createTag()}
+            disabled={!newName.trim() || busy}
+            style={{
+              padding: '7px 14px', borderRadius: 8, fontSize: 12, fontWeight: 600,
+              border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+              color: 'var(--color-text)', cursor: newName.trim() ? 'pointer' : 'default',
+              opacity: newName.trim() ? 1 : 0.5,
+            }}
+          >
+            Add
+          </button>
+        </div>
+
+        {/* Farbwahl erscheint erst beim Tippen: Solange man nichts anlegt, ist
+            sie nur Fläche, die vom Wesentlichen ablenkt. */}
+        {newName.trim() && (
+          <div style={{ marginBottom: 18 }}>
+            <ColourPicker value={newColor} onChange={setNewColor} />
+            <div style={{ marginTop: 12 }}>
+              <IconPicker value={newIcon} onChange={setNewIcon} />
+            </div>
+          </div>
+        )}
+
+        <label style={{ display: 'block', fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)', marginBottom: 4 }}>
+          From
+        </label>
+        <input
+          list="aether-correspondents"
+          value={correspondent}
+          onChange={e => setCorrespondent(e.target.value)}
+          placeholder="Stadtwerke, Amazon, Finanzamt…"
+          maxLength={80}
+          style={{
+            width: '100%', padding: '7px 10px', borderRadius: 8, fontSize: 13,
+            border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+            color: 'var(--color-text)', outline: 'none',
+          }}
+        />
+        {/* Vorschläge aus dem Bestand. Ein <datalist> statt einer eigenen
+            Auswahlliste: Der Browser bringt Filtern, Tastaturbedienung und die
+            Darstellung am Telefon schon mit, und tippen bleibt trotzdem
+            möglich – genau das braucht ein Feld, das Vorhandenes treffen *und*
+            Neues anlegen können muss. */}
+        <datalist id="aether-correspondents">
+          {knownCorrespondents
+            .filter(c => (file.group_id ? c.group_id === file.group_id : !c.group_id))
+            .map(c => <option key={c.id} value={c.name} />)}
+        </datalist>
+        <p style={{ margin: '6px 0 18px', fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+          Who the document is from. Exactly one — unlike tags. A new name is
+          created as you save it.
+        </p>
+
+        <label style={{ display: 'block', fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)', marginBottom: 4 }}>
+          Document date
+        </label>
+        <input
+          type="date"
+          value={date}
+          onChange={e => setDate(e.target.value)}
+          style={{
+            width: '100%', padding: '7px 10px', borderRadius: 8, fontSize: 13,
+            border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+            color: 'var(--color-text)', outline: 'none', colorScheme: 'dark',
+          }}
+        />
+        <p style={{ margin: '6px 0 0', fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+          The date printed on the document — not when you uploaded it. A receipt
+          from December scanned in January still belongs to the old year.
+        </p>
+
+        {error && (
+          <p style={{ margin: '14px 0 0', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>
+        )}
+
+        <div style={{ display: 'flex', justifyContent: 'flex-end', gap: 10, marginTop: 22 }}>
+          <button
+            onClick={onClose}
+            style={{
+              padding: '8px 16px', border: 'none', background: 'none', cursor: 'pointer',
+              fontSize: 13, color: 'var(--color-text-muted)',
+            }}
+          >
+            Cancel
+          </button>
+          <button
+            onClick={() => void save()}
+            disabled={busy}
+            style={{
+              padding: '8px 18px', borderRadius: 8, border: 'none', cursor: 'pointer',
+              fontSize: 13, fontWeight: 600, color: '#fff',
+              background: 'var(--color-primary)', opacity: busy ? 0.6 : 1,
+            }}
+          >
+            {busy ? 'Saving…' : 'Save'}
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+/** Kleine Reihe Aufkleber, wie sie unter einer Kachel steht. */
+export function TagRow({ tags, max = 3 }: { tags: Tag[]; max?: number }) {
+  if (tags.length === 0) return null
+  const shown = tags.slice(0, max)
+  const rest = tags.length - shown.length
+  return (
+    <div style={{
+      display: 'flex', gap: 4, minWidth: 0,
+      // Kein Umbruch: In einer Kachelzeile ist eine zweite Zeile genau das,
+      // was hier vermieden werden soll. Was nicht passt, wird zu „+n".
+      overflow: 'hidden',
+    }}>
+      {shown.map(t => <TagChip key={t.id} tag={t} size="sm" />)}
+      {rest > 0 && (
+        <span style={{ fontSize: 10, color: 'var(--color-text-muted)', alignSelf: 'center' }}>
+          +{rest}
+        </span>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/components/TagEditDialog.tsx b/frontend/src/components/TagEditDialog.tsx
new file mode 100644
index 0000000..720dac3
--- /dev/null
+++ b/frontend/src/components/TagEditDialog.tsx
@@ -0,0 +1,322 @@
+import { useState } from 'react'
+import { tagsApi, correspondentsApi, notifyTagsChanged, type Correspondent, type Tag } from '../api/client'
+import { tagPalette, tagColor } from './TagChip'
+
+/**
+ * Ein Etikett umbenennen, einfärben oder löschen.
+ *
+ * Erreichbar über Rechtsklick in der Seitenleiste – dort, wo die Etiketten
+ * stehen. Ein eigener Verwaltungsbereich im Admin-Panel wäre der falsche Ort:
+ * Etiketten gehören dem Einzelnen, nicht der Anlage.
+ */
+export default function TagEditDialog({ tag, onClose, onChanged }: {
+  tag: Tag
+  onClose: () => void
+  onChanged: (tag: Tag) => void
+}) {
+  const [name, setName] = useState(tag.name)
+  const [color, setColor] = useState(tag.color || tagColor(tag))
+  const [icon, setIcon] = useState(tag.icon ?? '')
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  async function save() {
+    if (!name.trim()) { setError('Name must not be empty'); return }
+    setBusy(true); setError(null)
+    try {
+      const updated = await tagsApi.update(tag.id, name.trim(), color, icon)
+      notifyTagsChanged()
+      onChanged(updated)
+      onClose()
+    } catch {
+      setError('That name is already taken')
+      setBusy(false)
+    }
+  }
+
+  return (
+    <div
+      onClick={onClose}
+      style={{
+        position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.55)',
+        display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 220, padding: 20,
+      }}
+    >
+      <div
+        onClick={e => e.stopPropagation()}
+        style={{
+          width: 380, maxWidth: '100%',
+          background: 'var(--color-surface)', border: '1px solid var(--color-border)',
+          borderRadius: 14, padding: 22, boxShadow: '0 20px 60px rgba(0,0,0,0.5)',
+        }}
+      >
+        <h3 style={{ margin: '0 0 18px', fontSize: 15, fontWeight: 700, color: 'var(--color-text)' }}>
+          Edit tag
+        </h3>
+
+        <label style={{ display: 'block', fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)', marginBottom: 4 }}>
+          Name
+        </label>
+        <input
+          value={name}
+          autoFocus
+          onChange={e => setName(e.target.value)}
+          onKeyDown={e => { if (e.key === 'Enter') void save() }}
+          style={{
+            width: '100%', padding: '8px 11px', borderRadius: 8, fontSize: 13, marginBottom: 18,
+            border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+            color: 'var(--color-text)', outline: 'none',
+          }}
+        />
+
+        <label style={{ display: 'block', fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)', marginBottom: 8 }}>
+          Colour
+        </label>
+        <ColourPicker value={color} onChange={setColor} />
+
+        <div style={{ marginTop: 16, marginBottom: 4, fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)' }}>
+          Icon
+        </div>
+        <IconPicker value={icon} onChange={setIcon} />
+
+        {/* Vorschau: Die Farbe wirkt am Aufkleber anders als am nackten Punkt,
+            weil sie dort nur als Rahmen und Hintergrundhauch auftaucht. */}
+        <div style={{ marginTop: 14, fontSize: 11, color: 'var(--color-text-muted)' }}>
+          Preview:{' '}
+          <span style={{
+            display: 'inline-flex', padding: '3px 9px', borderRadius: 999,
+            fontSize: 12, fontWeight: 600, color,
+            background: `${color}22`, border: `1px solid ${color}55`,
+          }}>
+            {icon && <span style={{ marginRight: 5 }}>{icon}</span>}
+            {name.trim() || 'tag'}
+          </span>
+        </div>
+
+        {error && <p style={{ margin: '14px 0 0', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>}
+
+        {/* Löschen sitzt im Menü davor, nicht hier: Ein Dialog, in dem
+            „Save" und „Delete" nebeneinander liegen, lädt zum Fehlgriff ein. */}
+        <div style={{ display: 'flex', justifyContent: 'flex-end', marginTop: 24, gap: 10 }}>
+          <button
+            onClick={onClose}
+            style={{
+              padding: '8px 16px', border: 'none', background: 'none', cursor: 'pointer',
+              fontSize: 13, color: 'var(--color-text-muted)',
+            }}
+          >
+            Cancel
+          </button>
+          <button
+            onClick={() => void save()}
+            disabled={busy}
+            style={{
+              padding: '8px 18px', borderRadius: 8, border: 'none', cursor: 'pointer',
+              fontSize: 13, fontWeight: 600, color: '#fff',
+              background: 'var(--color-primary)', opacity: busy ? 0.6 : 1,
+            }}
+          >
+            Save
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+/** Farbwahl aus einer festen Reihe. */
+/**
+ * Die angebotenen Symbole.
+ *
+ * Bewusst eine **kurze, geordnete Auswahl** statt der vollen Emoji-Tastatur:
+ * Bei 3000 Möglichkeiten wählt man beim zweiten Etikett ein anderes Bild für
+ * dieselbe Sache. Zwanzig Vorschläge decken ab, wofür Menschen Dokumente
+ * ablegen – wer etwas anderes will, tippt es ins Feld daneben.
+ */
+export const iconChoices = [
+  '🧾', '💶', '🎓', '📚', '🏛️', '⚡', '🏠', '🚗', '🏥', '🛒',
+  '📦', '✈️', '🔧', '💼', '📱', '🐾', '🎁', '📄', '⭐', '🔒',
+]
+
+/**
+ * Symbolwahl. „Kein Symbol" steht als erste Möglichkeit dabei – sonst wäre
+ * ein einmal gewähltes Emoji nicht mehr loszuwerden.
+ */
+export function IconPicker({ value, onChange }: { value: string; onChange: (i: string) => void }) {
+  return (
+    <div>
+      <div style={{ display: 'flex', flexWrap: 'wrap', gap: 6 }}>
+        <button
+          onClick={() => onChange('')}
+          title="No icon"
+          style={{
+            width: 30, height: 30, borderRadius: 8, cursor: 'pointer',
+            border: `2px solid ${value === '' ? 'var(--color-text)' : 'var(--color-border)'}`,
+            background: 'var(--color-surface-2)', color: 'var(--color-text-muted)',
+            display: 'flex', alignItems: 'center', justifyContent: 'center', padding: 0,
+          }}
+        >
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5">
+            <line x1="5" y1="19" x2="19" y2="5" />
+          </svg>
+        </button>
+        {iconChoices.map(ic => (
+          <button
+            key={ic}
+            onClick={() => onChange(ic)}
+            style={{
+              width: 30, height: 30, borderRadius: 8, cursor: 'pointer', fontSize: 15,
+              border: `2px solid ${value === ic ? 'var(--color-text)' : 'transparent'}`,
+              background: 'var(--color-surface-2)', padding: 0, lineHeight: 1,
+            }}
+          >
+            {ic}
+          </button>
+        ))}
+      </div>
+      {/* Freies Feld für alles, was nicht in der Auswahl steht. Zwei Wege zum
+          selben Ziel sind hier richtig: Die Auswahl ist schnell, das Feld ist
+          vollständig. */}
+      <input
+        value={value}
+        onChange={e => onChange(e.target.value)}
+        placeholder="or paste any emoji"
+        maxLength={16}
+        style={{
+          marginTop: 8, width: 150, padding: '5px 9px', borderRadius: 8, fontSize: 13,
+          border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+          color: 'var(--color-text)', outline: 'none',
+        }}
+      />
+    </div>
+  )
+}
+
+export function ColourPicker({ value, onChange }: { value: string; onChange: (c: string) => void }) {
+  return (
+    <div style={{ display: 'flex', flexWrap: 'wrap', gap: 8 }}>
+      {tagPalette.map(c => (
+        <button
+          key={c}
+          onClick={() => onChange(c)}
+          title={c}
+          style={{
+            width: 26, height: 26, borderRadius: '50%', cursor: 'pointer',
+            background: c,
+            // Der gewählte Kreis bekommt einen Ring mit Abstand statt eines
+            // Häkchens: Auf dunklen Farben wäre ein weißes Häkchen kaum zu
+            // sehen, auf hellen ein schwarzes.
+            border: value === c ? '2px solid var(--color-surface)' : '2px solid transparent',
+            boxShadow: value === c ? `0 0 0 2px ${c}` : 'none',
+            transition: 'box-shadow 0.12s',
+          }}
+        />
+      ))}
+    </div>
+  )
+}
+
+/**
+ * Einen Absender umbenennen.
+ *
+ * Weniger als beim Etikett – ein Absender hat keine Farbe. Umbenennen ist
+ * dafür wichtiger als dort: Aus „Amazon" wird „Amazon EU S.à r.l.", und alle
+ * bisherigen Rechnungen sollen mitkommen. Genau das leistet ein eigenes Feld
+ * gegenüber einem in den Dateinamen geschriebenen Absender.
+ */
+export function CorrespondentRenameDialog({ correspondent, onClose, onChanged }: {
+  correspondent: Correspondent
+  onClose: () => void
+  onChanged: (c: Correspondent) => void
+}) {
+  const [name, setName] = useState(correspondent.name)
+  const [icon, setIcon] = useState(correspondent.icon ?? '')
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  async function save() {
+    if (!name.trim()) { setError('Name must not be empty'); return }
+    setBusy(true); setError(null)
+    try {
+      const updated = await correspondentsApi.update(correspondent.id, name.trim(), icon)
+      notifyTagsChanged()
+      onChanged(updated)
+      onClose()
+    } catch {
+      setError('That name is already taken')
+      setBusy(false)
+    }
+  }
+
+  return (
+    <div
+      onClick={onClose}
+      style={{
+        position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.55)',
+        display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 300, padding: 20,
+      }}
+    >
+      <div
+        onClick={e => e.stopPropagation()}
+        style={{
+          width: 360, maxWidth: '100%', background: 'var(--color-surface)',
+          border: '1px solid var(--color-border)', borderRadius: 14, padding: 22,
+          boxShadow: '0 20px 60px rgba(0,0,0,0.5)',
+        }}
+      >
+        <h3 style={{ margin: '0 0 16px', fontSize: 15, fontWeight: 700, color: 'var(--color-text)' }}>
+          Edit sender
+        </h3>
+        <input
+          value={name}
+          onChange={e => setName(e.target.value)}
+          onKeyDown={e => { if (e.key === 'Enter') void save() }}
+          autoFocus
+          maxLength={80}
+          style={{
+            width: '100%', padding: '8px 11px', borderRadius: 8, fontSize: 13,
+            border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+            color: 'var(--color-text)', outline: 'none',
+          }}
+        />
+        <div style={{ marginTop: 16, marginBottom: 4, fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)' }}>
+          Icon
+        </div>
+        <IconPicker value={icon} onChange={setIcon} />
+
+        <p style={{ margin: '10px 0 0', fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+          {correspondent.file_count > 0
+            ? `${correspondent.file_count} ${correspondent.file_count === 1 ? 'document keeps' : 'documents keep'} this sender under the new name.`
+            : 'Nothing is from this sender yet.'}
+        </p>
+
+        {error && (
+          <p style={{ margin: '12px 0 0', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>
+        )}
+
+        <div style={{ display: 'flex', justifyContent: 'flex-end', gap: 10, marginTop: 20 }}>
+          <button
+            onClick={onClose}
+            style={{
+              padding: '8px 16px', border: 'none', background: 'none', cursor: 'pointer',
+              fontSize: 13, color: 'var(--color-text-muted)',
+            }}
+          >
+            Cancel
+          </button>
+          <button
+            onClick={() => void save()}
+            disabled={busy}
+            style={{
+              padding: '8px 18px', borderRadius: 8, border: 'none', cursor: 'pointer',
+              fontSize: 13, fontWeight: 600, color: '#fff',
+              background: 'var(--color-primary)', opacity: busy ? 0.6 : 1,
+            }}
+          >
+            Save
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/UploadQueue.tsx b/frontend/src/components/UploadQueue.tsx
new file mode 100644
index 0000000..b69e071
--- /dev/null
+++ b/frontend/src/components/UploadQueue.tsx
@@ -0,0 +1,57 @@
+interface UploadItem {
+  id: string
+  name: string
+  progress: number // 0-100
+  status: 'uploading' | 'done' | 'error'
+  error?: string
+}
+
+interface Props {
+  items: UploadItem[]
+  onDismiss: (id: string) => void
+}
+
+export type { UploadItem }
+
+export default function UploadQueue({ items, onDismiss }: Props) {
+  if (items.length === 0) return null
+
+  return (
+    <div className="fixed bottom-4 right-4 w-72 space-y-2 z-40">
+      {items.map(item => (
+        <div
+          key={item.id}
+          className="rounded-xl p-3 text-sm shadow-lg border"
+          style={{ background: 'var(--color-surface)', borderColor: 'var(--color-border)' }}>
+          <div className="flex items-center justify-between mb-1.5">
+            <span className="truncate font-medium text-xs" style={{ color: 'var(--color-text)', maxWidth: 180 }}>
+              {item.name}
+            </span>
+            {item.status !== 'uploading' && (
+              <button onClick={() => onDismiss(item.id)}
+                      className="ml-2 opacity-50 hover:opacity-100 text-xs shrink-0"
+                      style={{ color: 'var(--color-text-muted)' }}>✕</button>
+            )}
+          </div>
+
+          {item.status === 'uploading' && (
+            <div className="h-1.5 rounded-full overflow-hidden" style={{ background: 'var(--color-surface-2)' }}>
+              <div
+                className="h-full rounded-full transition-all"
+                style={{
+                  width: `${item.progress}%`,
+                  background: 'linear-gradient(90deg, var(--color-primary), var(--color-accent))',
+                }} />
+            </div>
+          )}
+          {item.status === 'done' && (
+            <p style={{ color: 'var(--color-success)' }} className="text-xs">✓ Uploaded</p>
+          )}
+          {item.status === 'error' && (
+            <p style={{ color: 'var(--color-danger)' }} className="text-xs truncate">✕ {item.error}</p>
+          )}
+        </div>
+      ))}
+    </div>
+  )
+}
diff --git a/frontend/src/components/UserMenu.tsx b/frontend/src/components/UserMenu.tsx
new file mode 100644
index 0000000..7d2e9ea
--- /dev/null
+++ b/frontend/src/components/UserMenu.tsx
@@ -0,0 +1,204 @@
+import { createContext, useContext, useEffect, useRef, useState } from 'react'
+import type { ReactNode } from 'react'
+import type { User } from '../api/client'
+import type { View } from '../hooks/useNavHistory'
+
+/**
+ * Der Nutzerbereich – oben rechts in jeder Kopfleiste.
+ *
+ * Vorher saß er unten links in der Seitenleiste, mit dem Abmelden-Symbol
+ * unmittelbar daneben. Zwei Dinge waren daran falsch:
+ *
+ * 1. **Abmelden lag einen Fehlklick entfernt** vom Knopf, der zu den
+ *    Einstellungen führt. Es ist die einzige Handlung in dieser Anwendung, die
+ *    man nicht rückgängig machen kann, ohne sich neu anzumelden – und sie war
+ *    die am leichtesten erreichbare.
+ * 2. Oben rechts ist der Ort, an dem Menschen den eigenen Zugang suchen. Unten
+ *    links steht sonst das, was zum *Ort* gehört – der Speicherbalken bleibt
+ *    deshalb dort.
+ *
+ * Weitergereicht wird über einen Context, nicht über Eigenschaften: Sonst
+ * müsste jede der sechs Seiten Nutzer, Abmelden und Umschalten durchreichen,
+ * nur damit die Kopfleiste sie hat.
+ */
+interface UserMenuValue {
+  user: User
+  onNavigate: (view: View) => void
+  onLogout: () => Promise<void>
+  /** Öffnet die Seitenleiste – nur auf dem Handy sichtbar, siehe PageHeader. */
+  onOpenSidebar?: () => void
+}
+
+const Ctx = createContext<UserMenuValue | null>(null)
+
+export function UserMenuProvider({ value, children }: { value: UserMenuValue; children: ReactNode }) {
+  return <Ctx.Provider value={value}>{children}</Ctx.Provider>
+}
+
+/**
+ * Den Schalter für die Seitenleiste holt sich die Kopfleiste hier ab.
+ *
+ * Über denselben Context wie der Nutzerbereich, aus demselben Grund: Sonst
+ * müsste jede der sechs Seiten eine Funktion durchreichen, die sie selbst
+ * nicht braucht.
+ */
+export function useSidebarToggle(): (() => void) | undefined {
+  return useContext(Ctx)?.onOpenSidebar
+}
+
+/** Anzeigename, sonst die Kennung. Nur *einer* von beiden wird gezeigt – zwei
+ *  Zeilen mit fast demselben Wort darunter sind keine Information. */
+export function displayNameOf(user: User): string {
+  return user.display_name?.trim() || user.username
+}
+
+export default function UserMenu() {
+  const ctx = useContext(Ctx)
+  const [open, setOpen] = useState(false)
+  const boxRef = useRef<HTMLDivElement>(null)
+
+  // Klick daneben und Escape schließen – wie bei der Suche und den Dialogen.
+  useEffect(() => {
+    if (!open) return
+    function onDown(e: MouseEvent) {
+      if (!boxRef.current?.contains(e.target as Node)) setOpen(false)
+    }
+    function onKey(e: KeyboardEvent) {
+      if (e.key === 'Escape') setOpen(false)
+    }
+    document.addEventListener('mousedown', onDown)
+    document.addEventListener('keydown', onKey)
+    return () => {
+      document.removeEventListener('mousedown', onDown)
+      document.removeEventListener('keydown', onKey)
+    }
+  }, [open])
+
+  // Ohne Context (etwa auf der Freigabe-Seite ohne Anmeldung) gibt es nichts
+  // zu zeigen.
+  if (!ctx) return null
+  const { user, onNavigate, onLogout } = ctx
+  const name = displayNameOf(user)
+
+  return (
+    <div ref={boxRef} style={{ position: 'relative', flexShrink: 0 }}>
+      <button
+        onClick={() => setOpen(o => !o)}
+        title={name}
+        style={{
+          display: 'flex', alignItems: 'center', gap: 8,
+          background: open ? 'var(--color-surface-2)' : 'transparent',
+          border: 'none', borderRadius: 8, cursor: 'pointer',
+          padding: '4px 8px 4px 4px', maxWidth: 180,
+        }}
+        onMouseEnter={e => { if (!open) e.currentTarget.style.background = 'var(--color-surface-2)' }}
+        onMouseLeave={e => { if (!open) e.currentTarget.style.background = 'transparent' }}
+      >
+        <Avatar name={name} size={26} />
+        <span style={{
+          fontSize: 13, fontWeight: 500, color: 'var(--color-text)',
+          overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+        }}>
+          {name}
+        </span>
+      </button>
+
+      {open && (
+        <div style={{
+          position: 'absolute', top: 'calc(100% + 6px)', right: 0,
+          minWidth: 200,
+          background: 'var(--color-surface)',
+          border: '1px solid var(--color-border)',
+          borderRadius: 10, boxShadow: '0 12px 32px rgba(0,0,0,0.45)',
+          zIndex: 60, padding: 4,
+        }}>
+          {/* Kopf des Menüs: hier ist Platz für beides – der Anzeigename oben,
+              die Kennung als Nebenangabe. In der Leiste selbst steht nur der
+              Anzeigename, dort wäre die zweite Zeile nur Doppelung. */}
+          <div style={{ padding: '8px 10px 10px' }}>
+            <div style={{
+              fontSize: 13, fontWeight: 600, color: 'var(--color-text)',
+              overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+            }}>
+              {name}
+            </div>
+            {user.display_name?.trim() && user.display_name.trim() !== user.username && (
+              <div style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>{user.username}</div>
+            )}
+            {user.is_admin && (
+              <div style={{ fontSize: 10, fontWeight: 600, color: 'var(--color-primary)', marginTop: 2 }}>
+                Administrator
+              </div>
+            )}
+          </div>
+
+          <Divider />
+
+          <Item label="Settings" onClick={() => { setOpen(false); onNavigate('profile') }} icon={
+            <><circle cx="12" cy="12" r="3" /><path d="M19.4 15a1.65 1.65 0 00.33 1.82l.06.06a2 2 0 11-2.83 2.83l-.06-.06a1.65 1.65 0 00-1.82-.33 1.65 1.65 0 00-1 1.51V21a2 2 0 11-4 0v-.09A1.65 1.65 0 009 19.4a1.65 1.65 0 00-1.82.33l-.06.06a2 2 0 11-2.83-2.83l.06-.06a1.65 1.65 0 00.33-1.82 1.65 1.65 0 00-1.51-1H3a2 2 0 110-4h.09A1.65 1.65 0 004.6 9a1.65 1.65 0 00-.33-1.82l-.06-.06a2 2 0 112.83-2.83l.06.06A1.65 1.65 0 009 4.6a1.65 1.65 0 001-1.51V3a2 2 0 114 0v.09a1.65 1.65 0 001 1.51 1.65 1.65 0 001.82-.33l.06-.06a2 2 0 112.83 2.83l-.06.06A1.65 1.65 0 0019.4 9v0a1.65 1.65 0 001.51 1H21a2 2 0 110 4h-.09a1.65 1.65 0 00-1.51 1z" /></>
+          } />
+
+          {user.is_admin && (
+            <Item label="Admin panel" onClick={() => { setOpen(false); onNavigate('admin') }} icon={
+              <><path d="M12 3l8 4v5c0 4.4-3.4 8.3-8 9-4.6-.7-8-4.6-8-9V7l8-4z" /></>
+            } />
+          )}
+
+          <Divider />
+
+          {/* Abmelden zuletzt und mit Abstand – die einzige Handlung hier, die
+              man nicht zurücknehmen kann. */}
+          <Item label="Sign out" danger onClick={() => { setOpen(false); void onLogout() }} icon={
+            <><path d="M9 21H5a2 2 0 01-2-2V5a2 2 0 012-2h4" /><polyline points="16 17 21 12 16 7" /><line x1="21" y1="12" x2="9" y2="12" /></>
+          } />
+        </div>
+      )}
+    </div>
+  )
+}
+
+/** Der farbige Kreis mit dem ersten Buchstaben. */
+export function Avatar({ name, size = 26 }: { name: string; size?: number }) {
+  return (
+    <span style={{
+      width: size, height: size, borderRadius: '50%',
+      background: 'var(--color-primary)',
+      display: 'flex', alignItems: 'center', justifyContent: 'center',
+      fontSize: Math.round(size * 0.45), fontWeight: 700, color: '#fff', flexShrink: 0,
+    }}>
+      {(name[0] ?? '?').toUpperCase()}
+    </span>
+  )
+}
+
+function Divider() {
+  return <div style={{ height: 1, background: 'var(--color-border)', margin: '4px 0' }} />
+}
+
+function Item({ label, icon, onClick, danger }: {
+  label: string
+  icon: ReactNode
+  onClick: () => void
+  danger?: boolean
+}) {
+  const color = danger ? 'var(--color-danger)' : 'var(--color-text)'
+  return (
+    <button
+      onClick={onClick}
+      style={{
+        display: 'flex', alignItems: 'center', gap: 10, width: '100%',
+        padding: '7px 10px', borderRadius: 7, border: 'none', background: 'transparent',
+        cursor: 'pointer', textAlign: 'left', fontSize: 13, color,
+      }}
+      onMouseEnter={e => e.currentTarget.style.background = 'var(--color-surface-2)'}
+      onMouseLeave={e => e.currentTarget.style.background = 'transparent'}
+    >
+      <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+           strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"
+           style={{ flexShrink: 0, opacity: danger ? 1 : 0.7 }}>
+        {icon}
+      </svg>
+      {label}
+    </button>
+  )
+}
diff --git a/frontend/src/components/VersionsDialog.tsx b/frontend/src/components/VersionsDialog.tsx
new file mode 100644
index 0000000..8be4a9c
--- /dev/null
+++ b/frontend/src/components/VersionsDialog.tsx
@@ -0,0 +1,216 @@
+import { useState, useEffect } from 'react'
+import { versionsApi, type FileItem, type FileVersion } from '../api/client'
+import { formatBytes } from '../pages/FileBrowser'
+import { useOverlayDismiss } from '../hooks/useOverlayDismiss'
+
+interface Props {
+  file: FileItem
+  onClose: () => void
+  onRestored: (updated: FileItem) => void
+}
+
+// Muss zu maxVersionsKept im Backend passen (internal/files/handler.go).
+const MAX_VERSIONS_KEPT = 5
+
+function formatDate(iso: string): string {
+  return new Date(iso).toLocaleString(undefined, {
+    day: '2-digit', month: 'short', year: 'numeric',
+    hour: '2-digit', minute: '2-digit',
+  })
+}
+
+export default function VersionsDialog({ file, onClose, onRestored }: Props) {
+  const [versions, setVersions] = useState<FileVersion[]>([])
+  const [loading, setLoading] = useState(true)
+  const [restoring, setRestoring] = useState<string | null>(null)
+  const overlay = useOverlayDismiss(onClose)
+
+  useEffect(() => {
+    versionsApi.list(file.id)
+      .then(data => setVersions(data ?? []))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [file.id])
+
+  async function restore(v: FileVersion) {
+    setRestoring(v.id)
+    try {
+      const updated = await versionsApi.restore(file.id, v.id)
+      onRestored(updated)
+      onClose()
+    } catch {
+      setRestoring(null)
+    }
+  }
+
+  return (
+    <div style={{
+      position: 'fixed', inset: 0, zIndex: 200,
+      background: 'rgba(0,0,0,0.5)',
+      display: 'flex', alignItems: 'center', justifyContent: 'center',
+      padding: 16,
+    }} {...overlay}>
+      <div style={{
+        background: 'var(--color-surface)',
+        border: '1px solid var(--color-border)',
+        borderRadius: 16,
+        width: 520, maxWidth: '100%', maxHeight: '80vh',
+        display: 'flex', flexDirection: 'column',
+        overflow: 'hidden',
+      }}>
+
+        {/* Header */}
+        <div style={{
+          padding: '16px 20px',
+          borderBottom: '1px solid var(--color-border)',
+          display: 'flex', alignItems: 'center', justifyContent: 'space-between',
+        }}>
+          <div>
+            <h3 style={{ margin: 0, fontSize: 15, fontWeight: 600, color: 'var(--color-text)' }}>
+              Version history
+            </h3>
+            <p style={{ margin: '2px 0 0', fontSize: 12, color: 'var(--color-text-muted)' }}>
+              {file.name}
+            </p>
+            <p style={{ margin: '4px 0 0', fontSize: 11, color: 'var(--color-text-muted)' }}>
+              {file.versioning_enabled
+                ? `Versioning on – the last ${MAX_VERSIONS_KEPT} revisions are kept`
+                : 'Versioning off – overwriting replaces the file with no history'}
+            </p>
+          </div>
+          <button
+            onClick={onClose}
+            style={{ background: 'none', border: 'none', cursor: 'pointer', color: 'var(--color-text-muted)', padding: 4, borderRadius: 6 }}
+          >
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <line x1="18" y1="6" x2="6" y2="18" /><line x1="6" y1="6" x2="18" y2="18" />
+            </svg>
+          </button>
+        </div>
+
+        {/* Current version */}
+        <div style={{
+          padding: '12px 20px',
+          borderBottom: '1px solid var(--color-border)',
+          background: 'rgba(var(--color-primary-rgb), 0.05)',
+          display: 'flex', alignItems: 'center', gap: 12,
+        }}>
+          <div style={{
+            width: 32, height: 32, borderRadius: 8,
+            background: 'var(--color-primary)',
+            display: 'flex', alignItems: 'center', justifyContent: 'center',
+            fontSize: 11, fontWeight: 700, color: '#fff', flexShrink: 0,
+          }}>
+            v{file.version}
+          </div>
+          <div style={{ flex: 1, minWidth: 0 }}>
+            <p style={{ margin: 0, fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>
+              Current version
+            </p>
+            <p style={{ margin: '2px 0 0', fontSize: 11, color: 'var(--color-text-muted)' }}>
+              {formatBytes(file.size)} · {formatDate(file.updated_at)}
+            </p>
+          </div>
+          <a
+            href={`/api/v1/files/${file.id}/download`}
+            download={file.name}
+            style={{
+              padding: '5px 12px', borderRadius: 6,
+              border: '1px solid var(--color-border)',
+              color: 'var(--color-text)', fontSize: 12,
+              textDecoration: 'none', whiteSpace: 'nowrap',
+            }}
+          >
+            Download
+          </a>
+        </div>
+
+        {/* Older versions */}
+        <div style={{ flex: 1, overflowY: 'auto', padding: 16 }}>
+          {loading && (
+            <div style={{ display: 'flex', justifyContent: 'center', padding: 32 }}>
+              <div style={{ width: 20, height: 20, border: '2px solid var(--color-primary)', borderTopColor: 'transparent', borderRadius: '50%', animation: 'spin 0.7s linear infinite' }} />
+              <style>{`@keyframes spin{to{transform:rotate(360deg)}}`}</style>
+            </div>
+          )}
+
+          {!loading && versions.length === 0 && (
+            <div style={{ textAlign: 'center', padding: 32, color: 'var(--color-text-muted)', fontSize: 13 }}>
+              No older versions yet.
+              <br />
+              <span style={{ fontSize: 11, marginTop: 4, display: 'block' }}>
+                Upload a file with the same name to create a version.
+              </span>
+            </div>
+          )}
+
+          {!loading && versions.length > 0 && (
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
+              {versions.map(v => (
+                <div key={v.id} style={{
+                  display: 'flex', alignItems: 'center', gap: 12,
+                  padding: '10px 12px', borderRadius: 10,
+                  border: '1px solid var(--color-border)',
+                  background: 'var(--color-surface)',
+                }}>
+                  <div style={{
+                    width: 32, height: 32, borderRadius: 8,
+                    background: 'var(--color-surface-2)',
+                    display: 'flex', alignItems: 'center', justifyContent: 'center',
+                    fontSize: 11, fontWeight: 600, color: 'var(--color-text-muted)', flexShrink: 0,
+                  }}>
+                    v{v.version}
+                  </div>
+                  <div style={{ flex: 1, minWidth: 0 }}>
+                    <p style={{ margin: 0, fontSize: 12, color: 'var(--color-text)' }}>
+                      {formatDate(v.created_at)}
+                    </p>
+                    <p style={{ margin: '2px 0 0', fontSize: 11, color: 'var(--color-text-muted)' }}>
+                      {formatBytes(v.size)}
+                    </p>
+                  </div>
+                  <div style={{ display: 'flex', gap: 6, flexShrink: 0 }}>
+                    <a
+                      href={versionsApi.download(file.id, v.id)}
+                      download={file.name}
+                      style={{
+                        padding: '4px 10px', borderRadius: 6,
+                        border: '1px solid var(--color-border)',
+                        color: 'var(--color-text)', fontSize: 11,
+                        textDecoration: 'none', whiteSpace: 'nowrap',
+                      }}
+                    >
+                      Download
+                    </a>
+                    <button
+                      onClick={() => restore(v)}
+                      disabled={restoring === v.id}
+                      style={{
+                        padding: '4px 10px', borderRadius: 6,
+                        border: '1px solid var(--color-primary)',
+                        background: 'transparent', color: 'var(--color-primary)',
+                        fontSize: 11, cursor: 'pointer', whiteSpace: 'nowrap',
+                        opacity: restoring === v.id ? 0.6 : 1,
+                      }}
+                    >
+                      {restoring === v.id ? 'Restoring…' : 'Restore'}
+                    </button>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+
+        <div style={{
+          padding: '10px 20px',
+          borderTop: '1px solid var(--color-border)',
+          fontSize: 11, color: 'var(--color-text-muted)',
+          textAlign: 'center',
+        }}>
+          Up to {MAX_VERSIONS_KEPT} revisions are kept
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/components/filetypes.ts b/frontend/src/components/filetypes.ts
new file mode 100644
index 0000000..1bbb589
--- /dev/null
+++ b/frontend/src/components/filetypes.ts
@@ -0,0 +1,80 @@
+/**
+ * Dateiarten an einer Stelle. Symbol, Farbe und Cover leiteten ihre
+ * Entscheidung vorher jeweils selbst aus dem MIME-Typ ab – dabei laufen die
+ * drei mit der Zeit auseinander, und eine MP3 bekommt ein Symbol für Ton, aber
+ * die Farbe für „unbekannt".
+ */
+export type FileKind =
+  | 'image' | 'video' | 'audio' | 'pdf' | 'archive'
+  | 'sheet' | 'slides' | 'doc' | 'code' | 'text' | 'other'
+
+/** Endungen, die der MIME-Typ oft nicht verrät. Ein `.tar.gz` kommt je nach
+ *  Betreuer als application/gzip, application/x-tar oder octet-stream an. */
+const archiveExt = ['zip', 'tar', 'gz', 'tgz', 'bz2', 'xz', 'rar', '7z', 'zst', 'deb', 'rpm']
+const codeExt = [
+  'js', 'ts', 'tsx', 'jsx', 'go', 'py', 'rs', 'rb', 'php', 'java', 'c', 'h', 'cpp',
+  'sh', 'bash', 'sql', 'json', 'yaml', 'yml', 'toml', 'xml', 'html', 'css', 'ini', 'conf',
+]
+const sheetExt = ['csv', 'tsv', 'xls', 'xlsx', 'ods', 'numbers']
+const slidesExt = ['ppt', 'pptx', 'odp', 'key']
+/** Nur die Textverarbeitung. Markdown und .txt gehören zu 'text' – sie sind
+ *  lesbarer Text, kein Office-Format, und lassen sich hier sogar bearbeiten. */
+const docExt = ['doc', 'docx', 'odt', 'rtf', 'pages']
+const textExt = ['md', 'txt', 'log', 'rst']
+
+export function extensionOf(name: string): string {
+  const dot = name.lastIndexOf('.')
+  if (dot <= 0 || dot === name.length - 1) return ''
+  // Bei .tar.gz ist die zweite Endung die aussagekräftige.
+  const ext = name.slice(dot + 1).toLowerCase()
+  if (ext === 'gz' && name.toLowerCase().endsWith('.tar.gz')) return 'tar.gz'
+  return ext
+}
+
+export function fileKind(mime: string, name = ''): FileKind {
+  const m = (mime || '').toLowerCase()
+  const ext = extensionOf(name).replace('tar.', '')
+
+  if (m.startsWith('image/')) return 'image'
+  if (m.startsWith('video/')) return 'video'
+  if (m.startsWith('audio/')) return 'audio'
+  if (m.includes('pdf')) return 'pdf'
+
+  if (archiveExt.includes(ext) ||
+      m.includes('zip') || m.includes('tar') || m.includes('gzip') ||
+      m.includes('compressed') || m.includes('x-rar') || m.includes('7z')) return 'archive'
+
+  if (sheetExt.includes(ext) ||
+      m.includes('spreadsheet') || m.includes('excel') || m.includes('csv')) return 'sheet'
+  if (slidesExt.includes(ext) ||
+      m.includes('presentation') || m.includes('powerpoint')) return 'slides'
+  if (textExt.includes(ext)) return 'text'
+  if (codeExt.includes(ext)) return 'code'
+  if (docExt.includes(ext) ||
+      m.includes('msword') || m.includes('wordprocessing') ||
+      m.includes('opendocument.text') || m.includes('rtf')) return 'doc'
+  if (m.startsWith('text/')) return 'text'
+  return 'other'
+}
+
+/** Je Art eine Farbe. Sie trägt das Symbol, den Rahmen und den Verlauf des
+ *  Covers – so ist eine Datei schon an der Farbe einzuordnen. */
+export const kindColors: Record<FileKind, string> = {
+  image: '#8b5cf6',
+  video: '#ec4899',
+  audio: '#06b6d4',
+  pdf: '#ef4444',
+  archive: '#f59e0b',
+  sheet: '#22c55e',
+  // Kräftiges Orangerot – deutlich genug vom Bernstein der Archive und vom
+  // Rot der PDFs entfernt, damit die drei nebeneinander unterscheidbar sind.
+  slides: '#ea580c',
+  doc: '#3b82f6',
+  code: '#14b8a6',
+  text: '#94a3b8',
+  other: '#6366f1',
+}
+
+export function kindColor(mime: string, name = ''): string {
+  return kindColors[fileKind(mime, name)]
+}
diff --git a/frontend/src/components/icons.tsx b/frontend/src/components/icons.tsx
new file mode 100644
index 0000000..94e11a5
--- /dev/null
+++ b/frontend/src/components/icons.tsx
@@ -0,0 +1,256 @@
+/**
+ * Einheitlicher Icon-Satz für Menüs und Werkzeugleisten.
+ *
+ * Bewusst Striche statt Emoji: Emoji werden von jedem Betriebssystem anders
+ * gezeichnet, haben eigene Farben und optische Größen – nebeneinander wirkt
+ * eine Liste davon unruhig. Diese hier erben Farbe (`currentColor`) und Größe
+ * vom Aufrufer und sitzen alle auf demselben Raster.
+ */
+import { fileKind, kindColor, kindColors } from './filetypes'
+
+interface IconProps {
+  size?: number
+}
+
+const base = (size: number) => ({
+  width: size,
+  height: size,
+  viewBox: '0 0 24 24',
+  fill: 'none',
+  stroke: 'currentColor',
+  strokeWidth: 1.75,
+  strokeLinecap: 'round' as const,
+  strokeLinejoin: 'round' as const,
+  style: { flexShrink: 0 },
+})
+
+export const DownloadIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+    <polyline points="7 10 12 15 17 10" />
+    <line x1="12" y1="15" x2="12" y2="3" />
+  </svg>
+)
+
+export const ShareIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <circle cx="18" cy="5" r="3" />
+    <circle cx="6" cy="12" r="3" />
+    <circle cx="18" cy="19" r="3" />
+    <line x1="8.6" y1="10.5" x2="15.4" y2="6.5" />
+    <line x1="8.6" y1="13.5" x2="15.4" y2="17.5" />
+  </svg>
+)
+
+export const PeopleIcon = ({ size = 15 }: IconProps) => (
+  <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+    <circle cx="9" cy="8" r="3.5" />
+    <path d="M2 21v-1a7 7 0 0114 0v1" />
+    <path d="M17 11a3 3 0 100-6M19 21v-1a6 6 0 00-3-5.2" />
+  </svg>
+)
+
+export const InfoIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <circle cx="12" cy="12" r="9" />
+    <path d="M12 11v5" />
+    <path d="M12 8h.01" />
+  </svg>
+)
+
+export const HistoryIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <path d="M3 3v5h5" />
+    <path d="M3.05 13A9 9 0 106 5.3L3 8" />
+    <path d="M12 7v5l4 2" />
+  </svg>
+)
+
+export const RenameIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <path d="M12 20h9" />
+    <path d="M16.5 3.5a2.12 2.12 0 013 3L7 19l-4 1 1-4z" />
+  </svg>
+)
+
+export const MoveIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2z" />
+    <polyline points="12 11 15 14 12 17" />
+    <line x1="9" y1="14" x2="15" y2="14" />
+  </svg>
+)
+
+export const TrashIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <polyline points="3 6 5 6 21 6" />
+    <path d="M19 6l-1 14H6L5 6M10 11v6M14 11v6M9 6V4h6v2" />
+  </svg>
+)
+
+export const FolderOpenIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v1H3z" />
+    <path d="M3 10h18l-2 8a2 2 0 01-2 1.6H5A2 2 0 013 18z" />
+  </svg>
+)
+
+/** Gefüllt, wenn der Ordner bereits Favorit ist. */
+export const StarIcon = ({ size = 15, filled = false }: IconProps & { filled?: boolean }) => (
+  <svg {...base(size)} fill={filled ? 'currentColor' : 'none'}>
+    <polygon points="12 2.8 15 9 21.6 9.8 16.8 14.3 18.1 21 12 17.8 5.9 21 7.2 14.3 2.4 9.8 9 9" />
+  </svg>
+)
+
+export const CheckIcon = ({ size = 15 }: IconProps) => (
+  <svg {...base(size)}>
+    <polyline points="20 6 9 17 4 12" />
+  </svg>
+)
+
+// ── Dateitypen ───────────────────────────────────────────────────────────────
+// Lagen bis 22.08.2026 in FileBrowser.tsx. Hierher gezogen, als die Suche sie
+// ebenfalls brauchte – eine Komponente sollte nichts aus einer Seite
+// importieren. Welche Art eine Datei hat, entscheidet filetypes.ts.
+
+export function getMimeColor(mime: string, name = ''): string {
+  return kindColor(mime, name)
+}
+
+export function FileTypeIcon({ mime, name = '', size = 20 }: { mime: string; name?: string; size?: number }) {
+  const kind = fileKind(mime, name)
+  const color = kindColors[kind]
+  const svg = (children: React.ReactNode, filled = false) => (
+    <svg width={size} height={size} viewBox="0 0 24 24"
+         fill={filled ? color : 'none'} stroke={filled ? 'none' : color} strokeWidth="1.5"
+         strokeLinecap="round" strokeLinejoin="round">
+      {children}
+    </svg>
+  )
+
+  switch (kind) {
+    case 'image':
+      return svg(<>
+        <rect x="3" y="3" width="18" height="18" rx="2" />
+        <circle cx="8.5" cy="8.5" r="1.5" />
+        <polyline points="21 15 16 10 5 21" />
+      </>)
+    case 'video':
+      return svg(<>
+        <rect x="2" y="4" width="20" height="16" rx="2" />
+        <polygon points="10 9 15 12 10 15" fill={color} stroke="none" />
+        <line x1="6" y1="4" x2="6" y2="20" />
+        <line x1="18" y1="4" x2="18" y2="20" />
+      </>)
+    case 'audio':
+      return svg(<>
+        <path d="M9 18V6l10-2v12" />
+        <circle cx="6.5" cy="18" r="2.5" />
+        <circle cx="16.5" cy="16" r="2.5" />
+      </>)
+    case 'pdf':
+      // Dieselbe Blattform wie beim Dokument, nur in Rot. Ein eigener
+      // gefuellter Block war der Versuch, beide staerker zu trennen – dafuer
+      // reichen Farbe und der Aufkleber mit der Endung.
+      return svg(<>
+        <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z" />
+        <polyline points="14 2 14 8 20 8" />
+        <line x1="16" y1="13" x2="8" y2="13" />
+        <line x1="16" y1="17" x2="8" y2="17" />
+        <line x1="10" y1="9" x2="8" y2="9" />
+      </>)
+    case 'archive':
+      // Kiste mit Verschluss – ein Ordnersymbol wäre hier irreführend.
+      return svg(<>
+        <path d="M3 7l2-3h14l2 3v13a1 1 0 01-1 1H4a1 1 0 01-1-1z" />
+        <line x1="3" y1="7" x2="21" y2="7" />
+        <path d="M10 11h4" />
+        <path d="M10 14h4" />
+      </>)
+    case 'sheet':
+      // Tabellenraster mit hervorgehobener Kopfzeile – so liest man es sofort
+      // als Tabelle und nicht als Fenster.
+      return svg(<>
+        <rect x="3" y="3" width="18" height="18" rx="2" />
+        <path d="M3 8.5h18" />
+        <line x1="3" y1="14" x2="21" y2="14" />
+        <line x1="9.5" y1="8.5" x2="9.5" y2="21" />
+      </>)
+    case 'slides':
+      // Leinwand auf Fuß mit einem Balkendiagramm – das Bild, das jeder mit
+      // einer Präsentation verbindet.
+      return svg(<>
+        <rect x="3" y="3" width="18" height="13" rx="2" />
+        <path d="M12 16v3" />
+        <path d="M8.5 21h7" />
+        <path d="M7.5 12.5v-2M11 12.5V8M14.5 12.5v-3.5" />
+      </>)
+    case 'code':
+      return svg(<>
+        <polyline points="16 18 22 12 16 6" />
+        <polyline points="8 6 2 12 8 18" />
+      </>)
+    case 'doc':
+    case 'text':
+      return svg(<>
+        <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z" />
+        <polyline points="14 2 14 8 20 8" />
+        <line x1="16" y1="13" x2="8" y2="13" />
+        <line x1="16" y1="17" x2="8" y2="17" />
+        <line x1="10" y1="9" x2="8" y2="9" />
+      </>)
+    default:
+      return svg(<>
+        <path d="M13 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V9z" />
+        <polyline points="13 2 13 9 20 9" />
+      </>)
+  }
+}
+
+/**
+ * Der Ordner – eine Definition für Kachel, Liste und Suchtreffer. Lag vorher
+ * dreimal im Code und lief prompt auseinander.
+ *
+ * Ganzzahlige Koordinaten auf dem 48er-Raster, und die Anzeigegröße ist ein
+ * Vielfaches davon: So landet jede Kante auf einem ganzen Pixel statt zwischen
+ * zweien, wo die Kantenglättung sie weichzeichnet.
+ *
+ * Die vordere Lage deckt voll, nur die hintere ist durchscheinend. Beide
+ * durchscheinend zu machen, sah auf dem dunklen Grund blass aus.
+ */
+export function FolderGlyph({ size = 48, color = '#f59e0b' }: { size?: number; color?: string }) {
+  return (
+    <svg width={size} height={size} viewBox="0 0 48 48" fill="none">
+      {/* Hintere Lage mit Reiter – schaut oben links hervor */}
+      <path d="M5 13a3 3 0 013-3h8l4 4h17a3 3 0 013 3v5H5z" fill={color} opacity="0.55" />
+      {/* Vordere Tasche */}
+      <rect x="5" y="15" width="38" height="26" rx="4" fill={color} />
+      {/* Feine helle Oberkante, sonst wirkt die Tasche wie ein flacher Klecks */}
+      <rect x="5" y="15" width="38" height="3" rx="1.5" fill="#fff" opacity="0.16" />
+    </svg>
+  )
+}
+
+/** Etikett – dieselbe Form wie in der Kopfleiste der Etikettenansicht. */
+export function TagIcon() {
+  return (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+         strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <path d="M3 7v6.2a2 2 0 00.6 1.4l6.8 6.8a2 2 0 002.8 0l6.2-6.2a2 2 0 000-2.8l-6.8-6.8A2 2 0 0011.2 5H5a2 2 0 00-2 2z" />
+      <circle cx="7.5" cy="9.5" r="1.2" fill="currentColor" stroke="none" />
+    </svg>
+  )
+}
+
+/** Ein Blatt mit Stift – „im Office-Server bearbeiten". Bewusst nicht das
+ *  Symbol eines bestimmten Anbieters: Dahinter kann Collabora oder OnlyOffice
+ *  stecken, und das soll dem Menüpunkt nicht anzusehen sein. */
+export function OfficeIcon() {
+  return (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+         strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <path d="M13 3H7a2 2 0 00-2 2v14a2 2 0 002 2h10a2 2 0 002-2v-6" />
+      <path d="M18.5 2.5a2.1 2.1 0 013 3L15 12l-4 1 1-4z" />
+    </svg>
+  )
+}
diff --git a/frontend/src/components/pdf.css b/frontend/src/components/pdf.css
new file mode 100644
index 0000000..5399540
--- /dev/null
+++ b/frontend/src/components/pdf.css
@@ -0,0 +1,208 @@
+/*
+ * Textebene von PDF.js.
+ *
+ * Der Block unten ist **wörtlich** aus pdfjs-dist/web/pdf_viewer.css
+ * übernommen, nur die Klasse heißt `.pdf-textLayer` statt `.textLayer`.
+ *
+ * Beim ersten Anlauf hatte ich ihn von Hand gekürzt – „wir zeigen nur Seiten
+ * an, der Rest ist Werkzeugleiste". Dabei fielen drei Zeilen weg, die wie
+ * Kleinkram aussahen und keiner waren:
+ *
+ *     --min-font-size / --text-scale-factor / scale(var(--min-font-size-inv))
+ *
+ * PDF.js misst beim ersten Aufbau, wie klein der Browser Schrift überhaupt
+ * noch darstellt (Chrome erzwingt eine Mindestgröße), setzt daraus
+ * `--min-font-size` und rechnet sie mit der Skalierung wieder heraus. Ohne
+ * dieses Paar wird jede kleine Schrift vom Browser aufgeblasen: Die
+ * unsichtbaren Textstücke sitzen dann größer da als die gemalten Buchstaben
+ * darunter – zu sehen erst beim **Markieren**, wo die Auswahl als grobe,
+ * versetzte Kästen über dem Text lag statt auf ihm.
+ *
+ * Deshalb hier nichts mehr von Hand kürzen. Was die Datei mitbringt, gehört
+ * zusammen; was wir zusätzlich wollen, steht darunter.
+ */
+
+.pdf-textLayer{
+  color-scheme:only light;
+
+  position:absolute;
+  text-align:initial;
+  inset:0;
+  overflow:clip;
+  opacity:1;
+  line-height:1;
+  letter-spacing:normal;
+  word-spacing:normal;
+  -webkit-text-size-adjust:none;
+     -moz-text-size-adjust:none;
+          text-size-adjust:none;
+  forced-color-adjust:none;
+  transform-origin:0 0;
+  caret-color:CanvasText;
+  z-index:0;
+
+  &.highlighting{
+    touch-action:none;
+  }
+
+  :is(span, br){
+    color:transparent;
+    position:absolute;
+    white-space:pre;
+    cursor:text;
+    transform-origin:0% 0%;
+    -webkit-user-select:text;
+       -moz-user-select:text;
+            user-select:text;
+  }
+  --min-font-size:1;
+  --text-scale-factor:calc(var(--total-scale-factor) * var(--min-font-size));
+  --min-font-size-inv:calc(1 / var(--min-font-size));
+
+  > :not(.markedContent),
+  .markedContent span:not(.markedContent){
+    z-index:1;
+
+    --font-height:0;
+    font-size:calc(var(--text-scale-factor) * var(--font-height));
+
+    --scale-x:1;
+    --rotate:0deg;
+    transform:rotate(var(--rotate)) scaleX(var(--scale-x)) scale(var(--min-font-size-inv));
+  }
+
+  .markedContent{
+    display:contents;
+  }
+
+  span[role="img"]{
+    -webkit-user-select:none;
+       -moz-user-select:none;
+            user-select:none;
+    cursor:default;
+  }
+
+  .highlight{
+    --highlight-bg-color:rgb(180 0 170 / 0.25);
+    --highlight-selected-bg-color:rgb(0 100 0 / 0.25);
+    --highlight-backdrop-filter:none;
+    --highlight-selected-backdrop-filter:none;
+
+    @media screen and (forced-colors: active){
+      --highlight-bg-color:transparent;
+      --highlight-selected-bg-color:transparent;
+      --highlight-backdrop-filter:var(--hcm-highlight-filter);
+      --highlight-selected-backdrop-filter:var(
+        --hcm-highlight-selected-filter
+      );
+    }
+
+    margin:-1px;
+    padding:1px;
+    background-color:var(--highlight-bg-color);
+    backdrop-filter:var(--highlight-backdrop-filter);
+    border-radius:4px;
+
+    &.appended{
+      position:initial;
+    }
+
+    &.begin{
+      border-radius:4px 0 0 4px;
+    }
+
+    &.end{
+      border-radius:0 4px 4px 0;
+    }
+
+    &.middle{
+      border-radius:0;
+    }
+
+    &.selected{
+      background-color:var(--highlight-selected-bg-color);
+      backdrop-filter:var(--highlight-selected-backdrop-filter);
+      scroll-margin-top:50px;
+    }
+  }
+
+  ::-moz-selection{
+    background:rgba(0 0 255 / 0.25);
+    background:color-mix(in srgb, AccentColor, transparent 50%);
+    color:transparent;
+  }
+
+  ::selection{
+    background:rgba(0 0 255 / 0.25);
+    background:color-mix(in srgb, AccentColor, transparent 50%);
+    color:transparent;
+  }
+
+  &.selectionRendering{
+    ::-moz-selection{
+      background:transparent;
+      color:transparent;
+    }
+    ::selection{
+      background:transparent;
+      color:transparent;
+    }
+  }
+  br::-moz-selection{
+    background:transparent;
+  }
+  br::selection{
+    background:transparent;
+  }
+
+  .endOfContent{
+    display:block;
+    position:absolute;
+    inset:100% 0 0;
+    z-index:0;
+    cursor:default;
+    -webkit-user-select:none;
+       -moz-user-select:none;
+            user-select:none;
+  }
+
+  &.selecting .endOfContent{
+    top:0;
+  }
+}
+/*
+ * Fundstellen der Suche.
+ *
+ * Eine eigene Ebene über der Textebene, kein <mark> im Text. Warum, steht
+ * ausführlich in PdfViewer.tsx bei `paint` – kurz: Der Grund eines <mark>
+ * ragte oben aus der Textebene heraus, und die schneidet ab (`overflow:
+ * clip`). Das sah man als angeschnittene Streifen. Diese Ebene schneidet
+ * nichts ab; die Kästen sind dieselben, die der Browser beim Markieren mit
+ * der Maus malt.
+ *
+ * `pointer-events: none`, damit die Ebene das Markieren mit der Maus nicht
+ * abfängt – darunter liegt die Schrift, die man auswählen können soll.
+ *
+ * Die Farbe bleibt durchsichtig: Der lesbare Text steht auf dem gemalten Bild
+ * *darunter*. Mit 0,95 Deckkraft lag ein satter Block über dem Wort, und
+ * ausgerechnet das gesuchte Wort war das einzige, das man nicht mehr lesen
+ * konnte. Der Betrachter von PDF.js selbst arbeitet aus demselben Grund mit
+ * 0,25.
+ */
+.pdf-hitLayer {
+  position: absolute;
+  inset: 0;
+  z-index: 1;
+  pointer-events: none;
+}
+.pdf-hit {
+  position: absolute;
+  background: rgba(245, 158, 11, 0.3);
+  border-radius: 2px;
+}
+.pdf-hit.pdf-hit-current {
+  background: rgba(245, 158, 11, 0.55);
+  /* Der aktuelle Treffer bekommt zusätzlich eine Kante statt noch mehr Farbe –
+     Deckkraft würde wieder das Wort verschlucken. */
+  box-shadow: 0 0 0 1px rgba(180, 83, 9, 0.75);
+}
diff --git a/frontend/src/hooks/useAppSettings.tsx b/frontend/src/hooks/useAppSettings.tsx
new file mode 100644
index 0000000..046d776
--- /dev/null
+++ b/frontend/src/hooks/useAppSettings.tsx
@@ -0,0 +1,115 @@
+import { createContext, useCallback, useContext, useEffect, useState, type ReactNode } from 'react'
+import { publicApi } from '../api/client'
+import { applyTheme } from '../theme'
+
+/**
+ * Hält die serverseitigen Anzeige-Einstellungen (Name, Farben) und wendet das
+ * Farbschema an.
+ *
+ * Bewusst über den öffentlichen Endpunkt: so ist schon die Login-Seite im
+ * richtigen Namen und Farbschema, bevor überhaupt jemand angemeldet ist.
+ * `refresh()` holt den gespeicherten Stand erneut – das nutzt das Admin-Panel
+ * nach dem Speichern und um eine nicht gespeicherte Vorschau zu verwerfen.
+ */
+interface AppSettingsValue {
+  cloudName: string
+  /** Leer, wenn kein Logo hinterlegt ist. */
+  logoUrl: string
+  /** Leer, wenn kein eigenes App-Symbol hinterlegt ist. */
+  faviconUrl: string
+  /** Die 192er-Fassung desselben Symbols – Vorschau im Admin-Bereich. */
+  appIconUrl: string
+  /** Die vom Administrator gesetzten Farben (Grundlage, wenn der Nutzer
+   *  keine eigenen hat). */
+  globalColors: { primary?: string; accent?: string }
+  /** Gibt es einen Office-Server? Steuert nur, ob der Menuepunkt erscheint. */
+  officeEnabled: boolean
+  refresh: () => Promise<void>
+}
+
+const Ctx = createContext<AppSettingsValue>({
+  cloudName: 'Aether',
+  officeEnabled: false,
+  logoUrl: '',
+  faviconUrl: '',
+  appIconUrl: '',
+  globalColors: {},
+  refresh: async () => {},
+})
+
+/**
+ * Tauscht das Tab-Symbol aus. Der Eintrag in index.html wird ersetzt statt
+ * ergaenzt – haengt man einen zweiten an, sucht sich der Browser einen davon
+ * aus, und welchen, ist von Browser zu Browser verschieden.
+ *
+ * Ohne eigenes Favicon steht wieder die mitgelieferte Datei da, damit ein
+ * Entfernen im Admin-Bereich nicht einen leeren Platz hinterlaesst.
+ */
+/**
+ * Faerbt die Systemleisten der installierten App.
+ *
+ * `<meta name="theme-color">` stand fest auf dem Indigo der Voreinstellung –
+ * das Manifest nannte aber die eingestellte Primaerfarbe. In der installierten
+ * App war die Statusleiste damit in einer Farbe, die sonst nirgends vorkommt.
+ */
+function applyThemeColor(primary?: string) {
+  if (!primary) return
+  const meta = document.querySelector<HTMLMetaElement>('meta[name="theme-color"]')
+    ?? document.head.appendChild(Object.assign(document.createElement('meta'), { name: 'theme-color' }))
+  meta.content = primary
+}
+
+function applyFavicon(url: string, touchUrl: string) {
+  const link = document.querySelector<HTMLLinkElement>('link[rel="icon"]')
+    ?? document.head.appendChild(Object.assign(document.createElement('link'), { rel: 'icon' }))
+  if (url) {
+    link.removeAttribute('type') // Typ kommt aus dem Content-Type der Antwort
+    link.href = url
+  } else {
+    link.type = 'image/svg+xml'
+    link.href = '/icon.svg'
+  }
+
+  // Das Symbol auf dem Startbildschirm von iOS – dafuer die 192er-Fassung,
+  // nicht die 64er aus dem Tab. Android holt seines aus dem Manifest, das der
+  // Server erzeugt.
+  const touch = document.querySelector<HTMLLinkElement>('link[rel="apple-touch-icon"]')
+  if (touch) touch.href = touchUrl || '/icon-192.png'
+}
+
+export function AppSettingsProvider({ children }: { children: ReactNode }) {
+  const [cloudName, setCloudName] = useState('Aether')
+  const [logoUrl, setLogoUrl] = useState('')
+  const [faviconUrl, setFaviconUrl] = useState('')
+  const [appIconUrl, setAppIconUrl] = useState('')
+  const [globalColors, setGlobalColors] = useState<{ primary?: string; accent?: string }>({})
+  const [officeEnabled, setOfficeEnabled] = useState(false)
+
+  const refresh = useCallback(async () => {
+    try {
+      const cfg = await publicApi.config()
+      setCloudName(cfg.cloud_name || 'Aether')
+      setLogoUrl(cfg.logo_url ?? '')
+      setFaviconUrl(cfg.favicon_url ?? '')
+      setAppIconUrl(cfg.apple_touch_icon_url ?? '')
+      applyFavicon(cfg.favicon_url ?? '', cfg.apple_touch_icon_url ?? '')
+      setGlobalColors({ primary: cfg.primary_color, accent: cfg.accent_color })
+      setOfficeEnabled(!!cfg.office_enabled)
+      applyTheme(cfg.primary_color, cfg.accent_color)
+      applyThemeColor(cfg.primary_color)
+      document.title = cfg.cloud_name || 'Aether'
+    } catch {
+      /* Erreichbarkeit des Servers ist nicht Sache des Themings – Vorgaben bleiben */
+    }
+  }, [])
+
+  useEffect(() => { void refresh() }, [refresh])
+
+  return (
+    <Ctx.Provider value={{ cloudName, logoUrl, faviconUrl, appIconUrl, globalColors, officeEnabled, refresh }}>{children}</Ctx.Provider>
+  )
+}
+
+export function useAppSettings() {
+  return useContext(Ctx)
+}
diff --git a/frontend/src/hooks/useAuth.ts b/frontend/src/hooks/useAuth.ts
new file mode 100644
index 0000000..9ac0652
--- /dev/null
+++ b/frontend/src/hooks/useAuth.ts
@@ -0,0 +1,55 @@
+import { useState, useEffect, useCallback } from 'react'
+import { authApi, setCSRFToken, type User } from '../api/client'
+
+export interface AuthState {
+  user: User | null
+  loading: boolean
+  login: (username: string, password: string) => Promise<void>
+  logout: () => Promise<void>
+  /** Lädt den Nutzer neu – vor allem für den Speicherverbrauch, der sich
+   *  bei jedem Hoch- und Herunterladen ändert. */
+  refreshUser: () => Promise<void>
+}
+
+export function useAuth(): AuthState {
+  const [user, setUser] = useState<User | null>(null)
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    authApi.me()
+      .then(({ user, csrf_token }) => {
+        setCSRFToken(csrf_token)
+        setUser(user)
+      })
+      .catch(() => setUser(null))
+      .finally(() => setLoading(false))
+  }, [])
+
+  const login = useCallback(async (username: string, password: string) => {
+    const { user, csrf_token } = await authApi.login(username, password)
+    setCSRFToken(csrf_token)
+    setUser(user)
+  }, [])
+
+  const refreshUser = useCallback(async () => {
+    try {
+      const { user, csrf_token } = await authApi.me()
+      // /auth/me erneuert das CSRF-Cookie bei jedem Aufruf. Wird das neue
+      // Token hier nicht übernommen, passen Cookie und Kopfzeile nicht mehr
+      // zusammen und jeder folgende schreibende Aufruf scheitert mit 403.
+      setCSRFToken(csrf_token)
+      setUser(user)
+    } catch {
+      /* Eine fehlgeschlagene Aktualisierung darf die Sitzung nicht beenden –
+         der angezeigte Wert bleibt dann eben kurz veraltet. */
+    }
+  }, [])
+
+  const logout = useCallback(async () => {
+    await authApi.logout()
+    setCSRFToken('')
+    setUser(null)
+  }, [])
+
+  return { user, loading, login, logout, refreshUser }
+}
diff --git a/frontend/src/hooks/useNavHistory.ts b/frontend/src/hooks/useNavHistory.ts
new file mode 100644
index 0000000..f724002
--- /dev/null
+++ b/frontend/src/hooks/useNavHistory.ts
@@ -0,0 +1,176 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { FolderItem } from '../api/client'
+
+export type View = 'files' | 'trash' | 'incoming' | 'shared' | 'admin' | 'profile' | 'tags' | 'from'
+
+const views: View[] = ['files', 'trash', 'incoming', 'shared', 'admin', 'profile', 'tags', 'from']
+
+export interface NavState {
+  view: View
+  /** Ordnerkette der Dateiansicht – leer heisst Wurzel. */
+  folderPath: FolderItem[]
+  /** Gewaehltes Etikett in der Etikettenansicht. Steht im Pfad (`/tags/<id>`),
+   *  damit ein Lesezeichen auf „alle Steuerbelege 2026" zeigen kann. */
+  tagId?: string
+  /** Gewaehlter Absender (`/from/<id>`) – „alles von den Stadtwerken". */
+  correspondentId?: string
+}
+
+/** Was im History-Eintrag steckt. Der Zaehler unterscheidet zwei Eintraege am
+ *  selben Ort und wandert beim Zurueckgehen mit. */
+interface NavEntry extends NavState {
+  index: number
+}
+
+const stateKey = 'aether:nav'
+
+function entryOf(raw: unknown): NavEntry | null {
+  const holder = raw as Record<string, unknown> | null
+  const e = holder?.[stateKey] as NavEntry | undefined
+  if (!e || !views.includes(e.view) || !Array.isArray(e.folderPath)) return null
+  return {
+    view: e.view,
+    folderPath: e.folderPath,
+    tagId: typeof e.tagId === 'string' ? e.tagId : undefined,
+    correspondentId: typeof e.correspondentId === 'string' ? e.correspondentId : undefined,
+    index: typeof e.index === 'number' ? e.index : 0,
+  }
+}
+
+/**
+ * Die Ansicht steht im Pfad (`/admin`), damit ein Lesezeichen sie trifft. Der
+ * Server liefert fuer jeden unbekannten Pfad die Anwendung aus (`spaHandler`),
+ * die Adresse ist also direkt aufrufbar.
+ */
+function viewFromUrl(): View {
+  const first = window.location.pathname.split('/')[1]
+  return views.includes(first as View) ? (first as View) : 'files'
+}
+
+function idFromUrl(prefix: string): string | undefined {
+  const parts = window.location.pathname.split('/')
+  return parts[1] === prefix && parts[2] ? parts[2] : undefined
+}
+
+function urlFor(s: NavState): string {
+  if (s.view === 'files') return '/'
+  if (s.view === 'tags' && s.tagId) return `/tags/${s.tagId}`
+  if (s.view === 'from' && s.correspondentId) return `/from/${s.correspondentId}`
+  return `/${s.view}`
+}
+
+function sameSpot(a: NavState, b: NavState): boolean {
+  if (a.view !== b.view) return false
+  // Zwei Etiketten sind zwei Orte – sonst ersetzte der Wechsel den Eintrag im
+  // Verlauf und die Zurueck-Taste spraenge an ihnen vorbei.
+  if (a.view === 'tags') return a.tagId === b.tagId
+  if (a.view === 'from') return a.correspondentId === b.correspondentId
+  if (a.view !== 'files') return true
+  const x = a.folderPath.at(-1)?.id
+  const y = b.folderPath.at(-1)?.id
+  return x === y
+}
+
+/**
+ * Haelt Ansicht und Ordnerkette im Verlauf des Browsers. Damit gehen die
+ * Zurueck-Taste, die Maustasten an der Seite und die Wischgeste – und ein
+ * Neuladen landet wieder da, wo man war, denn den State bringt der Browser
+ * zum Eintrag mit.
+ *
+ * Bedient wird das ausschliesslich ueber den Browser. Eigene Vor/Zurueck-Knoepfe
+ * standen bis zum 23.08.2026 in der Werkzeugleiste und sind wieder raus: Zwei
+ * Bedienelemente fuer dieselbe Sache, von denen eines nur die halbe Wahrheit
+ * kennt – ob es vorwaerts weitergeht, verraet der Browser einer Seite naemlich
+ * nicht.
+ */
+export function useNavHistory() {
+  const [state, setState] = useState<NavState>(() => {
+    const restored = entryOf(window.history.state)
+    return restored
+      ? {
+          view: restored.view, folderPath: restored.folderPath,
+          tagId: restored.tagId, correspondentId: restored.correspondentId,
+        }
+      : {
+          view: viewFromUrl(), folderPath: [],
+          tagId: idFromUrl('tags'), correspondentId: idFromUrl('from'),
+        }
+  })
+
+  const indexRef = useRef(entryOf(window.history.state)?.index ?? 0)
+
+  // Der erste Eintrag hat noch keinen State – ohne ihn faende ein spaeteres
+  // Zurueck nichts vor.
+  useEffect(() => {
+    if (entryOf(window.history.state)) return
+    const entry: NavEntry = { ...state, index: indexRef.current }
+    window.history.replaceState({ [stateKey]: entry }, '', urlFor(state))
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+
+  useEffect(() => {
+    function onPop(e: PopStateEvent) {
+      const entry = entryOf(e.state)
+      if (!entry) return
+      indexRef.current = entry.index
+      setState({
+        view: entry.view, folderPath: entry.folderPath,
+        tagId: entry.tagId, correspondentId: entry.correspondentId,
+      })
+    }
+    window.addEventListener('popstate', onPop)
+    return () => window.removeEventListener('popstate', onPop)
+  }, [])
+
+  // Der Verlauf wird beim Navigieren beschrieben – die Funktionen brauchen den
+  // aktuellen Stand, ohne selbst neu zu entstehen.
+  const stateRef = useRef(state)
+  stateRef.current = state
+
+  const navigate = useCallback((next: NavState) => {
+    // Denselben Ort nicht zweimal in den Verlauf legen: sonst braeuchte ein
+    // Klick auf den Ordner, in dem man schon steht, ein Zurueck.
+    if (sameSpot(stateRef.current, next)) {
+      const entry: NavEntry = { ...next, index: indexRef.current }
+      window.history.replaceState({ [stateKey]: entry }, '', urlFor(next))
+      setState(next)
+      return
+    }
+    const index = indexRef.current + 1
+    indexRef.current = index
+    window.history.pushState({ [stateKey]: { ...next, index } }, '', urlFor(next))
+    setState(next)
+  }, [])
+
+  // Die Ordnerkette faehrt bei jedem Ansichtswechsel mit, sonst stuende man
+  // nach einem Abstecher in den Papierkorb wieder in der Wurzel.
+  const setView = useCallback((view: View) => {
+    navigate({ view, folderPath: stateRef.current.folderPath })
+  }, [navigate])
+
+  const setFolderPath = useCallback((folderPath: FolderItem[]) => {
+    navigate({ view: 'files', folderPath })
+  }, [navigate])
+
+  /** Zu einem Etikett springen – eigener Eintrag im Verlauf. */
+  const setTag = useCallback((tagId: string) => {
+    navigate({ view: 'tags', folderPath: stateRef.current.folderPath, tagId })
+  }, [navigate])
+
+  /** Zu einem Absender springen – „alles von den Stadtwerken". */
+  const setCorrespondent = useCallback((correspondentId: string) => {
+    navigate({ view: 'from', folderPath: stateRef.current.folderPath, correspondentId })
+  }, [navigate])
+
+  return {
+    view: state.view,
+    folderPath: state.folderPath,
+    tagId: state.tagId,
+    correspondentId: state.correspondentId,
+    setView,
+    setFolderPath,
+    setTag,
+    setCorrespondent,
+    navigate,
+  }
+}
diff --git a/frontend/src/hooks/useOverlayDismiss.ts b/frontend/src/hooks/useOverlayDismiss.ts
new file mode 100644
index 0000000..c913173
--- /dev/null
+++ b/frontend/src/hooks/useOverlayDismiss.ts
@@ -0,0 +1,25 @@
+import { useRef, type MouseEvent } from 'react'
+
+/**
+ * Klick auf das Overlay schließt den Dialog – aber nur, wenn Drücken UND
+ * Loslassen beide auf dem Overlay passiert sind.
+ *
+ * Ohne die Merker-Prüfung reicht ein reines `onClick` nicht: Markiert man Text
+ * im Dialog und lässt die Maus außerhalb los, feuert der Browser `click` auf
+ * dem gemeinsamen Vorfahren – das Overlay. Der Dialog schlösse dann mitten in
+ * der Textauswahl. Ein `e.target === e.currentTarget`-Check allein hilft dabei
+ * nicht, weil das Ziel in genau diesem Fall tatsächlich das Overlay ist.
+ */
+export function useOverlayDismiss(onDismiss: () => void) {
+  const startedOnOverlay = useRef(false)
+
+  return {
+    onMouseDown: (e: MouseEvent) => {
+      startedOnOverlay.current = e.target === e.currentTarget
+    },
+    onClick: (e: MouseEvent) => {
+      if (startedOnOverlay.current && e.target === e.currentTarget) onDismiss()
+      startedOnOverlay.current = false
+    },
+  }
+}
diff --git a/frontend/src/index.css b/frontend/src/index.css
new file mode 100644
index 0000000..134d636
--- /dev/null
+++ b/frontend/src/index.css
@@ -0,0 +1,82 @@
+@import "tailwindcss";
+
+/* ── Design tokens (CSS variables) ──────────────────────────────────────────
+   Admin sets these globally in Phase 4. Users can override their own palette.
+   Defaults here are the Aether built-in theme.                              */
+:root {
+  --color-primary:     #6366f1;
+  --color-primary-rgb: 99, 102, 241;   /* für halbtransparente Flächen */
+  --color-primary-fg:  #ffffff;
+  --color-accent:      #8b5cf6;
+  --color-accent-rgb:  139, 92, 246;
+  --color-accent-fg:   #ffffff;
+  --color-background:  #0f172a;
+  --color-surface:     #1e293b;
+  --color-surface-2:   #334155;
+  --color-border:      #334155;
+  --color-text:        #f1f5f9;
+  --color-text-muted:  #94a3b8;
+  --color-danger:      #ef4444;
+  /* Ordnergelb. Vier Stellen benutzten diesen Namen bereits, definiert war er
+     nie – die Symbole erschienen deshalb schwarz. */
+  --color-warning:     #f59e0b;
+  --color-success:     #22c55e;
+  --radius:            0.5rem;
+}
+
+body {
+  background-color: var(--color-background);
+  color: var(--color-text);
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  -webkit-font-smoothing: antialiased;
+  margin: 0;
+  /* Kein Gummiband-Scrollen am Rand: In der installierten App sieht ein
+     Inhalt, der sich über den Anschlag hinausziehen lässt, nach einem Fehler
+     aus – es gibt ja keine Adressleiste, die dabei mitfährt. */
+  overscroll-behavior-y: none;
+}
+
+/* ── Sichere Bereiche (installierte App) ────────────────────────────────────
+   Mit viewport-fit=cover reicht die Seite bis unter Statusleiste und
+   Wischbalken. Ohne diese Abstände säße der obere Rand hinter der Uhr und der
+   Speicherbalken der Seitenleiste hinter dem Wischbalken – erreichbar wäre er
+   dann nicht mehr.
+
+   **Als Variablen, nicht als Klassen.** Vorher standen hier
+   `.aether-safe-top { padding-top: env(...) }` und zwei Geschwister – und sie
+   wirkten nirgends. Alle drei Stellen setzen ihren Abstand als Inline-Stil
+   (`style={{ padding: '12px 16px' }}`), und ein Inline-Stil schlägt jede
+   Klasse. Der Abstand wurde also berechnet und sofort überschrieben; in der
+   installierten App klebte die Kopfleiste an der Statusleiste.
+
+   Mit Variablen gibt es diesen Wettstreit nicht: Die Stelle, die den Abstand
+   ohnehin setzt, rechnet ihn selbst ein –
+   `paddingTop: 'calc(12px + var(--safe-top))'`.
+
+   env() ist auf Geräten ohne Aussparung 0, die Variablen kosten dort nichts.
+   Nur in der installierten App gesetzt: Im Browser übernimmt die Adressleiste
+   diese Aufgabe schon. */
+:root {
+  --safe-top: 0px;
+  --safe-bottom: 0px;
+  --safe-left: 0px;
+}
+
+@media (display-mode: standalone) {
+  :root {
+    --safe-top:    env(safe-area-inset-top, 0px);
+    --safe-bottom: env(safe-area-inset-bottom, 0px);
+    --safe-left:   env(safe-area-inset-left, 0px);
+  }
+}
+
+* {
+  box-sizing: border-box;
+}
+
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: var(--color-surface-2); border-radius: 999px; }
+::-webkit-scrollbar-thumb:hover { background: var(--color-text-muted); }
+
+::selection { background: var(--color-primary); color: #fff; }
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
new file mode 100644
index 0000000..a717695
--- /dev/null
+++ b/frontend/src/main.tsx
@@ -0,0 +1,12 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+)
diff --git a/frontend/src/pages/AdminPage.tsx b/frontend/src/pages/AdminPage.tsx
new file mode 100644
index 0000000..f5017d9
--- /dev/null
+++ b/frontend/src/pages/AdminPage.tsx
@@ -0,0 +1,54 @@
+import { useState, useEffect } from 'react'
+import { adminApi, type AdminUser } from '../api/client'
+import PageHeader from '../components/PageHeader'
+import Tabs from '../components/Tabs'
+type Tab = 'users' | 'groups' | 'theming' | 'audit'
+
+import UsersTab from './admin/UsersTab'
+import GroupsTab from './admin/GroupsTab'
+import ThemingTab from './admin/ThemingTab'
+import AuditTab from './admin/AuditTab'
+
+export default function AdminPage() {
+  const [tab, setTab] = useState<Tab>('users')
+  const [allUsers, setAllUsers] = useState<AdminUser[]>([])
+
+  useEffect(() => {
+    adminApi.listUsers().then(data => setAllUsers(data ?? [])).catch(() => {})
+  }, [])
+
+  const tabs: { id: Tab; label: string }[] = [
+    { id: 'users', label: 'Users' },
+    { id: 'groups', label: 'Groups' },
+    { id: 'theming', label: 'Theming' },
+    // „Activity" statt „Audit log": Der Reiter zeigt nicht mehr nur das
+    // Protokoll, sondern davor auch den Stand der Texterkennung und die
+    // Speicherbereinigung – alles, was im Hintergrund läuft. Die Kennung
+    // bleibt 'audit', sie steht in keiner Adresse und muss nicht wandern.
+    { id: 'audit', label: 'Activity' },
+  ]
+
+  return (
+    <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+      <PageHeader
+        icon={
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <path d="M12 2l8 4v6c0 5-3.5 8.5-8 10-4.5-1.5-8-5-8-10V6z" />
+            <path d="M9.5 12.5l1.8 1.8 3.4-3.6" />
+          </svg>
+        }
+        title="Admin panel"
+        meta="Users, groups, appearance and activity"
+      />
+
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+      <Tabs tabs={tabs} active={tab} onChange={setTab} />
+
+      {tab === 'users' && <UsersTab />}
+      {tab === 'groups' && <GroupsTab allUsers={allUsers} />}
+      {tab === 'theming' && <ThemingTab />}
+      {tab === 'audit' && <AuditTab />}
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/pages/FileBrowser.tsx b/frontend/src/pages/FileBrowser.tsx
new file mode 100644
index 0000000..e5add0c
--- /dev/null
+++ b/frontend/src/pages/FileBrowser.tsx
@@ -0,0 +1,1072 @@
+import React, { useState, useEffect, useCallback, useRef, type DragEvent } from 'react'
+import {
+  filesApi, foldersApi, versionsApi, uploadWithProgress, downloadZip,
+  tagsChangedEvent,
+  isOfficeFile, type Correspondent, type FileItem, type FolderItem, type SearchHit, type Tag, type User, APIError
+} from '../api/client'
+import Breadcrumb from '../components/Breadcrumb'
+import SearchBox from '../components/SearchBox'
+import PageHeader from '../components/PageHeader'
+import GridView, { ListView } from '../components/FileViews'
+import FilePreview, { canPreview } from '../components/FilePreview'
+import ContextMenu, { type MenuItem } from '../components/ContextMenu'
+import UploadQueue, { type UploadItem } from '../components/UploadQueue'
+import InputDialog from '../components/Dialog'
+import ShareDialog from '../components/ShareDialog'
+import ShareWithDialog from '../components/ShareWithDialog'
+import ConfirmDialog from '../components/ConfirmDialog'
+import VersionsDialog from '../components/VersionsDialog'
+import FileInfoDialog from '../components/FileInfoDialog'
+import MoveTo from '../components/MoveTo'
+import TagDialog from '../components/TagDialog'
+import OfficeEditor from '../components/OfficeEditor'
+import { useAppSettings } from '../hooks/useAppSettings'
+import { DownloadIcon, ShareIcon, HistoryIcon, RenameIcon, MoveIcon, TrashIcon, FolderOpenIcon, StarIcon, CheckIcon, PeopleIcon, TagIcon, OfficeIcon, InfoIcon } from '../components/icons'
+
+interface Props {
+  user: User
+  /** Ordnerkette – liegt im Verlauf des Browsers, nicht hier. */
+  folderPath: FolderItem[]
+  onNavigate: (path: FolderItem[]) => void
+  /** Nach Änderungen am Bestand aufrufen, damit der Speicherbalken stimmt. */
+  onUserChanged?: () => Promise<void>
+}
+
+// Robust client-side ID for upload-queue keys. crypto.randomUUID() only exists
+// in secure contexts (https/localhost); fall back so uploads work everywhere
+// (e.g. behind VS Code port forwarding).
+function uid(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID()
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
+}
+
+type Dialog =
+  | { type: 'rename'; file: FileItem }
+  | { type: 'rename-folder'; folder: FolderItem }
+  | { type: 'confirm-delete-folder'; folder: FolderItem }
+  | { type: 'new-folder' }
+  | { type: 'share'; file: FileItem }
+  | { type: 'share-with'; resource: { type: 'folder' | 'file'; id: string; name: string } }
+  | { type: 'versions'; file: FileItem }
+  | { type: 'confirm-delete'; file: FileItem }
+  | { type: 'move-file'; file: FileItem }
+  | { type: 'move-folder'; folder: FolderItem }
+  | { type: 'tags'; file: FileItem }
+  | { type: 'info'; file: FileItem }
+
+interface CtxMenu { x: number; y: number; items: MenuItem[] }
+
+/** Löst den Download aus, ohne einen Tab zu öffnen.
+ *
+ *  `window.open` erzeugte ein leeres Fenster, das je nach Browser stehen blieb
+ *  oder kommentarlos zuklappte. Ein Klick auf ein Anker-Element mit
+ *  `download`-Attribut ist keine Navigation – der Browser behandelt es direkt
+ *  als Download und der Dateiname aus `Content-Disposition` bleibt erhalten. */
+function downloadFile(file: FileItem) {
+  const a = document.createElement('a')
+  a.href = filesApi.download(file.id)
+  a.download = file.name
+  document.body.appendChild(a)
+  a.click()
+  a.remove()
+}
+
+type ViewMode = 'grid' | 'list'
+type Sort = 'name-asc' | 'name-desc' | 'size-asc' | 'size-desc' | 'date-asc' | 'date-desc'
+
+const sortLabels: Record<Sort, string> = {
+  'name-asc': 'Name A–Z',
+  'name-desc': 'Name Z–A',
+  'size-asc': 'Smallest first',
+  'size-desc': 'Largest first',
+  'date-asc': 'Oldest first',
+  'date-desc': 'Newest first',
+}
+
+/** Einstellungen im Browser des Nutzers. Ein privater Zwischenspeicher, der
+ *  fehlen darf – deshalb überall abgesichert statt geprüft. */
+function loadPref<T extends string>(key: string, fallback: T): T {
+  try {
+    const v = localStorage.getItem(key)
+    return (v as T) || fallback
+  } catch { return fallback }
+}
+function savePref(key: string, value: string) {
+  try { localStorage.setItem(key, value) } catch { /* privates Fenster */ }
+}
+
+/** Ordner haben keine Größe und kein sinnvolles Änderungsdatum in der Liste –
+ *  sie werden deshalb immer nach Namen sortiert, nur die Richtung zählt. */
+function sortFolders(folders: FolderItem[], sort: Sort): FolderItem[] {
+  const desc = sort.endsWith('-desc') && sort.startsWith('name')
+  return [...folders].sort((a, b) =>
+    desc ? b.name.localeCompare(a.name) : a.name.localeCompare(b.name))
+}
+
+function sortFiles(files: FileItem[], sort: Sort): FileItem[] {
+  const [field, dir] = sort.split('-')
+  const factor = dir === 'desc' ? -1 : 1
+  return [...files].sort((a, b) => {
+    switch (field) {
+      case 'size': return (a.size - b.size) * factor
+      case 'date': return (new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime()) * factor
+      default: return a.name.localeCompare(b.name) * factor
+    }
+  })
+}
+
+export function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`
+  return `${(n / 1024 ** 3).toFixed(1)} GB`
+}
+
+
+export default function FileBrowser({
+  user: _user, folderPath, onNavigate, onUserChanged,
+}: Props) {
+  const [files, setFiles] = useState<FileItem[]>([])
+  const [folders, setFolders] = useState<FolderItem[]>([])
+  const [loading, setLoading] = useState(true)
+  const [uploads, setUploads] = useState<UploadItem[]>([])
+  const [ctxMenu, setCtxMenu] = useState<CtxMenu | null>(null)
+  const [dialog, setDialog] = useState<Dialog | null>(null)
+  const [dragging, setDragging] = useState(false)
+  const [dragOverFolder, setDragOverFolder] = useState<string | null>(null)
+  const [viewMode, setViewMode] = useState<ViewMode>(() => loadPref('aether:view', 'grid'))
+  const [sort, setSort] = useState<Sort>(() => loadPref('aether:sort', 'name-asc'))
+  const [preview, setPreview] = useState<FileItem | null>(null)
+  /** Datei, die gerade im Office-Server bearbeitet wird. */
+  const [editing, setEditing] = useState<FileItem | null>(null)
+  const { officeEnabled } = useAppSettings()
+
+  /** Datei, zu der gerade aus der Suche gesprungen wurde – siehe openHitFile.
+   *  Die Markierung verschwindet von selbst; ein Rahmen, der bleibt, sähe
+   *  irgendwann wie ein Zustand aus statt wie ein Hinweis. */
+  /** Etiketten je Datei-ID – kommen mit der Ordnerliste in einer Abfrage mit,
+   *  nicht einzeln je Kachel. */
+  const [fileTags, setFileTags] = useState<Record<string, Tag[]>>({})
+  /** Absender je Datei-ID – kommt mit derselben Abfrage wie die Etiketten. */
+  const [fileCorrespondents, setFileCorrespondents] =
+    useState<Record<string, Correspondent>>({})
+
+  /**
+   * Ausgewählte Dateien für den Sammel-Download.
+   *
+   * Der zuletzt angeklickte Eintrag wird gemerkt, damit die Umschalttaste
+   * einen Bereich auswählen kann – wie in jedem Dateimanager.
+   */
+  const [selected, setSelected] = useState<Set<string>>(() => new Set())
+  const lastPicked = useRef<string | null>(null)
+
+  const [highlightId, setHighlightId] = useState<string | null>(null)
+  /**
+   * Das Wort, mit dem die zuletzt angesprungene Datei gefunden wurde.
+   *
+   * Es wandert bis in den PDF-Betrachter durch: Findet die Volltextsuche
+   * „Garantie" auf Seite 7 eines Scans, soll das Öffnen auch dort landen und
+   * nicht auf Seite 1. Gilt nur für die *eine* Datei aus dem Treffer – wer
+   * danach weiterblättert, sucht nicht mehr.
+   */
+  const [hitTerm, setHitTerm] = useState<{ id: string; term: string } | null>(null)
+  useEffect(() => {
+    if (!highlightId) return
+    const t = setTimeout(() => setHighlightId(null), 2600)
+    return () => clearTimeout(t)
+  }, [highlightId])
+
+  // Ansicht und Sortierung überleben das Neuladen – eine Einstellung, die man
+  // bei jedem Besuch neu treffen muss, ist keine.
+  useEffect(() => { savePref('aether:view', viewMode) }, [viewMode])
+  useEffect(() => { savePref('aether:sort', sort) }, [sort])
+  const fileInputRef = useRef<HTMLInputElement>(null)
+
+  const currentFolderId = folderPath.at(-1)?.id
+
+  /** Nur die Absender-Zuordnung neu holen, ohne die ganze Dateiliste. */
+  const reloadCorrespondents = useCallback(async () => {
+    try {
+      const data = await filesApi.list(currentFolderId)
+      setFileCorrespondents(data.correspondents ?? {})
+    } catch {
+      /* die Kachel zeigt dann den alten Stand – kein Grund für eine Meldung */
+    }
+  }, [currentFolderId])
+
+  const load = useCallback(async () => {
+    setLoading(true)
+    try {
+      const data = await filesApi.list(currentFolderId)
+      setFiles(data.files ?? [])
+      setFolders(data.folders ?? [])
+      setFileTags(data.tags ?? {})
+      setFileCorrespondents(data.correspondents ?? {})
+    } catch {
+      // silent
+    } finally {
+      setLoading(false)
+    }
+  }, [currentFolderId])
+
+  // Nach Änderungen am Bestand: Liste neu holen und den Speicherverbrauch
+  // nachziehen. Der Wert steckt im Nutzer-Objekt und wurde bisher nur beim
+  // Anmelden geholt – der Balken blieb deshalb bis zum nächsten Neuladen stehen.
+  const reload = useCallback(async () => {
+    await load()
+    await onUserChanged?.()
+  }, [load, onUserChanged])
+
+  useEffect(() => { load() }, [load])
+
+  // Beim Ordnerwechsel die Auswahl verwerfen: Eine Auswahl, die man nicht mehr
+  // sieht, aber beim Herunterladen mitkäme, wäre eine böse Überraschung.
+  useEffect(() => { setSelected(new Set()); lastPicked.current = null }, [currentFolderId])
+
+  /**
+   * Escape hebt die Auswahl auf.
+   *
+   * Nur, wenn sonst nichts offen ist: Vorschau und Dialoge haben dieselbe
+   * Taste, und die soll zuerst *die* schließen. Sonst stünde man nach dem
+   * Schließen eines Dialogs plötzlich ohne Auswahl da, ohne zu wissen, warum.
+   *
+   * Ebenso nicht, während man in einem Feld tippt – dort bedeutet Escape
+   * „Eingabe verwerfen", nicht „Auswahl aufheben".
+   */
+  useEffect(() => {
+    if (selected.size === 0) return
+    function onKey(e: KeyboardEvent) {
+      if (e.key !== 'Escape') return
+      if (preview || dialog || ctxMenu) return
+      const el = document.activeElement
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) return
+      setSelected(new Set())
+      lastPicked.current = null
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [selected.size, preview, dialog, ctxMenu])
+
+  /**
+   * Nach einer Änderung an den Etiketten die Liste neu holen.
+   *
+   * Beim Setzen an *einer* Datei genügt es, deren Eintrag nachzuziehen – das
+   * macht der Dialog selbst. Beim Umbenennen oder Löschen betrifft es aber
+   * jede Datei, die das Etikett trägt: Ohne das stünde an den Kacheln noch
+   * der alte Name, und nach dem Löschen ein Aufkleber, den es nicht mehr gibt.
+   */
+  useEffect(() => {
+    window.addEventListener(tagsChangedEvent, load)
+    return () => window.removeEventListener(tagsChangedEvent, load)
+  }, [load])
+
+  // ── Navigation ─────────────────────────────────────────────────────────────
+
+  function navigateTo(folder: FolderItem) {
+    const idx = folderPath.findIndex(f => f.id === folder.id)
+    onNavigate(idx >= 0 ? folderPath.slice(0, idx + 1) : [...folderPath, folder])
+  }
+
+  function navigateById(folderId: string | undefined) {
+    if (!folderId) { onNavigate([]); return }
+    const idx = folderPath.findIndex(f => f.id === folderId)
+    if (idx >= 0) onNavigate(folderPath.slice(0, idx + 1))
+  }
+
+  /**
+   * Doppelklick auf eine Datei: anschauen, wenn der Browser das kann – sonst
+   * herunterladen. Vorher lud ein Doppelklick immer herunter, was bei einem
+   * Bild ein Umweg über den Download-Ordner war.
+   */
+  /**
+   * Doppelklick auf eine Datei.
+   *
+   * Bei einem Textdokument oder einer Tabelle heisst „oeffnen" **bearbeiten** –
+   * dafuer gibt es die Datei. Die Vorschau bleibt fuer alles, was man nur
+   * ansieht; heruntergeladen wird, was der Browser nicht zeigen kann.
+   */
+  function openFile(file: FileItem) {
+    if (officeEnabled && isOfficeFile(file.name)) setEditing(file)
+    else if (canPreview(file)) setPreview(file)
+    else downloadFile(file)
+  }
+
+  const sortedFolders = sortFolders(folders, sort)
+  const sortedFiles = sortFiles(files, sort)
+
+  // Blättern in der Vorschau geht nur über das, was sich auch anzeigen lässt –
+  // sonst landet man mit dem Pfeil auf einer ZIP-Datei und sieht nichts.
+  const previewable = sortedFiles.filter(canPreview)
+  function stepPreview(delta: number) {
+    if (!preview) return
+    const i = previewable.findIndex(f => f.id === preview.id)
+    if (i < 0) return
+    const next = previewable[(i + delta + previewable.length) % previewable.length]
+    setPreview(next)
+  }
+
+  /**
+   * Datei-Treffer: in den Ordner springen und die Datei gleich zeigen. Nur
+   * hinzuspringen und den Nutzer selbst suchen zu lassen wäre die halbe Sache –
+   * er hat sie ja gerade benannt.
+   */
+  /**
+   * Treffer aus der Suche: **nur** zum Ordner springen, nicht öffnen.
+   *
+   * Bis zum 23.08.2026 ging zugleich die Vorschau auf. Das war verwirrend –
+   * ein Klick in einer Trefferliste ließ unangekündigt einen Betrachter über
+   * den Bildschirm klappen, und wer nur nachsehen wollte, *wo* die Datei liegt,
+   * musste ihn erst wieder schließen. Geöffnet wird jetzt dort, wo man es
+   * erwartet: mit einem Doppelklick auf die Datei selbst.
+   *
+   * Damit der Sprung trotzdem etwas taugt, wird die Datei kurz umrandet und in
+   * den sichtbaren Bereich geholt – in einem Ordner mit fünfzig Einträgen
+   * suchte man sonst von vorn.
+   */
+  function toggleSelect(id: string, range: boolean) {
+    setSelected(prev => {
+      const next = new Set(prev)
+      const list = sortedFiles
+      if (range && lastPicked.current) {
+        // Bereich zwischen dem zuletzt angeklickten und diesem Eintrag – in
+        // der *angezeigten* Reihenfolge, nicht in der Reihenfolge der Daten.
+        const a = list.findIndex(f => f.id === lastPicked.current)
+        const b = list.findIndex(f => f.id === id)
+        if (a >= 0 && b >= 0) {
+          for (let i = Math.min(a, b); i <= Math.max(a, b); i++) next.add(list[i].id)
+          return next
+        }
+      }
+      next.has(id) ? next.delete(id) : next.add(id)
+      return next
+    })
+    lastPicked.current = id
+  }
+
+  function downloadSelection() {
+    const here = folderPath.at(-1)?.name
+    downloadZip({
+      fileIds: [...selected],
+      name: here ? `${here} (selection)` : 'selection',
+    })
+  }
+
+  function openHitFile(hit: SearchHit, term: string) {
+    openFromSearch(hit.folder_id, hit.folder_name)
+    setHighlightId(hit.id)
+    // Nur bei einem Inhaltstreffer: Wurde bloß der Dateiname getroffen, steht
+    // das Wort im Dokument womöglich nirgends, und die Suche im Betrachter
+    // meldete „keine Treffer" – ein Hinweis auf einen Fehler, wo keiner ist.
+    setHitTerm(hit.matched_content ? { id: hit.id, term } : null)
+  }
+
+  /**
+   * Sprung aus der Trefferliste. Die Kette darüber kennen wir nicht – es gibt
+   * keine Abfrage, die zu einer Ordner-ID die Vorfahren liefert –, deshalb
+   * fängt der Pfad beim Ziel selbst an. Dasselbe tut die Seitenleiste bei
+   * einem Favoriten.
+   */
+  function openFromSearch(folderId: string | null, folderName: string) {
+    if (!folderId) { onNavigate([]); return }
+    onNavigate([{
+      id: folderId, owner_id: null, group_id: null, parent_id: null,
+      name: folderName, created_at: '',
+    }])
+  }
+
+  // ── Upload ──────────────────────────────────────────────────────────────────
+
+  async function uploadFiles(fileList: File[]) {
+    const folderId = currentFolderId
+
+    // Register all items in the queue immediately
+    const items = fileList.map(file => ({ id: uid(), file }))
+    setUploads(u => [...u, ...items.map(({ id, file }) => ({
+      id, name: file.name, progress: 0, status: 'uploading' as const,
+    }))])
+
+    // Upload up to 3 files in parallel
+    const concurrency = 3
+    const queue = [...items]
+    const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+      while (queue.length > 0) {
+        const item = queue.shift()!
+        try {
+          await uploadWithProgress(item.file, folderId, ({ percent }) => {
+            setUploads(u => u.map(x => x.id === item.id ? { ...x, progress: percent } : x))
+          })
+          setUploads(u => u.map(x => x.id === item.id ? { ...x, progress: 100, status: 'done' } : x))
+        } catch (err) {
+          const msg = err instanceof APIError ? err.message : 'Upload failed'
+          setUploads(u => u.map(x => x.id === item.id ? { ...x, status: 'error', error: msg } : x))
+        }
+      }
+    })
+
+    await Promise.all(workers)
+    await reload()
+  }
+
+  async function onDrop(e: DragEvent) {
+    e.preventDefault()
+    setDragging(false)
+    const t = e.dataTransfer.types
+    if (t.includes('aether-file-id') || t.includes('aether-folder-id')) return  // internal move, not upload
+
+    // Capture FileSystemEntries synchronously – the DataTransferItemList is only
+    // valid during the drop event itself.
+    const entries: FileSystemEntry[] = []
+    const items = e.dataTransfer.items
+    if (items && items.length) {
+      for (let i = 0; i < items.length; i++) {
+        const entry = items[i].webkitGetAsEntry?.()
+        if (entry) entries.push(entry)
+      }
+    }
+    const fileList = Array.from(e.dataTransfer.files)
+
+    // If any dropped item is a directory, traverse it and upload as a folder tree.
+    if (entries.some(en => en.isDirectory)) {
+      const gathered = await gatherFromEntries(entries)
+      if (gathered.length) await uploadFolder(gathered)
+    } else if (fileList.length) {
+      uploadFiles(fileList)
+    }
+  }
+
+  // Recursively walk dropped FileSystemEntries into {file, relativePath} pairs.
+  async function gatherFromEntries(entries: FileSystemEntry[]): Promise<{ file: File; relativePath: string }[]> {
+    const out: { file: File; relativePath: string }[] = []
+
+    async function walk(entry: FileSystemEntry, prefix: string): Promise<void> {
+      if (entry.isFile) {
+        const fileEntry = entry as FileSystemFileEntry
+        const file = await new Promise<File>((res, rej) => fileEntry.file(res, rej))
+        out.push({ file, relativePath: prefix + entry.name })
+      } else if (entry.isDirectory) {
+        const reader = (entry as FileSystemDirectoryEntry).createReader()
+        const children: FileSystemEntry[] = []
+        // readEntries returns in batches – loop until it yields nothing.
+        for (;;) {
+          const batch: FileSystemEntry[] = await new Promise((res, rej) => reader.readEntries(res, rej))
+          if (batch.length === 0) break
+          children.push(...batch)
+        }
+        for (const child of children) await walk(child, prefix + entry.name + '/')
+      }
+    }
+
+    for (const entry of entries) await walk(entry, '')
+    return out
+  }
+
+  async function handleDropOnFolder(e: React.DragEvent, folder: FolderItem) {
+    e.preventDefault()
+    e.stopPropagation()
+    setDragOverFolder(null)
+
+    const fileId = e.dataTransfer.getData('aether-file-id')
+    if (fileId) {
+      try {
+        await filesApi.move(fileId, folder.id)
+        await reload()
+      } catch { /* silent */ }
+      return
+    }
+
+    const srcFolderId = e.dataTransfer.getData('aether-folder-id')
+    if (srcFolderId && srcFolderId !== folder.id) {
+      try {
+        await foldersApi.move(srcFolderId, folder.id)
+        await reload()
+      } catch { /* silent */ }
+    }
+  }
+
+  async function handleMoveFile(file: FileItem, targetFolderId: string | null) {
+    setDialog(null)
+    try {
+      await filesApi.move(file.id, targetFolderId)
+      await reload()
+    } catch { /* silent */ }
+  }
+
+  async function handleMoveFolder(folder: FolderItem, targetParentId: string | null) {
+    setDialog(null)
+    try {
+      await foldersApi.move(folder.id, targetParentId)
+      await reload()
+    } catch { /* silent */ }
+  }
+
+  async function uploadFolder(entries: { file: File; relativePath: string }[]) {
+    if (!entries.length) return
+    const folderId = currentFolderId
+
+    // relativePath looks like "TopFolder/sub/file.txt" — the full tree (including the
+    // dropped folder itself) is recreated under the current folder.
+    const folderCache = new Map<string, string>()  // "a/b" → folderId
+
+    async function ensureFolder(relPath: string): Promise<string | undefined> {
+      if (!relPath) return folderId
+      if (folderCache.has(relPath)) return folderCache.get(relPath)!
+      const parts = relPath.split('/')
+      let currentParent = folderId
+      let accumulated = ''
+      for (const part of parts) {
+        accumulated = accumulated ? `${accumulated}/${part}` : part
+        if (folderCache.has(accumulated)) {
+          currentParent = folderCache.get(accumulated)!
+        } else {
+          const f = await foldersApi.create(part, currentParent)
+          folderCache.set(accumulated, f.id)
+          currentParent = f.id
+        }
+      }
+      return currentParent
+    }
+
+    // Group files by their folder path (everything except the filename).
+    const grouped = new Map<string, { file: File; relativePath: string }[]>()
+    for (const entry of entries) {
+      const parts = entry.relativePath.split('/')
+      parts.pop()  // remove filename
+      const folderPart = parts.join('/')
+      if (!grouped.has(folderPart)) grouped.set(folderPart, [])
+      grouped.get(folderPart)!.push(entry)
+    }
+
+    // Register upload queue items
+    const queued = entries.map(e => ({ id: uid(), entry: e }))
+    setUploads(u => [...u, ...queued.map(({ id, entry }) => ({
+      id, name: entry.relativePath, progress: 0, status: 'uploading' as const,
+    }))])
+
+    let itemIdx = 0
+    for (const [relFolderPath, files] of grouped) {
+      const targetId = await ensureFolder(relFolderPath).catch(() => folderId)
+
+      for (const { file } of files) {
+        const uploadId = queued[itemIdx++]?.id
+        try {
+          await uploadWithProgress(file, targetId, ({ percent }) => {
+            if (uploadId) setUploads(u => u.map(x => x.id === uploadId ? { ...x, progress: percent } : x))
+          })
+          if (uploadId) setUploads(u => u.map(x => x.id === uploadId ? { ...x, progress: 100, status: 'done' } : x))
+        } catch (err) {
+          const msg = err instanceof APIError ? err.message : 'Upload failed'
+          if (uploadId) setUploads(u => u.map(x => x.id === uploadId ? { ...x, status: 'error', error: msg } : x))
+        }
+      }
+    }
+    await reload()
+  }
+
+  // ── Actions ────────────────────────────────────────────────────────────────
+
+  async function handleDelete(file: FileItem) {
+    try {
+      await filesApi.delete(file.id)
+      setFiles(f => f.filter(x => x.id !== file.id))
+      // Die Liste wird bewusst nur lokal angepasst (schneller), der belegte
+      // Speicher muss aber vom Server kommen – sonst bleibt der Balken stehen.
+      await onUserChanged?.()
+    } catch { /* todo: toast */ }
+    setDialog(null)
+  }
+
+  async function handleRename(file: FileItem, name: string) {
+    try {
+      const updated = await filesApi.rename(file.id, name)
+      setFiles(f => f.map(x => x.id === file.id ? updated : x))
+    } catch { /* todo: toast */ }
+    setDialog(null)
+  }
+
+  async function handleCreateFolder(name: string) {
+    try {
+      const folder = await foldersApi.create(name, currentFolderId)
+      setFolders(f => [...f, folder].sort((a, b) => a.name.localeCompare(b.name)))
+    } catch { /* todo: toast */ }
+    setDialog(null)
+  }
+
+  async function handleRenameFolder(folder: FolderItem, name: string) {
+    try {
+      const updated = await foldersApi.rename(folder.id, name)
+      setFolders(f => f.map(x => x.id === folder.id ? updated : x).sort((a, b) => a.name.localeCompare(b.name)))
+    } catch { /* todo: toast */ }
+    setDialog(null)
+  }
+
+  async function handleDeleteFolder(folder: FolderItem) {
+    try {
+      await foldersApi.delete(folder.id)
+      setFolders(f => f.filter(x => x.id !== folder.id))
+      await onUserChanged?.()
+    } catch { /* todo: toast */ }
+    setDialog(null)
+  }
+
+  async function toggleVersioning(file: FileItem, enabled: boolean) {
+    try {
+      const updated = await versionsApi.setEnabled(file.id, enabled)
+      setFiles(fs => fs.map(f => f.id === file.id ? updated : f))
+    } catch { /* Zustand bleibt, wie er war */ }
+  }
+
+  function openFileMenu(e: React.MouseEvent, file: FileItem) {
+    e.preventDefault()
+    setCtxMenu({
+      x: e.clientX, y: e.clientY,
+      // Nach Zweck gruppiert: erst was man am häufigsten will, dann Teilen,
+      // dann Verwalten, und ganz unten abgesetzt das Löschen.
+      items: [
+        { label: 'Download', icon: <DownloadIcon />, onClick: () => downloadFile(file) },
+        // Nachschlagen statt anfassen – deshalb direkt beim Herunterladen und
+        // nicht unten bei Umbenennen/Verschieben. Beantwortet Fragen, die die
+        // Kachel nicht beantwortet: Bildmaße, genaue Bytezahl, Prüfsumme.
+        { label: 'Properties…', icon: <InfoIcon />, onClick: () => setDialog({ type: 'info', file }) },
+        { separator: true },
+        {
+          label: 'Share with people…',
+          icon: <PeopleIcon />,
+          onClick: () => setDialog({ type: 'share-with', resource: { type: 'file', id: file.id, name: file.name } }),
+        },
+        { label: 'Share link…', icon: <ShareIcon />, onClick: () => setDialog({ type: 'share', file }) },
+        { separator: true },
+        // Zwischen Teilen und Verwalten: Etikettieren ist beides nicht ganz –
+        // es ordnet ein, ohne die Datei anzufassen.
+        // Hiess bis zum 23.08.2026 „Tags…". Der Dialog setzt inzwischen drei
+        // Dinge – Etiketten, Absender und Belegdatum –, und ein Menuepunkt,
+        // der nur eines davon nennt, laesst die anderen beiden unauffindbar.
+        { label: 'Organise…', icon: <TagIcon />, onClick: () => setDialog({ type: 'tags', file }) },
+        // Nur bei passenden Dateien und nur, wenn es einen Office-Server gibt.
+        // Ein Punkt, der immer scheitert, ist schlimmer als keiner.
+        ...(officeEnabled && isOfficeFile(file.name)
+          ? [{ label: 'Edit in Office…', icon: <OfficeIcon />, onClick: () => setEditing(file) }]
+          : []),
+        { separator: true },
+        { label: 'Version history…', icon: <HistoryIcon />, onClick: () => setDialog({ type: 'versions', file }) },
+        {
+          label: 'Keep versions',
+          icon: <CheckIcon />,
+          checked: file.versioning_enabled,
+          onClick: () => toggleVersioning(file, !file.versioning_enabled),
+        },
+        { separator: true },
+        { label: 'Rename…', icon: <RenameIcon />, onClick: () => setDialog({ type: 'rename', file }) },
+        { label: 'Move to…', icon: <MoveIcon />, onClick: () => setDialog({ type: 'move-file', file }) },
+        { separator: true },
+        { label: 'Delete', icon: <TrashIcon />, danger: true, onClick: () => setDialog({ type: 'confirm-delete', file }) },
+      ]
+    })
+  }
+
+  function openFolderMenu(e: React.MouseEvent, folder: FolderItem) {
+    e.preventDefault()
+    const isFav = (window as any).__aetherIsFavorite?.(folder.id) ?? false
+
+    // Ein Gruppenordner gehört der Gruppe, nicht dem, der ihn gerade offen hat.
+    // Umbenennen, Verschieben und Löschen fehlen deshalb ganz statt als
+    // Einträge, die nur eine Fehlermeldung liefern – der Server lehnt sie
+    // ohnehin ab. Alles *innerhalb* des Ordners bleibt normal bedienbar.
+    const isGroupFolder = folder.group_id !== null
+
+    setCtxMenu({
+      x: e.clientX, y: e.clientY,
+      items: [
+        { label: 'Open', icon: <FolderOpenIcon />, onClick: () => navigateTo(folder) },
+        {
+          label: 'Favourite',
+          icon: <StarIcon filled={isFav} />,
+          checked: isFav,
+          onClick: () => isFav
+            ? (window as any).__aetherRemoveFavorite?.(folder.id)
+            : (window as any).__aetherAddFavorite?.(folder),
+        },
+        ...(isGroupFolder ? [] : [
+          { separator: true as const },
+          {
+            label: 'Share with people…',
+            icon: <PeopleIcon />,
+            onClick: () => setDialog({ type: 'share-with', resource: { type: 'folder' as const, id: folder.id, name: folder.name } }),
+          },
+          { separator: true as const },
+          // Ganzer Ordnerinhalt als Archiv – mit Unterordnern, ihre Struktur
+          // bleibt im Archiv erhalten.
+          { label: 'Download as ZIP', icon: <DownloadIcon />, onClick: () => downloadZip({ folderId: folder.id, name: folder.name }) },
+          { separator: true as const },
+          { label: 'Rename…', icon: <RenameIcon />, onClick: () => setDialog({ type: 'rename-folder', folder }) },
+          { label: 'Move to…', icon: <MoveIcon />, onClick: () => setDialog({ type: 'move-folder', folder }) },
+          { separator: true as const },
+          { label: 'Delete', icon: <TrashIcon />, danger: true, onClick: () => setDialog({ type: 'confirm-delete-folder', folder }) },
+        ]),
+      ]
+    })
+  }
+
+  // ── Render ─────────────────────────────────────────────────────────────────
+
+  const isEmpty = !loading && files.length === 0 && folders.length === 0
+
+  return (
+    <div
+      style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}
+      onDragOver={e => {
+        e.preventDefault()
+        const t = e.dataTransfer.types
+        if (t.includes('Files') && !t.includes('aether-file-id') && !t.includes('aether-folder-id')) setDragging(true)
+      }}
+      onDragLeave={e => { if (!e.currentTarget.contains(e.relatedTarget as Node)) setDragging(false) }}
+      onDrop={onDrop}
+    >
+      {/* Drag overlay */}
+      {dragging && (
+        <div style={{
+          position: 'fixed', inset: 0, zIndex: 100,
+          background: 'rgba(var(--color-primary-rgb), 0.12)',
+          border: '3px dashed var(--color-primary)',
+          borderRadius: 16,
+          margin: 8,
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+          pointerEvents: 'none',
+        }}>
+          <div style={{ textAlign: 'center' }}>
+            <div style={{ fontSize: 48, marginBottom: 8 }}>☁️</div>
+            <p style={{ color: 'var(--color-primary)', fontWeight: 600, fontSize: 18 }}>Drop to upload</p>
+          </div>
+        </div>
+      )}
+
+      {/* Kopfleiste – dieselbe Höhe wie in allen anderen Ansichten */}
+      <PageHeader left={<Breadcrumb path={folderPath} onNavigate={navigateById} />}>
+        {/* Auswahlleiste: ersetzt Suche und Sortierung, solange etwas markiert
+            ist. Sie *neben* die anderen Elemente zu setzen wäre auf schmalen
+            Schirmen eine dritte Zeile – und solange man auswählt, will man
+            ohnehin nichts anderes. */}
+        {selected.size > 0 ? (
+          <div style={{ display: 'flex', alignItems: 'center', gap: 10, flex: 1, minWidth: 0 }}>
+            <span style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)', flexShrink: 0 }}>
+              {selected.size} selected
+            </span>
+            <button
+              onClick={downloadSelection}
+              style={{
+                display: 'flex', alignItems: 'center', gap: 7,
+                padding: '6px 14px', borderRadius: 8, border: 'none', cursor: 'pointer',
+                fontSize: 12, fontWeight: 600, color: '#fff', background: 'var(--color-primary)',
+                flexShrink: 0,
+              }}
+            >
+              <DownloadIcon /> Download as ZIP
+            </button>
+            <button
+              onClick={() => setSelected(new Set())}
+              style={{
+                padding: '6px 10px', borderRadius: 8, cursor: 'pointer', fontSize: 12,
+                border: '1px solid var(--color-border)', background: 'transparent',
+                color: 'var(--color-text-muted)', flexShrink: 0,
+              }}
+            >
+              Clear
+            </button>
+          </div>
+        ) : (
+          <SearchBox onOpenFolder={openFromSearch} onOpenFile={openHitFile} />
+        )}
+
+        {/* Sortierung */}
+        <select
+          value={sort}
+          onChange={e => setSort(e.target.value as Sort)}
+          title="Sort by"
+          style={{
+            padding: '6px 8px', borderRadius: 8, fontSize: 12,
+            border: '1px solid var(--color-border)',
+            background: 'var(--color-surface-2)',
+            color: 'var(--color-text-muted)', cursor: 'pointer',
+          }}
+        >
+          {(Object.keys(sortLabels) as Sort[]).map(key => (
+            <option key={key} value={key}>{sortLabels[key]}</option>
+          ))}
+        </select>
+
+        {/* View toggle */}
+        <div style={{ display: 'flex', borderRadius: 8, overflow: 'hidden', border: '1px solid var(--color-border)' }}>
+          <button
+            onClick={() => setViewMode('grid')}
+            style={{
+              padding: '6px 10px', border: 'none', cursor: 'pointer',
+              background: viewMode === 'grid' ? 'var(--color-surface-2)' : 'transparent',
+              color: viewMode === 'grid' ? 'var(--color-text)' : 'var(--color-text-muted)',
+            }}
+            title="Grid view"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
+              <rect x="3" y="3" width="7" height="7" rx="1" /><rect x="14" y="3" width="7" height="7" rx="1" />
+              <rect x="3" y="14" width="7" height="7" rx="1" /><rect x="14" y="14" width="7" height="7" rx="1" />
+            </svg>
+          </button>
+          <button
+            onClick={() => setViewMode('list')}
+            style={{
+              padding: '6px 10px', border: 'none', cursor: 'pointer',
+              background: viewMode === 'list' ? 'var(--color-surface-2)' : 'transparent',
+              color: viewMode === 'list' ? 'var(--color-text)' : 'var(--color-text-muted)',
+            }}
+            title="List view"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <line x1="8" y1="6" x2="21" y2="6" /><line x1="8" y1="12" x2="21" y2="12" /><line x1="8" y1="18" x2="21" y2="18" />
+              <circle cx="3" cy="6" r="1" fill="currentColor" /><circle cx="3" cy="12" r="1" fill="currentColor" /><circle cx="3" cy="18" r="1" fill="currentColor" />
+            </svg>
+          </button>
+        </div>
+
+        <button
+          onClick={() => setDialog({ type: 'new-folder' })}
+          style={{
+            padding: '6px 14px', borderRadius: 8, border: '1px solid var(--color-border)',
+            background: 'transparent', color: 'var(--color-text-muted)', fontSize: 13, cursor: 'pointer',
+          }}
+          title="New folder"
+        >
+          + Folder
+        </button>
+        <button
+          onClick={() => fileInputRef.current?.click()}
+          style={{
+            padding: '6px 14px', borderRadius: 8, border: 'none',
+            background: 'var(--color-primary)', color: '#fff', fontSize: 13, fontWeight: 600, cursor: 'pointer',
+          }}
+          title="Upload files (drag & drop for folders)"
+        >
+          Upload
+        </button>
+      </PageHeader>
+
+      {/* Content */}
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+        {loading && (
+          <div style={{ display: 'flex', justifyContent: 'center', paddingTop: 80 }}>
+            <div style={{
+              width: 24, height: 24,
+              border: '2px solid var(--color-primary)',
+              borderTopColor: 'transparent',
+              borderRadius: '50%',
+              animation: 'spin 0.7s linear infinite',
+            }} />
+          </div>
+        )}
+
+        {!loading && isEmpty && (
+          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', paddingTop: 100, gap: 12 }}>
+            <div style={{ fontSize: 56, opacity: 0.25 }}>☁️</div>
+            <p style={{ color: 'var(--color-text-muted)', fontSize: 14, margin: 0 }}>
+              Drag files here or click <strong>Upload</strong>
+            </p>
+          </div>
+        )}
+
+        {!loading && !isEmpty && viewMode === 'grid' && (
+          <GridView
+            highlightId={highlightId}
+            fileTags={fileTags}
+            fileCorrespondents={fileCorrespondents}
+            selected={selected}
+            onToggleSelect={toggleSelect}
+            folders={sortedFolders}
+            files={sortedFiles}
+            onFolderOpen={navigateTo}
+            onFolderMenu={openFolderMenu}
+            onFileMenu={openFileMenu}
+            onFileOpen={openFile}
+            onFileDownload={downloadFile}
+            onFolderDrop={handleDropOnFolder}
+            dragOverFolder={dragOverFolder}
+            onFolderDragOver={setDragOverFolder}
+          />
+        )}
+
+        {!loading && !isEmpty && viewMode === 'list' && (
+          <ListView
+            highlightId={highlightId}
+            fileTags={fileTags}
+            fileCorrespondents={fileCorrespondents}
+            selected={selected}
+            onToggleSelect={toggleSelect}
+            folders={sortedFolders}
+            files={sortedFiles}
+            onFolderOpen={navigateTo}
+            onFolderMenu={openFolderMenu}
+            onFileMenu={openFileMenu}
+            onFileOpen={openFile}
+            onFileDownload={downloadFile}
+            onFolderDrop={handleDropOnFolder}
+            dragOverFolder={dragOverFolder}
+            onFolderDragOver={setDragOverFolder}
+          />
+        )}
+      </div>
+
+      {editing && (
+        <OfficeEditor
+          file={editing}
+          onClose={() => {
+            setEditing(null)
+            // Der Office-Server hat womoeglich gespeichert – Groesse, Datum
+            // und Fassung stimmen dann nicht mehr. Einmal nachladen.
+            void load()
+          }}
+        />
+      )}
+
+      {preview && (
+        <FilePreview
+          file={preview}
+          onPrev={previewable.length > 1 ? () => stepPreview(-1) : undefined}
+          onNext={previewable.length > 1 ? () => stepPreview(1) : undefined}
+          onClose={() => setPreview(null)}
+          onSaved={reload}
+          searchTerm={hitTerm?.id === preview.id ? hitTerm.term : undefined}
+        />
+      )}
+
+      {/* Hidden file input */}
+      <input
+        ref={fileInputRef}
+        type="file"
+        multiple
+        style={{ display: 'none' }}
+        onChange={e => {
+          const list = Array.from(e.target.files ?? [])
+          if (list.length) uploadFiles(list)
+          e.target.value = ''
+        }}
+      />
+
+      <UploadQueue items={uploads} onDismiss={id => setUploads(u => u.filter(x => x.id !== id))} />
+      {ctxMenu && <ContextMenu {...ctxMenu} onClose={() => setCtxMenu(null)} />}
+
+      {dialog?.type === 'rename' && (
+        <InputDialog
+          title="Rename"
+          defaultValue={dialog.file.name}
+          confirmLabel="Rename"
+          onConfirm={name => handleRename(dialog.file, name)}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'rename-folder' && (
+        <InputDialog
+          title="Rename folder"
+          defaultValue={dialog.folder.name}
+          confirmLabel="Rename"
+          onConfirm={name => handleRenameFolder(dialog.folder, name)}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'confirm-delete-folder' && (
+        <ConfirmDialog
+          title="Delete folder"
+          message={`Move "${dialog.folder.name}" and all its contents to the trash?`}
+          confirmLabel="Delete"
+          danger
+          onConfirm={() => handleDeleteFolder(dialog.folder)}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'new-folder' && (
+        <InputDialog
+          title="New folder"
+          placeholder="Folder name"
+          confirmLabel="Create"
+          onConfirm={handleCreateFolder}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'share-with' && (
+        <ShareWithDialog
+          resource={dialog.resource}
+          onClose={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'share' && (
+        <ShareDialog
+          file={dialog.file}
+          onClose={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'versions' && (
+        <VersionsDialog
+          file={dialog.file}
+          onClose={() => setDialog(null)}
+          onRestored={updated => {
+            setFiles(f => f.map(x => x.id === updated.id ? updated : x))
+            setDialog(null)
+          }}
+        />
+      )}
+      {dialog?.type === 'confirm-delete' && (
+        <ConfirmDialog
+          title="Move to trash"
+          message={`Move "${dialog.file.name}" to the trash?`}
+          confirmLabel="Move to trash"
+          danger
+          onConfirm={() => handleDelete(dialog.file)}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+
+      {dialog?.type === 'info' && (
+        <FileInfoDialog
+          file={dialog.file}
+          tags={fileTags[dialog.file.id] ?? []}
+          correspondent={fileCorrespondents[dialog.file.id]}
+          onClose={() => setDialog(null)}
+        />
+      )}
+
+      {dialog?.type === 'tags' && (
+        <TagDialog
+          file={dialog.file}
+          current={fileTags[dialog.file.id] ?? []}
+          currentCorrespondent={fileCorrespondents[dialog.file.id]}
+          onClose={() => setDialog(null)}
+          onSaved={tags => {
+            // Nur die eine Datei nachziehen statt die ganze Liste neu zu holen.
+            setFileTags(prev => ({ ...prev, [dialog.file.id]: tags }))
+            // Der Absender kann dabei neu entstanden sein und hat dann eine ID,
+            // die hier niemand kennt. Deshalb einmal nachladen – sonst zeigte
+            // die Kachel den alten Absender, bis man den Ordner wechselt.
+            void reloadCorrespondents()
+          }}
+        />
+      )}
+
+      {dialog?.type === 'move-file' && (
+        <MoveTo
+          title={`Move "${dialog.file.name}"`}
+          onConfirm={targetId => handleMoveFile(dialog.file, targetId)}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+      {dialog?.type === 'move-folder' && (
+        <MoveTo
+          title={`Move "${dialog.folder.name}"`}
+          excludeId={dialog.folder.id}
+          onConfirm={targetId => handleMoveFolder(dialog.folder, targetId)}
+          onCancel={() => setDialog(null)}
+        />
+      )}
+
+      <style>{`@keyframes spin { to { transform: rotate(360deg); } }`}</style>
+    </div>
+  )
+}
+
+// ── Grid View ────────────────────────────────────────────────────────────────
diff --git a/frontend/src/pages/LoginPage.tsx b/frontend/src/pages/LoginPage.tsx
new file mode 100644
index 0000000..3300a83
--- /dev/null
+++ b/frontend/src/pages/LoginPage.tsx
@@ -0,0 +1,163 @@
+import { useState, useEffect, type FormEvent } from 'react'
+import { APIError, publicApi, type PublicConfig } from '../api/client'
+
+interface Props {
+  onLogin: (username: string, password: string) => Promise<void>
+}
+
+export default function LoginPage({ onLogin }: Props) {
+  const [username, setUsername] = useState('')
+  const [password, setPassword] = useState('')
+  const [error, setError] = useState('')
+  const [loading, setLoading] = useState(false)
+  const [config, setConfig] = useState<PublicConfig>({ oidc_enabled: false, cloud_name: 'Aether', external_apps: [] })
+
+  useEffect(() => {
+    // Show OIDC error from redirect if present
+    const params = new URLSearchParams(window.location.search)
+    if (params.get('error')) setError('SSO sign-in failed. Please sign in locally.')
+
+    publicApi.config().then(setConfig).catch(() => {})
+  }, [])
+
+  async function handleSubmit(e: FormEvent) {
+    e.preventDefault()
+    setError('')
+    setLoading(true)
+    try {
+      await onLogin(username, password)
+    } catch (err) {
+      setError(err instanceof APIError ? err.message : 'Login failed')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return (
+    <div className="min-h-screen flex items-center justify-center px-4">
+      <div className="w-full max-w-sm">
+        {/* Logo / branding */}
+        <div className="text-center mb-8">
+          {/* Eigenes Logo ersetzt die Standardwolke, wenn eines hinterlegt ist.
+              Kein farbiger Kasten dahinter: Ein Logo bringt seinen eigenen
+              Hintergrund mit, und ein Kachelrahmen drumherum sähe nach Versehen
+              aus. */}
+          {config.logo_url ? (
+            <img
+              src={config.logo_url}
+              alt={config.cloud_name}
+              className="mx-auto mb-4 object-contain"
+              style={{ maxHeight: 64, maxWidth: 200 }}
+            />
+          ) : (
+            <div className="inline-flex items-center justify-center w-14 h-14 rounded-2xl mb-4"
+                 style={{ background: 'var(--color-primary)' }}>
+              <svg className="w-7 h-7 text-white" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={1.5}>
+                <path strokeLinecap="round" strokeLinejoin="round"
+                  d="M2.25 15a4.5 4.5 0 004.5 4.5H18a3.75 3.75 0 001.332-7.257 3 3 0 00-3.758-3.848 5.25 5.25 0 00-10.233 2.33A4.502 4.502 0 002.25 15z" />
+              </svg>
+            </div>
+          )}
+          <h1 className="text-2xl font-semibold" style={{ color: 'var(--color-text)' }}>{config.cloud_name}</h1>
+          <p className="text-sm mt-1" style={{ color: 'var(--color-text-muted)' }}>Sign in</p>
+        </div>
+
+        {/* OIDC login */}
+        {config.oidc_enabled && (
+          <a
+            href="/api/v1/auth/oidc/login"
+            className="flex items-center justify-center gap-3 w-full rounded-xl px-4 py-3 text-sm font-semibold mb-4 border transition-all"
+            style={{
+              background: 'var(--color-surface)',
+              borderColor: 'var(--color-border)',
+              color: 'var(--color-text)',
+              textDecoration: 'none',
+            }}
+            onMouseEnter={e => (e.currentTarget.style.borderColor = 'var(--color-primary)')}
+            onMouseLeave={e => (e.currentTarget.style.borderColor = 'var(--color-border)')}
+          >
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <circle cx="12" cy="12" r="10" />
+              <path d="M12 8v4l3 3" />
+            </svg>
+            Sign in with SSO / OIDC
+          </a>
+        )}
+
+        {config.oidc_enabled && (
+          <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 16 }}>
+            <hr style={{ flex: 1, border: 'none', borderTop: '1px solid var(--color-border)' }} />
+            <span style={{ fontSize: 12, color: 'var(--color-text-muted)' }}>or</span>
+            <hr style={{ flex: 1, border: 'none', borderTop: '1px solid var(--color-border)' }} />
+          </div>
+        )}
+
+        <form onSubmit={handleSubmit}
+              className="rounded-xl p-6 space-y-4 border"
+              style={{ background: 'var(--color-surface)', borderColor: 'var(--color-border)' }}>
+          {error && (
+            <div className="rounded-lg px-4 py-3 text-sm"
+                 style={{ background: '#7f1d1d33', color: '#fca5a5', border: '1px solid #7f1d1d' }}>
+              {error}
+            </div>
+          )}
+
+          <div>
+            <label className="block text-sm font-medium mb-1.5" style={{ color: 'var(--color-text-muted)' }}>
+              Username
+            </label>
+            <input
+              type="text"
+              autoComplete="username"
+              required
+              value={username}
+              onChange={e => setUsername(e.target.value)}
+              className="w-full rounded-lg px-3 py-2.5 text-sm outline-none transition-all"
+              style={{
+                background: 'var(--color-surface-2)',
+                border: '1px solid var(--color-border)',
+                color: 'var(--color-text)',
+              }}
+              onFocus={e => e.currentTarget.style.borderColor = 'var(--color-primary)'}
+              onBlur={e => e.currentTarget.style.borderColor = 'var(--color-border)'}
+            />
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium mb-1.5" style={{ color: 'var(--color-text-muted)' }}>
+              Password
+            </label>
+            <input
+              type="password"
+              autoComplete="current-password"
+              required
+              value={password}
+              onChange={e => setPassword(e.target.value)}
+              className="w-full rounded-lg px-3 py-2.5 text-sm outline-none transition-all"
+              style={{
+                background: 'var(--color-surface-2)',
+                border: '1px solid var(--color-border)',
+                color: 'var(--color-text)',
+              }}
+              onFocus={e => e.currentTarget.style.borderColor = 'var(--color-primary)'}
+              onBlur={e => e.currentTarget.style.borderColor = 'var(--color-border)'}
+            />
+          </div>
+
+          <button
+            type="submit"
+            disabled={loading}
+            className="w-full rounded-lg py-2.5 text-sm font-semibold transition-opacity disabled:opacity-60"
+            style={{ background: 'var(--color-primary)', color: 'var(--color-primary-fg)' }}>
+            {loading ? 'Signing in…' : 'Sign in'}
+          </button>
+        </form>
+
+        {/* WebDAV hint */}
+        <p style={{ textAlign: 'center', fontSize: 11, color: 'var(--color-text-muted)', marginTop: 16 }}>
+          WebDAV: <code style={{ fontFamily: 'monospace' }}>/dav/</code>
+        </p>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/pages/ProfilePage.tsx b/frontend/src/pages/ProfilePage.tsx
new file mode 100644
index 0000000..2edbfed
--- /dev/null
+++ b/frontend/src/pages/ProfilePage.tsx
@@ -0,0 +1,429 @@
+import { useState, useEffect } from 'react'
+import { authApi, ocrApi, type User, type OcrStatus } from '../api/client'
+import { applyTheme } from '../theme'
+import { useAppSettings } from '../hooks/useAppSettings'
+import AppPasswords from '../components/AppPasswords'
+import PageHeader from '../components/PageHeader'
+import Tabs from '../components/Tabs'
+
+interface Props {
+  user: User
+  /** Nach dem Speichern aufrufen, damit Seitenleiste und Kopfzeile den
+   *  neuen Anzeigenamen übernehmen – sonst bliebe der alte bis zum Neuladen. */
+  onUserChanged?: () => Promise<void>
+}
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`
+  return `${(n / 1024 ** 3).toFixed(1)} GB`
+}
+
+function Card({ children, title }: { children: React.ReactNode; title: string }) {
+  return (
+    <div style={{
+      background: 'var(--color-surface)', border: '1px solid var(--color-border)',
+      borderRadius: 12, padding: 24, marginBottom: 20,
+    }}>
+      <h3 style={{ margin: '0 0 18px', fontSize: 15, fontWeight: 700, color: 'var(--color-text)' }}>{title}</h3>
+      {children}
+    </div>
+  )
+}
+
+/**
+ * Der Stand der Texterkennung – für die **eigenen** Dateien.
+ *
+ * Bis zum 23.08.2026 sah diese Zahl nur der Administrator. Das ist die falsche
+ * Person: Wissen muss es, wer gerade eine Rechnung hochgeladen hat und sie
+ * nicht findet. „Wird noch gelesen" und „ist nicht drin" sehen in einer leeren
+ * Trefferliste identisch aus.
+ */
+function IndexingCard() {
+  const [status, setStatus] = useState<OcrStatus | null>(null)
+
+  useEffect(() => {
+    let alive = true
+    let timer: ReturnType<typeof setTimeout>
+    async function tick() {
+      try {
+        const s = await ocrApi.myStatus()
+        if (!alive) return
+        setStatus(s)
+        // Nur nachfragen, solange sich etwas bewegt – steht die Warteschlange,
+        // ändert sich die Zahl erst beim nächsten Upload.
+        if ((s.pending ?? 0) + (s.running ?? 0) > 0) timer = setTimeout(tick, 5000)
+      } catch {
+        if (alive) setStatus(null)
+      }
+    }
+    tick()
+    return () => { alive = false; clearTimeout(timer) }
+  }, [])
+
+  if (!status) return null
+
+  const pending = (status.pending ?? 0) + (status.running ?? 0)
+  const indexed = status.indexed ?? 0
+  const bad = status.failed ?? 0
+
+  let text: string
+  if (!status.enabled) {
+    text = 'Turned off on this server — the contents of your documents are not searchable, only their names.'
+  } else if (pending > 0) {
+    text = `${indexed} read so far, ${pending} still to go. A scanned page takes about a minute — search will find them once they are done.`
+  } else if (indexed === 0) {
+    text = 'Nothing read yet. PDFs and images are read automatically after upload, so their contents become searchable.'
+  } else {
+    text = `${indexed} ${indexed === 1 ? 'document is' : 'documents are'} searchable by their contents — not just by file name.`
+  }
+  if (bad > 0) text += ` ${bad} could not be read (damaged or password-protected).`
+
+  return (
+    <Card title="Document search">
+      <div style={{ display: 'flex', alignItems: 'flex-start', gap: 10 }}>
+        <span style={{
+          width: 8, height: 8, borderRadius: '50%', flexShrink: 0, marginTop: 5,
+          background: !status.enabled
+            ? 'var(--color-text-muted)'
+            : pending > 0 ? 'var(--color-warning)' : 'var(--color-success)',
+        }} />
+        <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)', lineHeight: 1.55 }}>
+          {text}
+        </p>
+      </div>
+    </Card>
+  )
+}
+
+function Field({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 4, marginBottom: 14 }}>
+      <label style={{ fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)' }}>{label}</label>
+      {children}
+    </div>
+  )
+}
+
+function Input({ value, onChange, type = 'text', placeholder, disabled }: {
+  value: string; onChange?: (v: string) => void; type?: string; placeholder?: string; disabled?: boolean
+}) {
+  return (
+    <input
+      type={type}
+      value={value}
+      onChange={e => onChange?.(e.target.value)}
+      placeholder={placeholder}
+      disabled={disabled}
+      style={{
+        padding: '8px 10px', borderRadius: 8, border: '1px solid var(--color-border)',
+        background: disabled ? 'var(--color-surface-2)' : 'var(--color-surface-2)',
+        color: disabled ? 'var(--color-text-muted)' : 'var(--color-text)',
+        fontSize: 13, outline: 'none', opacity: disabled ? 0.7 : 1,
+      }}
+    />
+  )
+}
+
+function SaveBtn({ onClick, loading, saved, disabled }: { onClick: () => void; loading: boolean; saved: boolean; disabled?: boolean }) {
+  return (
+    <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginTop: 4 }}>
+      <button
+        onClick={onClick}
+        disabled={loading || disabled}
+        style={{
+          padding: '8px 20px', borderRadius: 8, border: 'none',
+          background: 'var(--color-primary)', color: '#fff',
+          fontSize: 13, fontWeight: 600, cursor: loading || disabled ? 'default' : 'pointer',
+          opacity: loading || disabled ? 0.7 : 1,
+        }}
+      >
+        {loading ? 'Saving…' : 'Save'}
+      </button>
+      {saved && <span style={{ fontSize: 12, color: '#22c55e', fontWeight: 600 }}>✓ Saved</span>}
+    </div>
+  )
+}
+
+type Tab = 'account' | 'access' | 'appearance' | 'storage'
+
+/**
+ * Reiter statt vier Abschnitte untereinander – dieselbe Aufteilung wie im
+ * Admin-Bereich, über dieselbe Komponente.
+ *
+ * Sortiert nach dem, was man tatsächlich aufsucht: erst das eigene Konto, dann
+ * der Zugang für Geräte, dann das Aussehen. Der Speicher steht zuletzt; er ist
+ * eine Anzeige, kein Bedienelement, und derselbe Balken steht ohnehin unten in
+ * der Seitenleiste. Vorher stand er ganz oben und war das Erste, was man sah.
+ */
+export default function ProfilePage({ user, onUserChanged }: Props) {
+  const [tab, setTab] = useState<Tab>('account')
+  const tabs: { id: Tab; label: string }[] = [
+    { id: 'account', label: 'Account' },
+    { id: 'access', label: 'Access' },
+    { id: 'appearance', label: 'Appearance' },
+    { id: 'storage', label: 'Storage' },
+  ]
+  // Profile
+  const [displayName, setDisplayName] = useState(user.display_name ?? '')
+  const [profileLoading, setProfileLoading] = useState(false)
+  const [profileSaved, setProfileSaved] = useState(false)
+
+  // Password
+  const [currentPw, setCurrentPw] = useState('')
+  const [newPw, setNewPw] = useState('')
+  const [confirmPw, setConfirmPw] = useState('')
+  const [pwLoading, setPwLoading] = useState(false)
+  const [pwSaved, setPwSaved] = useState(false)
+  const [pwError, setPwError] = useState('')
+
+  // Persönliche Palette. Leer heisst: die globale Einstellung des
+  // Administrators gilt – der Farbwähler zeigt dann deren Wert als Ausgangspunkt.
+  const { globalColors, refresh: refreshSettings } = useAppSettings()
+  const [primary, setPrimary] = useState(user.primary_color || globalColors.primary || '#6366f1')
+  const [accent, setAccent] = useState(user.accent_color || globalColors.accent || '#8b5cf6')
+  const [useCustom, setUseCustom] = useState(user.use_custom_theme)
+  const [themeLoading, setThemeLoading] = useState(false)
+  const [themeSaved, setThemeSaved] = useState(false)
+
+  // Vorschau: die Wahl wirkt sofort auf die ganze Oberfläche. Wird der Bereich
+  // ohne Speichern verlassen, stellt der Abgleich den gesicherten Stand her.
+  function preview(p: string, a: string) {
+    if (useCustom) applyTheme(p, a)
+  }
+
+  // Umschalten wirkt sofort und speichert – die Farben bleiben dabei erhalten,
+  // man kann also beliebig hin und her wechseln.
+  async function toggleCustom(enabled: boolean) {
+    setUseCustom(enabled)
+    applyTheme(
+      enabled ? primary : globalColors.primary,
+      enabled ? accent : globalColors.accent,
+    )
+    await authApi.setUseCustomTheme(enabled).catch(() => {})
+    await onUserChanged?.()
+  }
+
+  useEffect(() => {
+    return () => {
+      void refreshSettings()
+      applyTheme(
+        user.use_custom_theme ? (user.primary_color || globalColors.primary) : globalColors.primary,
+        user.use_custom_theme ? (user.accent_color || globalColors.accent) : globalColors.accent,
+      )
+    }
+  }, []) // eslint-disable-line react-hooks/exhaustive-deps
+
+  async function saveProfile() {
+    setProfileLoading(true)
+    await authApi.updateProfile(displayName).catch(() => {})
+    await onUserChanged?.()
+    setProfileLoading(false)
+    setProfileSaved(true)
+    setTimeout(() => setProfileSaved(false), 2000)
+  }
+
+  async function changePassword() {
+    setPwError('')
+    if (newPw !== confirmPw) { setPwError('Passwords do not match'); return }
+    if (newPw.length < 8) { setPwError('At least 8 characters'); return }
+    setPwLoading(true)
+    try {
+      await authApi.changePassword(currentPw, newPw)
+      setCurrentPw(''); setNewPw(''); setConfirmPw('')
+      setPwSaved(true)
+      setTimeout(() => setPwSaved(false), 2000)
+    } catch {
+      setPwError('Current password is incorrect')
+    } finally {
+      setPwLoading(false)
+    }
+  }
+
+  async function saveTheme() {
+    setThemeLoading(true)
+    const result = await authApi.updateColors(primary, accent).catch(() => null)
+    // Wer Farben speichert, will sie auch sehen.
+    if (result && !useCustom) {
+      setUseCustom(true)
+      await authApi.setUseCustomTheme(true).catch(() => {})
+      applyTheme(primary, accent)
+    }
+    setThemeLoading(false)
+    if (result) {
+      // Nutzer neu laden, damit die Palette in der gesamten Anwendung greift.
+      await onUserChanged?.()
+      setThemeSaved(true)
+      setTimeout(() => setThemeSaved(false), 2000)
+    }
+  }
+
+  const usedPct = user.quota_bytes > 0 ? Math.min((user.used_bytes / user.quota_bytes) * 100, 100) : 0
+
+  return (
+    <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+      <PageHeader
+        icon={
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <circle cx="12" cy="8" r="4" />
+            <path d="M4 21v-1a8 8 0 0116 0v1" />
+          </svg>
+        }
+        title="Settings"
+        meta="Your account, devices and appearance"
+      />
+
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+      <div style={{ maxWidth: 560 }}>
+
+        <Tabs tabs={tabs} active={tab} onChange={setTab} />
+
+        {tab === 'account' && (<>
+        <Card title="Profile">
+          <Field label="Username">
+            <Input value={user.username} disabled />
+          </Field>
+          <Field label="Display name">
+            <Input value={displayName} onChange={setDisplayName} placeholder="Your name" />
+          </Field>
+          <SaveBtn onClick={saveProfile} loading={profileLoading} saved={profileSaved} />
+        </Card>
+
+        {/* Passwortänderung nur für Konten, die hier auch ein Passwort haben.
+            Wer sich über den Identitätsanbieter anmeldet, hat keines – das
+            Formular könnte nur fehlschlagen, und zwar mit „current password
+            incorrect", was nach einem Tippfehler aussieht statt nach dem
+            wahren Grund. Der Server weist den Aufruf zusätzlich ab; das hier
+            ist die Erklärung, nicht die Absicherung. */}
+        {user.is_oidc ? (
+          <Card title="Password">
+            <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)', lineHeight: 1.55 }}>
+              You sign in through your identity provider, so this account has no
+              password here. Change it where you sign in.
+            </p>
+          </Card>
+        ) : (
+        <Card title="Change password">
+          <Field label="Current password">
+            <Input type="password" value={currentPw} onChange={setCurrentPw} />
+          </Field>
+          <Field label="New password">
+            <Input type="password" value={newPw} onChange={setNewPw} placeholder="At least 8 characters" />
+          </Field>
+          <Field label="Confirm new password">
+            <Input type="password" value={confirmPw} onChange={setConfirmPw} />
+          </Field>
+          {pwError && <p style={{ margin: '0 0 10px', fontSize: 12, color: 'var(--color-danger)' }}>{pwError}</p>}
+          <SaveBtn onClick={changePassword} loading={pwLoading} saved={pwSaved} disabled={!currentPw || !newPw || !confirmPw} />
+        </Card>
+        )}
+        </>)}
+
+        {tab === 'access' && (<>
+        {/* App-Passwörter sind der einzige Weg, ein Gerät anzubinden – das
+            Kontopasswort wird an /dav/ abgelehnt. Der Hinweis gehört deshalb
+            hierher und nicht in die Dokumentation. */}
+        <Card title="App passwords">
+          <p style={{ margin: '0 0 16px', fontSize: 12, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+            For WebDAV and sync clients. Your account password is rejected there
+            on purpose — it is also the admin login. Each app password can be
+            revoked on its own without locking out your other devices.
+          </p>
+          <AppPasswords username={user.username} />
+        </Card>
+        </>)}
+
+        {tab === 'appearance' && (<>
+        <Card title="Colours">
+          {/* Schalter zuerst: er bestimmt, ob die Farbwahl darunter überhaupt
+              greift. Die Werte bleiben in beiden Stellungen gespeichert. */}
+          <div style={{
+            display: 'flex', alignItems: 'center', gap: 12,
+            padding: '10px 12px', marginBottom: 16, borderRadius: 10,
+            background: 'var(--color-surface-2)',
+          }}>
+            <div style={{ flex: 1 }}>
+              <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>
+                Use my own colours
+              </div>
+              <div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginTop: 2 }}>
+                {useCustom
+                  ? 'Your palette is active. Turn off to use the server theme.'
+                  : 'Using the server theme. Your colours stay saved.'}
+              </div>
+            </div>
+            <button
+              role="switch"
+              aria-checked={useCustom}
+              onClick={() => toggleCustom(!useCustom)}
+              style={{
+                width: 42, height: 24, borderRadius: 999, flexShrink: 0,
+                border: 'none', cursor: 'pointer', padding: 3,
+                background: useCustom ? 'var(--color-primary)' : 'var(--color-border)',
+                display: 'flex', justifyContent: useCustom ? 'flex-end' : 'flex-start',
+                transition: 'background 0.15s',
+              }}
+            >
+              <span style={{
+                width: 18, height: 18, borderRadius: '50%', background: '#fff',
+                display: 'block', transition: 'transform 0.15s',
+              }} />
+            </button>
+          </div>
+
+          {/* Ausgegraut statt versteckt: man sieht, welche Farben hinterlegt
+              sind, auch während das Server-Thema aktiv ist. */}
+          <div style={{ opacity: useCustom ? 1 : 0.45, pointerEvents: useCustom ? 'auto' : 'none' }}>
+          <Field label="Primary colour">
+            <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+              <input
+                type="color"
+                value={primary}
+                onChange={e => { setPrimary(e.target.value); preview(e.target.value, accent) }}
+                style={{ width: 40, height: 36, borderRadius: 8, border: '1px solid var(--color-border)', cursor: 'pointer', padding: 2 }}
+              />
+              <span style={{ fontSize: 13, fontFamily: 'monospace', color: 'var(--color-text)' }}>{primary}</span>
+            </div>
+          </Field>
+          <Field label="Accent colour">
+            <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+              <input
+                type="color"
+                value={accent}
+                onChange={e => { setAccent(e.target.value); preview(primary, e.target.value) }}
+                style={{ width: 40, height: 36, borderRadius: 8, border: '1px solid var(--color-border)', cursor: 'pointer', padding: 2 }}
+              />
+              <span style={{ fontSize: 13, fontFamily: 'monospace', color: 'var(--color-text)' }}>{accent}</span>
+            </div>
+          </Field>
+          <SaveBtn onClick={saveTheme} loading={themeLoading} saved={themeSaved} />
+          </div>
+        </Card>
+        </>)}
+
+        {tab === 'storage' && (<>
+        {/* Reine Anzeige – ändern lässt sich das Kontingent nur im
+            Admin-Bereich. Der Kartentitel wiederholt die Abschnittsüberschrift
+            deshalb nicht, sondern sagt, was in der Karte steht. */}
+        <Card title="Space used">
+          <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 6 }}>
+            <span style={{ fontSize: 13, color: 'var(--color-text)' }}>{formatBytes(user.used_bytes)} used</span>
+            <span style={{ fontSize: 13, color: 'var(--color-text-muted)' }}>{formatBytes(user.quota_bytes)} total</span>
+          </div>
+          <div style={{ height: 8, background: 'var(--color-surface-2)', borderRadius: 999 }}>
+            <div style={{
+              width: `${usedPct}%`, height: '100%', borderRadius: 999,
+              background: usedPct > 90 ? 'var(--color-danger)' : 'var(--color-primary)',
+              transition: 'width 0.3s',
+            }} />
+          </div>
+        </Card>
+          <IndexingCard />
+        </>)}
+
+      </div>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/pages/SharePage.tsx b/frontend/src/pages/SharePage.tsx
new file mode 100644
index 0000000..971e1bd
--- /dev/null
+++ b/frontend/src/pages/SharePage.tsx
@@ -0,0 +1,177 @@
+import { useState, useEffect } from 'react'
+import { sharesApi, type PublicShareInfo } from '../api/client'
+
+interface Props {
+  token: string
+}
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`
+  return `${(n / 1024 ** 3).toFixed(1)} GB`
+}
+
+export default function SharePage({ token }: Props) {
+  const [info, setInfo] = useState<PublicShareInfo | null>(null)
+  const [error, setError] = useState('')
+  const [password, setPassword] = useState('')
+  const [needsPassword, setNeedsPassword] = useState(false)
+  const [downloading, setDownloading] = useState(false)
+  const [wrongPassword, setWrongPassword] = useState(false)
+
+  useEffect(() => {
+    sharesApi.getInfo(token)
+      .then(data => {
+        setInfo(data)
+        setNeedsPassword(data.link.has_password)
+      })
+      .catch(() => setError('This link is not valid or has expired.'))
+  }, [token])
+
+  async function download() {
+    setDownloading(true)
+    setWrongPassword(false)
+    try {
+      const res = await sharesApi.download(token, needsPassword ? password : undefined)
+      if (res.status === 401) {
+        setWrongPassword(true)
+        setDownloading(false)
+        return
+      }
+      if (!res.ok) {
+        setError('Download failed.')
+        setDownloading(false)
+        return
+      }
+      const blob = await res.blob()
+      const url = URL.createObjectURL(blob)
+      const a = document.createElement('a')
+      a.href = url
+      a.download = info?.file_name ?? 'download'
+      a.click()
+      URL.revokeObjectURL(url)
+    } catch {
+      setError('Download failed.')
+    }
+    setDownloading(false)
+  }
+
+  return (
+    <div style={{
+      minHeight: '100vh',
+      display: 'flex',
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center',
+      background: 'var(--color-background)',
+      padding: 24,
+    }}>
+      {/* Brand */}
+      <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 40 }}>
+        <div style={{
+          width: 32, height: 32, borderRadius: 8,
+          background: 'var(--color-primary)',
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+        }}>
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="white" strokeWidth="1.5">
+            <path strokeLinecap="round" strokeLinejoin="round"
+              d="M2.25 15a4.5 4.5 0 004.5 4.5H18a3.75 3.75 0 001.332-7.257 3 3 0 00-3.758-3.848 5.25 5.25 0 00-10.233 2.33A4.502 4.502 0 002.25 15z" />
+          </svg>
+        </div>
+        <span style={{ fontWeight: 700, fontSize: 18, color: 'var(--color-text)' }}>Aether</span>
+      </div>
+
+      <div style={{
+        background: 'var(--color-surface)',
+        border: '1px solid var(--color-border)',
+        borderRadius: 16,
+        padding: 32,
+        width: 420,
+        maxWidth: '100%',
+        textAlign: 'center',
+      }}>
+        {error ? (
+          <>
+            <div style={{ fontSize: 48, marginBottom: 16 }}>🔗</div>
+            <h2 style={{ margin: '0 0 8px', fontSize: 18, color: 'var(--color-text)' }}>Link not found</h2>
+            <p style={{ color: 'var(--color-text-muted)', fontSize: 14 }}>{error}</p>
+          </>
+        ) : !info ? (
+          <div style={{ display: 'flex', justifyContent: 'center', padding: 24 }}>
+            <div style={{ width: 24, height: 24, border: '2px solid var(--color-primary)', borderTopColor: 'transparent', borderRadius: '50%', animation: 'spin 0.7s linear infinite' }} />
+            <style>{`@keyframes spin { to { transform: rotate(360deg); } }`}</style>
+          </div>
+        ) : (
+          <>
+            {/* File icon */}
+            <div style={{ fontSize: 52, marginBottom: 16 }}>
+              {info.mime_type.startsWith('image/') ? '🖼' :
+               info.mime_type.startsWith('video/') ? '🎬' :
+               info.mime_type.startsWith('audio/') ? '🎵' :
+               info.mime_type.includes('pdf') ? '📄' :
+               info.mime_type.includes('zip') ? '📦' : '📁'}
+            </div>
+
+            <h2 style={{ margin: '0 0 6px', fontSize: 18, fontWeight: 600, color: 'var(--color-text)', wordBreak: 'break-word' }}>
+              {info.file_name}
+            </h2>
+            <p style={{ margin: '0 0 24px', fontSize: 13, color: 'var(--color-text-muted)' }}>
+              {formatBytes(info.file_size)}
+              {info.link.expires_at && (
+                <span> · Expires {new Date(info.link.expires_at).toLocaleDateString()}</span>
+              )}
+            </p>
+
+            {needsPassword && (
+              <div style={{ marginBottom: 16 }}>
+                <input
+                  type="password"
+                  placeholder="Enter password"
+                  value={password}
+                  onChange={e => setPassword(e.target.value)}
+                  onKeyDown={e => e.key === 'Enter' && download()}
+                  style={{
+                    width: '100%', padding: '10px 14px', borderRadius: 8,
+                    border: `1px solid ${wrongPassword ? 'var(--color-danger)' : 'var(--color-border)'}`,
+                    background: 'var(--color-surface-2)',
+                    color: 'var(--color-text)', fontSize: 14, outline: 'none',
+                    boxSizing: 'border-box',
+                  }}
+                />
+                {wrongPassword && (
+                  <p style={{ margin: '6px 0 0', fontSize: 12, color: 'var(--color-danger)' }}>
+                    Incorrect password
+                  </p>
+                )}
+              </div>
+            )}
+
+            <button
+              onClick={download}
+              disabled={downloading || (needsPassword && !password)}
+              style={{
+                width: '100%', padding: '11px 0', borderRadius: 10, border: 'none',
+                background: 'var(--color-primary)', color: '#fff',
+                fontSize: 15, fontWeight: 600, cursor: downloading ? 'wait' : 'pointer',
+                opacity: (downloading || (needsPassword && !password)) ? 0.7 : 1,
+                display: 'flex', alignItems: 'center', justifyContent: 'center', gap: 8,
+              }}
+            >
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5">
+                <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+                <polyline points="7 10 12 15 17 10" />
+                <line x1="12" y1="15" x2="12" y2="3" />
+              </svg>
+              {downloading ? 'Downloading…' : 'Download'}
+            </button>
+
+            <p style={{ margin: '16px 0 0', fontSize: 11, color: 'var(--color-text-muted)' }}>
+              Shared via Aether · Downloaded {info.link.download_count}×
+            </p>
+          </>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/pages/SharedPage.tsx b/frontend/src/pages/SharedPage.tsx
new file mode 100644
index 0000000..e5a7c52
--- /dev/null
+++ b/frontend/src/pages/SharedPage.tsx
@@ -0,0 +1,170 @@
+import { useState, useEffect } from 'react'
+import { sharesApi, type ShareLink } from '../api/client'
+import ConfirmDialog from '../components/ConfirmDialog'
+import PageHeader from '../components/PageHeader'
+
+function shareURL(token: string): string {
+  return `${window.location.origin}/s/${token}`
+}
+
+function formatDate(iso: string): string {
+  return new Date(iso).toLocaleDateString(undefined, { day: '2-digit', month: 'short', year: 'numeric' })
+}
+
+function formatDateTime(iso: string): string {
+  return new Date(iso).toLocaleString(undefined, { day: '2-digit', month: 'short', year: 'numeric', hour: '2-digit', minute: '2-digit' })
+}
+
+export default function SharedPage() {
+  const [links, setLinks] = useState<ShareLink[]>([])
+  const [loading, setLoading] = useState(true)
+  const [copied, setCopied] = useState<string | null>(null)
+  const [confirmDelete, setConfirmDelete] = useState<ShareLink | null>(null)
+
+  useEffect(() => {
+    sharesApi.list()
+      .then(data => setLinks(data ?? []))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [])
+
+  async function copy(token: string) {
+    await navigator.clipboard.writeText(shareURL(token))
+    setCopied(token)
+    setTimeout(() => setCopied(null), 2000)
+  }
+
+  async function deleteLink(link: ShareLink) {
+    await sharesApi.delete(link.id)
+    setLinks(l => l.filter(x => x.id !== link.id))
+    setConfirmDelete(null)
+  }
+
+  const now = new Date()
+
+  return (
+    <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+      <PageHeader
+        icon={
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <circle cx="18" cy="5" r="3" /><circle cx="6" cy="12" r="3" /><circle cx="18" cy="19" r="3" />
+            <line x1="8.59" y1="13.51" x2="15.42" y2="17.49" />
+            <line x1="15.41" y1="6.51" x2="8.59" y2="10.49" />
+          </svg>
+        }
+        title="Shared links"
+        meta={links.length > 0 ? `${links.length} link${links.length !== 1 ? 's' : ''}` : undefined}
+      />
+
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+        {loading && (
+          <div style={{ display: 'flex', justifyContent: 'center', paddingTop: 80 }}>
+            <div style={{ width: 24, height: 24, border: '2px solid var(--color-primary)', borderTopColor: 'transparent', borderRadius: '50%', animation: 'spin 0.7s linear infinite' }} />
+            <style>{`@keyframes spin { to { transform: rotate(360deg); } }`}</style>
+          </div>
+        )}
+
+        {!loading && links.length === 0 && (
+          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', paddingTop: 100, gap: 12 }}>
+            <div style={{ fontSize: 56, opacity: 0.25 }}>🔗</div>
+            <p style={{ color: 'var(--color-text-muted)', fontSize: 14, margin: 0 }}>No shared links yet</p>
+            <p style={{ color: 'var(--color-text-muted)', fontSize: 12, margin: 0 }}>Select a file and click "Share" to create a link</p>
+          </div>
+        )}
+
+        {!loading && links.length > 0 && (
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+            {links.map(link => {
+              const expired = link.expires_at ? new Date(link.expires_at) < now : false
+              return (
+                <div key={link.id} style={{
+                  display: 'flex', alignItems: 'center', gap: 14,
+                  padding: '12px 14px',
+                  background: 'var(--color-surface)',
+                  border: `1px solid ${expired ? 'var(--color-danger)' : 'var(--color-border)'}`,
+                  borderRadius: 10,
+                  opacity: expired ? 0.6 : 1,
+                }}>
+                  {/* Icon */}
+                  <div style={{
+                    width: 36, height: 36, borderRadius: 8, flexShrink: 0,
+                    background: expired ? 'rgba(239,68,68,0.1)' : 'rgba(var(--color-primary-rgb), 0.1)',
+                    display: 'flex', alignItems: 'center', justifyContent: 'center',
+                  }}>
+                    <svg width="16" height="16" viewBox="0 0 24 24" fill="none"
+                      stroke={expired ? 'var(--color-danger)' : 'var(--color-primary)'} strokeWidth="2">
+                      <path d="M10 13a5 5 0 007.54.54l3-3a5 5 0 00-7.07-7.07l-1.72 1.71" />
+                      <path d="M14 11a5 5 0 00-7.54-.54l-3 3a5 5 0 007.07 7.07l1.71-1.71" />
+                    </svg>
+                  </div>
+
+                  {/* Info */}
+                  <div style={{ flex: 1, minWidth: 0 }}>
+                    <p style={{
+                      margin: 0, fontSize: 12, color: 'var(--color-text)',
+                      overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                      fontFamily: 'monospace',
+                    }}>
+                      {shareURL(link.token)}
+                    </p>
+                    <div style={{ marginTop: 4, display: 'flex', gap: 10, flexWrap: 'wrap', fontSize: 11, color: 'var(--color-text-muted)' }}>
+                      <span>Created {formatDate(link.created_at)}</span>
+                      {link.has_password && <span>🔒 Password protected</span>}
+                      {link.expires_at && (
+                        <span style={{ color: expired ? 'var(--color-danger)' : 'inherit' }}>
+                          {expired ? 'Expired' : 'Expires'} {formatDateTime(link.expires_at)}
+                        </span>
+                      )}
+                      <span>{link.download_count}× downloaded</span>
+                    </div>
+                  </div>
+
+                  {/* Actions */}
+                  <button
+                    onClick={() => copy(link.token)}
+                    title="Copy link"
+                    style={{
+                      padding: '5px 12px', borderRadius: 6, flexShrink: 0,
+                      border: '1px solid var(--color-border)',
+                      background: copied === link.token ? 'rgba(34,197,94,0.1)' : 'transparent',
+                      color: copied === link.token ? '#22c55e' : 'var(--color-text)',
+                      fontSize: 12, cursor: 'pointer', whiteSpace: 'nowrap',
+                    }}
+                  >
+                    {copied === link.token ? '✓ Copied' : 'Copy link'}
+                  </button>
+                  <button
+                    onClick={() => setConfirmDelete(link)}
+                    title="Delete link"
+                    style={{
+                      padding: '5px 8px', borderRadius: 6, flexShrink: 0,
+                      border: '1px solid var(--color-border)',
+                      background: 'transparent', color: 'var(--color-text-muted)',
+                      cursor: 'pointer', display: 'flex', alignItems: 'center',
+                    }}
+                  >
+                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+                      <polyline points="3 6 5 6 21 6" />
+                      <path d="M19 6l-1 14H6L5 6M10 11v6M14 11v6M9 6V4h6v2" />
+                    </svg>
+                  </button>
+                </div>
+              )
+            })}
+          </div>
+        )}
+      </div>
+
+      {confirmDelete && (
+        <ConfirmDialog
+          title="Delete share link"
+          message="The link will stop working immediately. The file itself is not affected."
+          confirmLabel="Delete link"
+          danger
+          onConfirm={() => deleteLink(confirmDelete)}
+          onCancel={() => setConfirmDelete(null)}
+        />
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/pages/SharedWithMePage.tsx b/frontend/src/pages/SharedWithMePage.tsx
new file mode 100644
index 0000000..1b9f89b
--- /dev/null
+++ b/frontend/src/pages/SharedWithMePage.tsx
@@ -0,0 +1,129 @@
+import { useState, useEffect } from 'react'
+import { aclApi, filesApi, type SharedResource } from '../api/client'
+import { formatBytes } from './FileBrowser'
+import PageHeader from '../components/PageHeader'
+import { FolderGlyph } from '../components/icons'
+
+interface Props {
+  /** Öffnet einen freigegebenen Ordner in der Dateiansicht. */
+  onOpenFolder: (folderId: string, folderName: string) => void
+}
+
+/** „Geteilt mit mir": alles, worauf man Zugriff bekommen hat, ohne es zu
+ *  besitzen. Die Daten liegen weiterhin beim Eigentümer – hier wird nur
+ *  darauf verwiesen. */
+export default function SharedWithMePage({ onOpenFolder }: Props) {
+  const [items, setItems] = useState<SharedResource[]>([])
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    aclApi.sharedWithMe()
+      .then(d => setItems(d ?? []))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [])
+
+  return (
+    <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+      <PageHeader
+        icon={
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+            <path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2z" />
+            <circle cx="12" cy="13" r="2" />
+            <path d="M8.5 18a3.5 3.5 0 017 0" />
+          </svg>
+        }
+        title="Shared with me"
+        meta="Files and folders other people gave you access to"
+      />
+
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+
+      {loading ? (
+        <p style={{ fontSize: 13, color: 'var(--color-text-muted)' }}>Loading…</p>
+      ) : items.length === 0 ? (
+        <div style={{
+          padding: 40, textAlign: 'center', borderRadius: 12,
+          border: '1px dashed var(--color-border)',
+        }}>
+          <p style={{ margin: 0, fontSize: 14, color: 'var(--color-text)' }}>Nothing shared with you yet</p>
+          <p style={{ margin: '6px 0 0', fontSize: 12, color: 'var(--color-text-muted)' }}>
+            When someone shares a file or folder, it shows up here.
+          </p>
+        </div>
+      ) : (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: 8, maxWidth: 760 }}>
+          {items.map(item => (
+            <div
+              key={`${item.type}-${item.id}`}
+              onClick={() => item.type === 'folder' && onOpenFolder(item.id, item.name)}
+              style={{
+                display: 'flex', alignItems: 'center', gap: 14,
+                padding: '13px 16px', borderRadius: 11,
+                border: '1px solid var(--color-border)',
+                background: 'var(--color-surface)',
+                cursor: item.type === 'folder' ? 'pointer' : 'default',
+              }}
+              onMouseEnter={e => { if (item.type === 'folder') e.currentTarget.style.borderColor = 'var(--color-primary)' }}
+              onMouseLeave={e => { e.currentTarget.style.borderColor = 'var(--color-border)' }}
+            >
+              <span style={{ flexShrink: 0, display: 'flex' }}>
+                {item.type === 'folder' ? (
+                  <FolderGlyph size={24} />
+                ) : (
+                  <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="var(--color-text-muted)" strokeWidth="1.8">
+                    <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z" />
+                    <polyline points="14 2 14 8 20 8" />
+                  </svg>
+                )}
+              </span>
+
+              <div style={{ flex: 1, minWidth: 0 }}>
+                <div style={{
+                  fontSize: 14, fontWeight: 600, color: 'var(--color-text)',
+                  overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                }}>
+                  {item.name}
+                </div>
+                <div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginTop: 2 }}>
+                  Shared by {item.owner_name}
+                  {/* Ohne diesen Hinweis wundert man sich, woher eine Freigabe
+                      kommt, die man nie persönlich bekommen hat. */}
+                  {item.via_group && ` via ${item.via_group}`}
+                  {item.type === 'file' && ` · ${formatBytes(item.size)}`}
+                </div>
+              </div>
+
+              <span style={{
+                flexShrink: 0, padding: '3px 10px', borderRadius: 999,
+                fontSize: 11, fontWeight: 600,
+                background: item.permission === 'write'
+                  ? 'rgba(var(--color-primary-rgb), 0.12)'
+                  : 'var(--color-surface-2)',
+                color: item.permission === 'write' ? 'var(--color-primary)' : 'var(--color-text-muted)',
+              }}>
+                {item.permission === 'write' ? 'Can edit' : 'View only'}
+              </span>
+
+              {item.type === 'file' && (
+                <a
+                  href={filesApi.download(item.id)}
+                  download={item.name}
+                  onClick={e => e.stopPropagation()}
+                  style={{
+                    flexShrink: 0, padding: '5px 12px', borderRadius: 7,
+                    border: '1px solid var(--color-border)',
+                    color: 'var(--color-text)', fontSize: 12, textDecoration: 'none',
+                  }}
+                >
+                  Download
+                </a>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+      </div>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/frontend/src/pages/TagsPage.tsx b/frontend/src/pages/TagsPage.tsx
new file mode 100644
index 0000000..44b1a75
--- /dev/null
+++ b/frontend/src/pages/TagsPage.tsx
@@ -0,0 +1,221 @@
+import { useEffect, useState } from 'react'
+import { tagsApi, correspondentsApi, filesApi, downloadZip, type Correspondent, type Tag, type TaggedFile } from '../api/client'
+import PageHeader from '../components/PageHeader'
+import { FileTypeIcon } from '../components/icons'
+import TagChip, { tagColor } from '../components/TagChip'
+import { formatBytes } from './FileBrowser'
+
+/**
+ * Alles, was ein Etikett trägt – über Ordnergrenzen hinweg.
+ *
+ * Das ist die Ansicht, für die Etiketten gebaut werden. Die Suche beantwortet
+ * „wo steht dieses Wort"; hier geht es um „zeig mir alles, was ich als
+ * absetzbar markiert habe" – eine Frage, die kein Volltext beantworten kann,
+ * weil „absetzbar" in keiner Rechnung steht.
+ *
+ * Sortiert nach Belegdatum, nicht nach Namen: Wer im März alle Belege des
+ * Vorjahres zusammensucht, will sie in zeitlicher Ordnung.
+ */
+interface Props {
+  tagId?: string
+  /**
+   * Absender statt Etikett. Dieselbe Seite, weil es dieselbe Frage in anderer
+   * Richtung ist: „zeig mir alles mit diesem Merkmal, quer über die Ordner".
+   * Eine zweite, fast gleiche Seite liefe mit der Zeit auseinander – genau
+   * das war bei den Kopfleisten schon einmal passiert.
+   */
+  correspondentId?: string
+  onOpenFolder: (folderId: string | null, folderName: string) => void
+}
+
+export default function TagsPage({ tagId, correspondentId, onOpenFolder }: Props) {
+  const [tag, setTag] = useState<Tag | null>(null)
+  const [correspondent, setCorrespondent] = useState<Correspondent | null>(null)
+  const [files, setFiles] = useState<TaggedFile[]>([])
+  const [loading, setLoading] = useState(true)
+  const [missing, setMissing] = useState(false)
+
+  /** Was gerade gefiltert wird – Etikett oder Absender. */
+  const subject = correspondentId ? correspondent : tag
+  const id = correspondentId ?? tagId
+  const isFrom = !!correspondentId
+
+  useEffect(() => {
+    if (!id) { setLoading(false); return }
+    let alive = true
+    setLoading(true); setMissing(false)
+    setTag(null); setCorrespondent(null)
+    const load = isFrom
+      ? Promise.all([correspondentsApi.list(), correspondentsApi.files(id)])
+          .then(([all, hits]) => {
+            const found = all.find(c => c.id === id) ?? null
+            return [found, hits] as const
+          })
+      : Promise.all([tagsApi.list(), tagsApi.files(id)])
+          .then(([all, hits]) => {
+            const found = all.find(t => t.id === id) ?? null
+            return [found, hits] as const
+          })
+    load
+      .then(([found, hits]) => {
+        if (!alive) return
+        if (isFrom) setCorrespondent(found as Correspondent | null)
+        else setTag(found as Tag | null)
+        setMissing(!found)
+        setFiles(hits)
+      })
+      .catch(() => { if (alive) setMissing(true) })
+      .finally(() => { if (alive) setLoading(false) })
+    return () => { alive = false }
+  }, [id, isFrom])
+
+  const total = files.reduce((sum, f) => sum + f.size, 0)
+
+  return (
+    <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+      <PageHeader
+        icon={isFrom ? <CorrespondentGlyph /> : (
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M3 7v6.2a2 2 0 00.6 1.4l6.8 6.8a2 2 0 002.8 0l6.2-6.2a2 2 0 000-2.8l-6.8-6.8A2 2 0 0011.2 5H5a2 2 0 00-2 2z" />
+            <circle cx="7.5" cy="9.5" r="1.5" fill="currentColor" stroke="none" />
+          </svg>
+        )}
+        title={subject?.name ?? (isFrom ? 'From' : 'Tags')}
+        meta={
+          loading ? '' :
+          missing ? '' :
+          `${files.length} ${files.length === 1 ? 'file' : 'files'} · ${formatBytes(total)}`
+        }
+      >
+        {/* Der Zweck der ganzen Kette: filtern, alles holen, weitergeben.
+            „Alle Belege 2026 an den Steuerberater" ist genau ein Klick. */}
+        {subject && files.length > 0 && (
+          <button
+            onClick={() => downloadZip({ fileIds: files.map(f => f.id), name: subject.name })}
+            style={{
+              display: 'flex', alignItems: 'center', gap: 7,
+              padding: '6px 14px', borderRadius: 8, border: 'none', cursor: 'pointer',
+              fontSize: 12, fontWeight: 600, color: '#fff', background: 'var(--color-primary)',
+            }}
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+                 strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+              <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4" />
+              <polyline points="7 10 12 15 17 10" />
+              <line x1="12" y1="15" x2="12" y2="3" />
+            </svg>
+            Download all as ZIP
+          </button>
+        )}
+      </PageHeader>
+
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+        {loading && (
+          <p style={{ color: 'var(--color-text-muted)', fontSize: 13 }}>Loading…</p>
+        )}
+
+        {!loading && !id && (
+          <Empty text={isFrom
+            ? 'Pick a sender in the sidebar to see everything from them.'
+            : 'Pick a tag in the sidebar to see everything that carries it.'} />
+        )}
+
+        {!loading && id && missing && (
+          <Empty text={isFrom ? 'This sender no longer exists.' : 'This tag no longer exists.'} />
+        )}
+
+        {!loading && subject && files.length === 0 && (
+          <Empty text={isFrom
+            ? `Nothing is from “${subject.name}” yet. Right-click a file and choose “Organise…”.`
+            : `Nothing is tagged “${subject.name}” yet. Right-click a file and choose “Organise…”.`} />
+        )}
+
+        {!loading && subject && files.length > 0 && (
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+            {files.map(f => (
+              <button
+                key={f.id}
+                onDoubleClick={() => onOpenFolder(f.folder_id, f.folder_name)}
+                onClick={() => onOpenFolder(f.folder_id, f.folder_name)}
+                title={`Open ${f.folder_name || 'Home'}`}
+                style={{
+                  display: 'flex', alignItems: 'center', gap: 12, width: '100%',
+                  padding: '9px 12px', borderRadius: 8, border: 'none',
+                  background: 'transparent', cursor: 'pointer', textAlign: 'left',
+                }}
+                onMouseEnter={e => e.currentTarget.style.background = 'var(--color-surface-2)'}
+                onMouseLeave={e => e.currentTarget.style.background = 'transparent'}
+              >
+                {/* Vorschaubild, wo es eins gibt – sonst das Typsymbol. In
+                    einer Liste reicht die kleine Fassung; die großen Cover
+                    gehören zu den Kacheln. */}
+                {f.has_thumbnail ? (
+                  <img src={filesApi.thumbnail(f.id)} alt="" style={{
+                    width: 22, height: 22, borderRadius: 4, objectFit: 'cover', flexShrink: 0,
+                  }} />
+                ) : (
+                  <span style={{ display: 'flex', flexShrink: 0 }}>
+                    <FileTypeIcon mime={f.mime_type} name={f.name} size={22} />
+                  </span>
+                )}
+                <span style={{ flex: 1, minWidth: 0 }}>
+                  <span style={{
+                    display: 'block', fontSize: 13, color: 'var(--color-text)',
+                    overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+                  }}>
+                    {f.name}
+                  </span>
+                  <span style={{ display: 'block', fontSize: 11, color: 'var(--color-text-muted)' }}>
+                    in {f.folder_name || 'Home'}
+                  </span>
+                </span>
+                {/* Das Belegdatum steht rechts, weil danach sortiert wird – wer
+                    eine Liste nach einer Spalte sortiert, sucht diese Spalte. */}
+                <span style={{
+                  width: 96, textAlign: 'right', fontSize: 12, flexShrink: 0,
+                  color: f.document_date ? 'var(--color-text)' : 'var(--color-text-muted)',
+                }}>
+                  {f.document_date ? f.document_date.slice(0, 10) : '—'}
+                </span>
+                <span style={{ width: 76, textAlign: 'right', fontSize: 12, color: 'var(--color-text-muted)', flexShrink: 0 }}>
+                  {formatBytes(f.size)}
+                </span>
+              </button>
+            ))}
+          </div>
+        )}
+
+        {!isFrom && tag?.group_id && (
+          <p style={{ marginTop: 20, fontSize: 11, color: 'var(--color-text-muted)' }}>
+            <TagChip tag={tag} size="sm" /> is a group tag — everyone in{' '}
+            <strong style={{ color: tagColor(tag) }}>{tag.group_name}</strong> sees it.
+          </p>
+        )}
+      </div>
+    </div>
+  )
+}
+
+/** Ein Umschlag – „von wem". Bewusst nicht dasselbe Zeichen wie beim Etikett:
+ *  Es sind zwei verschiedene Fragen, und die Kopfzeile soll das zeigen. */
+function CorrespondentGlyph() {
+  return (
+    <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+         strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <rect x="2" y="5" width="20" height="14" rx="2" />
+      <polyline points="2.5 6.5 12 13 21.5 6.5" />
+    </svg>
+  )
+}
+
+function Empty({ text }: { text: string }) {
+  return (
+    <div style={{
+      display: 'flex', alignItems: 'center', justifyContent: 'center',
+      height: '60%', color: 'var(--color-text-muted)', fontSize: 13,
+      textAlign: 'center', padding: 20,
+    }}>
+      {text}
+    </div>
+  )
+}
diff --git a/frontend/src/pages/TrashPage.tsx b/frontend/src/pages/TrashPage.tsx
new file mode 100644
index 0000000..62cd98f
--- /dev/null
+++ b/frontend/src/pages/TrashPage.tsx
@@ -0,0 +1,198 @@
+import { useState, useEffect } from 'react'
+import { trashApi, filesApi, type TrashItem } from '../api/client'
+import { formatBytes } from './FileBrowser'
+import PageHeader from '../components/PageHeader'
+import ConfirmDialog from '../components/ConfirmDialog'
+
+interface Props {
+  /** Wiederherstellen verändert den belegten Speicher – Balken nachziehen. */
+  onUserChanged?: () => Promise<void>
+}
+
+export default function TrashPage({ onUserChanged }: Props) {
+  const [items, setItems] = useState<TrashItem[]>([])
+  const [loading, setLoading] = useState(true)
+  const [confirmDelete, setConfirmDelete] = useState<TrashItem | null>(null)
+  const [confirmEmpty, setConfirmEmpty] = useState(false)
+  const [emptying, setEmptying] = useState(false)
+
+  useEffect(() => {
+    trashApi.list()
+      .then(data => setItems(data ?? []))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [])
+
+  async function restore(file: TrashItem) {
+    await trashApi.restore(file.id)
+    setItems(i => i.filter(x => x.id !== file.id))
+    await onUserChanged?.()
+  }
+
+  async function emptyAll() {
+    setEmptying(true)
+    try {
+      await trashApi.emptyAll()
+      setItems([])
+      await onUserChanged?.()
+    } catch { /* Liste bleibt stehen, damit der Fehlschlag sichtbar ist */ }
+    setEmptying(false)
+    setConfirmEmpty(false)
+  }
+
+  async function deletePermanently(file: TrashItem) {
+    await trashApi.deletePermanently(file.id)
+    setItems(i => i.filter(x => x.id !== file.id))
+    setConfirmDelete(null)
+  }
+
+  return (
+    <div style={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+      <PageHeader
+        icon={
+          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <polyline points="3 6 5 6 21 6" />
+            <path d="M19 6l-1 14H6L5 6M10 11v6M14 11v6M9 6V4h6v2" />
+          </svg>
+        }
+        title="Trash"
+        meta={items.length > 0 ? `${items.length} item${items.length !== 1 ? 's' : ''}` : undefined}
+      >
+        {items.length > 0 && (
+          <button
+            onClick={() => setConfirmEmpty(true)}
+            disabled={emptying}
+            style={{
+              padding: '6px 14px', borderRadius: 8, fontSize: 12, fontWeight: 500,
+              border: '1px solid var(--color-danger)', background: 'transparent',
+              color: 'var(--color-danger)', cursor: emptying ? 'default' : 'pointer',
+            }}
+          >
+            {emptying ? 'Emptying…' : 'Empty trash'}
+          </button>
+        )}
+      </PageHeader>
+
+      <div style={{ flex: 1, overflowY: 'auto', padding: 20 }}>
+        {loading && (
+          <div style={{ display: 'flex', justifyContent: 'center', paddingTop: 80 }}>
+            <div style={{ width: 24, height: 24, border: '2px solid var(--color-primary)', borderTopColor: 'transparent', borderRadius: '50%', animation: 'spin 0.7s linear infinite' }} />
+            <style>{`@keyframes spin { to { transform: rotate(360deg); } }`}</style>
+          </div>
+        )}
+
+        {!loading && items.length === 0 && (
+          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', paddingTop: 100, gap: 12 }}>
+            <div style={{ fontSize: 56, opacity: 0.25 }}>🗑</div>
+            <p style={{ color: 'var(--color-text-muted)', fontSize: 14, margin: 0 }}>Trash is empty</p>
+          </div>
+        )}
+
+        {!loading && items.length > 0 && (
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+            {items.map(file => (
+              <div key={file.id} style={{
+                display: 'flex', alignItems: 'center', gap: 14,
+                padding: '10px 14px',
+                background: 'var(--color-surface)',
+                border: '1px solid var(--color-border)',
+                borderRadius: 10,
+              }}>
+                {/* Thumbnail or icon */}
+                <div style={{
+                  width: 44, height: 44, borderRadius: 8, flexShrink: 0,
+                  overflow: 'hidden', background: 'var(--color-surface-2)',
+                  display: 'flex', alignItems: 'center', justifyContent: 'center',
+                }}>
+                  {file.has_thumbnail ? (
+                    <img
+                      src={filesApi.thumbnail(file.id)}
+                      alt=""
+                      style={{ width: '100%', height: '100%', objectFit: 'cover' }}
+                      onError={e => { e.currentTarget.style.display = 'none' }}
+                    />
+                  ) : (
+                    <span style={{ fontSize: 20 }}>{mimeEmoji(file.mime_type)}</span>
+                  )}
+                </div>
+
+                {/* Info */}
+                <div style={{ flex: 1, minWidth: 0 }}>
+                  <p style={{ margin: 0, fontSize: 13, fontWeight: 500, color: 'var(--color-text)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                    {file.name}
+                  </p>
+                  <p style={{ margin: '3px 0 0', fontSize: 11, color: 'var(--color-text-muted)', display: 'flex', gap: 8, flexWrap: 'wrap' }}>
+                    <span>{formatBytes(file.size)}</span>
+                    <span style={{ display: 'flex', alignItems: 'center', gap: 3 }}>
+                      <svg width="10" height="10" viewBox="0 0 24 24" fill="var(--color-warning)" stroke="none">
+                        <path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2z" />
+                      </svg>
+                      {file.folder_path ? `Home / ${file.folder_path}` : 'Home'}
+                    </span>
+                  </p>
+                </div>
+
+                {/* Actions */}
+                <button
+                  onClick={() => restore(file)}
+                  style={{
+                    padding: '5px 12px', borderRadius: 6,
+                    border: '1px solid var(--color-border)',
+                    background: 'transparent', color: 'var(--color-text)',
+                    fontSize: 12, cursor: 'pointer', whiteSpace: 'nowrap', flexShrink: 0,
+                  }}
+                >
+                  Restore
+                </button>
+                <button
+                  onClick={() => setConfirmDelete(file)}
+                  style={{
+                    padding: '5px 12px', borderRadius: 6,
+                    border: '1px solid var(--color-danger)',
+                    background: 'transparent', color: 'var(--color-danger)',
+                    fontSize: 12, cursor: 'pointer', whiteSpace: 'nowrap', flexShrink: 0,
+                  }}
+                >
+                  Delete forever
+                </button>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+
+      {confirmDelete && (
+        <ConfirmDialog
+          title="Permanently delete"
+          message={`"${confirmDelete.name}" permanently delete? This cannot be undone.`}
+          confirmLabel="Delete forever"
+          danger
+          onConfirm={() => deletePermanently(confirmDelete)}
+          onCancel={() => setConfirmDelete(null)}
+        />
+      )}
+
+      {confirmEmpty && (
+        <ConfirmDialog
+          title="Empty trash"
+          message={`${items.length} ${items.length === 1 ? 'file' : 'files'} will be deleted permanently, including all revisions. This cannot be undone.`}
+          confirmLabel="Delete forever"
+          danger
+          onConfirm={emptyAll}
+          onCancel={() => setConfirmEmpty(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+function mimeEmoji(mime: string): string {
+  if (mime.startsWith('image/')) return '🖼'
+  if (mime.startsWith('video/')) return '🎬'
+  if (mime.startsWith('audio/')) return '🎵'
+  if (mime.includes('pdf')) return '📄'
+  if (mime.includes('zip') || mime.includes('tar')) return '📦'
+  if (mime.includes('word') || mime.includes('document')) return '📝'
+  if (mime.includes('sheet') || mime.includes('excel')) return '📊'
+  return '📁'
+}
diff --git a/frontend/src/pages/admin/AuditTab.tsx b/frontend/src/pages/admin/AuditTab.tsx
new file mode 100644
index 0000000..120ed8e
--- /dev/null
+++ b/frontend/src/pages/admin/AuditTab.tsx
@@ -0,0 +1,329 @@
+import { useState, useEffect } from 'react'
+import { adminApi, type AuditEntry, type OcrStatus } from '../../api/client'
+import {   formatBytes } from './ui'
+
+// Audit-Log, Speicher-Bereinigung und der Stand der Texterkennung –
+// alles, was im Hintergrund läuft und sonst unbeobachtbar wäre.
+
+// ── Audit Tab ─────────────────────────────────────────────────────────────────
+
+const PAGE_SIZE = 50
+
+/** Aktionsnamen sind maschinenlesbar (`admin.user_delete`). Hier stehen die
+ *  lesbaren Entsprechungen – was nicht drinsteht, wird aus dem Schlüssel
+ *  hergeleitet, damit neue Aktionen nicht als leere Zeile erscheinen. */
+const ACTION_LABELS: Record<string, string> = {
+  'auth.login': 'Signed in',
+  'auth.login_failed': 'Sign-in failed',
+  'auth.logout': 'Signed out',
+  'auth.password_change': 'Changed password',
+  'app_password.create': 'Created app password',
+  'app_password.revoke': 'Revoked app password',
+  'admin.user_create': 'Created user',
+  'admin.user_update': 'Updated user',
+  'admin.user_delete': 'Deleted user',
+  'admin.user_password_reset': 'Reset a password',
+  'admin.group_create': 'Created group',
+  'admin.group_update': 'Updated group',
+  'admin.group_delete': 'Deleted group',
+  'admin.group_member_add': 'Added group member',
+  'admin.group_member_remove': 'Removed group member',
+  'admin.settings_update': 'Changed settings',
+  'share.create': 'Created share link',
+  'share.delete': 'Deleted share link',
+  'file.delete': 'Moved file to trash',
+  'file.restore': 'Restored file',
+  'file.trash_empty': 'Emptied trash',
+  'file.hard_delete': 'Permanently deleted file',
+  'system.gc': 'Cleaned up orphaned data',
+}
+
+function actionLabel(action: string): string {
+  return ACTION_LABELS[action] ?? action.split('.').pop()?.replace(/_/g, ' ') ?? action
+}
+
+/** Fehlgeschlagene Anmeldungen und endgültige Löschungen sind das, wonach man
+ *  im Protokoll sucht – die bekommen Farbe, der Rest bleibt ruhig. */
+function actionColor(action: string): string {
+  if (action === 'auth.login_failed') return 'var(--color-danger)'
+  if (action.includes('delete')) return 'var(--color-warning)'
+  return 'var(--color-text-muted)'
+}
+
+/**
+ * Stand der Texterkennung.
+ *
+ * Ohne diese Anzeige ist nicht zu unterscheiden, ob die Volltextsuche nichts
+ * findet oder den Bestand noch gar nicht gelesen hat. Nach dem ersten Start
+ * läuft die Erkennung je nach Menge stundenlang – bei einem Scan rund eine
+ * Minute je Seite –, und eine Suche ohne Treffer sieht in dieser Zeit aus wie
+ * ein Fehler.
+ */
+function IndexingStatus() {
+  const [status, setStatus] = useState<OcrStatus | null>(null)
+  const [failed, setFailed] = useState(false)
+
+  useEffect(() => {
+    let alive = true
+    let timer: ReturnType<typeof setTimeout>
+
+    async function tick() {
+      try {
+        const s = await adminApi.ocrStatus()
+        if (!alive) return
+        setStatus(s)
+        setFailed(false)
+        // Nur nachfragen, solange sich etwas bewegt. Steht die Warteschlange
+        // still, ändert sich die Zahl erst beim nächsten Upload – dann wäre
+        // jede weitere Anfrage verschenkt.
+        const busy = (s.pending ?? 0) + (s.running ?? 0) > 0
+        if (busy) timer = setTimeout(tick, 5000)
+      } catch {
+        if (alive) setFailed(true)
+      }
+    }
+    tick()
+    return () => { alive = false; clearTimeout(timer) }
+  }, [])
+
+  if (failed || !status) return null
+
+  const pending = status.pending ?? 0
+  const running = status.running ?? 0
+  const indexed = status.indexed ?? 0
+  const bad = status.failed ?? 0
+  const busy = pending + running > 0
+
+  let text: string
+  if (!status.enabled) {
+    text = 'Off — file contents are not searchable. Set OCR_ENABLED and make sure ocrmypdf and tesseract are in the image.'
+  } else if (busy) {
+    text = `${indexed} indexed · ${pending + running} to go — a scanned page takes about a minute.`
+  } else if (indexed === 0) {
+    text = 'No documents indexed yet. PDFs and images are read after upload.'
+  } else {
+    text = `${indexed} ${indexed === 1 ? 'document' : 'documents'} indexed — their contents are searchable.`
+  }
+  if (bad > 0) {
+    text += ` ${bad} could not be read.`
+  }
+
+  return (
+    <div style={{
+      display: 'flex', alignItems: 'center', gap: 12, marginBottom: 16,
+      padding: '12px 14px', borderRadius: 10,
+      border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+    }}>
+      {/* Der Punkt sagt den Zustand auch ohne Lesen: grün fertig, gelb läuft,
+          gedämpft aus. */}
+      <span style={{
+        width: 8, height: 8, borderRadius: '50%', flexShrink: 0,
+        background: !status.enabled
+          ? 'var(--color-text-muted)'
+          : busy ? 'var(--color-warning)' : 'var(--color-success)',
+      }} />
+      <div style={{ flex: 1, minWidth: 0 }}>
+        <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>
+          Full-text indexing
+        </div>
+        <div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginTop: 2 }}>
+          {text}
+        </div>
+      </div>
+      {busy && (
+        <div style={{
+          width: 12, height: 12, flexShrink: 0,
+          border: '2px solid var(--color-primary)', borderTopColor: 'transparent',
+          borderRadius: '50%', animation: 'spin 0.7s linear infinite',
+        }} />
+      )}
+    </div>
+  )
+}
+
+/** Der GC läuft von selbst alle 12 Stunden. Der Knopf ist da, damit man sieht,
+ *  was er tut – ein Aufräumjob, der unbeobachtbar Dateien löscht, ist schwer zu
+ *  vertrauen. */
+function StorageCleanup() {
+  const [running, setRunning] = useState(false)
+  const [result, setResult] = useState<string | null>(null)
+
+  async function run() {
+    setRunning(true)
+    setResult(null)
+    try {
+      const r = await adminApi.runCleanup()
+      setResult(
+        r.deleted > 0
+          ? `${r.deleted} orphaned ${r.deleted === 1 ? 'file' : 'files'} removed, ${formatBytes(r.freed_bytes)} freed (${r.scanned} scanned)`
+          : `Nothing to clean up — all ${r.scanned} stored files are accounted for`,
+      )
+    } catch {
+      setResult('Cleanup failed')
+    } finally {
+      setRunning(false)
+    }
+  }
+
+  return (
+    <div style={{
+      display: 'flex', alignItems: 'center', gap: 12, marginBottom: 16,
+      padding: '12px 14px', borderRadius: 10,
+      border: '1px solid var(--color-border)', background: 'var(--color-surface-2)',
+    }}>
+      <div style={{ flex: 1, minWidth: 0 }}>
+        <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>
+          Storage cleanup
+        </div>
+        <div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginTop: 2 }}>
+          {result ?? 'Removes stored files that no longer belong to any record. Runs automatically every 12 hours.'}
+        </div>
+      </div>
+      <button
+        onClick={run}
+        disabled={running}
+        style={{
+          padding: '7px 16px', borderRadius: 8, flexShrink: 0,
+          border: '1px solid var(--color-border)', background: 'var(--color-surface)',
+          color: 'var(--color-text)', fontSize: 12, fontWeight: 600,
+          cursor: running ? 'default' : 'pointer', opacity: running ? 0.6 : 1,
+        }}
+      >
+        {running ? 'Running…' : 'Run now'}
+      </button>
+    </div>
+  )
+}
+
+export default function AuditTab() {
+  const [entries, setEntries] = useState<AuditEntry[]>([])
+  const [total, setTotal] = useState(0)
+  const [actions, setActions] = useState<string[]>([])
+  const [filter, setFilter] = useState('')
+  const [page, setPage] = useState(0)
+  const [loading, setLoading] = useState(true)
+
+  useEffect(() => {
+    adminApi.listAuditActions().then(a => setActions(a ?? [])).catch(() => {})
+  }, [])
+
+  useEffect(() => {
+    setLoading(true)
+    adminApi.listAudit({ action: filter || undefined, limit: PAGE_SIZE, offset: page * PAGE_SIZE })
+      .then(res => { setEntries(res.entries ?? []); setTotal(res.total) })
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [filter, page])
+
+  const pages = Math.ceil(total / PAGE_SIZE)
+
+  return (
+    <div>
+      <IndexingStatus />
+      <StorageCleanup />
+
+      <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 16 }}>
+        <select
+          value={filter}
+          onChange={e => { setFilter(e.target.value); setPage(0) }}
+          style={{
+            padding: '7px 10px', borderRadius: 8, border: '1px solid var(--color-border)',
+            background: 'var(--color-surface-2)', color: 'var(--color-text)', fontSize: 13,
+          }}
+        >
+          <option value="">All actions</option>
+          {actions.map(a => <option key={a} value={a}>{actionLabel(a)}</option>)}
+        </select>
+        <span style={{ fontSize: 12, color: 'var(--color-text-muted)' }}>
+          {total} {total === 1 ? 'entry' : 'entries'}
+        </span>
+      </div>
+
+      {loading ? (
+        <p style={{ fontSize: 13, color: 'var(--color-text-muted)' }}>Loading…</p>
+      ) : entries.length === 0 ? (
+        <p style={{ fontSize: 13, color: 'var(--color-text-muted)' }}>Nothing recorded yet.</p>
+      ) : (
+        <div style={{
+          border: '1px solid var(--color-border)', borderRadius: 12, overflow: 'hidden',
+        }}>
+          <table style={{ width: '100%', borderCollapse: 'collapse' }}>
+            <thead>
+              <tr style={{ background: 'var(--color-surface-2)' }}>
+                {['When', 'Who', 'Action', 'Target', 'From'].map(h => (
+                  <th key={h} style={{
+                    textAlign: 'left', padding: '9px 12px', fontSize: 11,
+                    fontWeight: 700, color: 'var(--color-text-muted)',
+                    textTransform: 'uppercase', letterSpacing: 0.4,
+                  }}>{h}</th>
+                ))}
+              </tr>
+            </thead>
+            <tbody>
+              {entries.map(e => (
+                <tr key={e.id} style={{ borderTop: '1px solid var(--color-border)' }}>
+                  <td style={{ padding: '9px 12px', fontSize: 12, color: 'var(--color-text-muted)', whiteSpace: 'nowrap' }}>
+                    {new Date(e.created_at).toLocaleString()}
+                  </td>
+                  <td style={{ padding: '9px 12px', fontSize: 13, color: 'var(--color-text)' }}>
+                    {e.actor_name}
+                    {/* Fehlt die actor_id, ist das Konto gelöscht – der Name bleibt
+                        stehen, damit der Eintrag lesbar bleibt. Bei einem Fehlversuch
+                        auf einen unbekannten Namen gab es dagegen nie ein Konto,
+                        „gelöscht" wäre dort schlicht falsch. */}
+                    {e.actor_id === null && e.actor_name !== 'system'
+                      && e.action !== 'auth.login_failed' && (
+                      <span style={{ fontSize: 11, color: 'var(--color-text-muted)' }}> (deleted account)</span>
+                    )}
+                  </td>
+                  <td style={{ padding: '9px 12px', fontSize: 13, color: actionColor(e.action), fontWeight: 500 }}>
+                    {actionLabel(e.action)}
+                  </td>
+                  <td style={{ padding: '9px 12px', fontSize: 12, color: 'var(--color-text-muted)', maxWidth: 280 }}>
+                    {e.target_name || e.detail || '—'}
+                    {e.target_name && e.detail && (
+                      <div style={{ fontSize: 11, opacity: 0.8 }}>{e.detail}</div>
+                    )}
+                  </td>
+                  <td style={{ padding: '9px 12px', fontSize: 12, color: 'var(--color-text-muted)', fontFamily: 'monospace' }}>
+                    {e.ip ?? '—'}
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+
+      {pages > 1 && (
+        <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginTop: 14 }}>
+          <button
+            onClick={() => setPage(p => Math.max(0, p - 1))}
+            disabled={page === 0}
+            style={{
+              padding: '6px 14px', borderRadius: 8, border: '1px solid var(--color-border)',
+              background: 'transparent', color: 'var(--color-text)', fontSize: 12,
+              cursor: page === 0 ? 'default' : 'pointer', opacity: page === 0 ? 0.5 : 1,
+            }}
+          >
+            Previous
+          </button>
+          <span style={{ fontSize: 12, color: 'var(--color-text-muted)' }}>
+            Page {page + 1} of {pages}
+          </span>
+          <button
+            onClick={() => setPage(p => Math.min(pages - 1, p + 1))}
+            disabled={page >= pages - 1}
+            style={{
+              padding: '6px 14px', borderRadius: 8, border: '1px solid var(--color-border)',
+              background: 'transparent', color: 'var(--color-text)', fontSize: 12,
+              cursor: page >= pages - 1 ? 'default' : 'pointer', opacity: page >= pages - 1 ? 0.5 : 1,
+            }}
+          >
+            Next
+          </button>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/pages/admin/GroupsTab.tsx b/frontend/src/pages/admin/GroupsTab.tsx
new file mode 100644
index 0000000..acb654c
--- /dev/null
+++ b/frontend/src/pages/admin/GroupsTab.tsx
@@ -0,0 +1,357 @@
+import { useState, useEffect, useCallback } from 'react'
+import { adminApi, type AdminUser, type AdminGroup, type GroupMember, type GroupFolder } from '../../api/client'
+import ConfirmDialog from '../../components/ConfirmDialog'
+import { FolderGlyph } from '../../components/icons'
+import { Card, Btn, Input, Modal, formatBytes } from './ui'
+
+// Gruppen und Gruppenordner.
+
+// ── Groups Tab ────────────────────────────────────────────────────────────────
+
+/** Gruppenordner: ein Ordner, der der Gruppe gehört statt einer Person. Jedes
+ *  Mitglied sieht ihn in seiner Wurzel; entfernen kann ihn nur der Admin – und
+ *  zwar hier, nicht in der Dateiansicht. Deshalb steht der Löschen-Knopf
+ *  ausschließlich an dieser Stelle. */
+function GroupFolders({ groups }: { groups: AdminGroup[] }) {
+  const [folders, setFolders] = useState<GroupFolder[]>([])
+  const [loading, setLoading] = useState(true)
+  const [groupId, setGroupId] = useState('')
+  const [name, setName] = useState('')
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState('')
+  const [confirming, setConfirming] = useState<GroupFolder | null>(null)
+
+  useEffect(() => { load() }, [])
+
+  async function load() {
+    try {
+      setFolders(await adminApi.listGroupFolders() ?? [])
+    } catch {
+      setError('Could not load group folders')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  async function create() {
+    if (!groupId || !name.trim()) return
+    setBusy(true); setError('')
+    try {
+      await adminApi.createGroupFolder(groupId, name.trim())
+      setName('')
+      await load()
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Could not create group folder')
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  async function remove(folder: GroupFolder) {
+    setConfirming(null)
+    try {
+      await adminApi.deleteGroupFolder(folder.id)
+      await load()
+    } catch {
+      setError('Could not delete group folder')
+    }
+  }
+
+  return (
+    <div style={{ marginBottom: 28 }}>
+      <h3 style={{ margin: '0 0 4px', fontSize: 15, fontWeight: 700, color: 'var(--color-text)' }}>
+        Group folders
+      </h3>
+      <p style={{ margin: '0 0 14px', fontSize: 12, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+        A folder that belongs to the group instead of a person. Every member sees it
+        next to their own folders and can work in it. Members cannot delete or rename
+        the folder itself — only you can, here.
+      </p>
+
+      <div style={{ display: 'flex', gap: 8, marginBottom: 14 }}>
+        <select
+          value={groupId}
+          onChange={e => setGroupId(e.target.value)}
+          style={{
+            padding: '8px 10px', borderRadius: 8, border: '1px solid var(--color-border)',
+            background: 'var(--color-surface-2)', color: 'var(--color-text)', fontSize: 13,
+          }}
+        >
+          <option value="">Choose a group…</option>
+          {groups.map(g => <option key={g.id} value={g.id}>{g.name}</option>)}
+        </select>
+        <input
+          value={name}
+          onChange={e => setName(e.target.value)}
+          onKeyDown={e => { if (e.key === 'Enter') create() }}
+          placeholder="Folder name"
+          style={{
+            flex: 1, minWidth: 0, padding: '8px 10px', borderRadius: 8,
+            border: '1px solid var(--color-border)',
+            background: 'var(--color-surface-2)', color: 'var(--color-text)',
+            fontSize: 13, outline: 'none',
+          }}
+        />
+        <button
+          onClick={create}
+          disabled={!groupId || !name.trim() || busy}
+          style={{
+            padding: '8px 18px', borderRadius: 8, border: 'none', flexShrink: 0,
+            background: 'var(--color-primary)', color: '#fff', fontSize: 13, fontWeight: 600,
+            cursor: !groupId || !name.trim() || busy ? 'default' : 'pointer',
+            opacity: !groupId || !name.trim() || busy ? 0.5 : 1,
+          }}
+        >
+          {busy ? 'Creating…' : 'Create'}
+        </button>
+      </div>
+
+      {error && <p style={{ margin: '0 0 10px', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>}
+
+      {loading ? (
+        <p style={{ fontSize: 13, color: 'var(--color-text-muted)' }}>Loading…</p>
+      ) : folders.length === 0 ? (
+        <p style={{ fontSize: 13, color: 'var(--color-text-muted)' }}>No group folders yet.</p>
+      ) : (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
+          {folders.map(f => (
+            <div key={f.id} style={{
+              display: 'flex', alignItems: 'center', gap: 12,
+              padding: '10px 12px', borderRadius: 9, border: '1px solid var(--color-border)',
+            }}>
+              <span style={{ flexShrink: 0, display: 'flex' }}>
+                <FolderGlyph size={20} color="rgb(var(--color-primary-rgb))" />
+              </span>
+              <div style={{ flex: 1, minWidth: 0 }}>
+                <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>{f.name}</div>
+                <div style={{ fontSize: 11, color: 'var(--color-text-muted)', marginTop: 2 }}>
+                  {f.group_name} · {f.members} {f.members === 1 ? 'member' : 'members'} · {formatBytes(f.used_bytes)} used
+                </div>
+              </div>
+              <button
+                onClick={() => setConfirming(f)}
+                style={{
+                  padding: '5px 12px', borderRadius: 7, flexShrink: 0,
+                  border: '1px solid var(--color-danger)', background: 'transparent',
+                  color: 'var(--color-danger)', fontSize: 12, cursor: 'pointer',
+                }}
+              >
+                Delete
+              </button>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {confirming && (
+        <ConfirmDialog
+          title="Delete group folder"
+          message={`"${confirming.name}" and everything in it will be permanently deleted for all ${confirming.members} members. This cannot be undone.`}
+          confirmLabel="Delete permanently"
+          danger
+          onConfirm={() => remove(confirming)}
+          onCancel={() => setConfirming(null)}
+        />
+      )}
+    </div>
+  )
+}
+
+export default function GroupsTab({ allUsers }: { allUsers: AdminUser[] }) {
+  const [groups, setGroups] = useState<AdminGroup[]>([])
+  const [members, setMembers] = useState<Record<string, GroupMember[]>>({})
+  const [expanded, setExpanded] = useState<string | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [newName, setNewName] = useState('')
+  const [newDesc, setNewDesc] = useState('')
+  const [showCreate, setShowCreate] = useState(false)
+  const [editing, setEditing] = useState<AdminGroup | null>(null)
+  const [confirmGroup, setConfirmGroup] = useState<AdminGroup | null>(null)
+  const [groupError, setGroupError] = useState('')
+  const [editName, setEditName] = useState('')
+  const [editDesc, setEditDesc] = useState('')
+
+  const load = useCallback(() => {
+    adminApi.listGroups()
+      .then(data => setGroups(data ?? []))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [])
+
+  useEffect(() => { load() }, [load])
+
+  async function toggleExpand(groupId: string) {
+    if (expanded === groupId) { setExpanded(null); return }
+    setExpanded(groupId)
+    if (!members[groupId]) {
+      const data = await adminApi.listMembers(groupId).catch(() => [])
+      setMembers(m => ({ ...m, [groupId]: data ?? [] }))
+    }
+  }
+
+  async function handleCreate() {
+    if (!newName) return
+    await adminApi.createGroup(newName, newDesc)
+    setNewName(''); setNewDesc(''); setShowCreate(false); load()
+  }
+
+  async function handleDelete(g: AdminGroup) {
+    setConfirmGroup(null)
+    try {
+      await adminApi.deleteGroup(g.id)
+      load()
+    } catch (e) {
+      setGroupError(`Could not delete group: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
+  function openEdit(g: AdminGroup) {
+    setEditing(g); setEditName(g.name); setEditDesc(g.description ?? '')
+  }
+
+  async function handleUpdate() {
+    if (!editing || !editName.trim()) return
+    try {
+      await adminApi.updateGroup(editing.id, editName.trim(), editDesc)
+      setEditing(null); load()
+    } catch (e) {
+      setGroupError(`Could not save group: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
+  async function handleAddMember(groupId: string, userId: string) {
+    await adminApi.addMember(groupId, userId)
+    const data = await adminApi.listMembers(groupId).catch(() => [])
+    setMembers(m => ({ ...m, [groupId]: data ?? [] }))
+    load()
+  }
+
+  async function handleRemoveMember(groupId: string, userId: string) {
+    await adminApi.removeMember(groupId, userId)
+    setMembers(m => ({ ...m, [groupId]: (m[groupId] ?? []).filter(x => x.user_id !== userId) }))
+    load()
+  }
+
+  return (
+    <div>
+      {/* Gruppenordner zuerst: Mitgliedschaft ohne gemeinsamen Ordner tut nichts,
+          der Ordner ist der eigentliche Zweck einer Gruppe. */}
+      <GroupFolders groups={groups} />
+
+      <div style={{
+        height: 1, background: 'var(--color-border)', margin: '0 0 24px',
+      }} />
+
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 16 }}>
+        <h2 style={{ margin: 0, fontSize: 18, fontWeight: 700, color: 'var(--color-text)' }}>Groups</h2>
+        <Btn variant="primary" onClick={() => setShowCreate(v => !v)}>+ Create group</Btn>
+      </div>
+
+      {showCreate && (
+        <Card style={{ marginBottom: 16 }}>
+          <div style={{ display: 'flex', gap: 10, alignItems: 'flex-end' }}>
+            <div style={{ flex: 1 }}><Input label="Name" value={newName} onChange={setNewName} placeholder="e.g. Editors" /></div>
+            <div style={{ flex: 2 }}><Input label="Description" value={newDesc} onChange={setNewDesc} placeholder="Optional" /></div>
+            <Btn variant="primary" onClick={handleCreate} disabled={!newName}>Create</Btn>
+            <Btn onClick={() => setShowCreate(false)}>Cancel</Btn>
+          </div>
+        </Card>
+      )}
+
+      {groupError && (
+        <Card style={{
+          marginBottom: 12, borderColor: 'var(--color-danger)',
+          background: 'rgba(239,68,68,0.08)', padding: '10px 14px',
+          display: 'flex', alignItems: 'center', gap: 10,
+        }}>
+          <span style={{ flex: 1, fontSize: 13, color: 'var(--color-danger)' }}>{groupError}</span>
+          <button onClick={() => setGroupError('')} style={{
+            background: 'none', border: 'none', cursor: 'pointer',
+            color: 'var(--color-danger)', fontSize: 16, lineHeight: 1,
+          }}>×</button>
+        </Card>
+      )}
+
+      {confirmGroup && (
+        <ConfirmDialog
+          title="Delete group"
+          message={`Delete group "${confirmGroup.name}"? Members keep their accounts and files – only the group is removed.`}
+          confirmLabel="Delete group"
+          danger
+          onConfirm={() => handleDelete(confirmGroup)}
+          onCancel={() => setConfirmGroup(null)}
+        />
+      )}
+
+      {editing && (
+        <Modal title={`Edit group "${editing.name}"`} onClose={() => setEditing(null)}>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
+            <Input label="Name" value={editName} onChange={setEditName} />
+            <Input label="Description" value={editDesc} onChange={setEditDesc} placeholder="Optional" />
+            <div style={{ display: 'flex', gap: 8, justifyContent: 'flex-end' }}>
+              <Btn onClick={() => setEditing(null)}>Cancel</Btn>
+              <Btn variant="primary" onClick={handleUpdate} disabled={!editName.trim()}>Save</Btn>
+            </div>
+          </div>
+        </Modal>
+      )}
+
+      <Card>
+        {loading && <p style={{ color: 'var(--color-text-muted)', fontSize: 13 }}>Loading…</p>}
+        {!loading && groups.length === 0 && (
+          <p style={{ color: 'var(--color-text-muted)', fontSize: 13, textAlign: 'center', padding: '20px 0' }}>No groups yet</p>
+        )}
+        {groups.map((g, i) => {
+          const isOpen = expanded === g.id
+          const groupMembers = members[g.id] ?? []
+          const nonMembers = allUsers.filter(u => !groupMembers.some(m => m.user_id === u.id))
+          return (
+            <div key={g.id} style={{ borderBottom: i < groups.length - 1 ? '1px solid var(--color-border)' : 'none' }}>
+              <div style={{ display: 'flex', alignItems: 'center', padding: '12px 4px', gap: 10 }}>
+                <button onClick={() => toggleExpand(g.id)} style={{ background: 'none', border: 'none', cursor: 'pointer', color: 'var(--color-text-muted)', display: 'flex' }}>
+                  <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5"
+                    style={{ transform: isOpen ? 'rotate(90deg)' : 'none', transition: 'transform 0.15s' }}>
+                    <polyline points="9 18 15 12 9 6" />
+                  </svg>
+                </button>
+                <div style={{ flex: 1 }}>
+                  <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--color-text)' }}>{g.name}</div>
+                  {g.description && <div style={{ fontSize: 12, color: 'var(--color-text-muted)' }}>{g.description}</div>}
+                </div>
+                <span style={{ fontSize: 12, color: 'var(--color-text-muted)' }}>{g.member_count} {g.member_count === 1 ? 'member' : 'members'}</span>
+                <Btn size="sm" onClick={() => openEdit(g)}>Edit</Btn>
+                <Btn size="sm" variant="danger" onClick={() => handleDelete(g)}>Delete</Btn>
+              </div>
+
+              {isOpen && (
+                <div style={{ paddingLeft: 28, paddingBottom: 12 }}>
+                  {groupMembers.length === 0 && <p style={{ fontSize: 12, color: 'var(--color-text-muted)', margin: '4px 0 8px' }}>No members</p>}
+                  {groupMembers.map(m => (
+                    <div key={m.user_id} style={{ display: 'flex', alignItems: 'center', gap: 8, padding: '4px 0' }}>
+                      <span style={{ fontSize: 13, color: 'var(--color-text)', flex: 1 }}>{m.username}{m.display_name ? ` (${m.display_name})` : ''}</span>
+                      <Btn size="sm" variant="danger" onClick={() => handleRemoveMember(g.id, m.user_id)}>Remove</Btn>
+                    </div>
+                  ))}
+                  {nonMembers.length > 0 && (
+                    <div style={{ display: 'flex', gap: 8, marginTop: 8, alignItems: 'center' }}>
+                      <select
+                        style={{ padding: '5px 8px', borderRadius: 7, border: '1px solid var(--color-border)', background: 'var(--color-surface-2)', color: 'var(--color-text)', fontSize: 12 }}
+                        defaultValue=""
+                        onChange={e => { if (e.target.value) { handleAddMember(g.id, e.target.value); e.target.value = '' } }}
+                      >
+                        <option value="" disabled>Add member…</option>
+                        {nonMembers.map(u => (
+                          <option key={u.id} value={u.id}>{u.username}</option>
+                        ))}
+                      </select>
+                    </div>
+                  )}
+                </div>
+              )}
+            </div>
+          )
+        })}
+      </Card>
+    </div>
+  )
+}
diff --git a/frontend/src/pages/admin/ThemingTab.tsx b/frontend/src/pages/admin/ThemingTab.tsx
new file mode 100644
index 0000000..5dc8677
--- /dev/null
+++ b/frontend/src/pages/admin/ThemingTab.tsx
@@ -0,0 +1,295 @@
+import { useState, useEffect } from 'react'
+import { adminApi, type AppSettings } from '../../api/client'
+import { applyTheme } from '../../theme'
+import { useAppSettings } from '../../hooks/useAppSettings'
+import ConfirmDialog from '../../components/ConfirmDialog'
+import { Card, Btn, Input } from './ui'
+
+// Erscheinungsbild: Name, Farben, Logo und App-Symbol.
+
+// ── Theming Tab ───────────────────────────────────────────────────────────────
+
+/** Bild-Verwaltung für Logo und Favicon. Getrennt vom übrigen
+ *  Theming-Formular, weil ein Upload sofort wirkt statt erst beim Speichern –
+ *  ein Bild in einem Formular mit Speichern-Knopf würde die Frage aufwerfen,
+ *  ob es schon hochgeladen ist. */
+interface ImageSettingProps {
+  label: string
+  url: string
+  /** Quadratischer Rahmen fürs Favicon, breiter fürs Logo. */
+  preview: { width: number; height: number }
+  accept: string
+  hint: string
+  removeTitle: string
+  removeMessage: string
+  onUpload: (file: File) => Promise<unknown>
+  onRemove: () => Promise<unknown>
+  onDone: () => Promise<void>
+}
+
+function ImageSetting({
+  label, url, preview, accept, hint, removeTitle, removeMessage,
+  onUpload, onRemove, onDone,
+}: ImageSettingProps) {
+  const [busy, setBusy] = useState(false)
+  const [error, setError] = useState('')
+  const [confirming, setConfirming] = useState(false)
+  const what = label.toLowerCase()
+
+  async function pick(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0]
+    // Zurücksetzen, damit dieselbe Datei erneut gewählt werden kann.
+    e.target.value = ''
+    if (!file) return
+
+    setBusy(true); setError('')
+    try {
+      await onUpload(file)
+      await onDone()
+    } catch (err) {
+      setError(err instanceof Error ? err.message : `Could not upload the ${what}`)
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  async function remove() {
+    setConfirming(false)
+    setBusy(true); setError('')
+    try {
+      await onRemove()
+      await onDone()
+    } catch {
+      setError(`Could not remove the ${what}`)
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  return (
+    <Card style={{ maxWidth: 480, marginBottom: 16 }}>
+      <div style={{ fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)', marginBottom: 10 }}>
+        {label}
+      </div>
+
+      <div style={{ display: 'flex', alignItems: 'center', gap: 16 }}>
+        <div style={{
+          width: preview.width, height: preview.height, borderRadius: 10, flexShrink: 0,
+          border: '1px solid var(--color-border)',
+          background: 'var(--color-surface-2)',
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+          overflow: 'hidden',
+        }}>
+          {url ? (
+            <img src={url} alt="" style={{ maxWidth: '100%', maxHeight: '100%', objectFit: 'contain' }} />
+          ) : (
+            <span style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>none</span>
+          )}
+        </div>
+
+        <div style={{ flex: 1, minWidth: 0 }}>
+          <div style={{ display: 'flex', gap: 8, marginBottom: 6 }}>
+            <label style={{
+              padding: '7px 14px', borderRadius: 8,
+              background: 'var(--color-primary)', color: '#fff',
+              fontSize: 12, fontWeight: 600,
+              cursor: busy ? 'default' : 'pointer', opacity: busy ? 0.6 : 1,
+            }}>
+              {busy ? 'Uploading…' : url ? 'Replace' : 'Upload'}
+              <input type="file" accept={accept}
+                     onChange={pick} disabled={busy} style={{ display: 'none' }} />
+            </label>
+            {url && (
+              <button
+                onClick={() => setConfirming(true)}
+                disabled={busy}
+                style={{
+                  padding: '7px 14px', borderRadius: 8,
+                  border: '1px solid var(--color-border)', background: 'transparent',
+                  color: 'var(--color-text-muted)', fontSize: 12, cursor: 'pointer',
+                }}
+              >
+                Remove
+              </button>
+            )}
+          </div>
+          <p style={{ margin: 0, fontSize: 11, color: 'var(--color-text-muted)', lineHeight: 1.5 }}>
+            {hint}
+          </p>
+        </div>
+      </div>
+
+      {error && <p style={{ margin: '10px 0 0', fontSize: 12, color: 'var(--color-danger)' }}>{error}</p>}
+
+      {confirming && (
+        <ConfirmDialog
+          title={removeTitle}
+          message={removeMessage}
+          confirmLabel="Remove"
+          danger
+          onConfirm={remove}
+          onCancel={() => setConfirming(false)}
+        />
+      )}
+    </Card>
+  )
+}
+
+/** Die beiden Bilder des Erscheinungsbilds. */
+function BrandingSettings() {
+  const { logoUrl, appIconUrl, refresh } = useAppSettings()
+  return (
+    <>
+      <ImageSetting
+        label="Logo"
+        url={logoUrl}
+        preview={{ width: 84, height: 60 }}
+        accept="image/png,image/jpeg,image/webp,image/gif"
+        hint="Shown on the sign-in page and in the sidebar. PNG, JPEG, WebP or GIF, up to 2 MB. Takes effect immediately."
+        removeTitle="Remove logo"
+        removeMessage="The sign-in page and sidebar will show the default icon again."
+        onUpload={adminApi.uploadLogo}
+        onRemove={adminApi.deleteLogo}
+        onDone={refresh}
+      />
+      <ImageSetting
+        label="App icon"
+        url={appIconUrl}
+        preview={{ width: 60, height: 60 }}
+        accept="image/png,image/webp,image/gif,image/jpeg"
+        hint="Used for the browser tab and for the installed app. One square PNG, at least 192×192 (512×512 is better), up to 2 MB – all sizes are generated from it. The tab changes immediately; an already installed app follows within a day or two."
+        removeTitle="Remove app icon"
+        removeMessage="Tabs and the installed app will show the default Aether icon again."
+        onUpload={adminApi.uploadAppIcon}
+        onRemove={adminApi.deleteAppIcon}
+        onDone={refresh}
+      />
+    </>
+  )
+}
+
+export default function ThemingTab() {
+  const [settings, setSettings] = useState<Partial<AppSettings>>({})
+  const [loading, setLoading] = useState(true)
+  const [saving, setSaving] = useState(false)
+  const [saved, setSaved] = useState(false)
+  const { refresh } = useAppSettings()
+
+  useEffect(() => {
+    adminApi.getSettings()
+      .then(data => setSettings(data ?? {}))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [])
+
+  // Farbwahl wirkt sofort auf die ganze Oberfläche – man sieht das Ergebnis,
+  // bevor man sich festlegt. Beim Verlassen ohne Speichern wird der
+  // gespeicherte Stand wiederhergestellt, damit keine Vorschau hängen bleibt.
+  function previewColors(next: Partial<AppSettings>) {
+    applyTheme(next.primary_color, next.accent_color)
+  }
+
+  useEffect(() => {
+    return () => { void refresh() }
+  }, [refresh])
+
+  async function handleSave() {
+    setSaving(true)
+    const result = await adminApi.updateSettings({
+      cloud_name: settings.cloud_name,
+      primary_color: settings.primary_color,
+      accent_color: settings.accent_color,
+    }).catch(() => null)
+    setSaving(false)
+    if (result) {
+      setSettings(result)
+      setSaved(true)
+      // Neu laden statt nur die Variablen zu setzen: so übernimmt auch der
+      // Cloud-Name in der Seitenleiste und im Fenstertitel sofort.
+      await refresh()
+      setTimeout(() => setSaved(false), 2000)
+    }
+  }
+
+  if (loading) return <p style={{ color: 'var(--color-text-muted)', fontSize: 13 }}>Loading…</p>
+
+  return (
+    <div>
+      <h2 style={{ margin: '0 0 16px', fontSize: 18, fontWeight: 700, color: 'var(--color-text)' }}>Theming</h2>
+
+      <BrandingSettings />
+
+      <Card style={{ maxWidth: 480 }}>
+        <div style={{ display: 'flex', flexDirection: 'column', gap: 18 }}>
+          <Input
+            label="Cloud name"
+            value={settings.cloud_name ?? ''}
+            onChange={v => setSettings(s => ({ ...s, cloud_name: v }))}
+            placeholder="Aether"
+          />
+
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
+            <label style={{ fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)' }}>Primary colour</label>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+              <input
+                type="color"
+                value={settings.primary_color ?? '#6366f1'}
+                onChange={e => setSettings(s => {
+                  const next = { ...s, primary_color: e.target.value }
+                  previewColors(next)
+                  return next
+                })}
+                style={{ width: 40, height: 36, borderRadius: 8, border: '1px solid var(--color-border)', cursor: 'pointer', padding: 2 }}
+              />
+              <span style={{ fontSize: 13, fontFamily: 'monospace', color: 'var(--color-text)' }}>
+                {settings.primary_color ?? '#6366f1'}
+              </span>
+            </div>
+          </div>
+
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
+            <label style={{ fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)' }}>Accent colour</label>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
+              <input
+                type="color"
+                value={settings.accent_color ?? '#8b5cf6'}
+                onChange={e => setSettings(s => {
+                  const next = { ...s, accent_color: e.target.value }
+                  previewColors(next)
+                  return next
+                })}
+                style={{ width: 40, height: 36, borderRadius: 8, border: '1px solid var(--color-border)', cursor: 'pointer', padding: 2 }}
+              />
+              <span style={{ fontSize: 13, fontFamily: 'monospace', color: 'var(--color-text)' }}>
+                {settings.accent_color ?? '#8b5cf6'}
+              </span>
+            </div>
+          </div>
+
+          {/* Preview */}
+          <div style={{ padding: 14, borderRadius: 10, border: '1px solid var(--color-border)', background: 'var(--color-surface-2)' }}>
+            <p style={{ margin: '0 0 8px', fontSize: 11, fontWeight: 600, color: 'var(--color-text-muted)', textTransform: 'uppercase', letterSpacing: '0.06em' }}>Preview</p>
+            <div style={{ display: 'flex', gap: 8, alignItems: 'center' }}>
+              <div style={{ width: 28, height: 28, borderRadius: 7, background: settings.primary_color ?? '#6366f1', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="white" strokeWidth="1.5">
+                  <path strokeLinecap="round" strokeLinejoin="round" d="M2.25 15a4.5 4.5 0 004.5 4.5H18a3.75 3.75 0 001.332-7.257 3 3 0 00-3.758-3.848 5.25 5.25 0 00-10.233 2.33A4.502 4.502 0 002.25 15z" />
+                </svg>
+              </div>
+              <span style={{ fontWeight: 700, fontSize: 15, color: 'var(--color-text)' }}>{settings.cloud_name || 'Aether'}</span>
+              <div style={{ marginLeft: 'auto', padding: '4px 12px', borderRadius: 99, background: settings.primary_color ?? '#6366f1', color: '#fff', fontSize: 12, fontWeight: 600 }}>
+                Upload
+              </div>
+            </div>
+          </div>
+
+          <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
+            <Btn variant="primary" onClick={handleSave} disabled={saving}>
+              {saving ? 'Saving…' : 'Save settings'}
+            </Btn>
+            {saved && <span style={{ fontSize: 12, color: '#22c55e', fontWeight: 600 }}>✓ Saved</span>}
+          </div>
+        </div>
+      </Card>
+    </div>
+  )
+}
diff --git a/frontend/src/pages/admin/UsersTab.tsx b/frontend/src/pages/admin/UsersTab.tsx
new file mode 100644
index 0000000..c0b0cc1
--- /dev/null
+++ b/frontend/src/pages/admin/UsersTab.tsx
@@ -0,0 +1,264 @@
+import { useState, useEffect, useCallback } from 'react'
+import { adminApi, type AdminUser } from '../../api/client'
+import ConfirmDialog from '../../components/ConfirmDialog'
+import { Card, Btn, Input, Modal, formatBytes, bytesFromGB, gbFromBytes } from './ui'
+
+// Benutzerverwaltung: anlegen, bearbeiten, Passwort zurücksetzen, löschen.
+
+// ── Users Tab ─────────────────────────────────────────────────────────────────
+
+export default function UsersTab() {
+  const [users, setUsers] = useState<AdminUser[]>([])
+  const [loading, setLoading] = useState(true)
+  const [modal, setModal] = useState<'create' | 'edit' | 'reset' | null>(null)
+  const [selected, setSelected] = useState<AdminUser | null>(null)
+  const [resetResult, setResetResult] = useState('')
+  const [error, setError] = useState('')
+  const [confirmUser, setConfirmUser] = useState<AdminUser | null>(null)
+
+  // Create form
+  const [newUsername, setNewUsername] = useState('')
+  const [newDisplay, setNewDisplay] = useState('')
+  const [newPassword, setNewPassword] = useState('')
+  const [newIsAdmin, setNewIsAdmin] = useState(false)
+  const [newQuotaGB, setNewQuotaGB] = useState('10')
+
+  // Edit form
+  const [editDisplay, setEditDisplay] = useState('')
+  const [editIsAdmin, setEditIsAdmin] = useState(false)
+  const [editQuotaGB, setEditQuotaGB] = useState('10')
+
+  const load = useCallback(() => {
+    adminApi.listUsers()
+      .then(data => setUsers(data ?? []))
+      .catch(() => {})
+      .finally(() => setLoading(false))
+  }, [])
+
+  useEffect(() => { load() }, [load])
+
+  async function handleCreate() {
+    if (!newUsername || !newPassword) return
+    try {
+      await adminApi.createUser({
+        username: newUsername, display_name: newDisplay,
+        password: newPassword, is_admin: newIsAdmin,
+        quota_bytes: bytesFromGB(parseFloat(newQuotaGB) || 10),
+      })
+      setModal(null); setNewUsername(''); setNewDisplay(''); setNewPassword(''); setNewIsAdmin(false); setNewQuotaGB('10')
+      load()
+    } catch (e) {
+      setError(`Could not create user: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
+  async function handleEdit() {
+    if (!selected) return
+    try {
+      await adminApi.updateUser(selected.id, {
+        display_name: editDisplay,
+        is_admin: editIsAdmin,
+        quota_bytes: bytesFromGB(parseFloat(editQuotaGB) || 10),
+      })
+      setModal(null); setSelected(null); load()
+    } catch (e) {
+      setError(`Could not save: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
+  async function handleReset() {
+    if (!selected) return
+    try {
+      const res = await adminApi.resetPassword(selected.id)
+      setResetResult(res.new_password)
+    } catch (e) {
+      setError(`Could not reset password: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
+  async function handleDelete(user: AdminUser) {
+    setConfirmUser(null)
+    try {
+      await adminApi.deleteUser(user.id)
+      load()
+    } catch (e) {
+      setError(`Could not delete: ${e instanceof Error ? e.message : e}`)
+    }
+  }
+
+  return (
+    <div>
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 16 }}>
+        <h2 style={{ margin: 0, fontSize: 18, fontWeight: 700, color: 'var(--color-text)' }}>Users</h2>
+        <Btn variant="primary" onClick={() => setModal('create')}>+ Create user</Btn>
+      </div>
+
+      {error && (
+        <Card style={{
+          marginBottom: 12, borderColor: 'var(--color-danger)',
+          background: 'rgba(239,68,68,0.08)', padding: '10px 14px',
+          display: 'flex', alignItems: 'center', gap: 10,
+        }}>
+          <span style={{ flex: 1, fontSize: 13, color: 'var(--color-danger)' }}>{error}</span>
+          <button onClick={() => setError('')} style={{
+            background: 'none', border: 'none', cursor: 'pointer',
+            color: 'var(--color-danger)', fontSize: 16, lineHeight: 1,
+          }}>×</button>
+        </Card>
+      )}
+
+      <Card>
+        {loading && <p style={{ color: 'var(--color-text-muted)', fontSize: 13 }}>Loading…</p>}
+        {!loading && (
+          <table style={{ width: '100%', borderCollapse: 'collapse' }}>
+            <thead>
+              <tr style={{ borderBottom: '1px solid var(--color-border)' }}>
+                {['User', 'Storage', 'Quota', 'Groups', 'Role', ''].map(h => (
+                  <th key={h} style={{ padding: '6px 10px', textAlign: 'left', fontSize: 11, fontWeight: 700, color: 'var(--color-text-muted)', textTransform: 'uppercase', letterSpacing: '0.05em' }}>{h}</th>
+                ))}
+              </tr>
+            </thead>
+            <tbody>
+              {users.map(u => (
+                <tr key={u.id} style={{ borderBottom: '1px solid var(--color-border)' }}
+                  onMouseEnter={e => (e.currentTarget.style.background = 'var(--color-surface-2)')}
+                  onMouseLeave={e => (e.currentTarget.style.background = 'transparent')}
+                >
+                  <td style={{ padding: '10px 10px' }}>
+                    <div style={{ fontSize: 13, fontWeight: 600, color: 'var(--color-text)' }}>{u.username}</div>
+                    {u.display_name && <div style={{ fontSize: 11, color: 'var(--color-text-muted)' }}>{u.display_name}</div>}
+                  </td>
+                  <td style={{ padding: '10px 10px', fontSize: 12, color: 'var(--color-text-muted)' }}>
+                    {formatBytes(u.used_bytes)}
+                  </td>
+                  <td style={{ padding: '10px 10px', fontSize: 12, color: 'var(--color-text-muted)' }}>
+                    {formatBytes(u.quota_bytes)}
+                  </td>
+                  <td style={{ padding: '10px 10px' }}>
+                    {u.groups && u.groups.length > 0 ? (
+                      <div style={{ display: 'flex', flexWrap: 'wrap', gap: 4 }}>
+                        {u.groups.map(g => (
+                          <span key={g} style={{
+                            fontSize: 11, padding: '2px 8px', borderRadius: 99,
+                            background: 'var(--color-surface-2)', color: 'var(--color-text-muted)',
+                          }}>{g}</span>
+                        ))}
+                      </div>
+                    ) : (
+                      <span style={{ fontSize: 12, color: 'var(--color-text-muted)' }}>–</span>
+                    )}
+                  </td>
+                  <td style={{ padding: '10px 10px' }}>
+                    <span style={{
+                      fontSize: 11, fontWeight: 600, padding: '2px 8px', borderRadius: 99,
+                      background: u.is_admin ? 'rgba(var(--color-primary-rgb), 0.15)' : 'var(--color-surface-2)',
+                      color: u.is_admin ? 'var(--color-primary)' : 'var(--color-text-muted)',
+                    }}>
+                      {u.is_admin ? 'Admin' : 'User'}
+                    </span>
+                  </td>
+                  <td style={{ padding: '10px 10px' }}>
+                    <div style={{ display: 'flex', gap: 6, justifyContent: 'flex-end' }}>
+                      <Btn size="sm" onClick={() => {
+                        setSelected(u); setEditDisplay(u.display_name)
+                        setEditIsAdmin(u.is_admin); setEditQuotaGB(String(gbFromBytes(u.quota_bytes)))
+                        setModal('edit')
+                      }}>Edit</Btn>
+                      <Btn size="sm" onClick={() => { setSelected(u); setResetResult(''); setModal('reset') }}>Reset password</Btn>
+                      <Btn size="sm" variant="danger" onClick={() => handleDelete(u)}>Delete</Btn>
+                    </div>
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        )}
+      </Card>
+
+      {/* Create modal */}
+      {modal === 'create' && (
+        <Modal title="Create user" onClose={() => setModal(null)}>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
+            <Input label="Username *" value={newUsername} onChange={setNewUsername} placeholder="e.g. alice" />
+            <Input label="Display name" value={newDisplay} onChange={setNewDisplay} placeholder="Alice Smith" />
+            <Input label="Password *" type="password" value={newPassword} onChange={setNewPassword} />
+            <Input label="Quota (GB)" value={newQuotaGB} onChange={setNewQuotaGB} placeholder="10" />
+            <label style={{ display: 'flex', alignItems: 'center', gap: 8, fontSize: 13, cursor: 'pointer' }}>
+              <input type="checkbox" checked={newIsAdmin} onChange={e => setNewIsAdmin(e.target.checked)} />
+              Administrator
+            </label>
+            <div style={{ display: 'flex', justifyContent: 'flex-end', gap: 8, marginTop: 4 }}>
+              <Btn onClick={() => setModal(null)}>Cancel</Btn>
+              <Btn variant="primary" onClick={handleCreate} disabled={!newUsername || !newPassword}>Create</Btn>
+            </div>
+          </div>
+        </Modal>
+      )}
+
+      {/* Edit modal */}
+      {modal === 'edit' && selected && (
+        <Modal title={`Edit ${selected.username}`} onClose={() => { setModal(null); setSelected(null) }}>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
+            <Input label="Display name" value={editDisplay} onChange={setEditDisplay} />
+            <Input label="Quota (GB)" value={editQuotaGB} onChange={setEditQuotaGB} />
+            <label style={{ display: 'flex', alignItems: 'center', gap: 8, fontSize: 13, cursor: 'pointer' }}>
+              <input type="checkbox" checked={editIsAdmin} onChange={e => setEditIsAdmin(e.target.checked)} />
+              Administrator
+            </label>
+            <div style={{ display: 'flex', justifyContent: 'flex-end', gap: 8, marginTop: 4 }}>
+              <Btn onClick={() => { setModal(null); setSelected(null) }}>Cancel</Btn>
+              <Btn variant="primary" onClick={handleEdit}>Save</Btn>
+            </div>
+          </div>
+        </Modal>
+      )}
+
+      {/* Reset password modal */}
+      {modal === 'reset' && selected && (
+        <Modal title={`Reset password – ${selected.username}`} onClose={() => { setModal(null); setSelected(null); setResetResult('') }}>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
+            {!resetResult ? (
+              <>
+                <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)' }}>
+                  Generate a random password and pass it on to the user.
+                </p>
+                <div style={{ display: 'flex', justifyContent: 'flex-end', gap: 8 }}>
+                  <Btn onClick={() => { setModal(null); setSelected(null) }}>Cancel</Btn>
+                  <Btn variant="primary" onClick={handleReset}>Generate password</Btn>
+                </div>
+              </>
+            ) : (
+              <>
+                <p style={{ margin: 0, fontSize: 13, color: 'var(--color-text-muted)' }}>
+                  New password (shown only once):
+                </p>
+                <div style={{
+                  padding: '10px 14px', borderRadius: 8,
+                  background: 'var(--color-surface-2)', border: '1px solid var(--color-border)',
+                  fontFamily: 'monospace', fontSize: 14, color: 'var(--color-text)',
+                  userSelect: 'all',
+                }}>
+                  {resetResult}
+                </div>
+                <div style={{ display: 'flex', justifyContent: 'flex-end' }}>
+                  <Btn variant="primary" onClick={() => { setModal(null); setSelected(null); setResetResult('') }}>Done</Btn>
+                </div>
+              </>
+            )}
+          </div>
+        </Modal>
+      )}
+
+      {confirmUser && (
+        <ConfirmDialog
+          title="Delete user"
+          message={`Delete "${confirmUser.username}"? All of their files will be deleted as well. This cannot be undone.`}
+          confirmLabel="Delete user"
+          danger
+          onConfirm={() => handleDelete(confirmUser)}
+          onCancel={() => setConfirmUser(null)}
+        />
+      )}
+    </div>
+  )
+}
diff --git a/frontend/src/pages/admin/ui.tsx b/frontend/src/pages/admin/ui.tsx
new file mode 100644
index 0000000..3efe076
--- /dev/null
+++ b/frontend/src/pages/admin/ui.tsx
@@ -0,0 +1,119 @@
+import type React from 'react'
+import { useOverlayDismiss } from '../../hooks/useOverlayDismiss'
+
+/**
+ * Bausteine, die alle Reiter des Admin-Bereichs teilen: Karte, Knopf, Feld,
+ * Dialog – dazu die Umrechnung zwischen Bytes und Gigabyte.
+ *
+ * Lagen bis zum 23.08.2026 zusammen mit allen vier Reitern in einer Datei mit
+ * 1300 Zeilen.
+ */
+
+
+export function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`
+  return `${(n / 1024 ** 3).toFixed(1)} GB`
+}
+
+export function bytesFromGB(gb: number): number {
+  return Math.round(gb * 1024 ** 3)
+}
+
+export function gbFromBytes(bytes: number): number {
+  return Math.round((bytes / 1024 ** 3) * 10) / 10
+}
+
+// ── Shared UI ─────────────────────────────────────────────────────────────────
+
+export function Card({ children, style }: { children: React.ReactNode; style?: React.CSSProperties }) {
+  return (
+    <div style={{
+      background: 'var(--color-surface)',
+      border: '1px solid var(--color-border)',
+      borderRadius: 12, padding: 20,
+      ...style,
+    }}>
+      {children}
+    </div>
+  )
+}
+
+export function Btn({
+  children, onClick, variant = 'secondary', size = 'md', disabled,
+}: {
+  children: React.ReactNode
+  onClick?: () => void
+  variant?: 'primary' | 'secondary' | 'danger'
+  size?: 'sm' | 'md'
+  disabled?: boolean
+}) {
+  const colors = {
+    primary: { bg: 'var(--color-primary)', color: '#fff', border: 'none' },
+    secondary: { bg: 'transparent', color: 'var(--color-text-muted)', border: '1px solid var(--color-border)' },
+    danger: { bg: 'transparent', color: 'var(--color-danger)', border: '1px solid var(--color-danger)' },
+  }[variant]
+  return (
+    <button
+      onClick={onClick}
+      disabled={disabled}
+      style={{
+        padding: size === 'sm' ? '4px 12px' : '7px 16px',
+        fontSize: size === 'sm' ? 12 : 13,
+        fontWeight: 500,
+        borderRadius: 8,
+        cursor: disabled ? 'default' : 'pointer',
+        opacity: disabled ? 0.5 : 1,
+        ...colors,
+      }}
+    >
+      {children}
+    </button>
+  )
+}
+
+export function Input({ label, value, onChange, type = 'text', placeholder }: {
+  label: string; value: string; onChange: (v: string) => void; type?: string; placeholder?: string
+}) {
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
+      <label style={{ fontSize: 12, fontWeight: 600, color: 'var(--color-text-muted)' }}>{label}</label>
+      <input
+        type={type}
+        value={value}
+        onChange={e => onChange(e.target.value)}
+        placeholder={placeholder}
+        style={{
+          padding: '8px 10px', borderRadius: 8, border: '1px solid var(--color-border)',
+          background: 'var(--color-surface-2)', color: 'var(--color-text)', fontSize: 13,
+          outline: 'none',
+        }}
+      />
+    </div>
+  )
+}
+
+// ── Modal ─────────────────────────────────────────────────────────────────────
+
+export function Modal({ title, onClose, children }: { title: string; onClose: () => void; children: React.ReactNode }) {
+  const overlay = useOverlayDismiss(onClose)
+  return (
+    <div style={{
+      position: 'fixed', inset: 0, zIndex: 400, background: 'rgba(0,0,0,0.5)',
+      display: 'flex', alignItems: 'center', justifyContent: 'center', padding: 24,
+    }} {...overlay}>
+      <div style={{
+        background: 'var(--color-surface)', border: '1px solid var(--color-border)',
+        borderRadius: 14, width: '100%', maxWidth: 440,
+        boxShadow: '0 12px 40px rgba(0,0,0,0.25)',
+      }}>
+        <div style={{ padding: '18px 22px 14px', borderBottom: '1px solid var(--color-border)', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+          <h3 style={{ margin: 0, fontSize: 16, fontWeight: 700, color: 'var(--color-text)' }}>{title}</h3>
+          <button onClick={onClose} style={{ background: 'none', border: 'none', cursor: 'pointer', color: 'var(--color-text-muted)', fontSize: 18, lineHeight: 1 }}>×</button>
+        </div>
+        <div style={{ padding: 22 }}>{children}</div>
+      </div>
+    </div>
+  )
+}
diff --git a/frontend/src/test-setup.ts b/frontend/src/test-setup.ts
new file mode 100644
index 0000000..bd6540c
--- /dev/null
+++ b/frontend/src/test-setup.ts
@@ -0,0 +1 @@
+import '@testing-library/react'
diff --git a/frontend/src/theme.ts b/frontend/src/theme.ts
new file mode 100644
index 0000000..89ef29b
--- /dev/null
+++ b/frontend/src/theme.ts
@@ -0,0 +1,43 @@
+/**
+ * Anwenden der Farbeinstellungen auf die CSS-Variablen.
+ *
+ * Die Werte aus dem Admin-Panel landen in der Datenbank, wirken aber erst,
+ * wenn sie hier auf das Wurzelelement geschrieben werden. Ein Inline-Wert am
+ * `documentElement` überschreibt die Vorgaben aus `index.css`, weil er
+ * spezifischer ist als `:root`.
+ *
+ * Neben der Volltonfarbe wird das RGB-Tripel als eigene Variable gesetzt
+ * (`--color-primary-rgb`). Die Oberfläche braucht die Farbe an vielen Stellen
+ * halbtransparent – für zarte Flächen wie den aktiven Menüpunkt oder eine
+ * Auswahl. Mit dem Tripel geht das als `rgba(var(--color-primary-rgb), 0.15)`,
+ * ohne für jede Deckkraft eine eigene Variable zu pflegen.
+ */
+
+const HEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/
+
+/** "#6366f1" → "99, 102, 241"; Kurzform (#abc) wird ausgeschrieben. */
+function hexToRgb(hex: string): string | null {
+  if (!HEX.test(hex)) return null
+  let h = hex.slice(1)
+  if (h.length === 3) h = h.split('').map(c => c + c).join('')
+  const n = parseInt(h, 16)
+  return `${(n >> 16) & 255}, ${(n >> 8) & 255}, ${n & 255}`
+}
+
+function setColor(name: string, value?: string) {
+  const root = document.documentElement
+  const rgb = value ? hexToRgb(value) : null
+  if (value && rgb) {
+    root.style.setProperty(`--color-${name}`, value)
+    root.style.setProperty(`--color-${name}-rgb`, rgb)
+  } else {
+    // Ungültig oder leer: Vorgaben aus index.css wieder greifen lassen.
+    root.style.removeProperty(`--color-${name}`)
+    root.style.removeProperty(`--color-${name}-rgb`)
+  }
+}
+
+export function applyTheme(primary?: string, accent?: string) {
+  setColor('primary', primary)
+  setColor('accent', accent)
+}
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
new file mode 100644
index 0000000..aab8a43
--- /dev/null
+++ b/frontend/tsconfig.json
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    // Vites Zusaetze zum Import: ?url, ?raw und der Seiteneffekt-Import von CSS.
+    "types": ["vite/client"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "allowArbitraryExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"]
+}
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
new file mode 100644
index 0000000..9baceb7
--- /dev/null
+++ b/frontend/vite.config.ts
@@ -0,0 +1,104 @@
+import { cpSync, mkdirSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { defineConfig, type Plugin } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { VitePWA } from 'vite-plugin-pwa'
+
+/**
+ * Die 14 Standardschriften von PDF.js nach public/ kopieren.
+ *
+ * Aeltere PDFs betten Helvetica, Times und Courier nicht ein, sondern setzen
+ * sie voraus. Ohne diese Dateien malt PDF.js mit einer Ersatzschrift – lesbar,
+ * aber Zeilen brechen an anderer Stelle als im Original.
+ *
+ * Kopiert statt eingecheckt: 800 KB fremde Binaerdateien gehoeren nicht in den
+ * Quelltext, und die Fassung soll der Abhaengigkeit folgen. public/pdfjs steht
+ * deshalb in .gitignore.
+ */
+function pdfjsStandardFonts(): Plugin {
+  return {
+    name: 'aether-pdfjs-standard-fonts',
+    // Nicht 'buildStart': Im Entwicklungsbetrieb liest der Server public/
+    // beim Start ein, das Kopieren muss vorher passiert sein.
+    config() {
+      const require = createRequire(import.meta.url)
+      const from = join(dirname(require.resolve('pdfjs-dist/package.json')), 'standard_fonts')
+      const to = join(import.meta.dirname, 'public', 'pdfjs', 'standard_fonts')
+      mkdirSync(to, { recursive: true })
+      cpSync(from, to, { recursive: true })
+    },
+  }
+}
+
+export default defineConfig({
+  plugins: [
+    pdfjsStandardFonts(),
+    react(),
+    tailwindcss(),
+    VitePWA({
+      registerType: 'autoUpdate',
+      workbox: {
+        // Der Service Worker beantwortet jede Navigation aus dem Cache mit
+        // index.html – nötig, damit Adressen wie /admin oder /s/<token> auch
+        // offline funktionieren. Ohne diese Ausnahmen erwischt er aber auch
+        // Downloads: Ein Klick auf „Download" öffnet eine Navigation zu
+        // /api/v1/files/<id>/download, der Worker liefert die Anwendung statt
+        // der Datei, und es passiert sichtbar nichts.
+        navigateFallback: 'index.html',
+        navigateFallbackDenylist: [/^\/api\//, /^\/dav\//, /^\/share\//, /^\/branding\//, /^\/wopi\//],
+        // PDF.js bleibt aussen vor: Betrachter (435 KB), Arbeiter (1,3 MB)
+        // und Standardschriften (800 KB) sind zusammen zweieinhalb Megabyte,
+        // die nur braucht, wer ein PDF oeffnet. Vorab in den Cache zu legen
+        // hiesse, das jeder Installation aufzuladen.
+        //
+        // Offline waere davon ohnehin nichts gewonnen: Die Dokumente selbst
+        // liegen auf dem Server und werden nicht mitgecacht – ein Betrachter
+        // ohne Datei nuetzt nichts.
+        globIgnores: [
+          '**/pdfjs/standard_fonts/**',
+          '**/pdf.worker*.mjs',
+          '**/PdfViewer-*.js',
+          '**/PdfViewer-*.css',
+        ],
+        maximumFileSizeToCacheInBytes: 3 * 1024 * 1024,
+      },
+      // Das Manifest liefert der Server (/manifest.webmanifest): Name, Farbe
+      // und Symbol stehen in der Datenbank und sollen dem Admin-Bereich
+      // folgen. Gebaut waeren sie fest verdrahtet, und ein hochgeladenes
+      // Symbol erreichte die installierte App nie.
+      manifest: false,
+    }),
+  ],
+  server: {
+    host: true, // auf allen Interfaces lauschen (IPv4 + IPv6), nötig für VS-Code-Port-Forwarding
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8080',
+        changeOrigin: true,
+        proxyTimeout: 60 * 60 * 1000,
+        timeout: 60 * 60 * 1000,
+      },
+      '/share': {
+        target: 'http://localhost:8080',
+        changeOrigin: true,
+      },
+      // Logo, App-Symbol und Manifest kommen ebenfalls vom Backend – ohne
+      // diese beiden Eintraege fehlen sie im Entwicklungsbetrieb.
+      '/branding': {
+        target: 'http://localhost:8080',
+        changeOrigin: true,
+      },
+      '/manifest.webmanifest': {
+        target: 'http://localhost:8080',
+        changeOrigin: true,
+      },
+    },
+  },
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: './src/test-setup.ts',
+  },
+})