@quillmark/wasm 0.133.0 → 0.134.1

package/core/wasm.d.ts

@@ -21,12 +21,14 @@ export type PayloadItem =
  * `CardInput`, so a card read from one document pushes straight into another.
  *
  * `$` system entries are hoisted to named fields: `kind` (the `$kind`),
- * `quill` (`$quill` `name@version`, main card only), `ext` (`$ext`), and
- * `seed` (the `$seed` per-kind overlay map, main card only).
- * `payloadItems` carries user fields and comments in order.
+ * `id` (the `$id`, composable cards only), `quill` (`$quill`
+ * `name@version`, main card only), `ext` (`$ext`), and `seed` (the `$seed`
+ * per-kind overlay map, main card only). `payloadItems` carries user fields
+ * and comments in order.
  */
 export interface Card {
     kind: string;
+    id?: string;
     quill?: string;
     ext?: Record<string, unknown>;
     seed?: Record<string, unknown>;
@@ -41,10 +43,13 @@ export interface Card {
 /**
  * A card written *into* a document, accepted by `Document.insertCard`. Like
  * `Card`, but `body` also takes a markdown `string`, and every field but `kind`
- * is optional (defaulting to no payload items and an empty body).
+ * is optional (defaulting to no payload items and an empty body). A card
+ * without an `id` is minted one where it is placed; one whose `id` is not a
+ * card id, or is held by another card of the document, is refused.
  */
 export interface CardInput {
     kind: string;
+    id?: string;
     quill?: string;
     ext?: Record<string, unknown>;
     seed?: Record<string, unknown>;
@@ -52,156 +57,20 @@ export interface CardInput {
     body?: Content | string;
 }
 
-/**
- * Canonical richtext content: the model behind a card body and richtext fields.
- * One text sequence over a single coordinate space (Unicode scalar values):
- * `text` plus line attributes, anchored `marks`, and embedded `islands`. Every
- * edit is a splice; markdown is a projection, not the model.
- */
-export interface Content {
-    text: string;
-    lines: ContentLine[];
-    marks: ContentMark[];
-    islands: ContentIsland[];
-}
-
-/** One `\n`-separated segment of `Content.text`, in order. `kind` is a closed
- * set: `island` reads as `para`, and any other role outside it is refused
- * wherever content is decoded. Every role spells its payload in `attrs`, so
- * `kind === "heading"` narrows `attrs` to `{ level: number }` with no guard. */
-export type ContentLine = {
-    containers: ContentContainer[];
-    /** A within-block hard line break rather than a new block. Omitted (false) in the common case. */
-    continues?: boolean;
-} & ContentLineKind;
-
-/** A line's block role, shared by `ContentLine` and the `setKind` op. */
-export type ContentLineKind =
-| { kind: "para" }
-| { kind: "heading"; attrs: { level: number } }
-| { kind: "code"; attrs?: { lang?: string } }
-| { kind: "rule" };
-
-/** An ancestor block a line nests inside, outermost first. Closed like
- * `ContentLine.kind`.
- *
- * Two adjacent lines sit in the same container iff their whole path matches, so
- * `instance` is what tells one container from an adjacent sibling of identical
- * shape — two consecutive quotes, two consecutive lists — which contiguity
- * alone reads as one.
- *
- * **A writer owes a distinct value per adjacent sibling run.** Runs of one shape
- * sharing one arrive as one: a second list's items come back as continuation
- * paragraphs of the first, markers gone. Nothing reports that — an omitted field
- * and a `0` stamped on both are the same write — so a codec flattening a tree
- * takes them from `assignInstances` in `@quillmark/wasm` rather than by hand.
- * Any distinct pair works; a write is canonicalized to `0`/`1`.
- *
- * Absent is `0`, and a read omits it there, so a container with nothing adjacent
- * to be told apart from carries no key. A read does spell one on pairs no writer
- * had to: `1.` beside a list starting at `3` differs by `start`, so those runs
- * arrive apart with nothing written, and the canonical form spends a
- * discriminator anyway because Markdown reads only a list's first number. */
-export type ContentContainer =
-| {
-    container: "list_item";
-    /** `checked` is present on a task item: `true` ticked, `false` open. */
-    attrs: { ordered: boolean; start: number; ordinal: number; checked?: boolean };
-    instance?: number;
-}
-| { container: "quote"; instance?: number };
-
-/** A mark over char range `[start, end)` into `Content.text`. `type` is a
- * closed set, so `type === "link"` narrows `attrs` to `{ url: string }` with no
- * guard. An `anchor`'s `id` is a caller-supplied opaque
- * handle, unique per `Content` and invariant while the mark lives (positions
- * rebase, the id never does); it has no markdown projection and survives only
- * through the edit lane. */
-export type ContentMark = { start: number; end: number } & ContentMarkKind;
-
-/** A mark's type with its payload, shared by `ContentMark` and a `MarkOp`'s
- * `add` / `remove`. */
-export type ContentMarkKind =
-| { type: "strong" | "emph" | "underline" | "strike" | "code" }
-| { type: "link"; attrs: { url: string } }
-| { type: "anchor"; attrs: { id: string } }
-| { type: "font_family"; attrs: { name: string } };
-
-/** A cell in a `TableProps`. `marks` rides the prose `ContentMark` shape, but
- * each mark's `start`/`end` are USV offsets into this cell's `text`, not into
- * `Content.text`. A `\n` in `text` is a line break. */
-export interface TableCell {
-    text: string;
-    marks: ContentMark[];
-    /** The cell's horizontal alignment; absent is its column's. */
-    align?: "left" | "center" | "right";
-    /** The cell's vertical alignment; absent is the quill's. */
-    valign?: "top" | "middle" | "bottom";
-    /** The columns the cell spans, from 2; absent is one. Each cell it covers
-     * holds its slot as an empty placeholder. */
-    colspan?: number;
-    /** The rows the cell spans, from 2; absent is one. */
-    rowspan?: number;
-}
-
-/** `props` of a `type: "table"` island: a rectangular grid normalized to one
- * column count that `header`, every row of `rows`, `aligns` and `widths` all
- * share. A layout key at its default is absent; one holding a value outside
- * its type stays as written and reads as absent. */
-export interface TableProps {
-    header: TableCell[];
-    rows: TableCell[][];
-    /** Per-column alignment, one entry per column. */
-    aligns: ("none" | "left" | "center" | "right")[];
-    /** Per-column relative weights; `null` is an auto-fit column. Absent when
-     * every column is auto-fit. A weight is an integer from 1 to
-     * `Number.MAX_SAFE_INTEGER`. */
-    widths?: (number | null)[];
-    /** The table's placement; absent is the quill's. */
-    align?: "left" | "center" | "right";
-    /** How many rows from the top of `header` then `rows` are header rows;
-     * `0` draws `header` as the first body row, and absent is one. */
-    head?: number;
-}
-
-/** `props` of a `type: "image"` island. Stores and round-trips; no backend
- * typesets one, and a render that holds one warns `backend::declined_construct`,
- * because no backend resolves `url`. */
-export interface ImageProps {
-    url: string;
-    alt: string;
-}
-
-/** `props` of a `type: "footnote"` island: the note, shaped as one `TableCell`
- * with no `\n` at either edge. The island's slot is the reference, inline in
- * its paragraph. */
-export type FootnoteProps = TableCell;
-
-/** `props` of a `type: "math"` island: the equation's TeX, as written between
- * its dollars, on one line with no edge whitespace. `display` is present and
- * `true` on a `$$…$$` equation. */
-export interface MathProps {
-    tex: string;
-    display?: true;
-}
-
-/** A structured object occupying one island slot in `Content.text`. `type` is a
- * closed set, so `type === "table"` narrows `props` to `TableProps`. */
-export type ContentIsland = {
-    id: string;
-} & (
-| { type: "table"; props: TableProps }
-| { type: "image"; props: ImageProps }
-| { type: "footnote"; props: FootnoteProps }
-| { type: "math"; props: MathProps }
-);
-
 /**
  * A write address: one navigation concept for the whole `Document` surface. An
  * absent `field` targets the card body; an absent `card` targets the main card.
- * `{}` is the main-card body; `{ card: 2 }` the body of the composable card at
- * index 2; `{ field: "intro" }` the main card's `intro` field; `{ card: 2,
- * field: "intro" }` a card field.
+ * A composable card is named by its `$id` (`card.id`) or by its index: `{}` is
+ * the main-card body; `{ card: "c3xk7p" }` the body of the card holding that
+ * id, wherever it sits; `{ card: 2 }` the body of the card at index 2;
+ * `{ field: "intro" }` the main card's `intro` field; `{ card: "c3xk7p",
+ * field: "intro" }` a card field. An id no card holds throws
+ * `edit::unknown_card_id`.
+ *
+ * The content lane's writes (`apply`, `revise`, `replace`) take a
+ * card by `$id` only, and throw on an index: a card moved or inserted between
+ * a writer's read and its write shifts an index onto another card, and an
+ * equal body there would pass the `base` check.
  *
  * On the `Addr`-taking verbs a **bare string** is shorthand for `{ field: name }`
  * (`doc.storeField("qty", 3)`); a bare number is *not* an addr.
@@ -216,23 +85,23 @@ export type ContentIsland = {
  * inside takes the path as its own argument, `reader.getContentAt(addr, path)`.
  */
 export interface Addr {
-    card?: number;
+    card?: string | number;
     field?: string;
 }
 
 /**
- * A card-only address, taken by the card-scoped verbs (`storeFields`,
- * `storeExt`, `getExt`, `commitFields`, …). An absent `card` targets the main
- * card; a present `field` throws.
+ * A card-only address, taken by the card-scoped verbs (`storeExt`, `getExt`, `commitFields`, …). An absent `card` targets the main
+ * card, a string the card holding that `$id`, a number the card at that
+ * index; a present `field` throws.
  */
 export interface CardAddr {
-    card?: number;
+    card?: string | number;
 }
 
 /**
- * A text-splice change set over the USV content (CodeMirror `ChangeSet`
- * semantics), returned by `revise` and by the `rebase` codec. Map a stored
- * position through it with `mapPos`.
+ * A text-splice change set over the revised value's text, counted in UTF-16
+ * code units (CodeMirror `ChangeSet` semantics), returned in a revise's
+ * `Revised` receipt and taken back by `reattach`.
  *
  * Applying one admits an `insert` string rather than storing it verbatim: `\r`
  * and the Unicode bidi controls drop, and a line separator — VT, FF, NEL,
@@ -243,14 +112,34 @@ export interface Delta {
 }
 
 /**
- * The receipt of a revise (`revise`, `reviseContent`, `writer.reviseBody`,
- * `writer.reviseField`): the text `delta`, and one `parse::dropped_construct`
+ * The receipt of a typed revise (`writer.reviseBody`, `writer.reviseField`): the text `delta`, one `parse::dropped_construct`
  * warning per construct a markdown import dropped, anchored at the revised
- * address. `reviseContent` imports nothing, so its `warnings` is empty.
+ * address, and `droppedAnchors`, every anchor of the stored value, in its
+ * prose or a cell, whose id the revised value holds nowhere, each with the
+ * text of the line or cell it stood in. The revised
+ * address is the dropped anchors' path, so they carry none.
  */
 export interface Revised {
     delta: Delta;
     warnings: Diagnostic[];
+    droppedAnchors: { id: string; line: string }[];
+}
+
+/**
+ * What a revise's writer read, the optional last argument of the writer's
+ * `reviseBody` / `reviseField` / `reviseDocument`.
+ * Name one or neither; a key present with no string throws. `baseHash` is the
+ * hash the writer read, paired with the lane it writes on: `writer.hashAt` /
+ * `writer.hash`. A write onto a value that hashes otherwise
+ * throws `edit::stale_base`. `baseMarkdown` is the markdown the writer read, annotated
+ * or not (a `text` field's literal text): when the value has changed since,
+ * the writer's edit and the change since merge by line, so both land, and
+ * runs of lines both changed throw `edit::rebase_conflict`. Each refusal's
+ * `args.current` is the hash now, and leaves the value unchanged.
+ */
+export interface BaseOptions {
+    baseHash?: string;
+    baseMarkdown?: string;
 }
 
 /**
@@ -259,20 +148,26 @@ export interface Revised {
  * cell's anchors drop unnamed. `warnings` are the parse's, then each revised
  * content field's `parse::dropped_construct`, then the writer's `conform::*`.
  * A field that lands rather than revises, on an inserted card or over no stored
- * content, reports no drop.
+ * content, reports no drop. `from` names, for each composable card of the
+ * revised document, the index of the stored card it revises, or `null` for an
+ * inserted card; a stored card no entry names was removed, and only cards of
+ * one `$kind` pair.
  */
 export interface DocumentRevised {
     droppedAnchors: DocumentAnchor[];
     warnings: Diagnostic[];
+    from: (number | null)[];
 }
 
 /**
  * The read `toAnnotatedMarkdown` returns: `toMarkdown`'s markdown with a
- * read-only `<qm-anchor ref="…"></qm-anchor>` at each prose anchor's
- * start its line can hold, and every prose anchor of every body and content
- * field, spelled or not; a table cell's anchors are neither. Each names the
- * `path` of its body or field and the text of the `line` its start sits on,
- * island slots removed.
+ * `<qm-anchor ref="…"></qm-anchor>` at each prose anchor's start its line
+ * can hold, and a `<qm-island ref="…"></qm-island>` token for each island
+ * whose markdown does not read back, which every revise reads back; and every
+ * anchor of every body and content field, spelled or not, a table cell's or
+ * a note's listed unspelled. Each names the `path` of its body or field and
+ * the text of the `line` its start sits on, island slots removed, or of its
+ * cell.
  */
 export interface AnnotatedMarkdown {
     markdown: string;
@@ -282,9 +177,40 @@ export interface AnnotatedMarkdown {
 export interface DocumentAnchor {
     id: string;
     path: string;
+    /** The `$id` of the card `path` names; absent on the main card. */
+    cardId?: string;
     line: string;
 }
 
+/**
+ * An anchor's context at its address (`anchorContexts`, `anchorContext`,
+ * `reattach`): the text-quote selector a host stores beside a comment thread.
+ * `path` is the body or content value's `DocPath` string. `quote` is the
+ * anchored text as stored, an inline island its `U+FFFC` slot and a line break
+ * its `\n`, empty for a point; `prefix` and `suffix` are up to 32 scalar values
+ * of stored text on each side, cut at the value's edges or a cell's. `cardId` is the `$id`
+ * of the card `path` names, absent on the main card: `reattach` finds the card
+ * by it wherever the card now sits, and orphans the selector where no card of
+ * the path's kind holds it.
+ */
+export interface AnchorContext {
+    id: string;
+    path: string;
+    cardId?: string;
+    quote: string;
+    prefix: string;
+    suffix: string;
+}
+
+/**
+ * The receipt of `reattach`: each selector given, in order, either reattached
+ * with its context as read after the write, or orphaned as given.
+ */
+export interface Reattached {
+    reattached: AnchorContext[];
+    orphaned: AnchorContext[];
+}
+
 /**
  * A markdown import (`importMarkdown`): the canonical `content`, and one
  * `parse::dropped_construct` warning per construct it dropped, with no `path`.
@@ -294,106 +220,247 @@ export interface Imported {
     warnings: Diagnostic[];
 }
 
-/** Which side of a same-position insertion `mapPos` lands a point on. */
-export type Assoc = "before" | "after";
+
+
 
 /**
- * A mark edit in final-text coordinates (post-delta, post-line-op). `add` /
- * `remove` are a `ContentMark` under an op, so a held mark spreads in whole;
- * `removeAnchor` drops one identity anchor by id. An `add` of a `link` or a
- * `font_family` replaces the one under its range, and a mark added across a
- * line break reads back as one mark per line. An `add` of an `anchor`
- * requires a non-empty `id` not already live in the field; a collision or the
- * empty id throws.
+ * One rich-text value: a card body or a `richtext` field. Flat `text` where a
+ * `\n` opens a block, `U+2028` is a hard break and `U+FFFC` is an island's
+ * slot; one block record per `\n`-separated segment, each `\n` carrying the
+ * record of the block it opens and `blocks[0]` the first block's; containers
+ * the blocks' paths name; formatting marks; comment anchors; and islands, a
+ * table's cells and a footnote's note each a nested `Content` in its `slots`.
+ * Every part carries an id. Offsets are UTF-16 code units, JavaScript string
+ * indices, into the `text` of the value holding them.
  */
-export type MarkOp =
-| ({ op: "add" | "remove" } & ContentMark)
-| { op: "removeAnchor"; id: string };
+export interface Content {
+    text: string;
+    blocks: ContentBlock[];
+    containers?: ContentContainer[];
+    marks?: ContentMark[];
+    anchors?: ContentAnchor[];
+    islands?: ContentIsland[];
+}
+
+/** A block's record: its kind and attributes, and its container path,
+ *  outermost first. A kind, mark type or island type spelled `x-` and more
+ *  is one this build does not know, held as written: a block reads as a
+ *  paragraph, a mark formats nothing, an island renders as nothing. */
+export type ContentBlock = { id: string; path?: string[] } & ContentBlockKind;
+
+export type ContentBlockKind =
+| { kind: "para" }
+| { kind: "heading"; attrs: { level: number } }
+| { kind: "code"; attrs?: { lang?: string } }
+| { kind: "rule" }
+| { kind: `x-${string}`; attrs?: Record<string, unknown> };
+
+/** A list, a list item or a quote. An item's number is computed, never stored. */
+export type ContentContainer = { id: string } & (
+| { kind: "list"; attrs: { ordered: boolean; start: number } }
+| { kind: "item"; attrs?: { checked?: boolean } }
+| { kind: "quote" }
+);
+
+/** Formatting over `[start, end)`. Same-kind marks union; `link` and
+ *  `font_family` hold one value per character. */
+export type ContentMark = { start: number; end: number } & ContentMarkKind;
+
+export type ContentMarkKind =
+| { type: "strong" | "emph" | "underline" | "strike" | "code" }
+| { type: "link"; attrs: { url: string } }
+| { type: "font_family"; attrs: { name: string } }
+| { type: `x-${string}`; attrs?: Record<string, unknown> };
+
+/** A comment handle over `[start, end)` with a host-minted id; a point when
+ *  the two are equal. */
+export interface ContentAnchor {
+    id: string;
+    start: number;
+    end: number;
+}
+
+/** `props` of a `table` island. `columns` are column ids; each row maps a
+ *  column id to the slot holding its cell. `rows[0]` is the header row, and
+ *  `head` counts header rows from the top, absent at 1. `aligns` and `widths`
+ *  are keyed by column id, `cell_attrs` by slot id. */
+export interface TableProps {
+    columns: string[];
+    rows: { id: string; cells: Record<string, string> }[];
+    head?: number;
+    aligns?: Record<string, "left" | "center" | "right">;
+    widths?: Record<string, number>;
+    align?: "left" | "center" | "right";
+    cell_attrs?: Record<string, {
+        align?: "left" | "center" | "right";
+        valign?: "top" | "middle" | "bottom";
+        colspan?: number;
+        rowspan?: number;
+    }>;
+}
+
+/** An island: the object one `U+FFFC` of `text` stands for. A `table`'s cells
+ *  and a `footnote`'s `note` are its `slots`. */
+export type ContentIsland = { id: string; slots?: Record<string, Content> } & (
+| { type: "table"; props: TableProps }
+| { type: "image"; props: { url: string; alt: string } }
+| { type: "footnote"; props: Record<string, never> }
+| { type: "math"; props: { tex: string; display?: true } }
+| { type: `x-${string}`; props: Record<string, unknown> }
+);
 
 /**
- * A line/block edit. `split`/`join` splice `\n` in post-`delta`,
- * post-`islandOps` coordinates; `setKind`/`setContainers`/`setContinues` touch
- * metadata. `setContinues` sets or clears a line's within-block hard-break flag
- * (`ContentLine.continues`); `continues: true` lands as `false` on line 0, which
- * nothing precedes, on a line whose containers differ from the line above, and
- * on one following a heading, a rule or a block island's line, each a block of
- * one line. `setKind` lands a kind the line's text contradicts — `rule` over
- * prose, `code` over a slot — as `para`, which is what re-importing the line's
- * own markdown yields, and reads an `island` the union does not offer as the
- * `para` that spelling projects. Read the content back to see where an op
- * settled.
+ * An edit: a list of steps, each reading the value the step before it left.
+ * `apply` runs them all or none.
  */
-export type LineOp =
-| { op: "split"; at: number }
-| { op: "join"; line: number }
-| ({ op: "setKind"; line: number } & ContentLineKind)
-| { op: "setContainers"; line: number; containers: ContentContainer[] }
-| { op: "setContinues"; line: number; continues: boolean };
+export interface Change {
+    steps: Step[];
+}
 
 /**
- * An island edit: the only channel that reaches an island's payload, a table's
- * cells or an image's url. Both ops leave the field's text and marks alone, so
- * an island edit keeps every identity anchor in the field.
+ * One step, an object of one key naming it.
  *
- * `set` addresses an existing island by `id`; an unknown `id` throws. `insert`
- * places a new island's slot at `at` together with its entry, so a slot never
- * exists without an island behind it; its `id` must be non-empty and unused.
- * `at` is a position in the text the `delta` and this bundle's earlier island
- * ops left, so slots after `a` and `b` of `abc` go in at 1 and 3. A stale frame
- * misplaces slots and never throws. A `delta` insert string may not carry a
- * slot, which would orphan: split such a splice into the slot-free `delta` plus
- * one `insert` per slot.
+ * - `splice` replaces `delete`, which must be the text at `at`, with `insert`.
+ *   `marks` is the formatting the inserted text carries, offsets into
+ *   `insert`, a mark without `start`/`end` covering all of it; `blocks` the
+ *   record of each block an inserted `\n` opens; `islands` the island of each
+ *   inserted `U+FFFC`. `removed` is what the deleted text held, filled in on
+ *   the receipt's `applied`.
+ * - `setBlock` changes a block's kind, attributes or path.
+ * - `container` adds a container or sets an existing one's attributes, or
+ *   removes one no path names.
+ * - `mark` adds or removes formatting over a range.
+ * - `anchor` places, moves or removes a comment anchor.
+ * - `island` replaces an island's props, or inserts an island's slot at `at`.
+ * - `nested` applies a change inside one slot of an island.
  *
- * Deleting an island needs no op: a `delta` that removes its slot drops the
- * island whole. Re-landing it is an `insert` of the full island under its
- * original id; a pasted copy of a live island mints a fresh one.
- *
- * An island is *inline* (a slot inside a paragraph) or a **block** (that slot
- * alone on its own line), and the type settles which: markdown writes a `table`
- * as a block and an image inline. Both lines read `kind: "para"` — the block is
- * the slot's markup, not a role the line carries — so landing a block island is
- * two channels: `delta` inserts the `\n` that opens the line, `islandOps`
- * inserts the slot. `{ op: "split" }` cannot open that line, since line ops run
- * after island ops.
- *
- * A `table` has no inline placement: markdown writes it as a block, so an
- * `insert` whose `at` is not an empty line throws, as does a `set` retyping an
- * inline island into one. A table already sharing its line, as a `join` or an
- * `overwrite` of merged edits leaves one, stays there and takes its `set`;
- * markdown writes it on a line of its own.
+ * A `mark` step and an `anchor` placement take `quote`, the text their range
+ * covered when the writer read it, and an island insert takes `block`, the id
+ * of the block the writer read `at` in. A step whose `quote` or `block` the
+ * value no longer holds is refused as stale (`edit::content_apply`), as a
+ * splice is whose `delete` the value no longer holds. The receipt's `applied`
+ * fills both in.
  */
-export type IslandOp =
-| ({ op: "set" } & ContentIsland)
-| ({ op: "insert"; at: number } & ContentIsland);
+export type Step =
+| { splice: { at: number; delete?: string; insert: string;
+marks?: ({ start?: number; end?: number } & ContentMarkKind)[];
+blocks?: ContentBlock[]; islands?: ContentIsland[];
+removed?: { blocks?: ContentBlock[]; marks?: ContentMark[]; islands?: ContentIsland[] } } }
+| { setBlock: { id: string; kind?: ContentBlockKind["kind"]; attrs?: Record<string, unknown>; path?: string[] } }
+| { container: ContentContainer | { id: string; remove: true } }
+| { mark: { start: number; end: number; add: boolean; quote?: string } & ContentMarkKind }
+| { anchor: (ContentAnchor & { quote?: string }) | { id: string; remove: true } }
+| { island: { id: string; props: Record<string, unknown>; slots?: Record<string, Content> } | { at: number; island: ContentIsland; block?: string } }
+| { nested: { island: string; slot: string; change: Change } };
 
 /**
- * A committed content edit bundle for `applyChange`, applied in order: a text
- * `delta`, then `islandOps`, then `lineOps`, then `markOps` (mark ranges are in
- * final-text coordinates). Every field is optional.
- *
- * Within each channel ops apply in sequence against the state the earlier ones
- * left: an island `insert`'s `at` counts earlier ops' slots, and `lineOps`
- * positions and indices renumber through earlier `split`/`join`.
- *
- * **Mark rebase.** `delta`, `islandOps` and `lineOps` each move text, and each
- * rebases the marks already in the field by one rule: a range mark's `start`
- * takes assoc `after` and its `end` `before`, so an insertion at either edge
- * grows text *outside* the span; a **zero-width** mark takes `before`, so an
- * insertion at its own position leaves it put. That last case is the one
- * position where the two assocs differ, and where an anchor most often sits.
- *
- * `markOps` name the result, so a caller emitting them predicts this rebase.
- * `mapMarks(content, bundle)` runs it instead: pass the bundle's text-moving
- * channels, diff the marks it returns against the ones you intend, and emit
- * only the difference. Reproducing the rule by hand is a second copy to drift.
+ * What a write did. `applied` is the change in its normalized form, which
+ * `invert(applied, before)` undoes; `hash` is the value's new hash, the next
+ * write's `base`. `droppedAnchors` names each anchor the value held and holds
+ * nowhere now, as it read before: every one a `revise` or `replace` lost, and
+ * for an `apply` every one but those its `anchor` steps removed.
+ * `movedAnchors` names each surviving one whose text the write rewrote.
+ * `warnings` holds a `parse::dropped_construct` per construct a revise's
+ * markdown dropped.
+ * `rebased` says the write's `base` was a value the field had moved on from,
+ * and the write was rebased over what changed since.
  */
-export interface ChangeBundle {
-    delta?: Delta;
-    islandOps?: IslandOp[];
-    lineOps?: LineOp[];
-    markOps?: MarkOp[];
+export interface Receipt {
+    applied: Change;
+    hash: string;
+    droppedAnchors: DroppedAnchor[];
+    movedAnchors: { id: string; before: string; after: string }[];
+    warnings: Diagnostic[];
+    rebased: boolean;
+}
+
+/**
+ * A receipt's dropped anchor: its selector, which `reattach` takes as given,
+ * and the `island` and `slot` that held it, absent for an anchor in the
+ * value's own text.
+ */
+export interface DroppedAnchor extends AnchorContext {
+    island?: string;
+    slot?: string;
+}
+
+/** The hash a writer read. A value that has changed since rebases the write
+ *  over the change, refusing it with `edit::rebase_conflict` where the two
+ *  touch the same text or record, and with `edit::stale_base` where the document no
+ *  longer holds the change since. Pass it: a write without one lands over
+ *  whatever the value now holds. */
+export interface WriteOptions {
+    base?: string;
+}
+
+/** A position in a value: an offset into its text, or one inside an
+ *  island's slot. */
+export type Pos = number | { island: string; slot: string; at: Pos };
+
+/**
+ * Where `mapPos` carried a position, and what around it the change deleted:
+ * the character on its `assoc` side (`deleted`), the one before, the one
+ * after, or both in one deletion (`deletedAcross`).
+ */
+export interface MapResult {
+    pos: Pos;
+    deleted: boolean;
+    deletedBefore: boolean;
+    deletedAfter: boolean;
+    deletedAcross: boolean;
 }
 
+/** What `wrap` opens around the blocks it wraps: a quote, or a list with an
+ *  item per wrapped child, each `checked` as given. */
+export type WrapKind = { kind: "quote" } | { kind: "list"; ordered: boolean; checked?: boolean };
+
+/**
+ * A value as a merge of concurrent edits left it, for `repair`: shaped as
+ * `Content`, its invariants unchecked. `islands` is an array paired with the
+ * slots in order, or an object keyed by island id with `slot_ids` naming the
+ * island each `U+FFFC` carries, `null` for none. An anchor placed as a range
+ * carries `range: true`, since one collapsed to zero width reads as a point
+ * otherwise. An offset inside a character moves to its start, and one past
+ * the text to its end.
+ */
+export interface RawContent {
+    text: string;
+    blocks: ContentBlock[];
+    containers?: ContentContainer[];
+    marks?: ContentMark[];
+    anchors?: (ContentAnchor & { range?: boolean })[];
+    islands?: (ContentIsland & { slots?: Record<string, RawContent> })[]
+    | Record<string, Omit<ContentIsland, "id"> & { slots?: Record<string, RawContent> }>;
+    slot_ids?: (string | null)[];
+}
+
+/**
+ * One mend `repair` made. `inserts` marks one whose write-back inserts text
+ * or a slot, which only a session's single writer writes back; any peer may
+ * write back a report holding none.
+ */
+export type Repair = { inserts?: true } & (
+| { repair: "missing_container"; block: string; container: string }
+| { repair: "two_parents"; container: string }
+| { repair: "split_run"; container: string; fresh: string }
+| { repair: "orphan_slot"; island: string | null }
+| { repair: "orphan_island"; island: string }
+| { repair: "shared_island"; island: string; fresh: string }
+| { repair: "split_block"; island: string; block: string }
+| { repair: "empty_cell"; island: string; slot: string }
+| { repair: "collapsed_anchor"; id: string }
+| { repair: "invalid"; reason: string }
+| { repair: "in_slot"; island: string; slot: string; inner: Repair }
+);
+
+/** What `repair` read a merged value as: the valid `content`, and each
+ *  mend, none for a value already valid. */
+export interface Repaired {
+    content: Content;
+    repairs: Repair[];
+}
+
+
 
 
 /**
@@ -665,22 +732,40 @@ export class Document {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * **Apply** a committed content edit `bundle` at `addr`, the editor splice:
-     * text delta first, then island ops, then line ops, then mark ops (mark
-     * ranges in final-text coordinates), all-or-nothing. An absent `addr.field`
-     * targets the body, an absent `addr.card` the main card. The island channel
-     * moves an island alone, so anchors elsewhere in the field survive an edit
-     * `overwrite` would clear.
-     *
-     * Throws on an out-of-range card, a field that is not richtext, a malformed
-     * bundle, or an op that applies out of bounds; the value is unchanged on a
-     * failed apply.
-     *
-     * Each text-moving channel rebases the marks already in the field, by the
-     * rule on `ChangeBundle`; `mapMarks` answers where they land, so a caller
-     * building `markOps` need not predict it.
+     * The context of the anchor `id`, or `undefined` where no body or
+     * content value holds one.
      */
-    applyChange(addr: Addr | string, bundle: ChangeBundle): void;
+    anchorContext(id: string): AnchorContext | undefined;
+    /**
+     * Every anchor of every body and content value with its context, a table
+     * cell's or a note's included, in the order `toAnnotatedMarkdown` lists
+     * anchors: the selector a host stores beside a comment thread and hands
+     * back to `reattach`.
+     */
+    anchorContexts(): AnchorContext[];
+    /**
+     * The annotated read of the body or richtext field at `addr` alone: the
+     * scoped twin of `toAnnotatedMarkdown`, what a revise at `addr` reads
+     * back and the `baseMarkdown` it merges against. Each anchor names `addr`'s
+     * path. An absent field reads as the empty content. Throws as `hashAt`.
+     */
+    annotatedAt(addr: Addr | string): AnnotatedMarkdown;
+    /**
+     * The markdown at `addr` with a `qm-*` tag for each anchor and island id
+     * its lines can hold: what `revise` reads back. Throws as `read`.
+     */
+    annotated(addr: Addr | string): string;
+    /**
+     * **Apply** `change` to the value at `addr`, all its steps or none, and
+     * answer the `Receipt`. `opts.base` is the hash the writer read
+     * (`hash(addr)`), and the change's offsets are into the value it names:
+     * one the value has moved on from rebases the change over the change
+     * since, throwing `edit::rebase_conflict` where they touch the same text or
+     * record and `edit::stale_base` where the document no longer holds the change
+     * since. A refused change throws `edit::content_apply` and writes
+     * nothing.
+     */
+    apply(addr: Addr | string, change: Change, opts?: WriteOptions): Receipt;
     /**
      * The **body** markdown projection: an on-demand, lossy export (content-only
      * marks do not survive markdown). A body's type is a format fact, not a
@@ -707,11 +792,10 @@ export class Document {
     clone(): Document;
     /**
      * The newest storage version this build writes via
-     * [`toStored`](Document::to_stored): a document spelling a font mark, a
-     * `table` element, a merged table cell or a table head 0.130 cannot draw
-     * carries it, every other the tag before it, which a 0.130 build reads.
-     * The tag advances only when the wire format changes, not on every
-     * release.
+     * [`toStored`](Document::to_stored): a document holding a composable
+     * card, each carrying its `$id`, carries it. A document of the main card
+     * alone carries the oldest tag that holds its content. The tag advances
+     * only when the wire format changes, not on every release.
      */
     static currentStorageVersion(): string;
     /**
@@ -724,7 +808,7 @@ export class Document {
     static fromMarkdown(markdown: string): Document;
     /**
      * Reconstruct a `Document` from a versioned storage DTO string produced by
-     * [`toStored`](Document::to_stored). The result carries no parse-time warnings.
+     * [`toStored`](Document::to_stored), with no `warnings`.
      * Throws if `json` is not a valid storage DTO (malformed JSON, unknown
      * `schema`, missing fields, or unparseable quill reference).
      */
@@ -756,6 +840,23 @@ export class Document {
      * unread, which is the contract and why it is `unknown`.
      */
     getStored(addr: Addr | string): unknown;
+    /**
+     * The hash of the body or richtext field at `addr`, the `baseHash` a
+     * revise at `addr` checks: the hash of its content, an absent field the
+     * empty content. An absent `addr.field` reads the body, an absent
+     * `addr.card` the main card. Richtext only; the
+     * typed `writer.hashAt` reads a field of any type through its schema.
+     * Throws on an out-of-range card, a malformed field name, or a present
+     * non-content field value.
+     */
+    hashAt(addr: Addr | string): string;
+    /**
+     * With no `addr`, the hash of the document's stored form, the quill-free
+     * twin of `writer.hash()`: equal documents hash alike, whatever order a
+     * store kept their keys in. With one, the hash of the `Content` at
+     * `addr`, the `base` a write to it names. Throws as `read`.
+     */
+    hash(addr?: Addr | string): string;
     /**
      * Insert a card: `at` absent appends, a number inserts at that index (in
      * `0..=cards.length`). Accepts any `CardInput`, including a card read back
@@ -764,19 +865,6 @@ export class Document {
      * 1,000 cards.
      */
     insertCard(card: CardInput, at?: number): void;
-    /**
-     * Replace this document's contents **in place** from a versioned storage DTO
-     * string: the mutating twin of [`fromStored`](Document::from_stored).
-     * Parse-time `warnings` are cleared. Throws on an invalid DTO, leaving the
-     * document unchanged. A caller holding the document need not re-bind its
-     * variable.
-     */
-    loadStored(json: string): void;
-    /**
-     * The Quillmark Markdown rules, re-exposed from core. Constant across
-     * calls; read once and cache.
-     */
-    static markdownRules(): string;
     /**
      * Move the card at `from` to position `to`. `from == to` is a no-op.
      */
@@ -789,18 +877,6 @@ export class Document {
      * an invalid quill reference.
      */
     constructor(quill_ref: string);
-    /**
-     * **Overwrite** the content value at `addr` with exactly `rt`: value
-     * semantics, so the identity anchors of any previous value are gone. By
-     * anchor fate `overwrite` destroys, [`revise`](Document::revise) and
-     * [`reviseContent`](Document::revise_content) rebase, and
-     * [`applyChange`](Document::apply_change) preserves. An absent
-     * `addr.field` targets the body, an absent `addr.card` the main card.
-     *
-     * Throws on an out-of-range card, a malformed field name, or an `rt` that is
-     * not a canonical content object.
-     */
-    overwrite(addr: Addr | string, rt: Content): void;
     /**
      * `addr`'s canonical `DocPath` string, the anchor `Diagnostic.path` carries:
      * `pathFor()` is `main.body`, `pathFor("intro")` `main.intro`,
@@ -814,7 +890,7 @@ export class Document {
      * **Total on the index axis**, unlike the `Addr` reads, which throw there:
      * an out-of-range `{card: 7, field: "from"}` renders `cards[7].from`, which
      * parses back and resolves to nothing rather than mis-targeting. Only a
-     * malformed address throws.
+     * malformed address throws, or a card id no card holds.
      */
     pathFor(addr: Addr | string): string;
     /**
@@ -823,6 +899,32 @@ export class Document {
      * messages from this instead of re-stating the rule.
      */
     static quillRefHint(): string;
+    /**
+     * The `Content` at `addr`: an absent `addr.field` reads the body, an
+     * absent `addr.card` the main card, and an absent field the empty
+     * content. Throws on an out-of-range card, a malformed field name, or a
+     * present field value that is not content.
+     */
+    read(addr: Addr | string): Content;
+    /**
+     * Re-add anchors a write dropped, each at the `path` its selector names,
+     * where its `quote` is found exactly once with its context agreeing: four
+     * scalar values of quote or more, or a table's slot alone, eight of
+     * context on each side or the whole context where the value's edge cut
+     * it, and an empty quote a point where the two meet. Never a nearest match. Returns the `Reattached`
+     * receipt.
+     *
+     * A path naming no body or content value orphans its selector, and
+     * nothing remaps a card index. An id live anywhere in the document, a
+     * table cell's included, is answered as reattached and not written. Each
+     * id is answered once, by its first selector. `deltas` maps a path to the
+     * `delta` of the revise that dropped its anchors, and a match there must
+     * overlap text that revise inserted.
+     *
+     * Throws on a selector or delta that is not one, or a `path` that does
+     * not parse.
+     */
+    reattach(selectors: AnchorContext[], deltas?: Record<string, Delta>): Reattached;
     removeCard(index: number): Card | undefined;
     /**
      * Remove the `$ext` map on the card `addr` targets entirely, returning the
@@ -842,36 +944,20 @@ export class Document {
      */
     removeSeedOverlay(card_kind: string): any;
     /**
-     * **Revise** the richtext value at `addr` to `rt`, keeping each stored prose
-     * anchor whose id `rt` does not hold: the content twin of
-     * [`revise`](Document::revise), for a value built elsewhere such as a
-     * merge's projection. Diffs `rt` against the current value, carries those
-     * anchors through the diff, and returns the
-     * `Revised` receipt, whose `delta` an editor bridge maps its own positions
-     * through and whose `warnings` is empty. `rt`'s own anchors and island ids
-     * land as they are. An absent `addr.field` targets the body, an absent
-     * `addr.card` the main card; an absent field diffs from empty. Richtext
-     * only: a `text` field takes `overwrite`.
-     *
-     * Throws on an out-of-range card, a malformed field name, a present
-     * non-content field value, or an `rt` that is not a canonical content
-     * object.
+     * Write `content` over the value at `addr`, carrying each anchor it does
+     * not name where a diff keeps its text and reporting the rest in
+     * `droppedAnchors`. Throws as `apply`, and on a `content` that is not a
+     * `Content`.
      */
-    reviseContent(addr: Addr | string, rt: Content): Revised;
+    replace(addr: Addr | string, content: Content, opts?: WriteOptions): Receipt;
     /**
-     * **Revise** the richtext value at `addr` from a markdown string: the
-     * default write path. Imports the markdown, diffs it against the current
-     * value, rebases surviving identity anchors, and returns the `Revised`
-     * receipt: the text `delta` an editor bridge maps its own positions through
-     * (`mapPos`), and a `parse::dropped_construct` warning per construct the
-     * import dropped, its `path` the address written. An absent `addr.field`
-     * targets the body, an absent `addr.card` the main card; an absent field
-     * cold-imports from empty.
-     *
-     * Throws on an out-of-range card, a malformed field name, a present
-     * non-content field value, or an over-nested markdown input.
+     * Rewrite the value at `addr` as `markdown`: the anchors and islands
+     * whose `qm-*` tags it keeps (`annotated(addr)` spells them) stay put,
+     * and the rest keeps what a word-aligned diff keeps. Answers the
+     * `Receipt`, its `warnings` the import's. Throws as `apply`, and on an
+     * over-nested markdown input.
      */
-    revise(addr: Addr | string, markdown: string): Revised;
+    revise(addr: Addr | string, markdown: string, opts?: WriteOptions): Receipt;
     /**
      * The main card's `$seed[kind]` overlay object, or `undefined`. Feeds
      * `quill.seedCard(kind, overlay)` without serializing the whole main card,
@@ -904,18 +990,10 @@ export class Document {
      * write is [`commitField`](Document::commit_field). A bare string is `Addr`
      * shorthand for `{ field }`; `{ card: 2, field: "qty" }` targets a
      * composable card. A body address throws:
-     * write a body with `revise` / `overwrite`. Throws on an out-of-range card
+     * write a body with `writer.reviseBody` / `replace`. Throws on an out-of-range card
      * or a malformed name.
      */
     storeField(addr: Addr | string, value: any): void;
-    /**
-     * Store several fields verbatim and atomically on the card `addr` targets.
-     * `addr` is a **card address** (`{ card }`, absent = main) and comes first
-     * because `card` is itself a legal field name; a present `field` throws.
-     * Nothing is applied on error, and the thrown error's `diagnostics` carry
-     * one entry per offending field. Throws on an out-of-range card.
-     */
-    storeFields(addr: CardAddr, fields: Record<string, unknown>): void;
     /**
      * Merge a card-kind's seed `overlay` into the **main** card's `$seed` map
      * under `cardKind`, preserving sibling kinds; `$seed` is main-only, so this
@@ -925,10 +1003,11 @@ export class Document {
     storeSeedOverlay(card_kind: string, overlay: any): void;
     /**
      * `toMarkdown` with each prose anchor of every body and content field
-     * spelled read-only at its start where its line can hold the tag, and
-     * listed with its field's path and line either way. An import drops every
-     * tag, so `writer.reviseDocument` with the markdown keeps the anchors it keeps
-     * with `toMarkdown`'s.
+     * spelled at its start where its line can hold the tag, every anchor,
+     * a cell's too, listed with its field's path and line, and each island whose markdown
+     * does not read back spelled as its token. `writer.reviseDocument` reads
+     * both back: a kept tag pins its anchor, and a token keeps its island as
+     * stored.
      */
     toAnnotatedMarkdown(): AnnotatedMarkdown;
     /**
@@ -959,7 +1038,8 @@ export class Document {
      * The non-fatal diagnostics of the load that produced this document: parse
      * warnings, plus `conform::*` warnings when it came through `quill.parse`.
      * Session state, not document value: `equals` and the storage DTO exclude
-     * it, and `fromStored` / `loadStored` / `writer.reviseDocument` clear it.
+     * it. `fromStored` sets it to the stored value's anchor id
+     * collisions, and `writer.reviseDocument` clears it.
      */
     readonly warnings: Diagnostic[];
 }
@@ -1049,11 +1129,6 @@ export class Quill {
      * field's blank).
      */
     seedDocument(): Document;
-    /**
-     * Seed a starter main `Card` (carries `$quill`) from the schema: the
-     * `$kind: main` card of [`seedDocument`](Self::seed_document) alone.
-     */
-    seedMain(): Card;
     /**
      * `doc` as an authoring document: every field in the values form (each
      * content leaf its codec's text), every body as Markdown, each card
@@ -1115,6 +1190,20 @@ export class Quill {
     readonly warnings: Diagnostic[];
 }
 
+/**
+ * Deleting `[start, end)`: the splice, and where the range runs from a
+ * block's start into a later block, the `setBlock` giving the block that
+ * keeps the text the shape of the block the range ends in.
+ */
+export function deleteRange(content: Content, start: number, end: number): Change;
+
+/**
+ * A change taking `before` to `after`, word-aligned, for a writer with no
+ * steps of its own. Throws `edit::content_apply` where `after` is not a
+ * valid value.
+ */
+export function diff(before: Content, after: Content): Change;
+
 /**
  * Export canonical `Content` to its markdown projection. Throws if `rt` is not
  * canonical content.
@@ -1142,14 +1231,35 @@ export function formatDiagnostic(diagnostic: Diagnostic): string;
 export function formatDocPath(segs: DocPathSeg[]): string;
 
 /**
- * Import a markdown string: the pure, document-free codec. Returns the
+ * Import a markdown string: the markdown codec's import, pure and document-free. Returns the
  * canonical `content` and a `parse::dropped_construct` warning per construct
- * the import dropped, with no `path`. `overwrite(addr, importMarkdown(md).content)`
- * spells the cold, anchor-losing write; prefer `revise` for edit semantics.
+ * the import dropped, with no `path`. `replace(addr, importMarkdown(md).content)`
+ * spells the cold write; prefer `revise` for edit semantics.
  * Throws on an over-nested input.
  */
 export function importMarkdown(markdown: string): Imported;
 
+/**
+ * Tab over the blocks `first` to `last` (`first` alone when absent): the
+ * change nesting their items under the item before them. Throws
+ * `edit::content_apply` where `first` is in no item, the range leaves its
+ * list, or its first item is the list's first.
+ */
+export function indent(content: Content, first: string, last?: string | null): Change;
+
+/**
+ * Typing at `at`: the formatting the typed text carries, for a splice's
+ * `marks`, in canonical order. Throws `edit::content_apply` where `at` is
+ * past the text.
+ */
+export function inheritedMarks(content: Content, at: number): ContentMarkKind[];
+
+/**
+ * The change that undoes `change` on `before`. Throws `edit::content_apply`
+ * where `change` does not apply to `before`.
+ */
+export function invert(change: Change, before: Content): Change;
+
 /**
  * Whether `content` satisfies the one-line constraint of `text` and
  * `richtext`: one `Para` line, in no container, with no islands. Judged on
@@ -1167,41 +1277,36 @@ export function isInline(content: Content): boolean;
 export function isPlain(content: Content): boolean;
 
 /**
- * Where `bundle`'s text-moving channels (`delta`, then `islandOps`, then
- * `lineOps`) leave `content`'s marks: the final-text coordinates the bundle's
- * `markOps` are written in, under the rebase rule stated on `ChangeBundle`.
- * The document-free read an editor diffs against to decide which `markOps` to
- * emit, rather than reproducing that rule in its own language.
- *
- * `bundle.markOps` are ignored. The answer is normalized, as the store's is:
- * marks a text move drops (out of range, zero-width formatting) are absent,
- * and same-kind runs a move left adjacent arrive already unioned, so a bundle
- * carrying no `markOps` names the marks the field will hold.
- * Throws on a non-content `content`, a malformed bundle, or an op that applies
- * out of bounds: `applyChange`'s errors on the same ops.
+ * Backspace at the start of block `id`: the change joining it onto the block
+ * before it, under that block's record. Throws `edit::content_apply` for the
+ * first block or an id no block holds.
  */
-export function mapMarks(content: Content, bundle: ChangeBundle): ContentMark[];
+export function joinBlocks(content: Content, id: string): Change;
 
 /**
- * Map a base content position (a USV index into `Content.text`, not a UTF-16
- * offset) through a `delta` to its new position, holding a caret stable across
- * a `revise`. `assoc` decides the side of a same-position insertion (`"after"`
- * moves past it). Throws on a malformed `delta`.
- *
- * This maps a position the *caller* holds. For the marks already in a field,
- * `mapMarks` applies the store's own assoc rule across every channel of a
- * `ChangeBundle`.
+ * Where `pos` lands after `change`, and what around it the change deleted;
+ * `assoc` (`"after"` by default) picks the side of text inserted at it.
+ * Throws `edit::content_apply` where a splice deletes an island and names
+ * none in `removed`, as the receipt's `applied` always does.
  */
-export function mapPos(delta: Delta, pos: number, assoc: Assoc): number;
+export function mapPos(change: Change, pos: Pos, assoc?: "before" | "after"): MapResult;
 
 /**
- * The canonical form of `rt`: the content `overwrite` stores from it, read
+ * The canonical form of `rt`: the content `replace` stores from it, read
  * without a document. Normalizing rewrites structure, never the text, so the
- * answer's `text` is `rt.text`. Throws where `overwrite` would, with the same
+ * answer's `text` is `rt.text`. Throws where `replace` would, with the same
  * error under this verb's name.
  */
 export function normalize(rt: Content): Content;
 
+/**
+ * Shift-Tab over the blocks `first` to `last` (`first` alone when absent):
+ * the change lifting them out of the innermost item or quote holding
+ * `first`. Throws `edit::content_apply` where `first` is in neither or the
+ * range leaves it.
+ */
+export function outdent(content: Content, first: string, last?: string | null): Change;
+
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
  * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so
@@ -1211,13 +1316,18 @@ export function normalize(rt: Content): Content;
 export function parseDocPath(path: string): DocPathSeg[];
 
 /**
- * Rebase `markdown` onto a `base` content: the document-free twin of `revise`,
- * returning the new `content`, the text `delta` (offsets are USV indices into
- * `Content.text`, surviving anchors rebased), and the import's
- * `parse::dropped_construct` warnings, with no `path`. Throws on an
- * over-nested markdown input or a non-content `base`.
+ * The valid value every peer holding the merged state `raw` reads, and what
+ * was mended to reach it: total and deterministic, every id it mints derived
+ * from the ids involved. Throws only on a `raw` not shaped as content.
+ */
+export function repair(raw: RawContent): Repaired;
+
+/**
+ * Enter at `at`: the change splitting the block holding `at` there, the new
+ * block `newId` and the text keeping its id. Throws `edit::content_apply`
+ * where `at` is past the text.
  */
-export function rebase(base: Content, markdown: string): { content: Content; delta: Delta; warnings: Diagnostic[] };
+export function splitBlock(content: Content, at: number, newId: string): Change;
 
 /**
  * Runs at instantiation, so a Rust panic reaches the console as a stack trace
@@ -1226,21 +1336,37 @@ export function rebase(base: Content, markdown: string): { content: Content; del
  */
 export function start(): void;
 
+/**
+ * The change wrapping the blocks `first` to `last` in a quote or a list,
+ * around the children of their innermost shared item or quote that the range
+ * touches; a list the range sits in is wrapped whole.
+ */
+export function wrap(content: Content, first: string, last: string, kind: WrapKind): Change;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_document_free: (a: number, b: number) => void;
     readonly __wbg_quill_free: (a: number, b: number) => void;
+    readonly deleteRange: (a: number, b: number, c: number, d: number) => void;
+    readonly diff: (a: number, b: number, c: number) => void;
     readonly document__addCard: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly document__commitField: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document__commitFields: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document__hash: (a: number, b: number, c: number) => void;
+    readonly document__hashAt: (a: number, b: number, c: number, d: number) => void;
     readonly document__readerGet: (a: number, b: number, c: number, d: number) => void;
     readonly document__readerGetContent: (a: number, b: number, c: number, d: number) => void;
     readonly document__readerGetContentAt: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly document__reviseDocument: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly document_applyChange: (a: number, b: number, c: number, d: number) => void;
+    readonly document__revise: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly document__reviseDocument: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly document_anchorContext: (a: number, b: number, c: number, d: number) => void;
+    readonly document_anchorContexts: (a: number, b: number) => void;
+    readonly document_annotated: (a: number, b: number, c: number) => void;
+    readonly document_annotatedAt: (a: number, b: number, c: number) => void;
+    readonly document_apply: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
     readonly document_card: (a: number, b: number, c: number) => void;
     readonly document_cardCount: (a: number) => number;
@@ -1253,28 +1379,28 @@ export interface InitOutput {
     readonly document_fromStored: (a: number, b: number, c: number) => void;
     readonly document_getExt: (a: number, b: number, c: number) => void;
     readonly document_getStored: (a: number, b: number, c: number) => void;
+    readonly document_hash: (a: number, b: number, c: number) => void;
+    readonly document_hashAt: (a: number, b: number, c: number) => void;
     readonly document_insertCard: (a: number, b: number, c: number, d: number) => void;
-    readonly document_loadStored: (a: number, b: number, c: number, d: number) => void;
     readonly document_main: (a: number, b: number) => void;
-    readonly document_markdownRules: (a: number) => void;
     readonly document_moveCard: (a: number, b: number, c: number, d: number) => void;
     readonly document_new: (a: number, b: number, c: number) => void;
-    readonly document_overwrite: (a: number, b: number, c: number, d: number) => void;
     readonly document_pathFor: (a: number, b: number, c: number) => void;
     readonly document_quillRef: (a: number, b: number) => void;
     readonly document_quillRefHint: (a: number) => void;
+    readonly document_read: (a: number, b: number, c: number) => void;
+    readonly document_reattach: (a: number, b: number, c: number, d: number) => void;
     readonly document_removeCard: (a: number, b: number, c: number) => void;
     readonly document_removeExt: (a: number, b: number, c: number) => void;
     readonly document_removeField: (a: number, b: number, c: number) => void;
     readonly document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
-    readonly document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly document_reviseContent: (a: number, b: number, c: number, d: number) => void;
+    readonly document_replace: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_revise: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
     readonly document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
     readonly document_storageVersionOf: (a: number, b: number, c: number) => void;
     readonly document_storeExt: (a: number, b: number, c: number, d: number) => void;
     readonly document_storeField: (a: number, b: number, c: number, d: number) => void;
-    readonly document_storeFields: (a: number, b: number, c: number, d: number) => void;
     readonly document_storeSeedOverlay: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly document_toAnnotatedMarkdown: (a: number, b: number) => void;
     readonly document_toMarkdown: (a: number, b: number) => void;
@@ -1284,11 +1410,15 @@ export interface InitOutput {
     readonly formatDiagnostic: (a: number, b: number) => void;
     readonly formatDocPath: (a: number, b: number) => void;
     readonly importMarkdown: (a: number, b: number, c: number) => void;
+    readonly indent: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly inheritedMarks: (a: number, b: number, c: number) => void;
+    readonly invert: (a: number, b: number, c: number) => void;
     readonly isInline: (a: number, b: number) => void;
     readonly isPlain: (a: number, b: number) => void;
-    readonly mapMarks: (a: number, b: number, c: number) => void;
+    readonly joinBlocks: (a: number, b: number, c: number, d: number) => void;
     readonly mapPos: (a: number, b: number, c: number, d: number) => void;
     readonly normalize: (a: number, b: number) => void;
+    readonly outdent: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly parseDocPath: (a: number, b: number, c: number) => void;
     readonly quill__resolve: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quill_authoringSchema: (a: number, b: number) => void;
@@ -1304,14 +1434,15 @@ export interface InitOutput {
     readonly quill_schema: (a: number, b: number) => void;
     readonly quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly quill_seedDocument: (a: number) => number;
-    readonly quill_seedMain: (a: number, b: number) => void;
     readonly quill_toAuthoring: (a: number, b: number, c: number) => void;
     readonly quill_toBundle: (a: number, b: number) => void;
     readonly quill_toTree: (a: number) => number;
     readonly quill_validate: (a: number, b: number, c: number) => void;
     readonly quill_warnings: (a: number, b: number) => void;
-    readonly rebase: (a: number, b: number, c: number, d: number) => void;
+    readonly repair: (a: number, b: number) => void;
+    readonly splitBlock: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly start: () => void;
+    readonly wrap: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;