Zum Inhalt

Dateien

apps/server speichert Ordner und Dateien und jede Version einer Datei. Es ist eine Hono-App auf Bun (src/app.ts) über SQLite (bun:sqlite mit Drizzle, src/db/schema.ts) und einem Ordner mit Blobs; beides liegt im Datenordner, wer diesen Ordner kopiert, sichert also alles.

SQLite statt PostgreSQL: ein Prozess und ein Ordner im Betrieb, sonst nichts zu installieren, dieselbe Datenbank, die die Desktop-App lokal benutzen kann, und dieselbe Wahl wie firsttris/sekretaer, zu dem Schreibzeug dazukommen soll. Während mehrere Leute bearbeiten, laufen ihre Änderungen über das Relay im Speicher; die Datenbank sieht alle paar Sekunden eine Speicherung, was ein Schreiber zur Zeit leicht schafft. bun:sqlite ist synchron, die Repository-Funktionen sind es also auch: Eine Funktion, die nicht wartet (await), wird nicht mit anderen Anfragen verschachtelt, und eine Transaktion darf nicht warten (src/db/database.ts).

Daten

Tabelle Was sie enthält
nodes Ordner und Dateien in einem Baum (parent_id, null ist die Wurzel der Dateien des Eigentümers, owner_id, wem sie gehören; siehe Konten). Eine Datei hat mime, size und ihre neueste version.
versions Die gespeicherten Stände einer Datei, mit dem Alter ausgedünnt: Nummer, Größe, der SHA-256 ihrer Bytes und kept, wenn jemand sie behalten wollte.
media Welches Bild zu welcher Datei gehört: die Datei und der SHA-256 eines Bilds, das beim Bearbeiten in sie eingefügt wurde.
shares Wer einen Knoten sonst noch öffnen darf, mit edit oder view; siehe Konten.
invites Links, die einen Knoten teilen: ein zufälliges Token, die Rolle, wann er abläuft.
pending_shares Freigaben an eine Adresse, die noch kein Konto hat, übernommen bei ihrer ersten Anmeldung; siehe Konten.
access_tokens Persönliche Zugangsschlüssel für MCP-Clients: nur ihr SHA-256, Name, Umfang, Ablauf, letzte Benutzung; siehe den MCP-Server.

Die Bytes liegen im Blob-Speicher (src/blobs.ts), unter data/blobs/ab/abcdef… nach ihrem SHA-256: Dieselben Bytes werden nur einmal gespeichert, und ein Blob wird unter einem temporären Namen geschrieben und umbenannt, sodass ein Absturz nie einen halben Blob unter einem echten Schlüssel hinterlässt. Bilder, die beim Bearbeiten in ein Dokument eingefügt werden, kommen auch dorthin, benannt nach ihrem Hash (src/files/media.ts), und media vermerkt, in welche Datei jedes eingefügt wurde; nach dem Speichern enthält die Office-Datei sie selbst.

Namen sind pro Ordner eindeutig (auf der obersten Ebene pro Eigentümer), ohne Rücksicht auf Groß- und Kleinschreibung, wie unter macOS und Windows (ein partieller eindeutiger Index auf name_key unter den Knoten außerhalb des Papierkorbs; der Server führt name_key als den Namen in Kleinbuchstaben, weil SQLites eigenes lower() nur ASCII kennt und „Übersicht“ und „übersicht“ nebeneinander stehen ließe). Zeiten werden in Millisekunden gespeichert. Namen dürfen weder / \ : * ? " < > | noch Steuerzeichen enthalten, damit sich jede Datei auf jedem System unter ihrem Namen herunterladen lässt (packages/files-api/src/schemas.ts).

Speichern fügt eine Version hinzu. Gleichzeitige Speicherungen einer Datei sperren deren Zeile und bekommen aufeinanderfolgende Nummern.

Versionen

Der Editor speichert ein paar Sekunden nach jeder Änderung (AUTOSAVE_DELAY in packages/editor-core/src/session-progress.ts); ein Arbeitstag ergibt also Hunderte von Versionen. Nach jedem Speichern und Wiederherstellen dünnt der Server die älteren der Datei aus (src/files/thinning.ts), wie Nextcloud es tut:

Alter Was bleibt
bis zu einem Tag jede Version
bis zu 30 Tagen die neueste pro Stunde
bis zu einem Jahr die neueste pro Tag
älter die neueste pro Woche

