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 infiles(die neueste Version jeder Datei außerhalb des Papierkorbs),versions(die älteren, die das Ausdünnen übrig gelassen hat) undtrash(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:freeundtotaldes Laufwerks, auf dem der Datenordner liegt (statfs;freeist 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_MBin 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).