# Goethe Format 1

**The open file format of Goethe Write: the project package (`.goethe`) and the exchange file (`.goethex`)**

| | |
|---|---|
| Status | Version 1.0 (format 1), published 2026 |
| Describes | exactly what Goethe Write writes and reads today |
| Names | `.goethe`, `.goethex`, `com.goethecloud.goethe.project`, `com.goethecloud.goethe.exchange` and `application/vnd.goethecloud.goethex+zip` are final. They never change. |
| Licence | This specification: CC BY 4.0, © 2026 ICSL FZE. The JSON Schemas (`schema/`) and the reference reader (`reference/`): MIT. See [section 12](#12-licence). |
| Publisher | ICSL FZE, Sharjah, United Arab Emirates; questions to [hello@lexxington.com](mailto:hello@lexxington.com) |
| Address | https://goethecloud.com/format/ |
| Short German version | [Goethe-Format 1 – Kurzfassung](GOETHE_FORMAT_1.de.md) |

The key words MUST, MUST NOT, SHOULD, SHOULD NOT and MAY are used as in RFC 2119 and RFC 8174.

## Contents

1. [Overview](#1-overview)
2. [Versions: `manifest.json`](#2-versions-manifestjson)
3. [The project package (`.goethe`)](#3-the-project-package-goethe)
4. [The exchange file (`.goethex`)](#4-the-exchange-file-goethex)
5. [`project.json`](#5-projectjson)
6. [Texts](#6-texts)
7. [Research files, watermarks, guides](#7-research-files-watermarks-guides)
8. [What readers and writers must do](#8-what-readers-and-writers-must-do)
9. [Security and privacy](#9-security-and-privacy)
10. [What is stable in version 1, and what later versions change](#10-what-is-stable-in-version-1-and-what-later-versions-change)
11. [Schemas, reference reader and tests](#11-schemas-reference-reader-and-tests)
12. [Licence](#12-licence)
- [Appendix A: Registration of the media type (draft)](#appendix-a-registration-of-the-media-type-draft)
- [Appendix B: Examples](#appendix-b-examples)

## 1. Overview

A Goethe Write project holds a manuscript (a novel, a non-fiction book, a legal brief, a screenplay) together with
everything around it: the outline, characters and places, research files, comments and tracked changes, saved
versions, the story's facts and timeline, the settings for export, and the place where the writer stopped.

The format has **one content in two forms**:

| | Project (package) | Exchange file |
|---|---|---|
| What it is | a folder with the extension `.goethe`, shown by macOS and iOS as one document | the same entries as **one ZIP file** with the extension `.goethex` |
| What it is for | working: quick to save, good for Git and Time Machine | sending: mail, cloud, agencies, other programs |
| First entry | – | `mimetype`, stored, holding `application/vnd.goethecloud.goethex+zip` (as in EPUB and OpenDocument) |
| Equal when | the files are equal | the **unpacked** entries are equal (not the ZIP bytes) |

The content of both forms is the same: `manifest.json` (version), `project.json` (outline, knowledge, settings),
`texts/` (one RTF text per entry), `files/` (research files), `snapshots/` (saved versions), and a few optional parts.

### 1.1 Names and type identifiers

| | Project | Exchange file | Older projects |
|---|---|---|---|
| Extension | `.goethe` | `.goethex` | `.lexwrite` |
| Uniform Type Identifier | `com.goethecloud.goethe.project` | `com.goethecloud.goethe.exchange` | `com.lexxington.write.project` |
| Conforms to | `com.apple.package`, `public.composite-content` | `public.data`, `public.content` | `com.apple.package`, `public.composite-content` |
| MIME type | – (a folder; send the exchange file instead) | `application/vnd.goethecloud.goethex+zip` (not yet registered, Appendix A) | – |
| Name in the Finder (English) | Goethe Write Project | Goethe Write Exchange File | Goethe Write Project (old) |
| How Goethe Write declares it | exported; document type with role Editor, rank Owner | exported; role Editor, rank Owner | imported; role Editor, rank Alternate |

- The exchange file deliberately does **not** conform to `public.zip-archive`: otherwise the Finder would offer to
  unpack it with the Archive Utility instead of opening it in Goethe Write.
- The names are declared in the `Info.plist` of the Mac app and of the iPhone and iPad app. The document icons are
  drawn by the system from the app icon.
- **`.lexwrite`** is the extension Goethe Write used before the format had its name. Such a project is the same
  format (version 1). Goethe Write opens it and saves it in place under its old name. The first time the person
  saves it with ⌘S, Goethe Write asks once whether it should take the new extension; if yes, it is saved under the
  new name with "Save As", and the old file stays as it was. Nothing is ever renamed without asking.

### 1.2 Terms

| Term | Meaning |
|---|---|
| package | the `.goethe` folder (or `.lexwrite`) |
| exchange file | the `.goethex` ZIP file |
| entry | a file or folder of the package, named by its path relative to the package (`texts/…rtf`); in the exchange file a ZIP entry with the same path |
| node | an entry of the outline (`project.json › tree`): a root, a folder, a text, a character, a place or a research file |
| text | the formatted text of a node, an RTF file in `texts/` |
| anchor | a passage in a text, given by the node, a start and a length (section 6.4) |
| Goethe Write 1 | the app version this specification describes |

## 2. Versions: `manifest.json`

### 2.1 The manifest

`manifest.json` lies at the top of the package. Goethe Write writes it on every save:

```json
{
  "format" : 1,
  "generator" : "Goethe Write 1.0 (100)",
  "kind" : "project",
  "readableFrom" : 1
}
```

| Key | Type | Meaning |
|---|---|---|
| `format` | integer ≥ 1 | The version of this specification the package was written in. |
| `readableFrom` | integer ≥ 1 | A reader of at least this version may open, edit and save the package without losing anything. Never greater than `format`. |
| `kind` | string | What the package holds. Version 1 knows only `"project"`. |
| `generator` | string | The app and version that wrote it. Informative only; never a person's or device's name. |

- Goethe Write writes the keys in byte order, two spaces of indentation, `"key" : value`, a line feed at the end. The
  same manifest gives the same bytes on every device.
- **A package without `manifest.json` is version 1.** Every project saved before the manifest existed is such a
  package. A manifest that is not a JSON object counts as missing. A missing or non-integer `format` or `readableFrom`
  counts as 1.
- The manifest is rewritten on every save. Keys a writer does not know are not kept (they might no longer be true).
- In version 1 the manifest lists no files and no checksums. A later version adds them (section 10).

### 2.2 Reading rules

A reader that implements version *R* of this specification:

| Manifest says | The reader |
|---|---|
| `readableFrom` > *R* | MUST NOT open the package for editing. Goethe Write refuses it with the sentence "This project needs a newer version of Goethe Write (format *n*). Please update Goethe Write to open it." |
| `kind` is present and not a kind it knows | MUST NOT open it as a project. |
| `format` > *R*, `readableFrom` ≤ *R* | MAY open and edit it. It MUST keep every file and folder it does not know, MUST NOT lower `format` when saving, and SHOULD set `generator` to itself. |
| `format` ≤ *R* | reads it normally. |

### 2.3 Rules for later versions

- A later version that only **adds** (a new file or folder, a new optional key in a file older writers do not
  rewrite) raises `format` and keeps `readableFrom`.
- A later version that would be **damaged by an older writer**, or that older readers would misread, raises
  `readableFrom` as well.
- **Important:** Goethe Write 1 does not keep keys it does not know inside `project.json` (section 5.1). A later
  version that adds data which must survive Goethe Write 1 therefore puts it into a **new file**, which Goethe Write 1
  keeps byte for byte, or raises `readableFrom`.
- Version numbers are never reused, and the meaning of a key is never changed.

### 2.4 `project.json › format` is not the package version

`project.json` has a key `format` of its own. It is the layout number of that one file and is `2` in every package of
version 1. Goethe Write requires the key but does not look at its value. Readers decide by `manifest.json`, never by
this number.

## 3. The project package (`.goethe`)

### 3.1 Layout

```
Mein Roman.goethe/
  manifest.json                       version (section 2); written by Goethe Write 1, may be missing in older packages
  project.json                        outline, knowledge, settings, the person's window (section 5); required
  texts/                              always present, may be empty
    <NODE-ID>.rtf                     the text of a node (section 6)
    <NODE-ID>.rtfd/                   … or, when it holds pictures, an RTFD folder: TXT.rtf and the pictures
  files/                              always present, may be empty
    <NODE-ID>[.<ext>]                 the bytes of a research file (PDF, picture, document) (section 7.1)
  snapshots/                          always present, may be empty
    <SNAPSHOT-ID>.rtf | .rtfd/        saved versions of texts (project.json › bible.snapshots)
  deleted/                            only when not empty
    <DELETED-ID>.rtf | .rtfd/         deleted passages with their formatting (project.json › bible.deleted)
  guides.json                         optional: page guides (section 7.3)
  watermarks/                         optional: the picture of the watermark, <sha256>.png (section 7.2)
  …                                   anything else: kept by Goethe Write byte for byte (section 3.3)
```

- `<NODE-ID>` and the other ids are UUIDs, written in upper case (`0B5E2A9C-342B-429E-82C0-D92D21910489`).
  Goethe Write reads them in any case.
- The extensions `rtf` and `rtfd` are lower case; Goethe Write ignores a text file with another extension.
- **Every node that is not a research file has a text file**, also the roots and folders, also when the text is empty
  (an empty text is a short RTF with only its header). A node without a text file has an empty text.
- Text, research, snapshot and deleted files that no node or entry of `project.json` refers to are dropped by Goethe
  Write on the next save.

### 3.2 Reserved names

These names at the top of the package are reserved. A writer MUST NOT use them for anything else:

| Name | Use |
|---|---|
| `manifest.json`, `project.json`, `texts`, `files`, `snapshots`, `deleted`, `guides.json`, `watermarks` | version 1 (this specification) |
| `mimetype` | only in the exchange file; a package never has it. Goethe Write removes it from a package when it saves. |
| `scripts`, `media`, `sync`, `migration`, `QuickLook`, `goethe.json` | reserved for planned versions (screenplays as their own part, media, working together, previews) |

Names are case-sensitive in the format. Because the usual file systems of macOS and iOS are not, a writer MUST NOT
create two names that differ only by case or by Unicode normalization.

### 3.3 Unknown entries

- An entry at the top of the package that Goethe Write 1 does not know is kept **byte for byte** on every save
  (files, and folders with everything in them).
- Inside `texts/`, `files/`, `snapshots/` and `deleted/` nothing unknown survives: Goethe Write rebuilds these folders
  from `project.json`.
- Two known entries Goethe Write manages itself: `guides.json` is rewritten when a guide is edited (section 7.3), and
  pictures in `watermarks/` that no setting names are removed when the project is opened (section 7.2).

### 3.4 Saving safely

A writer SHOULD write a complete new package beside the old one and then replace the old one in one step, so that a
reader never sees half a package. Goethe Write does this through the system's safe saving of documents. Unchanged
files may be reused (hard links, clones).

## 4. The exchange file (`.goethex`)

### 4.1 ZIP profile

The exchange file is a ZIP archive (PKWARE APPNOTE) restricted as follows:

| | Rule |
|---|---|
| First entry | MUST be `mimetype`: stored (method 0), no extra field, no data descriptor, content exactly `application/vnd.goethecloud.goethex+zip` (ASCII, no line feed). Its name thus stands at byte 30 and the type at byte 38 of the file, where programs can recognise it. |
| Second entry | SHOULD be `manifest.json`, so a reader learns the version first. |
| Other entries | every file of the package with its path; folders as entries of their own whose names end in `/` (writers SHOULD write them, so empty folders come back; readers MUST NOT need them). Goethe Write writes them in the byte order of their paths. |
| Packing | only stored (0) and DEFLATE (8). Goethe Write packs an entry with DEFLATE when it gets smaller and is larger than 64 bytes. |
| Names | UTF-8 (general purpose bit 11 set when a name is not ASCII), `/` as separator, relative. Section 4.3 lists what is not allowed. |
| Not allowed | encryption (bits 0, 6 and 13), other packing methods, symbolic links, ZIP64, archives on several disks |
| Size in version 1 | below 4 GB and below 65,535 entries (no ZIP64). Larger projects cannot be exchanged in version 1. |
| Times | the time of writing, as the ZIP fields allow (informative) |
| Permissions | made by Unix: folders `0755`, files `0644` (informative) |

The `mimetype` entry is not part of the package. Unpacking an exchange file gives the package without it; packing a
package adds it.

### 4.2 Equality

Two exchange files are equal when their unpacked entries are equal: the same paths with the same bytes, `mimetype`
left aside. Their ZIP bytes differ with the time of writing and the packer, and nothing may depend on them. Goethe
Write's own tests compare the unpacked entries (section 11).

### 4.3 Reading safely

A reader MUST refuse an exchange file, with a reason, when:

- it is no ZIP archive, it has no entry `mimetype`, or `mimetype` holds another type (after trimming white space);
- an entry name is empty, absolute (`/…`), contains `..` or `.` as a part, an empty part (`a//b`), a backslash, a
  drive (`C:`), a control character (U+0000–U+001F, U+007F), or a part longer than 255 bytes;
- two entries have the same name, also when they differ only by case or Unicode normalization (except a folder
  listed twice);
- a path runs below a file (`a` is a file and `a/b` an entry);
- an entry is a symbolic link (made by Unix with file type `0120000`), encrypted, or packed with another method;
- a checksum (CRC-32) does not match, an entry unpacks to more or fewer bytes than its central directory says, two
  entries share bytes ("overlapping" entries), or the local header disagrees with the central directory;
- it uses ZIP64 or several disks;
- `project.json` is missing;
- `manifest.json` asks for a newer reader (section 2.2).

A reader SHOULD ignore entries below `__MACOSX/` and entries named `.DS_Store` (what the Finder adds when it packs a
folder), and SHOULD accept `mimetype` at another place than first, as long as its content is right.

**Limits.** A reader SHOULD set limits and MUST NOT unpack more than an entry declares. Goethe Write 1 refuses an
exchange file with more than 50,000 entries, more than 2 GiB unpacked, paths longer than 1,024 bytes or deeper than 32
folders, or an entry of 16 MiB or more that unpacks to more than 200 times its packed size. These limits belong to the
reader, not to the format; another reader may choose others.

Goethe Write never follows a link, never writes outside the package, needs no network and runs nothing from the file.

### 4.4 Opening and writing an exchange file in Goethe Write

- **Mac:** Opening a `.goethex` (double-click, File ▸ Open, Open Recent) makes its project a **new, untitled
  project** with the file's name. The person saves it where they like; closing asks where to keep it, and until then
  autosave keeps it safe. The exchange file itself is never written to. Opened again while that copy is unsaved, the
  copy comes to the front.
- **iPhone and iPad:** Opening a `.goethex` copies its project into the app's folder ("On My iPhone › Goethe") as a
  `.goethe` package, under the file's name (with a number if that name is taken), and opens it.
- **Writing:** File ▸ Export As ▸ "Goethe Write Exchange File (.goethex)" writes the whole project as it is at that moment, with
  its manifest, into a temporary file and then moves it into place.
- What an exchange file carries: **everything in the project**, including saved versions, deleted passages,
  comments with names, tracked changes and the research files (section 9).

## 5. `project.json`

`project.json` holds everything of the project except the texts and files: the outline (`tree`), the knowledge about
the story or the case (`bible`), the settings (`settings`), the window as the person left it (`window`), and a few
values beside them. The JSON Schema [`schema/project.schema.json`](schema/project.schema.json) describes every key
below.

### 5.1 Encoding

- UTF-8 JSON, one object. Goethe Write writes it with Apple's JSON encoder: indented by two spaces, `"key" : value`,
  keys sorted. **Key order has no meaning**; the sort order is the encoder's and need not be plain code-point order.
- `/` inside strings is written as `\/`. Other characters stand as UTF-8.
- **No `null` is written.** A key that is absent means "not set". Readers treat `null` like an absent key for every
  optional value.
- **Numbers:** integer keys hold whole numbers. Decimal keys hold numbers; a whole decimal value is written without a
  fraction (`12`), so readers MUST accept integers where a number is expected. NaN and infinities never occur.
- **Times:** ISO 8601 in UTC with whole seconds, `"2026-11-12T10:00:00Z"`. Readers SHOULD also accept fractional
  seconds and offsets. Older files wrote times as a number: **seconds since 2001-01-01T00:00:00Z** (not 1970).
- **Days** (`days`, `goals.deadline`) are local calendar days `yyyy-MM-dd` without a time zone.
- **Ids** are UUIDs written in upper case; readers compare them without regard to case.
- **Unknown keys** are ignored by Goethe Write 1 at every level and are **not kept** on the next save (section 2.3).
- **Order of arrays** is meaningful (outline, paragraphs, lists the person sorted) except where this section says
  otherwise. The top-level `expanded` is written from a set: its order changes between saves and means nothing.
  Apart from that array, the same project gives the same bytes.

In the tables below, **Req** "yes" means Goethe Write 1 refuses to open a file without that key (or with a value of
the wrong type there). All other keys may be absent; "Default" says what absence means. Types: *uuid* (a string),
*time* (a string as above), *int*, *number*, *bool*, *string*, `[T]` an array of T, `{string: T}` an object whose
values are T.

### 5.2 Top level

| Key | Type | Req | Default | Meaning |
|---|---|---|---|---|
| `format` | int | yes | – | Layout number of this file: `2` (section 2.4). |
| `tree` | `[Node]` | yes | – | The roots of the outline in sidebar order (5.5). An empty array opens as a new blank project. |
| `dailyGoal` | int | yes | – | Words a day for the manuscript; 0: none. |
| `days` | `{day: int}` | yes | – | Manuscript words when each day began (at most the latest 60 days). Words written today = words now − `days[today]`. |
| `expanded` | `[uuid]` | yes | – | Legacy copy of `window.expanded` for older versions of the app; order without meaning. Read only when `window.expanded` is absent. |
| `selection` | uuid | | the first text of the manuscript | The selected node. |
| `bible` | Bible | | empty | Knowledge about the story or the case (5.6). |
| `settings` | Settings | | defaults, with `storyTools: true` | Settings of the project (5.7). |
| `collapsed` | `[uuid]` | | – | Legacy: folded sidebar sections; read only when `window.sidebarFolded` is absent; never written. |
| `window` | Window | | defaults | The window as the person left it (5.8). |
| `goetheLog` | `[LogEntry]` | | `[]` | What the assistant Goethe changed, if the person keeps a record (5.9). Written only when not empty. |
| `manuscriptGoal` | Goal | | taken over once from the reading Mac's preferences | The manuscript's goal or limit (5.9). |

### 5.3 What makes Goethe Write 1 refuse a file

Goethe Write 1 refuses to open a project, rather than guess, when:

- a key marked **Req** is missing or has the wrong type, at the top level or in any object of `tree`, `bible`
  (outside `curves`, `order` and `goals`) or `goetheLog` (inside `settings.styles` and
  `settings.authorWorkspace.beats` and `drafts` such a fault only empties that list, see below);
- a value of a strict list of words (5.10) is unknown;
- a time string cannot be read, also in an optional key.

Some places are forgiving and fall back instead (marked "lenient" below). Where a whole list falls back because one
element is broken, the next save makes that loss permanent: `settings.styles` (back to the five default styles),
`settings.authorWorkspace.beats` and `drafts` (empty), `bible.curves` (empty), `bible.order.ownStatuses` (empty).
Writers of other programs MUST therefore write every **Req** key, also those whose meaning is "empty".

### 5.4 Migrations on reading

Goethe Write 1 changes a few things once when it reads a project; the next save writes the result. A project that was
read and saved once does not change again when it is read and saved (Goethe Write's tests check this, section 11).

| What | Change |
|---|---|
| `bible.beats` (older character beats) | each becomes entries of `bible.changes` (fields "Ziel", "Angst", "Beziehungen", or "Notiz"); `beats` is then written empty |
| `bible.arguments[].research`/`page`, `bible.events[].statements[].research`/`page` | where the item has an anchor of length > 0, they become an entry of `bible.sources` and are cleared |
| `settings.shownTools`, `settings.takenOver` | the tools shown by their groups are written down once, and `"tools"` goes into `takenOver` |
| `settings.authorWorkspace.stage`/`selectedDraft` | move to `window.stage`/`window.draft` |
| legacy keys of `window` (5.8) | move to this Mac's own store and are no longer written |
| `watermarks/` | pictures no setting names are removed (7.2) |
| `manuscriptGoal` absent | a character limit kept in the Mac's preferences becomes the project's goal |

### 5.5 The outline: `tree`

`tree` holds the **roots**. Each root has a kind; the first root of each kind counts:

| Root kind | Holds |
|---|---|
| `manuscript` | what is exported, in reading order (depth first) |
| `characters` | nodes of kind `character` |
| `places` | nodes of kind `place` |
| `research` | research texts, files and links |
| `trash` | "Recently Deleted": deleted nodes, newest on top; created when needed |

Root titles are stored in German (`Manuskript`, `Figuren`, `Orte`, `Recherche`, `Zuletzt gelöscht`) and shown in the
person's language; programs find roots by their kind, never by title.

**Node**

| Key | Type | Req | Default | Meaning |
|---|---|---|---|---|
| `id` | uuid | yes | – | Identity. Names `texts/<id>.rtf\|.rtfd` and `files/<id>.<ext>`. Unique in the whole tree. |
| `kind` | NodeKind | | `text` | lenient: an unknown kind is read as `text`. |
| `title` | string | | `""` | Shown as "Untitled" when empty. |
| `synopsis` | string | | `""` | Short description (on the card). |
| `status` | WriteStatus | | `none` | How far the text is; lenient. With `ownStatus`, the step that status counts as. |
| `label` | WriteLabel | | none | Colour tag; lenient; written only when set. |
| `includeInExport` | bool | | `true` | |
| `children` | `[Node]` | | `[]` | Children in outline order. Texts may have children too. |
| `notes` | string | | `""` | Notes beside the text; not exported. |
| `target` | int | | `0` | Word goal; 0: none. For a folder or a text with children it counts all words below. |
| `pov` | string | | `""` | Point of view: a name, not an id. |
| `place` | string | | `""` | Where the scene takes place: free text, not an id. |
| `when` | string | | `""` | The time as the writer writes it ("Tag 3, abends"). |
| `date` | time | | none | The date on the timeline. |
| `threads` | `[string]` | | `[]` | Plot lines. |
| `links` | `[uuid]` | | `[]` | Characters, places and research linked by hand. |
| `aliases` | `[string]` | | `[]` | Other names of a character or place. |
| `fields` | `[Field]` | | `[]` | Named values: profile fields, values of the project's own fields (keyed by `MetadataDefinition.name`), the ratings "Spannung" and "Stimmung" (0–5) and "Konflikt". |
| `file` | string | | none | Original file name of a research file (`"Kaufvertrag.pdf"`), for display. The bytes are in `files/` (7.1). |
| `url` | string | | none | A web page; a node with `url` and no `file` is a web link. |
| `origin` | uuid | | none | In the trash: the parent it was deleted from. |
| `lockedForGoethe` | bool | | not locked | The assistant Goethe never reads this node or anything below it. Written only as `true`. |
| `keywordList` | `[string]` | | `[]` | Keywords; written only when there are some. |
| `ownStatus` | uuid | | none | A status of the project's own (`bible.order.ownStatuses`); lenient. |

**Field:** `id` (uuid, Req), `name` (string, Req), `value` (string, Req). Names are compared trimmed and without regard
to case.

### 5.6 The knowledge: `bible`

All keys of `bible` are optional (default: empty). Goethe Write writes every list, also when empty, and `order` and
`goals` only when they hold something.

| Key | Type | Meaning |
|---|---|---|
| `characterRelations` | Relations | the relationship map |
| `facts` | `[Fact]` | setups and payoffs |
| `knowledge` | `[Knowledge]` | who learns or uses which fact, and where |
| `beats` | `[CharacterBeat]` | legacy (5.4) |
| `changes` | `[Change]` | how characters and places develop |
| `travel` | `[Travel]` | travel times between places |
| `rules` | `[WorldRule]` | rules of the story's world |
| `sources` | `[SourceLink]` | evidence for passages |
| `comments` | `[Comment]` | comments with replies |
| `collections` | `[Collection]` | saved selections |
| `rounds` | `[Round]` | revision rounds, in creation order |
| `snapshots` | `[Snapshot]` | saved versions, newest first |
| `deleted` | `[Deleted]` | deleted passages, newest first, at most 200 |
| `intended` | `[string]` | ids of warnings marked as intended (opaque strings) |
| `arguments` | `[Argument]` | the argument map |
| `clauses` | `[Clause]` | text modules |
| `variables` | `[Variable]` | values used in texts |
| `terms` | `[Term]` | defined terms |
| `events` | `[CaseEvent]` | the case's chronology with statements |
| `roles` | `[RoleMark]` | roles of passages (own submission, the other side's …) |
| `approvals` | `[Approval]` | approvals of texts |
| `tracked` | `[TrackedChange]` | tracked changes |
| `literature` | `[LegalSource]` | the bibliography |
| `statements` | `[Statement]` | statements of the text and how they relate |
| `relations` | `[Relation]` | relations between statements, passages, nodes and questions |
| `questions` | `[Question]` | open questions |
| `reviews` | `[Review]` | review state per node and dimension |
| `metadata` | `[FieldDefinition]` | the project's own fields |
| `clauseUses` | `[ClauseUse]` | where text modules were inserted |
| `curves` | `[Curve]` | curves the writer drew (lenient as a whole list) |
| `order` | OrderLists | own names of statuses and colours, own statuses, keywords (lenient) |
| `goals` | GoalPlan | deadline and writing days (lenient) |

Every **anchor** in the bible moves with the text when the text is edited (section 6.4).

**Anchor:** `node` (uuid, Req), `location` (int, Req), `length` (int, Req; 0 marks a position), `quote` (string, Req: the
passage when the anchor was made or last refreshed).

**Relations** (`characterRelations`; every key optional): `edges` `[Relation edge]`; `groups` `[Group]`; `positions`
`{string: {x: number, y: number}}` (key: a character's node id in upper case; the card's top-left corner in canvas
points, placed by hand; used only when finite and within ±1,000,000); `dismissed` `[string]` (declined suggestions: two
upper-case ids, sorted, joined by `|`).
- *Relation edge:* `id` (uuid; missing: a new one), `from`, `to` (uuid, Req: character nodes; `role` describes `from`
  in relation to `to`), `kind` (string: `family`, `love`, `friendship`, `rivalry`, `work`, `other`, or an own word;
  missing: derived from `role`), `role`, `inverseRole`, `note` (string), `directed` (bool, default `true`),
  `startScene`, `endScene` (uuid: the scenes between which it holds, inclusive).
- *Group:* `id` (uuid), `title` (string), `members` (`[uuid]`), `color` (int, one of 8 colours, modulo 8).

**Fact:** `id` (uuid), `kind` (FactKind), `title`, `detail` (string), `openOnPurpose` (bool) — all Req; `setup` (uuid: the
scene that introduces it), `payoff` (uuid: the scene that resolves it; absent: still open).

**Knowledge:** `id`, `fact` (a Fact id), `character`, `scene` (uuid), `kind` (`learns` or `uses`) — all Req.

**CharacterBeat** (legacy): `id`, `character`, `scene` (uuid), `goal`, `fear`, `relationships`, `note` (string),
`turningPoint` (bool) — all Req.

**Change:** `entity` (uuid: a character or place), `scene` (uuid: from this scene on) — Req; `id` (uuid; missing: a new
one), `field`, `value`, `note` (string), `turningPoint` (bool). The value at a point of the reading order is the last
change at or before it.

**Travel:** `id`, `from`, `to` (uuid: places), `hours` (number; both directions) — all Req.

**WorldRule:** `id`, `title`, `detail`, `kind` (`forbidden`: none of the patterns may appear; `requires`: where the
first pattern appears, one of the others must appear in the same scene), `patterns` (`[string]`: words, or regular
expressions in slashes `/teleport\w*/`), `threads` (`[string]`: only these plot lines; empty: everywhere), `enabled`
(bool) — all Req.

**SourceLink:** `anchor` (Req); `id` (uuid; missing: a new one), `research` (uuid: the research node), `page`, `quote`,
`note`, `checkedText` (string: the passage as it read when checked), `sourceDigest` (string: lower-case hex SHA-256 of
the research item when checked — its file bytes, else its URL, else its text, as UTF-8), `verified` (bool),
`checkedAt` (time).

**Comment:** `id`, `anchor` — Req; `text`, `author` (string), `date` (time; missing: the time of reading), `resolved`
(bool), `replies` (`[Reply]`, oldest first). **Reply:** `id`, `author`, `text`, `date` — all Req.

**Collection:** `id`, `title`, `statuses` (`[WriteStatus]`, strict), `labels` (`[WriteLabel]`, strict), `pov`, `thread`,
`place`, `text` (string), `openWork` (bool) — all Req, an empty value means the rule is not used; optional:
`character` (uuid), `manual` (`[uuid]`: when present, even empty, the collection holds exactly these nodes in this
order and the rules are ignored), `ownStatuses` (`[uuid]`), `keywords` (`[string]`: a node must have all),
`fieldRules` (`[{field: uuid of a FieldDefinition, value: string}]`, both Req: text, number and person fields contain
the value; a choice equals it; a multiple choice has it among its comma-separated values; check and date fields: `"1"`
set, `"0"` not set).

**Round:** `id`, `title`, `goal`, `color` (int 0–5: blue, red, green, purple, orange, teal), `started` (time),
`targetWords` (int; 0: none) — all Req; `finished` (time; absent: still running — the last running round is the
active one).

**Snapshot:** `id` (its text is `snapshots/<id>.rtf|.rtfd`), `node`, `title`, `date`, `words` (int), `variant` (bool:
`true` an alternative, `false` a backup) — all Req.

**Deleted:** `id` (newer entries also have `deleted/<id>.rtf|.rtfd`), `node`, `text` (the words, fields as their
values), `date` — all Req.

**Argument:** `id`, `kind` (`claim`, `evidence`, `counter`, `rebuttal`, `conclusion`), `title`, `detail`, `page` — Req;
`parent` (uuid: the argument it supports, attacks, answers or concludes; absent: a main claim), `anchor`, `research`
(uuid; see 5.4).

**Clause:** `id`, `title`, `category`, `note` (string), `variants` (`[Variant]`) — all Req. **Variant** (all optional):
`id`, `title`, `body` (text with variables `{{Name}}` and conditions `{{#wenn Name}} … {{/wenn}}`), `approved` (bool),
`approvedBy` (string), `approvedDate` (time), `version` (int, default 1), `history` (`[{version: int, body: string,
date: time, note: string}]`, all Req: earlier wordings).

**Variable** (all optional): `id`, `name` (**the key texts use**: `⟦var:<name>⟧`, section 6.3; the first variable with
that name counts), `value`, `note` (string), `research` (uuid), `history` (`[{value: string, validFrom: time}]`, both
Req: earlier values with the day they began to hold; the value at a date is the last entry with `validFrom` ≤ that
date, else `value`).

**Term:** `id`, `term`, `definition` (string), `aliases` (`[string]`) — Req; `anchor` (where the text defines it),
`changed` (time).

**CaseEvent:** `id`, `title`, `when` (string, as written), `participants` (`[uuid]`), `statements` (`[Statement of the
case]`), `note` — Req; `date` (time). **Statement of the case:** `id`, `party` ("Kläger", "Zeuge Müller"), `claim`,
`when`, `page` — Req; `research` (uuid; see 5.4), `anchor`.

**RoleMark:** `id`, `anchor`, `role` (`ownSubmission`, `opposingSubmission`, `undisputed`, `evidence`, `assessment`) — all
Req.

**Approval:** `id`, `node`, `by`, `date`, `note` — Req; `snapshot` (uuid: the approved version).

**TrackedChange:** `id`, `kind` (`insertion`: the anchored text was inserted; `deletion`: the anchored text is deleted
but stays in the text, struck through, until accepted), `anchor`, `author`, `date` — Req; `round` (uuid: the round
active at the time).

**LegalSource** (lenient; all 16 keys always written, all strings unless said): `id` (uuid), `kind` (`book`,
`commentary`, `article`, `chapter`, `online`; default `book`), `authors` ("Medicus, Dieter; Petersen, Jens"; names
without a comma are institutions), `edited` (bool: the names are editors), `title`, `shortTitle`, `edition` ("3" is
printed "3. Aufl." or "3rd edn"), `volume`, `place` (place of publication or publisher), `year`, `journal`, `page`,
`container` (the book a chapter appears in), `containerEditors`, `url`, `accessed`.

**Statement:** `id`, `anchor`, `kind` (`claim`, `evidence`, `assumption`, `conclusion`, `event`, `belief`, `falseBelief`,
`data`, `interpretation`, `recommendation`), `title`, `participants` (`[uuid]`), `occurred`, `knownSince` (strings, as
written), `created` (time), `checked` (bool), `checkedText`, `checkedBy`, `note` — Req; `occurredDate`, `knownDate`,
`validFrom`, `validUntil`, `checkedAt` (time), `knownScene` (uuid).

**Relation:** `id`, `from` (Ref), `kind` (`supports`, `contradicts`, `requires`, `supersedes`, `conditional`,
`resolves`: reads "`from` *kind* `to`"), `to` (Ref), `confirmed` (bool; `false`: a suggestion found by the app),
`note`, `created` — all Req. **Ref** is an object with exactly one of these keys, its value under `"_0"`:
`{"statement": {"_0": <uuid>}}`, `{"passage": {"_0": <Anchor>}}`, `{"node": {"_0": <uuid>}}`,
`{"question": {"_0": <uuid>}}`.

**Question:** `id`, `title`, `detail`, `anchors` (`[Anchor]`), `owner`, `state` (`open`, `decided`, `dropped`),
`decision`, `reasoning`, `decidedBy`, `created` — Req; `decidedAt` (time).

**Review:** `node`, `dimension` (`content`, `sources`, `language`, `approval`), `done` (bool), `openPoints` (int), `by`,
`reason` — Req; `date` (time). It has no id: one entry per node and dimension.

**FieldDefinition:** `id` (referred to by `fieldRules`), `name` (**the key under which nodes store the values** in
`fields`), `type` (`text`, `date`, `choice`, `multiChoice`, `person`, `number`, `check`), `options` (`[string]`),
`showInOutline` (bool) — all Req.

**ClauseUse:** `id`, `clause`, `variant` (uuid), `version` (int), `anchor`, `insertedText` (the wording as inserted,
fields as tokens `⟦…⟧`), `keepLocal` (bool), `date` — all Req.

**Curve:** `kind` (`tension`, `storyTime`, `mood`, `tempo`, `presence`; one unknown kind drops the whole list) — Req;
`id` (uuid), `character` (uuid: for `presence`), `points` (`[{id: uuid, at: number 0–1 (start to end of the
manuscript), value: number 0–5}]`, all Req; one broken point empties that curve).

**OrderLists** (lenient; all four written when present): `statusNames` (`{WriteStatus: string}`: the project's own
names of the steps), `ownStatuses` (`[{id: uuid, title: string, countsAs: WriteStatus}]`), `labelNames`
(`{WriteLabel: string}`), `keywords` (`[string]`).

**GoalPlan** (lenient): `deadline` (day), `writingDays` (`[int]`: 1 Sunday … 7 Saturday; default all), `dailyFromDeadline`
(bool: the daily goal follows from the deadline), `sessionGoal` (int: words per session).

### 5.7 Settings: `settings`

**Settings** (all optional). Goethe Write writes every key (`authorWorkspace` and `workKind` only when set). A wrong
type of `title`, `subtitle`, `author`, `caseNumber`, `language`, the four `…Tools`, `annexPrefix`, `trackChanges`,
`goetheRules` or a non-object `authorWorkspace` makes the file unreadable; the other keys are lenient.

| Key | Type | Default | Meaning |
|---|---|---|---|
| `workKind` | `novel`, `nonfiction`, `legal`, `screenplay` | derived from the tools | The kind of work; decides the phases and the screenplay features. |
| `title`, `subtitle`, `author` | string | `""` | For the title page, PDF and EPUB metadata, the watermark, and the fields `{title}`, `{subtitle}`, `{author}`. |
| `caseNumber` | string | `""` | Case number (Aktenzeichen); `{case}`. |
| `language` | string | `"de"` | Output language; a value starting with `en` gives English wording, anything else German. |
| `storyTools`, `legalTools`, `scienceTools`, `consultingTools` | bool | `true`, `false`, `false`, `false` | Tool groups: story (timeline, analysis, story, relationships), legal (arguments, chronology, clauses, terms, literature), science (literature, terms), consulting (clauses, terms). |
| `shownTools`, `hiddenTools` | `[string]` | `[]` | Tool ids shown beyond their groups, or hidden although their group is on (hidden wins): `overview`, `timeline`, `story`, `analysis`, `rules`, `arguments`, `chronology`, `clauses`, `terms`, `literature`, `questions`, `comments`, `relationships`. |
| `annexPrefix` | string | `"K"` | As in "Anlage K 1". |
| `styles` | `[Style]` | the five default styles | Paragraph styles; lenient as a whole list. |
| `trackChanges` | bool | `false` | Tracked changes are recorded. |
| `export` | Export | defaults | Page setup and export. |
| `goetheRules` | string | `""` | House rules for the assistant Goethe. |
| `takenOver` | `[string]` | `[]` | One-time migrations done: `tools`. |
| `authorWorkspace` | Workspace | empty | The phases Idee, Recherche, Beats and Drehbuch. |

**Style** (all Req): `style` (int: 0 body, 1–3 headings 1–3, 4 quotation, 5–7 headings 4–6; the first entry of a number
counts), `family` (string), `size` (number, points), `bold`, `italic` (bool), `lineSpacing` (number, a multiple of the
line), `spaceBefore`, `spaceAfter`, `indent` (number, points; for 4 also the right indent), `alignment` (`left`,
`center`, `justified`). The default set: 0 Charter 15 pt, line 1.3, after 8; 1–3 Helvetica Neue bold 21, 17, 15 pt,
line 1.15, before 22, 16, 12, after 8; 4 Charter italic 15 pt, indent 28.

Four **optional** keys of a Style (written since 13 November 2026, only when set; a value of another type counts as
absent and the rest of the style still applies) say how every paragraph of the style breaks across pages, as Word's
paragraph dialog („Zeilen- und Seitenumbruch“) and Pages' „Umbruch“ do:

| Key | Type | Absent | Meaning | In Word |
|---|---|---|---|---|
| `keepWithNext` | bool | on for headings (1–3, 5–7), off otherwise | the paragraph's last line stays on the page where the next paragraph begins | `w:keepNext` |
| `keepLines` | bool | on for headings, off otherwise | the paragraph does not break across pages (unless it is longer than a page) | `w:keepLines` |
| `pageBreakBefore` | bool | off | the paragraph begins a page | `w:pageBreakBefore` |
| `widowControl` | bool | on | no first line of a paragraph alone at a page's foot, no last line alone at the next page's top | `w:widowControl` |

Absent, a paragraph does what Goethe Write's pages always did: headings (and short paragraphs all in bold) stay with
the text after them and whole, and no paragraph leaves its first or last line alone. A paragraph's own value (6.2,
addition 6) overrides its style's.

**Export** (all optional and lenient; Goethe Write writes all 44 keys, `customPaper`, `mirrored`, `headerDistance`,
`footerDistance`, `scope` and `watermark` only when set). Lengths of the page are **centimetres**, of type **points**.

| Key | Type | Default | Meaning |
|---|---|---|---|
| `format` | `pdf`, `docx`, `epub`, `markdown`, `rtf` | `pdf` | Last export format. |
| `preset` | string | `text` | The look: `text` (as written), `standard`, `buch`, `normseite`, `schriftsatz`, `gutachten`; any other value acts as `standard`. |
| `titleHeadings` | `folders`, `all`, `none` | from `titles` | Which outline titles become headings. |
| `titles` | bool | `true` | Legacy; read only when `titleHeadings` is absent. |
| `separator` | string | `blank` | Between texts whose titles are not printed: `blank`, `stars`, or `text:<mark>` (one line, at most 24 characters). |
| `titlePage`, `tableOfContents`, `chapterNewPage`, `pageNumbers` | bool | `true` | |
| `tocDepth` | int | 2 | Heading levels in the table of contents. |
| `numberPosition` | string | `center` | `left`, `center`, `right` (footer), `topleft`, `topcenter`, `topright` (header). |
| `numberFormat` | string | `number` | `number` ("3"), `page` ("Seite 3"), `pageOf` ("Seite 3 von 12"). |
| `headerLeft`, `headerCenter`, `headerRight`, `footerLeft`, `footerCenter`, `footerRight` | string | `""` | Running heads; may hold `{title}`, `{subtitle}`, `{author}`, `{case}`, `{chapter}`, `{date}`, `{page}`, `{pages}`. |
| `furnitureFirstBare`, `furnitureMirrored`, `furnitureLines` | bool | `false` | First page without head and foot; left and right swapped on even pages; hairlines. |
| `furnitureFamily` | string | `""` | Font of head and foot; empty: as the look. |
| `furnitureSize` | number | 0 | Points; 0: as the look. |
| `font` | string | `Charter` | Body font when `preset` is not `text`. |
| `size` | number | 12 | Body size in points (used within 6–48). |
| `lineSpacing` | number | 1.3 | Multiple of the line. |
| `justified` | bool | `false` | |
| `marginTop`, `marginBottom`, `marginLeft`, `marginRight` | number | 2.5 | Centimetres; left and right are inner and outer when mirrored. |
| `paper` | string | `a4` | A paper id (`a3`, `a4`, `a5`, `a6`, `a7`, `b4`, `b5`, `b6`, `c4`, `c5`, `c6`, `dl`, `letter`, `legal`, `tabloid`, `executive`, `statement`, `book-…`, `uk-…`, `pod-…`), or `custom-<lower-case uuid>` for an own size. Readers lower-case it and read `buch-` as `book-`. Unknown: A4. |
| `customPaper` | Paper | none | The own size, so the project prints alike on another Mac: `id` (equals `paper`), `name`, `width`, `height` (numbers), `unit` (`mm`, `cm`, `in`, `pt`, `pica`, `cicero`), all Req; sides 70–1,500 mm. |
| `landscape` | bool | `false` | |
| `mirrored` | bool | as the look | Mirrored margins (absent: only `buch` mirrors). |
| `gutter` | number | 0 | Binding allowance, centimetres (0–5). |
| `headerDistance`, `footerDistance` | number | automatic | Centimetres from the paper's edge. |
| `marginNumbers`, `bibliography`, `numberHeadings` | bool | `false` | Paragraph numbers in the margin; a bibliography; numbered headings. |
| `scope` | uuid | the whole manuscript | Export only this part. |
| `includeReview` | bool | the reading Mac's preference, else `true` | Word export carries comments and tracked changes. |
| `watermark` | Watermark | none | See below. |

**Watermark** (lenient, all keys written except `picture` when unset): `kind` (`text`, `picture`), `text` (one line, may
hold `{title}`, `{subtitle}`, `{author}`, `{case}`, `{date}`, `{recipient}`), `font` (default "Helvetica Neue"), `bold`,
`size` (points; 0 automatic), `color` (`#RRGGBB`, default `#C0C0C0`), `opacity` (0.05–1, default 0.5), `slant`
(`rising` −45°, `falling` +45°, `level`), `picture` (`<sha256>.png` in `watermarks/`, section 7.2), `scale` (percent;
0 automatic), `washout` (bool, default `true`), `pages` (`all`, `notTitle`, `textOnly`), `recipient` (string),
`recipients` (`[string]`: one copy per name).

**Workspace** (`authorWorkspace`; Goethe Write writes exactly the first seven keys, each falls back on its own):
`logline`, `premise`, `genre`, `audience`, `notes` (string), `beats` (`[Beat]`), `drafts` (`[Draft]`); legacy, read
only: `stage`, `selectedDraft` (5.4). One broken beat or draft makes the whole list empty.

- **Beat:** `id` (uuid), `title`, `summary` (string), `act` (int, from 1), `threads` (`[string]`) — Req; `color`
  (WriteLabel), `scene` (uuid: the linked text), `x`, `y` (number: the card's place on the board in points; absent:
  automatic).
- **Draft** (a screenplay in Final Draft's model): `id` (uuid), `title` (string), `sourceScenes` (`[uuid]`: the
  manuscript's scenes it comes from), `blocks` (`[Block]`), `modified` (time) — Req; `originalData` (string, base64:
  **the imported file's bytes exactly as read** — an FDX, a Fountain file, or the text of a PDF), `originalFormat`
  (`fdx` or `fountain`; anything else is read as Fountain), `titlePage` (`[{spans: [Span], alignment: Left|Center|Right|Full}]`),
  `numbering` (scene numbers: `left`, `right`, `autoHideRight` (bool), `scheme` (`1A` or `A2`), `leftLocation`,
  `rightLocation` (inches), all Req), `revisions` (revision state: `mode` (bool), `active` (int), `shown` (`Active` or
  `All`), `location` (inches), `pageColors` (bool), `sets` (`[{id: int, name, mark, pageColor, style: string, full: bool,
  color?: string}]`, colours `#RRRRGGGGBBBB`), all Req). Absent optional keys mean "as in the original file".
- **Block** (a paragraph): `id` (uuid), `element` (the Final Draft paragraph type: `Scene Heading`, `Action`,
  `Character`, `Parenthetical`, `Dialogue`, `Transition`, `Shot`, `General`, …, an open list), `text` (string) — Req;
  `sourceIndex` (int: the paragraph's index in the document read from `originalData`), `sourcePath` (`[int, int]`: a
  voice of a dual dialogue), `dualGroup` (uuid), `dualVoice` (int 0 or 1), `spans` (`[Span]`: the formatted runs; when
  present they are what counts), `status` (WriteStatus of a scene), `number` (string: scene number; `""` none), `omitted`
  (`[Block]`: an omitted scene's old paragraphs), `deletions` (`[{offset: int (UTF-16 code units in the paragraph),
  revision?: int}]`).
- **Span:** `text` (string), `styles` (`[string]`: `Bold`, `Italic`, `Underline`, `Strikeout`, `AllCaps`, `HiddenText`
  and names a file brings) — Req; `attributes` (`{string: string}`: the FDX `<Text>` attributes as read).

Screenplays live here only for now; a later version gives them a part of their own (section 10).

### 5.8 The person's window: `window`

`window` holds what one person needs to find their place again: open folders, the caret in each text, the panels
chosen. It never holds the window's frame or the panels' sizes; those belong to the device and live in the device's
own store. **A reader MAY ignore `window` entirely.** Every key is optional and lenient.

| Key | Type | Meaning |
|---|---|---|
| `expanded` | `[uuid]` (sorted) | Open folders and texts in the sidebar, and `00000000-0000-4000-8000-0000000000A1` while the section "Werkzeuge" is open. Goethe Write always writes it; its presence tells Goethe Write that the file has the current layout. |
| `sidebarFolded` | `[uuid]` (sorted) | Folded sidebar sections: root ids, and `…0000000000A1` (Werkzeuge), `…0000000000A2` (Sammlungen), `…0000000000A3` (Projekt). |
| `infoFolded` | `[string]` (sorted) | Folded sections of the inspector (`synopsis`, `notes`, `details`, `scene`, `connections`, `revision`, `profile`, `file`, `rules`, `page`, `deleted`, …). |
| `infoPage` | string | The open page of the inspector, up to two steps joined by `/` (`entities/appearances`). |
| `places` | `{uuid: Place}` | Caret and scroll per text. **Place:** `location`, `length` (int, Req: the selection in UTF-16 code units, section 6.4), `top` (int: first visible character), `offset`, `width`, `scale` (number: scroll position and the view's width and magnification in points). |
| `timeline` | Timeline | The timeline's state (below). |
| `review` | Review | The review list: `filter` (`all`, `hints`, `comments`, `questions`, `changes`, `sources`), `sort` (`place`, `date`, `kind`, `person`), `showDone`, `showIntended` (bool), `person` (string), `part` (uuid). |
| `parts` | `{string: string}` | The part chosen on a tool page (`"story": "knowledge"`). |
| `tool` | string | The tool page shown in the middle (a tool id, 5.7). |
| `collection` | uuid | The collection shown. |
| `board` | `{mode: cards\|outline, folder: uuid}` | A folder shown as cards or table (both Req). |
| `stage` | string | The phase shown: `idea`, `research`, `beats`, `screenplay`, `revision`, `output` (never `manuscript`, which is the default). |
| `draft` | uuid | The screenplay draft chosen. |

**Timeline:** `mode` (`reading`, `chronology`, `analysis`), `x`, `y` (number: the first column in view of the older
board), `measure` (`even`, `pages`, `words`; absent: `even`), `zoom` (`work`, `part`, `chapter`), `anchor` (uuid: the
first scene in view), `collapsed` (`[string]`: units shown as one block: `work`, a folder id, `<uuid>#<n>`, `loose#<n>`,
`day:yyyy-MM-dd`, `undated`), `lanes` (`strands`, `characters`, `places`, `pov`), `hidden` (`[string]`: lane ids),
`solo` (string), `curves` (`[string]`, order meaningful; absent: tension and story time; `[]`: none), `presence`
(uuid), `more` (newer state: `viewports` (`{string: {rest, anchor, into, scale, fallback}}`), `places`, `laneHeights`
(`{lane: title|card}`), `laneColours` (`{lane: 1–8}`), `laneOrder` (`{kind: [lane]}`), `laneSort` (`name`, `count`,
`manual`), `locked`, `columnsOff`, `groups`, `opened`, `curvesOpen`, `propsOff` (`[string]`), `alwaysDark` (bool; absent:
on), `curveHeight` (int, default 72)). Lane ids: `strand:<name>`, `character:<uuid>`, `place:<uuid>`,
`place-text:<name>`, `pov:character:<uuid>`, `pov:<name>`, `none`.

**Legacy keys** (read once from older files, then moved to the device's store and never written again): `frame`
(string `"{{x, y}, {w, h}}"`), `sidebar`, `info` (`{width: number, dragged: bool}`), `columns` (`{string: {sidebar: bool,
info: bool}}`), `ribbonPinned`, `spread`, `sceneStrip`, `inspector` (bool), `ribbonTab`, `inspectorTab` (string),
`presentation` (`draft`, `pages`), `zoom` (`fit`, `pageWidth`, `wholePage`, or a positive number), `lineWidth`
(`narrow`, `medium`, `wide`).

### 5.9 Goethe's record and the manuscript's goal

**LogEntry** (`goetheLog`, oldest first, at most 2,000; written only when the person keeps a record): `id`, `date`,
`model` (the engine or model), `action` (what was asked), `context` (what it was about), `result` (what happened),
`texts` (`[{node: uuid, before: string, after: string}]`: lower-case hex SHA-256 of the text before and after) — all
Req. **The record never holds the text itself.**

**Goal** (`manuscriptGoal`, lenient): `amount` (int; 0: no goal), `unit` (`words`, `characters`), `bound` (`atLeast`: a
goal; `atMost`: a limit), `withNotes` (bool, default `true`: footnotes count).

### 5.10 Lists of words

| Name | Values |
|---|---|
| NodeKind | `manuscript`, `characters`, `places`, `research`, `trash` (roots); `folder`, `text`, `character`, `place`, `file` |
| WriteStatus | `none`, `idea`, `draft`, `revised`, `done` |
| WriteLabel | `red`, `orange`, `yellow`, `green`, `blue`, `purple`, `gray` |
| FactKind | `secret`, `clue`, `promise`, `question`, `fact` |

**Strict** (an unknown value makes Goethe Write 1 refuse the file): FactKind, `Knowledge.kind`, `WorldRule.kind`,
`Collection.statuses` and `labels`, `Argument.kind`, `RoleMark.role`, `TrackedChange.kind`, `Statement.kind`,
`Relation.kind`, the keys of Ref, `Question.state`, `Review.dimension`, `FieldDefinition.type`. **Strict for their
list only** (an unknown value empties the whole list): the values inside `settings.authorWorkspace.beats` and
`drafts`, `bible.curves[].kind`, `bible.order.ownStatuses`. **Lenient** (an unknown value falls back and is rewritten
on the next save): `Node.kind` (to `text`), `Node.status` (to `none`), `Node.label` (dropped), `LegalSource.kind` (to
`book`), `ownStatuses[].countsAs` (to `draft`), the Goal, `workKind` (dropped) and every value of `settings.export`,
`window` and `watermark`.

## 6. Texts

### 6.1 Files

- The text of node `<id>` is `texts/<id>.rtf`, or `texts/<id>.rtfd/` when it holds pictures: an RTFD folder with
  `TXT.rtf` (found without regard to case) and the picture files.
- Saved versions (`snapshots/`) and deleted passages (`deleted/`) are written the same way, named by their own id.
- Version 1 stores texts as RTF so that every word processor can open them. A later version moves to an open JSON
  model (section 10); RTF stays readable.

### 6.2 The RTF that Goethe Write writes

Goethe Write writes RTF through the macOS text system ("Cocoa RTF") and adds six things. A text with content begins
like this:

```
{\rtf1\ansi\ansicpg1252\cocoartf2907
\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 Charter-Roman;}
{\colortbl;\red255\green255\blue255;}
{\*\expandedcolortbl;;}{\*\lexxstyles v1 n=3 0*3}

\deftab708
\pard\pardeftab708\sl312\slmult1\sa160\pardirnatural\partightenfactor0

\f0\fs30 \cf0 Der Kaufvertrag vom 14. M\'e4rz 2024 …\
```

- **Characters:** a paragraph ends with `\` and a line feed; characters of code page 1252 are `\'hh`; all others
  `\uc0\uN ` (with `N` ≥ 32,768 written as such; characters above U+FFFF as two surrogate units); `\\`, `\{`, `\}`;
  tabs as a tab byte or `\tab`. Fonts are PostScript names; text colour is automatic (`\cf0`); line spacing
  `\slN\slmult1`.
- **No page setup** in the text (no `\paperw`, `\margl`): the page is a setting of the project (`settings.export`).
- **Not in the text:** comments (`bible.comments`) and tracked changes (`bible.tracked`). Text deleted while changes
  are tracked stays in the RTF as ordinary text until the deletion is accepted.
- **Links** are standard RTF fields: `{\field{\*\fldinst{HYPERLINK "…"}}{\fldrslt …}}`.

**Addition 1: footnotes** as Word writes them:

```
\uc0{\super\chftn{\footnote\pard\plain\uc0\f0\fs20 {\super\chftn} \u167  444 BGB, {\i Palandt}.}}
```

The note's text uses `{\b …}`, `{\i …}`, `{\ul …}`, `{\super …}`, `{\sub …}`, `\par`, `\tab`, and `\uN ` for every
character outside ASCII (`N` as a signed 16-bit number). Notes hold no footnotes, fields or pictures. Endnotes are
never written. Readers SHOULD also accept `{\*\footnote …}` (LibreOffice) and `{\footnote\ftnalt …}` (Word endnotes,
read as footnotes).

**Addition 2: paragraph styles**, a destination other programs skip:

```
{\*\lexxstyles v1 n=<P> <run> <run> …}
```

`<P>` is the number of paragraphs; a run is `<code>` or `<code>*<count>`; `<code>` is the style of the paragraph
(`0` body, `1`–`3` headings 1–3, `4` quotation, `5`–`7` headings 4–6, `-` none; `settings.styles` says how they look).
Paragraphs end at LF, CR, CRLF and U+2029 (not at U+2028 or U+000C); no empty paragraph follows the last break; an
empty text has no record. The Mac app writes the record after the header tables, the iPhone and iPad app before the
final `}`: readers search for it anywhere. It applies only when its count, `n` and the real number of paragraphs
agree.

**Addition 3: fields** are written as plain text tokens between U+27E6 and U+27E7, never as RTF fields:

| Token | Shown as |
|---|---|
| `⟦var:<name>⟧` | the value of the variable of that name (`bible.variables`), or `‹<name>›` |
| `⟦var:<name>@yyyy-MM-dd⟧` | its value on that day |
| `⟦ref:<node id>⟧` | a cross-reference to a text: its label in the export (`B. II. 1.`, `Abschnitt 2.1`, or its title in quotes), or `‹Verweis fehlt›` |
| `⟦ref:<node id>#<heading words>⟧` | a cross-reference to a heading in it (words normalized, at most 80 characters) |
| `⟦anlage:<node id>⟧` | an annex: `Anlage <settings.annexPrefix> <n>`, `n` its place among the children of the first research folder whose title begins with "Anlage" (else of the research root), or `‹Anlage fehlt›` |

In the RTF a token looks like `\uc0အ4 var:Aktenzeichenအ5 `. A reader finds tokens with the expression
`⟦(var|ref|anlage):([^⟧\n]{1,120})⟧`.

**Addition 4: pictures** (only in RTFD). Each picture character is

```
{{\NeXTGraphic Bild.png \width2400 \height1200 \appleattachmentpadding0 \appleembedtype0 \appleaqc
}¬}
```

where `¬` is the single byte `0xAC`, the picture's own character; `\width` and `\height` are the size shown, in
twips (1/20 point). The file name is that of a file in the RTFD folder; one file may serve several pictures, so a
reader takes the name from the reference and never guesses it. When a picture is placed on the page, `TXT.rtf` also
holds, right after its first line feed,

```
{\*\goethepictures <base64 of JSON>}
```

with `{"version":1,"entries":[{"ordinal":0,"width":160,"height":80,"placement":{"mode":"inline|paragraph|page",
"side":"left|right","slot":"top|bottom|whole","page":0,"x":0,"y":0,"gap":10,"angle":25,"bleed":false}}]}`;
`ordinal` counts the pictures of the text only (not footnotes or fields).

**Addition 5: character formats** that RTF as the macOS text system writes it cannot carry, a destination other
programs skip (written since 12 November 2026; a text without it has none of these formats):

```
{\*\lexxchars v1 len=<L> <start>+<length>:<mark>[,<mark>…] …}
```

`<L>` is the length of the text in UTF-16 code units **as it is written**: each footnote and each picture one
character, each field token (addition 3) as its characters; in the reference reader that is `raw`, not `text` (6.4).
Each run names a stretch, `<start>` and `<length>` in the same units (`<length>` at least 1, `<start> + <length>` at
most `<L>`), and the marks of all of its characters, separated by commas. Goethe Write writes one run for every
stretch of characters with the same marks, in ascending order, without characters that have none; readers accept any
order. The marks of version 1:

| Mark | Meaning | In Word |
|---|---|---|
| `sc` | Kapitälchen (small capitals): lower-case letters as small capitals, the letters stay as typed | `w:smallCaps` |
| `caps` | Versalien (all capitals): shown in capitals, the letters stay as typed (copying and searching find them as written) | `w:caps` |
| `hidden` | hidden text: not printed, not in PDF, EPUB, RTF or Markdown, not counted; shown in Goethe Write only with the formatting marks | `w:vanish` |
| `lang=<tag>` | the language of the passage, a BCP 47 tag (`en-GB`, `de-CH`, `la`); spelling and hyphenation follow it | `w:lang` |

`sc` and `caps` exclude each other in Goethe Write; a reader that finds both shows capitals. The record is written
after the header tables by the Mac app (the iPhone and iPad app does not write it yet); readers search for it anywhere.
It applies only when `<L>` is the length of the text read; otherwise, or when a run breaks these rules, **none** of it
applies (the text was changed by another program, and the places would be wrong). Marks a reader does not know are
skipped. Three formats of the same package need no record, because Cocoa RTF writes and reads them itself: the
tracking (Laufweite) as `\expndN\expndtwN` (quarter points and twips; in Word `w:spacing`), the double strike as
`\striked1` (Word `w:dstrike`), and no ligatures as `\CocoaLigature0` (Word `w14:ligatures w14:val="none"`;
`\CocoaLigature1` or nothing: the font's ligatures).

**Addition 6: Umbruch and tab leaders** of paragraphs, which Cocoa RTF cannot carry (it writes no `\keepn`, `\keep`,
`\pagebb`, `\widctlpar` and no leader `\tldot`; it reads none of them either), a destination other programs skip
(written since 13 November 2026; a text without it has none of these values):

```
{\*\lexxparas v1 n=<P> <run> <run> …}
```

`<P>` is the number of paragraphs, counted as for addition 2; a run is `<marks>` or `<marks>*<count>`; `<marks>` is
`-` for a paragraph without values or the paragraph's marks joined by `,` (no spaces):

| Mark | Meaning | In Word |
|---|---|---|
| `keepNext`, `keepNext=0` | Nicht vom nächsten trennen, on or explicitly off | `w:keepNext`, `w:keepNext w:val="0"` |
| `keepLines`, `keepLines=0` | Zeilen nicht trennen | `w:keepLines` |
| `pageBreakBefore`, `pageBreakBefore=0` | Seitenumbruch oberhalb | `w:pageBreakBefore` |
| `widowControl`, `widowControl=0` | Absatzkontrolle | `w:widowControl` |
| `tab<twips>=dot\|hyphen\|underscore` | the leader of the paragraph's tab stop at that place (twips = 1/20 point, as the RTF's own `\txN`; one twip either way matches): dots, dashes, a line | `w:tab w:leader="dot\|hyphen\|underscore"` |

A mark without `=` (or with `=1`) is on. A value the paragraph does not have is not written: its style decides (5.7).
Goethe Write writes the marks in this order, `tab` marks by place; readers accept any order. The record is written after
the header tables by the Mac app; readers search for it anywhere. It applies only when `<P>`, the runs' total and the
real number of paragraphs agree; otherwise, or when a run breaks these rules, **none** of it applies. Marks a reader
does not know, values it does not know and leaders of tab stops the paragraph does not have are skipped.

`{\*\lexxsources …}` is reserved (sources kept in a text); Goethe Write 1 does not write it.

**When the text does not fit these rules** (footnote groups and footnote characters disagree, as in damaged or foreign
files), Goethe Write reads the RTF with the system's reader alone: footnotes then vanish and the styles record is not
applied.

### 6.3 Plain text

To get the text as a person reads it, a reader:

1. reads the RTF, skipping destinations that start with `\*` and the tables (`fonttbl`, `colortbl`, `stylesheet`,
   `info`, `pict`, `object`, `header…`, `footer…`, `listtable`, `listoverridetable`, `revtbl`, `rsidtbl`, `fldinst`,
   …), keeping `fldrslt` and `listtext`;
2. maps `\par`, `\cell` to a line feed, `\line` to U+2028, `\page` to U+000C, `\tab` to a tab, `\uN` (with `\uc`) and
   `\'hh` (in the code page of `\ansicpg`) to their characters, `\~` to U+00A0, `\-` to U+00AD, `\_` to U+2011;
3. takes each footnote group out as a note, leaving one character U+FFFC in its place;
4. takes each `\NeXTGraphic` group as one U+FFFC (and drops the `0xAC` after it);
5. leaves out hidden text (`hidden`, addition 5), with the footnotes and pictures in it, as Goethe Write's export does;
6. shows each field token as its value (6.2).

The reference reader (section 11) does exactly this and prints footnotes as `[^n]` with the notes below the text,
numbered as they are shown (a footnote in hidden text gets no number). Anchors (6.4) still count the hidden text: it is
part of the text as Goethe Write holds it.

### 6.4 How Goethe Write counts the text: anchors

Many keys of `project.json` point into texts: every **anchor** (`location`, `length`) in `bible` (comments, sources,
roles, tracked changes, arguments, terms, statements, questions, clause uses, passages in relations), and
`window.places`. They count **UTF-16 code units** of the text **as Goethe Write holds it**, which is the plain text of
6.3 with these rules:

- a **footnote** is one character (U+FFFC); the note's own text is not counted;
- a **field** is one character (U+FFFC), not its token;
- a **picture** is one character (U+FFFC);
- list markers (a tab, `•` or the number, a tab) and outline labels count as written, and so does text deleted while
  changes are tracked;
- a character above U+FFFF counts as two; nothing is normalized.

`quote` (and `checkedText`) is the passage with these U+FFFC characters in it, as it was when the anchor was made or
last refreshed. Edits move `location` and `length`, but not every edit refreshes `quote`. A reader therefore takes the
passage at `location` when it equals `quote`, else the occurrence of `quote` nearest to `location`, else the range
clipped to the text. (Goethe Write's sample project has one anchor made before a footnote went into its passage: its
quote lacks that footnote's character.)

The mapping of `\line`, `\page`, `\cell` and list markers in item 2 of 6.3 follows the RTF specification and the
macOS text system; the files tested so far hold none of them, so a later revision confirms them against files with
lists, tables, line and page breaks.

## 7. Research files, watermarks, guides

### 7.1 Research files: `files/`

A research node (`kind: "file"`) has its bytes in `files/<id>.<ext>`, where `<ext>` is the extension of its original
file name (`Node.file`, e.g. `"Kaufvertrag.pdf"`); a file without an extension has none. **Readers find a node's file
by matching the id against the part of the name before the extension** and never rebuild the name from `Node.file`,
which is only the name shown. A node with `url` and no `file` is a web link and has no bytes.

### 7.2 Watermarks: `watermarks/`

The picture of a picture watermark lies in `watermarks/<sha256>.png`: the 64 lower-case hex digits of the SHA-256 of
the file's exact bytes. It is PNG (other formats are converted, at most 2,400 pixels on the long side).
`settings.export.watermark.picture` names it (the bare file name). The name is the picture's identity; a writer MUST
NOT store other bytes under it. When Goethe Write opens a project it removes every other file from the folder, and the
folder when nothing is left.

### 7.3 Page guides: `guides.json`

Blue-pencil guides on the pages, with a version of their own. The file exists only after a guide was edited; opening
or showing never creates it.

```json
{
  "entries" : [ { "axis" : "vertical", "base" : "textArea", "colour" : "bluePencil", "edge" : "inner",
                  "id" : "2D3F5B8E-7C41-4C1A-9E0B-5A1F2C3D4E5F", "locked" : false, "mirrorInBook" : true,
                  "offset" : 14.173228346456693, "owner" : "manuscript", "scope" : "all" } ],
  "format" : 1,
  "readableFrom" : 1
}
```

Goethe Write 1 accepts only `format` 1 with `readableFrom` 1. Otherwise, or when an entry is invalid, it shows no
guides, refuses to edit them, and keeps the file's bytes unchanged. Every key of an entry is required:

| Key | Meaning |
|---|---|
| `id` | uuid, unique in the file |
| `owner` | `manuscript`; also valid: `script:<x>`, `page:<x>`, `cover:<x>` (no `:`, space or control character in `<x>`, at most 256 bytes in all) |
| `axis` | `horizontal` (measured on y) or `vertical` (measured on x) |
| `base` | `sheet` (the paper) or `textArea` (the page's type area, mirrored on left-hand pages when margins are mirrored) |
| `edge` | horizontal: `top`, `bottom`, `centre`; vertical: `inner`, `outer`, `left`, `right`, `centre` |
| `offset` | points from that edge, finite, may be negative |
| `scope` | `all`, `left` or `right` pages (left-hand pages have even printed numbers) |
| `mirrorInBook` | `inner` and `outer` follow mirrored margins |
| `locked` | cannot be moved or deleted by hand |
| `colour` | `bluePencil` |

At most 2,000 guides in all and 200 per owner.

## 8. What readers and writers must do

**A reader**

1. MUST apply the rules of `manifest.json` (2.2).
2. MUST read the outline from `tree` and find each node's text in `texts/` by its id (`.rtf`, or `TXT.rtf` in an
   `.rtfd` folder), and its research file in `files/` by its id.
3. MUST NOT depend on the order of keys, on the order of `expanded`, or on ZIP bytes; MUST ignore keys and top-level
   entries it does not know.
4. SHOULD read the RTF additions of 6.2. A general RTF reader shows the text, but footnotes then stand in the text or
   are lost, and anchors no longer fit.
5. MUST follow 4.3 when it reads an exchange file.

**A writer** (a program that changes a package)

1. MUST write `manifest.json` by the rules of section 2, and MUST NOT lower `format` of a package it may edit.
2. MUST write every key marked **Req** (section 5), ids as UUIDs, times in UTC as in 5.1.
3. MUST keep every top-level entry it does not know, byte for byte (3.3), and the files of nodes it does not change.
4. SHOULD NOT add keys to `project.json`: Goethe Write 1 drops keys it does not know. A program that wants to keep data
   of its own in a package SHOULD use a top-level entry named by its reverse domain name (`com.example.tool/` or
   `com.example.tool.json`); Goethe Write keeps it.
5. SHOULD keep anchors valid when it changes a text (move `location` and `length` of the anchors in that node), and
   MUST NOT put files into `texts/`, `files/`, `snapshots/` or `deleted/` that `project.json` does not refer to.
6. SHOULD save safely (3.4).

**A writer of exchange files** MUST follow 4.1; Goethe Write never reads back what it cannot write.

## 9. Security and privacy

**Reading.** An exchange file comes from someone else. The rules of 4.3 protect against names that lead out of the
package ("zip slip"), links, archives that unpack to far more than they say ("zip bombs", also by overlapping
entries), and encryption. Readers MUST NOT follow links, write outside the package, start programs, or load anything
from the network because of a file's content. RTF is read with the system's text reader; RTF from other programs can
contain embedded objects (`\object`, `\pict`), which Goethe Write never writes; a reader SHOULD NOT run or display
embedded objects. JSON SHOULD be read with limits on size and depth.

**What a project contains.** A package, and so every exchange file made from it, holds **the whole project**:

- every text, also those in "Recently Deleted";
- saved versions of texts (`snapshots/`, `bible.snapshots`) and deleted passages (`deleted/`, `bible.deleted`, up to
  200);
- comments and replies with their authors' names, and tracked changes with names and times;
- the research files, and the bytes of every imported screenplay as they were read (`originalData`), including parts
  later deleted in Goethe Write;
- the record of what the assistant Goethe changed, if the person keeps one (`goetheLog`: actions and checksums, never
  the text);
- where the person stopped (`window`: open folders, caret positions).

It also holds the project's house rules for the assistant (`settings.goetheRules`). It never holds device values
(window frames, panel sizes), API keys, passwords or account data. "Für Goethe sperren" (`lockedForGoethe`) keeps the
assistant away from a part; it is not encryption, and the part is in the file like any other. A person who sends an exchange file SHOULD know what it carries; a later
version of Goethe Write may offer to leave parts out (section 10).

## 10. What is stable in version 1, and what later versions change

**Stable.** Every later version of Goethe Write reads what version 1 describes. Since version 1.0 of this
specification these stay as they are, and later versions only add to them:

- the two forms, their names, type identifiers and media type (final since version 1.0);
- the rules of `manifest.json` (section 2) and the ZIP profile of the exchange file (section 4);
- the layout of the package and the reserved names (section 3);
- the keys of `project.json` and their meaning (section 5);
- the RTF of texts with its six additions, and how anchors count (section 6).

**Planned for later versions** (not promises; each comes with a new `format`, and `readableFrom` rises where older
writers would lose data):

| Change | Why |
|---|---|
| Texts as an open **JSON block model** (paragraphs with their style, runs with marks, footnotes, comments and changes as ranges) instead of RTF; RTF stays readable for older projects | one exact meaning on every device and in every program; anchors without the RTF reader's rules |
| Screenplays as a **part of their own**, `scripts/<node id>/` (a head, one part per scene, comments and changes as records, the original FDX or Fountain bytes in `sources/`, versions), instead of `settings.authorWorkspace.drafts` | loss-free Final Draft round trips, working together scene by scene |
| `manifest.json` lists **every part with its SHA-256** and is written last | a package is complete or it is not; damage is found |
| Knowledge in parts of its own (characters and places, timeline, comments and changes as records) | several people and devices change different files |
| `expanded` written in a fixed order, keys of `project.json` that a version does not know kept | the same project gives the same bytes; newer data survives older writers |
| The person's window state outside `project.json` | a shared project carries nobody's caret |
| ZIP64 for exchange files over 4 GB | large research collections |
| Quick Look previews and Spotlight data, the media type registered with the IANA | the file shows its content outside Goethe Write |

## 11. Schemas, reference reader and tests

| File | What it is |
|---|---|
| [`schema/manifest.schema.json`](schema/manifest.schema.json) | JSON Schema (2020-12) of `manifest.json` |
| [`schema/project.schema.json`](schema/project.schema.json) | JSON Schema (2020-12) of `project.json`, every key of section 5, with its meaning |
| [`reference/goethe_read.py`](reference/goethe_read.py) | Reference reader: prints the outline and the plain text of a `.goethe`, `.lexwrite` or `.goethex` (without hidden text); `--json` for programs, with each text's paragraph styles, character formats and Umbruch (`styles`, `chars`, `paras`) |
| [`reference/check_schema.py`](reference/check_schema.py) | Checks packages and exchange files against the schemas; `--strict` lists keys the schemas do not describe |
| [`reference/test_goethe_read.py`](reference/test_goethe_read.py) | Tests of both; with `GOETHE_SAMPLES=<folder>` also every project Goethe Write wrote into that folder |
| [`reference/README.md`](reference/README.md) | How to use the three scripts |
| [`LICENSE.md`](LICENSE.md) | Which licence covers which file (section 12) |

All three scripts need Python 3.9 or later and nothing but its standard library:

```
python3 docs/format/reference/goethe_read.py "Mein Roman.goethex"
python3 docs/format/reference/check_schema.py --strict "Mein Roman.goethe"
python3 docs/format/reference/test_goethe_read.py
```

The schemas are open: they allow keys they do not list, because readers must ignore unknown keys. They are checked
against every sample project and every template Goethe Write can create, in both forms, and against a package written
before the manifest existed; `--strict` finds no key without a description.

**Goethe Write's own checks** (launch argument `-goetheFormatTest`, check `goetheFormatTest` of
`write/scripts/drehbuch-pruefen.sh`):

- the registration in the app's `Info.plist`;
- every sample and template → `.goethe` → read → the same outline and texts; after the first reading, read and written
  again byte for byte the same (only the documented migrations of 5.4 happen once);
- every one → `.goethex` → read → the same unpacked entries; `mimetype` first and stored; written twice the same;
  read back as a project and saved, the same package;
- a text with every character format of addition 5 (and tracking, a double strike, no ligatures) → `.goethe` and
  `.goethex` → read → the same formats in the same places; a record written for another length, against the rules, of
  another version or with a mark of a later version changes nothing it should not; a package without records reads
  as before;
- a text with paragraphs carrying every value of addition 6 and a tab stop with a leader, and styles with the keys of
  5.7 → `.goethe` and `.goethex` → read → the same values at the same paragraphs, the same styles; the macOS RTF reader
  alone and a reader of the ten older keys of Style read without error; a record for another number of paragraphs,
  of another version or against the rules applies not at all, unknown marks are skipped;
- unknown entries travel along in both forms;
- a `.lexwrite` package (also one without a manifest) opens, saves in place under its name and gets a manifest;
- a `.goethex` opens as an untitled project and is not written to;
- damaged, foreign and hostile files are refused with a sentence (not a ZIP, a PDF, a Word file, an EPUB, an
  OpenDocument file, cut off, a changed byte, a wrong checksum, names that lead out, absolute names, drives,
  backslashes, doubled names also by case, a file and a folder of the same name, links, encryption, unknown packing,
  ZIP64, overlapping entries, too many entries, too large, packed suspiciously far, too deep, an entry that unpacks to
  more than it says); never a crash;
- the reader limits of 4.3, the manifest's rules (a newer `format` is kept, a newer `readableFrom` and another `kind`
  are refused).

## 12. Licence

This specification and the files that come with it are published by ICSL FZE, Sharjah, United Arab Emirates.
[`LICENSE.md`](LICENSE.md) lists which licence covers which file.

- **The specification** (this text, `GOETHE_FORMAT_1.md`, and the German short version, `GOETHE_FORMAT_1.de.md`):
  © 2026 ICSL FZE, licensed under the Creative Commons Attribution 4.0 International licence (CC BY 4.0):
  [licence deed](https://creativecommons.org/licenses/by/4.0/),
  [legal code](https://creativecommons.org/licenses/by/4.0/legalcode.en). You may copy, share, translate and adapt it,
  for any purpose, also commercially, as long as you give credit, link to the licence and say whether you changed it.
  Suggested credit: `Goethe Format 1, © 2026 ICSL FZE, CC BY 4.0, https://goethecloud.com/format/`.
- **The JSON Schemas** (`schema/`) and **the reference reader** with its tests (`reference/`): Copyright (c) 2026
  ICSL FZE, licensed under the MIT License ([`schema/LICENSE`](schema/LICENSE),
  [`reference/LICENSE`](reference/LICENSE)). Each of these files names its licence in an SPDX line.
- **The format itself:** other programs are free to read and write files in Goethe Format 1.

Questions about the format and its licences: [hello@lexxington.com](mailto:hello@lexxington.com).

## Appendix A: Registration of the media type (draft)

`application/vnd.goethecloud.goethex+zip` is not registered yet. The registration in the IANA's vendor tree
(RFC 6838) is submitted by the publisher, ICSL FZE; this is the text to submit. The contact person, the e-mail address
and the author are filled in by the publisher when it submits the registration.

| Field | Value |
|---|---|
| Type name | application |
| Subtype name | `vnd.goethecloud.goethex+zip` |
| Required parameters | none |
| Optional parameters | none |
| Encoding considerations | binary |
| Security considerations | section 9 of this specification: ZIP containers from others can hold names that lead out of the folder, links, and entries that unpack to far more than they say; readers refuse them (section 4.3). The format holds no executable content. Texts are RTF; embedded objects are never written. |
| Interoperability considerations | a ZIP archive (PKWARE APPNOTE) restricted as in section 4.1; the first entry `mimetype` holds the type, stored, as in EPUB and OpenDocument |
| Published specification | this document, https://goethecloud.com/format/specification/ |
| Applications that use this media type | Goethe Write (macOS, iOS, iPadOS) |
| Fragment identifier considerations | none |
| Magic number | `50 4B 03 04` at offset 0, `mimetype` at offset 30, `application/vnd.goethecloud.goethex+zip` at offset 38 |
| File extension | `.goethex` |
| Macintosh file type code | none; Uniform Type Identifier `com.goethecloud.goethe.exchange` |
| Person and e-mail to contact | (filled in by the publisher at submission) |
| Intended usage | COMMON |
| Restrictions on usage | none |
| Author | (filled in by the publisher at submission) |
| Change controller | ICSL FZE, Sharjah, United Arab Emirates |

## Appendix B: Examples

An exchange file as `zipinfo` lists it (the sample project "Der Fall Berger", shortened):

```
-rw-r--r--  2.0 unx       39 b- stor 26-Nov-07 05:20 mimetype
-rw-r--r--  2.0 unx      103 b- defN 26-Nov-07 05:20 manifest.json
drwxr-xr-x  2.0 unx        0 b- stor 26-Nov-07 05:20 files/
-rw-r--r--  2.0 unx    24787 b- defN 26-Nov-07 05:20 files/178F6E39-5D77-4AF9-901D-C307C0BFF67E.pdf
-rw-r--r--  2.0 unx    …         defN …               project.json
drwxr-xr-x  2.0 unx        0 b- stor …               snapshots/
-rw-r--r--  2.0 unx    …         defN …               snapshots/….rtf
drwxr-xr-x  2.0 unx        0 b- stor …               texts/
-rw-r--r--  2.0 unx    …         defN …               texts/….rtf
```

Its `manifest.json`:

```json
{
  "format" : 1,
  "generator" : "Goethe Write 0.1 (1)",
  "kind" : "project",
  "readableFrom" : 1
}
```

Its `project.json` (shortened, written on one line where the file has several):

```json
{
  "bible" : {
    "comments" : [ { "anchor" : { "length" : 42, "location" : 0, "node" : "07659DCD-19AC-4112-B426-CBF5047F0824",
                                  "quote" : "Der Gutachter sprach leise und sehr genau." },
                     "author" : "Lektorat", "date" : "2026-11-12T11:27:07Z", "id" : "A200F17B-707C-46F8-8417-437940156263",
                     "replies" : [ ], "resolved" : false, "text" : "Name des Gutachters einführen?" } ],
    …
  },
  "dailyGoal" : 750,
  "days" : { "2026-11-12" : 172 },
  "expanded" : [ … ],
  "format" : 2,
  "manuscriptGoal" : { "amount" : 0, "bound" : "atLeast", "unit" : "words", "withNotes" : true },
  "selection" : "0B10D7BE-8DB1-487C-AF98-612DFF02B1EB",
  "settings" : { "language" : "de", "legalTools" : true, "storyTools" : true, "title" : "Der Fall Berger",
                 "workKind" : "novel", … },
  "tree" : [ { "id" : "270943A9-3193-4FC7-8701-3E1E9EC9FD47", "kind" : "manuscript", "title" : "Manuskript",
               "children" : [ … ], … }, … ],
  "window" : { "expanded" : [ "182FF84D-E431-45B4-AD96-82AE169812A0", … ], "timeline" : { "measure" : "pages" } }
}
```