Die neueste Version bleibt immer, und ebenso jede Version, die jemand behalten wollte („Version behalten“ im Versionen-Dialog, PATCH /files/:id/versions/:number mit { "kept": true }, für alle, die bearbeiten dürfen), und jede Version, die in einem Archiv abgelegt wurde: die verschickte Rechnung, der unterschriebene Vertrag. Mit SCHREIBZEUG_VERSIONS=all bleibt jede Version (Installation).

Die Zeile einer ausgedünnten Version verschwindet sofort; ihre Bytes bleiben im Blob-Speicher bis zur Sammlung (src/blob-collection.ts), die alle sechs Stunden läuft und die Blobs entfernt, auf die keine Version und kein Bild verweist und die vor mehr als einer Stunde gespeichert wurden. Eine Speicherung legt ihre Bytes ab, bevor sie deren Zeile schreibt, und das Ablegen schon vorhandener Bytes erneuert deren Zeit, sodass die Sammlung nie den Blob einer laufenden Speicherung nimmt.

Papierkorb

Wird ein Knoten in den Papierkorb gelegt, bekommen er und alles darunter trashed_at mit derselben Zeit, und er wird als trash_root markiert. Überall sonst ist „nicht im Papierkorb“ dann eine einzige Spalte. Der Papierkorb listet die Wurzeln; wer eine wiederherstellt, holt zurück, was mit ihr in den Papierkorb kam, während das, was schon vorher dort lag, im Papierkorb bleibt. Eine Wiederherstellung schlägt fehl, wenn der alte Ordner selbst im Papierkorb liegt oder der Name wieder vergeben ist.

API

Alles unter /api; Bodys sind JSON, sofern nicht anders angegeben. Jede Route außer /health, /info, Better Auths /auth/*, GET /invites/:token und DELETE /sessions (nur mit einem Token von Kontext, Kontext) braucht eine Sitzung oder einen persönlichen Zugangsschlüssel und handelt für dessen Benutzer (Konten, MCP-Server). Fehler sind { "error": { "kind", "message" } }, wobei kind eines ist von not_found (404), invalid (400), unauthorized (401), forbidden (403: die Rolle reicht nicht), not_a_folder (422), name_taken und conflict (409), too_large (413), internal (500), von POST /files/import auch link_expired (410) und upstream_failed (502) und von POST /files/:id/archive auch upstream_failed und upstream_refused (502).

Nur die Uploads (POST /files, PUT /files/:id/content, POST /files/:id/media, POST /files/:id/archive) nehmen Bodys bis SCHREIBZEUG_MAX_UPLOAD_MB. Better Auths /auth/* beantwortet einen Body über 64 KB mit 413, bevor es ihn liest, und jede andere Route einen über 16 MB (src/limits.ts): Buns eigenes Limit ist auf die Uploads ausgelegt, und Better Auth liest einen JSON-Body ganz, bevor es prüft, wer fragt.

Jeder Knoten in einer Antwort trägt role, was der Benutzer damit darf: owner, edit oder view.

Route Was sie tut
GET /nodes?parent=root\|<id> Ein Ordner: der Ordner, sein Pfad von der Wurzel (bei einem geteilten Ordner von dem Ordner, der geteilt wurde), seine Kinder (Ordner zuerst, nach Namen)
GET /nodes/:id Ein Knoten
PATCH /nodes/:id Umbenennen (name; braucht Bearbeiten und den Ordner, in dem er liegt, Teilen) und/oder verschieben (parentId, nur Eigentümer)
POST /nodes/:id/trash In den Papierkorb verschieben
POST /nodes/:id/restore Aus dem Papierkorb zurückholen
GET /trash, GET /recent Was im Papierkorb liegt; Dateien nach letzter Änderung (beide nur die eigenen des Benutzers)
GET /storage Wie viel Platz da ist, unten
GET /search?q= Knoten, deren Name q enthält, ohne Rücksicht auf Groß- und Kleinschreibung: die eigenen des Benutzers und was in oder unter dem liegt, was mit ihm geteilt ist, Dateien zuerst, höchstens 50
GET /nodes/:id/shares Mit wem der Knoten geteilt ist (nur Eigentümer)
PUT /nodes/:id/shares Mit dem Konto hinter email teilen oder dessen role ändern (edit, view)
DELETE /nodes/:id/shares/:userId Eine Freigabe zurücknehmen
GET /shared Was andere mit dem Benutzer geteilt haben, mit ownerName
GET /nodes/:id/invites Die Links des Knotens, die noch gelten (nur Eigentümer)
POST /nodes/:id/invites Ein neuer Link (role, days: 1, 7 oder 30)
DELETE /nodes/:id/invites/:token Einen Link löschen
GET /invites/:token Was ein Link teilt (nodeName, kind, ownerName, role, expiresAt); keine Sitzung nötig
POST /invites/:token/accept Einen Link annehmen: eine Freigabe mit seiner Rolle, nie schwächer als eine, die der Benutzer schon hat
POST /folders Neuer Ordner (parentId, name)
POST /files Hochladen (multipart: file, optional parentId)
POST /files/import Eine Kopie der Datei hinter dem Link einer anderen App als neue Datei (url, optional name, parentId), unten
POST /files/blank Neue Datei (parentId, name, format: docx, xlsx, pptx, oder md und txt, die leer sind)
GET /files/:id/content[?version=n] Die Bytes der neuesten oder einer bestimmten Version, als Download (Content-Disposition: attachment, X-Content-Type-Options: nosniff)
PUT /files/:id/content Speichern: Der Body wird zu einer neuen Version; aus einer gemeinsamen Sitzung mit x-schreibzeug-session-save (409, wenn diese Sitzung nicht mehr besteht; die Bearbeiten-Rolle wird zuerst geprüft, wer sie nicht hat, bekommt also 404/403, egal in welchem Zustand die Sitzung ist), siehe Zusammenarbeit. Mit If-Match: "<sha256>" nur, solange der Inhalt der neuesten Version diesen SHA-256 hat, sonst 409 (der Texteditor, Markdown- und Textdateien); ein fehlerhafter ergibt 400
GET /files/:id/versions Alle Versionen, neueste zuerst
POST /files/:id/media Ein beim Bearbeiten in die Datei eingefügtes Bild speichern (PNG, JPEG, GIF, BMP, nach seinen ersten Bytes); antwortet mit seinem Namen, <sha256>.<ext>. Braucht edit
GET /files/:id/media/:name Dieses Bild, für alle, die die Datei sehen dürfen; nur Bilder, die in diese Datei eingefügt wurden, nie ein anderer Blob über seinen Hash; mit X-Content-Type-Options: nosniff
POST /files/:id/copy Eine Kopie der neuesten Version, benannt „… (Kopie).docx“, neben dem Original, wenn der Benutzer dort etwas hinzufügen darf, sonst in seinen eigenen Dateien
POST /files/:id/versions/:number/restore Eine ältere Version wieder zur neuesten machen (als neue Version; die dazwischen bleiben)
PATCH /files/:id/versions/:number { "kept": true } bewahrt eine Version vor dem Ausdünnen, false gibt sie wieder frei (Bearbeiten)
POST /files/:id/archive Sendet die neueste Version als PDF/A und/oder die Datei selbst an das Archiv und behält sie (Bearbeiten), unten
GET /health { "ok": true }
GET /info { "mode": "server" }, mit oidc: { name }, wenn ein Anmeldeanbieter eingestellt ist, embedOrigin, wenn eine Website die App in einem Frame zeigen darf (Kontext), und archive: { name? }, wenn sich Dokumente in einem Archiv ablegen lassen; der lokale Server der Desktop-App antwortet { "mode": "local", "rootName" } (Desktop-App). Keine Sitzung nötig

Weitere Routen, beschrieben dort, wo sie hingehören:

Route Wo
GET /tokens, POST /tokens, DELETE /tokens/:id Persönliche Zugangsschlüssel, nur mit Sitzung (MCP-Server)
POST /files/:id/agent, GET /files/:id/outline Ein Auftrag für den offenen Editor (MCP-Server)
GET /collab/:fileId (WebSocket) Die Bearbeitungssitzung einer Datei (Zusammenarbeit)
GET /agent/:fileId (WebSocket) Ein offener Editor, der Aufträge annimmt (MCP-Server)
DELETE /sessions Kontext meldet jemanden überall ab (Kontext)
/mcp (außerhalb von /api) Der MCP-Endpunkt (MCP-Server)

Speicherplatz

GET /api/storage antwortet, wie viel die eigenen Dateien des Benutzers belegen und wie viel Platz übrig ist (src/files/storage.ts, src/disk.ts):

  • usage: die Größen ihrer Versionen, aufgeteilt in files (die neueste Version jeder Datei außerhalb des Papierkorbs), versions (die älteren, die das Ausdünnen übrig gelassen hat) und trash (jede Version dessen, was dort liegt). Das sind die Größen der Dateien: Der Blob-Speicher hält dieselben Bytes nur einmal, die Platte kann also weniger belegen. Eine geteilte Datei zählt für ihren Eigentümer.
  • disk: free und total des Laufwerks, auf dem der Datenordner liegt (statfs; free ist das, was ein unprivilegierter Prozess noch schreiben darf, ohne die für root reservierten Blöcke), jedes Mal neu abgefragt; null, wenn das System es nicht sagt. Jedes angemeldete Konto sieht es: Sie teilen sich das Laufwerk.
  • uploadLimit: SCHREIBZEUG_MAX_UPLOAD_MB in Bytes.

Die App zeigt es unten in der Navigation (ein Balken, der ab 80 % gelb und ab 95 % rot wird, wie der Postfach-Ring von Kontext, und was die Dateien des Benutzers belegen) und in den Einstellungen, aufgeteilt wie oben (apps/web/src/storage, apps/web/src/settings/storage-section.tsx). Bei weniger als 1 GB frei, oder weniger als dem Upload-Limit, wenn das größer ist, sagt ein Hinweis über jeder Dateiseite, dass Speicherungen bald fehlschlagen können (apps/web/src/lib/storage.ts); ein Anteil am Laufwerk würde nicht taugen, denn 5 % eines großen sind immer noch reichlich. Der lokale Server der Desktop-App beantwortet dieselbe Route mit dem Laufwerk seines Ordners und ohne usage, und die App zeigt nur diesen Hinweis (Desktop-App).

Eine Datei aus einer anderen App öffnen

Eine andere App kann eine Datei mit einem Link übergeben, etwa der Knopf „Öffnen mit Schreibzeug“ eines Archivs. Sie öffnet /open?url=<Link>&name=<Dateiname> in der Web-App (beides URL-kodiert); die Seite lässt, wenn nötig, zuerst anmelden, lässt den Server die Datei holen (POST /api/files/import) und öffnet die neue Datei in ihrem Editor. Schreibzeug bearbeitet eine Kopie in den Dateien des Benutzers; das Original bleibt in der anderen App. Wer das Archiv verwaltet, trägt als Adresse https://<schreibzeug>/open?url={url}&name={name} ein.

Der Server holt nur Links auf einem Origin aus SCHREIBZEUG_IMPORT_ORIGINS (Installation); ohne die Variable antwortet die Route 404 und holt nichts. Ein Link muss http(s) sein, ohne Benutzernamen oder Passwort, und genau auf einem dieser Origins liegen (src/files/import.ts), damit niemand den Server Adressen in seinem eigenen Netz abrufen lassen kann. Weiterleitungen werden nicht verfolgt. Der Download darf 60 Sekunden dauern und höchstens SCHREIBZEUG_MAX_UPLOAD_MB groß sein, gezählt, während die Bytes kommen, nicht nach Content-Length. Dann wird die Datei gespeichert wie ein Upload.

Der Name ist name, wenn er ein gültiger Name ist, sonst der aus Content-Disposition der Antwort, sonst „Datei“; ein Name ohne bekannte Endung bekommt die des Content-Type. Ist er im Ordner vergeben, wird die Datei zu „Name (2).ext“, „Name (3).ext“ und so weiter.

Antwort Wann
201 mit dem neuen Knoten Gespeichert
404 not_found SCHREIBZEUG_IMPORT_ORIGINS ist nicht gesetzt
403 forbidden Der Origin des Links ist nicht erlaubt
410 link_expired Die andere App antwortete 404 oder 410: Der Link ist abgelaufen oder die Datei gelöscht
413 too_large Größer als SCHREIBZEUG_MAX_UPLOAD_MB
502 upstream_failed Nicht erreichbar, zu langsam, eine Weiterleitung oder ein anderer Fehler

In einem Archiv ablegen

Ein Server kann mit einem Archiv eingerichtet sein, das fertige Dokumente als unveränderbare Originale aufbewahrt, etwa ein verschicktes Angebot oder einen unterschriebenen Vertrag, z. B. Belegt, ein selbst gehostetes Archiv für die GoBD. Dann hat das Menü „Datei“ jedes Editors, der ein PDF erstellen kann (Dokumente, Tabellen, Präsentationen, PDFs), den Eintrag „Im Archiv ablegen …“ (In <Name> ablegen … mit SCHREIBZEUG_ARCHIVE_NAME) für alle, die die Datei bearbeiten dürfen. Der Dialog sendet die gespeicherte Version als PDF/A, dasselbe, das „Als PDF/A herunterladen“ erstellt (PDF und Drucken), und auf Wunsch die Office-Datei selbst; danach verlinkt er jedes neue Dokument im Archiv. Noch nicht gespeicherte Änderungen werden vorher gespeichert, damit das Archiv eine gespeicherte Version bekommt, und diese Version wird dann behalten: Das Ausdünnen entfernt nie, was im Archiv liegt.

Der Browser erstellt das PDF/A und sendet es mit der Nummer der Version an POST /api/files/:id/archive (multipart: pdf, original=true, version). Der Server prüft das PDF knapp (es beginnt mit %PDF-, höchstens SCHREIBZEUG_MAX_UPLOAD_MB), nimmt das Original aus dem Blob-Speicher und sendet jede Datei als eigenes Dokument an <Archiv>/api/dokumente (Multipart-Feld datei, Authorization: Bearer <SCHREIBZEUG_ARCHIVE_TOKEN>, je 60 Sekunden; src/files/archive.ts). Weiterleitungen werden nicht verfolgt, damit der Schlüssel nur SCHREIBZEUG_ARCHIVE_URL erreicht; er geht nie an den Browser, in eine Antwort oder ins Log. Das Archiv beantwortet jedes Dokument mit JSON, das seine id enthält; seine Seite ist <Archiv>/dokumente/<id>. Die Antwort an den Browser ist { "version", "documents": [{ "kind": "pdf" | "original", "name", "id", "url" }] }. Jeder Upload ist ein neues Dokument im Archiv, auch wenn dieselbe Version zweimal geht.

Nötig ist Bearbeiten statt Ansehen, weil die Version behalten wird. Im Archiv braucht der Schlüssel das Recht „schreiben“; einer, der nur lesen darf, wird abgelehnt.

Antwort Wann
201 Im Archiv; die Version ist behalten
400 invalid Nichts ausgewählt, oder der Body ist kein PDF
403 forbidden, 404 not_found Der Benutzer darf die Datei nur ansehen oder gar nicht; 404 auch ohne SCHREIBZEUG_ARCHIVE_URL und _TOKEN
409 conflict Jemand hat inzwischen eine neuere Version gespeichert; erneutes Ablegen sendet diese
413 too_large Größer als SCHREIBZEUG_MAX_UPLOAD_MB, oder das Archiv antwortete 413
502 upstream_refused Das Archiv antwortete 401 oder 403: Wer den Server verwaltet, muss den Schlüssel prüfen
502 upstream_failed Nicht erreichbar, zu langsam, eine Weiterleitung, eine Antwort ohne id oder ein anderer Fehler

Ging das PDF und scheitert danach das Original, sagt die Meldung, dass das PDF im Archiv liegt, und die Version ist behalten.

Vorlagen

„Neu → Aus Vorlage …“ (apps/web/src/files/template-dialog.tsx) beginnt eine Datei aus einer Vorlage:

  • Eingebaut (packages/ooxml/src/templates.ts): ein Brief nach DIN 5008, ein Angebot, eine Rechnung mit dem, was § 14 UStG von einer verlangt, eine Kalkulation (Formeln für die Summen und die Steuer, Euro-Formate), ein Projektplan und eine Präsentation. Sie sind dort als Office-XML geschrieben; eckige Klammern markieren, was auszufüllen ist.
  • Eigene Vorlagen: jedes Dokument, jede Tabelle und jede Präsentation in einem Ordner namens „Vorlagen“ auf der obersten Ebene der Dateien des Benutzers. Sonst muss nichts eingerichtet werden, auf einem Server wie auf dem Rechner.

Die neue Datei sind die Bytes der Vorlage, hochgeladen unter dem angegebenen Namen (POST /files); die API braucht dafür also nichts Eigenes, und eine eigene Vorlage bleibt, wie sie ist.

Betrieb

Variable Standard
SCHREIBZEUG_DATA_DIR data: die Datenbank schreibzeug.db, die Blobs in blobs/, das erzeugte auth-secret
PORT 3000
SCHREIBZEUG_MAX_UPLOAD_MB 512
SCHREIBZEUG_IMPORT_ORIGINS nicht gesetzt: Aus Links wird keine Datei geholt, oben
SCHREIBZEUG_ARCHIVE_URL, SCHREIBZEUG_ARCHIVE_TOKEN, SCHREIBZEUG_ARCHIVE_NAME nicht gesetzt: Nichts wird in einem Archiv abgelegt, oben
SCHREIBZEUG_OPEN_SIGNUP, SCHREIBZEUG_AUTH_SECRET, SCHREIBZEUG_TRUSTED_ORIGINS, SCHREIBZEUG_TRUSTED_PROXIES siehe Konten
SCHREIBZEUG_URL, SCHREIBZEUG_EMBED_ORIGIN, OIDC_ISSUER, OIDC_CLIENT_ID, OIDC_CLIENT_SECRET, OIDC_NAME siehe Schreibzeug in Kontext
SCHREIBZEUG_WEB_DIR nicht gesetzt: nur die API. Die gebaute Web-App (apps/web/dist, nach bun run build), die daneben ausgeliefert wird, sodass eine Adresse App und API ausliefert (jede Datei mit X-Content-Type-Options: nosniff, damit ein Browser sie nie für einen anderen Typ hält); die Desktop-App öffnet diese Adresse

Das Image tristanteu/schreibzeug (docker/Dockerfile) enthält den Server und die gebaute Web-App mit ihrer Engine, mit den Daten in /data (SCHREIBZEUG_WEB_DIR=/app/web, Port 3000). Actions → Release veröffentlicht es auf Docker Hub und als ghcr.io/speicherstadt/schreibzeug, wenn ein v*-Tag gepusht wird; zum Selberbauen docker build -f docker/Dockerfile . (Installation).

bun run server startet ihn mit Reload; er wendet beim Start die Migrationen in apps/server/drizzle an. Nach einer Änderung am Schema schreibt bun run --filter @schreibzeug/server db:generate die nächste Migration. drizzle-kit 0.31 setzt die Ausdrücke eines SQLite-Index in Anführungszeichen wie Spaltennamen; prüf erzeugte Indizes auf Ausdrücken (wie nodes_name_per_parent in 0000_init.sql, von Hand korrigiert).

Tests

apps/server/test/files.test.ts registriert ein Konto und führt die App mit app.request() und dem typisierten Test-Client von Hono gegen eine echte SQLite-Datei aus: Jede Testdatei bekommt einen eigenen temporären Datenordner (test/harness.ts), der danach entfernt wird. Vitest läuft auf Bun (bun --bun vitest), was bun:sqlite braucht. Der E2E-Server startet auf einem leeren e2e/.data; die Screenshots legen ihre Datumsangaben in dessen Datenbank über ein kleines Bun-Skript fest (e2e/sqlite.ts), da Playwright auf Node läuft. apps/server/test/media.test.ts deckt beim Bearbeiten gespeicherte Bilder ab, storage.test.ts, was /storage zählt, units.test.ts die Einstellungen, Namen und kleine Hilfsfunktionen. Vorlagen: apps/web/src/files/templates.test.ts (welche Dateien zählen, die Namen) und e2e/templates.spec.ts (eine Datei aus einer eingebauten und aus einer eigenen Vorlage, in ihrem Editor geöffnet). e2e/files.spec.ts geht die Dateiliste durch, wie ein Mensch es tut. Öffnen aus einem Link: apps/server/test/import.test.ts gegen einen Bun-Server auf einem freien Port als andere App (erlaubte Origins, Weiterleitungen, Grenzen, abgelaufene Links, Namen) und e2e/open.spec.ts mit einem Ersatz-Archiv (e2e/fake-archive.ts), einschließlich der Anmeldung vorher. In einem Archiv ablegen: apps/server/test/archive.test.ts gegen ein Ersatz-Archiv auf einem freien Port (der Schlüssel nur in der Kopfzeile Authorization und nie in einer Antwort oder im Log, Weiterleitungen, abgelehnte Schlüssel, Grenzen, das Original, die behaltene Version), apps/web/src/editor/archive.test.ts (vorher speichern, die Schritte, die Texte) und e2e/save-to-archive.spec.ts mit demselben Ersatz-Archiv (ein PDF/A und das Original im Archiv, ein abgelehnter Schlüssel).