@quillmark/svelte 0.10.1 → 0.12.0

package/dist/visual/diagnostics.js

@@ -1,4 +1,4 @@
-import { nearestAddrForFieldPath } from '../core/address.js';
+import { nearestAddrForFieldPath, nestedAddrForFieldPath } from '../core/address.js';
 /** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
 export function fieldKeyToString(k) {
     return `${k.card ?? 'main'}:${k.field ?? '$body'}`;
@@ -42,11 +42,53 @@ export function routeAndResolve(diagnostics, cardIds) {
     }
     return out;
 }
+/** A field's routed diagnostics, each with its steps past the field: none for a
+ *  diagnostic anchored at the field itself, or one whose path is not a nested one
+ *  (a local commit error carries the field's own path). */
+export function deepen(diagnostics) {
+    return (diagnostics ?? []).map((d) => ({
+        steps: (d.path && nestedAddrForFieldPath(d.path)?.steps) || [],
+        diagnostic: d
+    }));
+}
+export function splitDeep(list) {
+    const here = [];
+    const below = new Map();
+    for (const d of list ?? []) {
+        if (d.steps.length === 0) {
+            here.push(d.diagnostic);
+            continue;
+        }
+        const [step, ...rest] = d.steps;
+        const bucket = below.get(step);
+        const next = { steps: rest, diagnostic: d.diagnostic };
+        if (bucket)
+            bucket.push(next);
+        else
+            below.set(step, [next]);
+    }
+    return { here, below };
+}
+/** The diagnostics a rung cannot hand down: the ones anchored here, plus every one
+ *  whose next step names nothing in `held`. Drawn at the rung's own foot, so a leaf the
+ *  tree does not draw still has its message read somewhere the user can see. */
+export function unrouted(split, held) {
+    const out = [...split.here];
+    for (const [step, list] of split.below)
+        if (!held(step))
+            for (const d of list)
+                out.push(d.diagnostic);
+    return out;
+}
 /**
  * Merge N routed groups into `Map<fieldKeyToString(key), Diagnostic[]>`.
- * Dedupes an identical `(severity, message)` pair landing on the same key from
+ * Dedupes an identical `(path, severity, message)` quad landing on the same key from
  * more than one group (e.g. the same error present in both `validate()` and
  * an external feed). Producer order within a key.
+ *
+ * The key is the field, but the walk past it is the `path`'s ({@link deepen}), so two
+ * cells of one container share a key and differ only there: without `path` in the
+ * quad, one message failing two rows draws on the first row alone.
  */
 export function mergeDiagnostics(...groups) {
     const byKey = new Map();
@@ -54,9 +96,14 @@ export function mergeDiagnostics(...groups) {
     for (const group of groups) {
         for (const { key, diagnostic } of group) {
             const k = fieldKeyToString(key);
-            // Collision-proof key: JSON-encode the triple so arbitrary `message` text
-            // can never merge two distinct triples into one (a real diagnostic dropped).
-            const dedupeKey = JSON.stringify([k, diagnostic.severity, diagnostic.message]);
+            // Collision-proof key: JSON-encode the quad so arbitrary `message` text
+            // can never merge two distinct quads into one (a real diagnostic dropped).
+            const dedupeKey = JSON.stringify([
+                k,
+                diagnostic.path ?? null,
+                diagnostic.severity,
+                diagnostic.message
+            ]);
             if (seen.has(dedupeKey))
                 continue;
             seen.add(dedupeKey);

package/dist/visual/ext.d.ts

@@ -4,23 +4,22 @@ import type { Document, CardAddr } from '@quillmark/wasm';
  * main). A key whose patch value is `undefined` is dropped; every other key in the
  * namespace is carried through untouched.
  *
- * **The namespace is the write unit.** `storeExtNamespace` replaces the namespace
- * it targets (preserving sibling namespaces, but not sibling keys) so a writer
- * that stores only its own key silently destroys the others, and
- * `removeExtNamespace` destroys all of them. `tips` and `title` are siblings here,
- * so a namespace-replacing dismissal would wipe every renamed card's title. Routing
- * every writer through this function is what makes that unexpressible rather than
- * merely documented: key N+1 inherits the merge instead of re-deriving it.
+ * **The whole map is the write unit.** `storeExt` replaces `$ext` entire, so a writer
+ * that stores only its own key silently destroys every sibling namespace, and a
+ * namespace-replacing write destroys the sibling keys inside it. `tips` and `title`
+ * are siblings here, so either would wipe every renamed card's title. Routing every
+ * writer through this function is what makes that unexpressible rather than merely
+ * documented: key N+1 inherits the merge instead of re-deriving it.
  *
  * The drop is an explicit `delete`, not a stored `undefined`: whether a JS
  * `undefined` survives the wasm-bindgen crossing is not a property worth depending
  * on.
  *
- * **A namespace emptied of keys is removed, not stored empty.** That is
- * `removeExtNamespace`'s one correct use: it takes the whole namespace, and there is
- * nothing left in this one to lose. `$ext` goes with it when `editor` was the last
- * namespace, so a document nothing has renamed or hinted carries no editor slot
- * rather than an empty one. A patch dropping keys the namespace does not have writes
- * nothing, so dismissing tips on a document that carries none is not a mutation.
+ * **A namespace emptied of keys is removed, not stored empty**, and `$ext` goes with
+ * it when `editor` was the last namespace — `removeExt` being the one call that drops
+ * the map, where `storeExt({})` records an explicit empty one. So a document nothing
+ * has renamed or hinted carries no editor slot rather than an empty one. A patch
+ * dropping keys the namespace does not have writes nothing, so dismissing tips on a
+ * document that carries none is not a mutation.
  */
 export declare function patchEditorExt(doc: Document, addr: CardAddr, patch: Record<string, unknown>): void;

package/dist/visual/ext.js

@@ -3,29 +3,27 @@
  * main). A key whose patch value is `undefined` is dropped; every other key in the
  * namespace is carried through untouched.
  *
- * **The namespace is the write unit.** `storeExtNamespace` replaces the namespace
- * it targets (preserving sibling namespaces, but not sibling keys) so a writer
- * that stores only its own key silently destroys the others, and
- * `removeExtNamespace` destroys all of them. `tips` and `title` are siblings here,
- * so a namespace-replacing dismissal would wipe every renamed card's title. Routing
- * every writer through this function is what makes that unexpressible rather than
- * merely documented: key N+1 inherits the merge instead of re-deriving it.
+ * **The whole map is the write unit.** `storeExt` replaces `$ext` entire, so a writer
+ * that stores only its own key silently destroys every sibling namespace, and a
+ * namespace-replacing write destroys the sibling keys inside it. `tips` and `title`
+ * are siblings here, so either would wipe every renamed card's title. Routing every
+ * writer through this function is what makes that unexpressible rather than merely
+ * documented: key N+1 inherits the merge instead of re-deriving it.
  *
  * The drop is an explicit `delete`, not a stored `undefined`: whether a JS
  * `undefined` survives the wasm-bindgen crossing is not a property worth depending
  * on.
  *
- * **A namespace emptied of keys is removed, not stored empty.** That is
- * `removeExtNamespace`'s one correct use: it takes the whole namespace, and there is
- * nothing left in this one to lose. `$ext` goes with it when `editor` was the last
- * namespace, so a document nothing has renamed or hinted carries no editor slot
- * rather than an empty one. A patch dropping keys the namespace does not have writes
- * nothing, so dismissing tips on a document that carries none is not a mutation.
+ * **A namespace emptied of keys is removed, not stored empty**, and `$ext` goes with
+ * it when `editor` was the last namespace — `removeExt` being the one call that drops
+ * the map, where `storeExt({})` records an explicit empty one. So a document nothing
+ * has renamed or hinted carries no editor slot rather than an empty one. A patch
+ * dropping keys the namespace does not have writes nothing, so dismissing tips on a
+ * document that carries none is not a mutation.
  */
 export function patchEditorExt(doc, addr, patch) {
-    // `getExtNamespace` reads just this namespace rather than serializing the whole
-    // card to fish out one `$ext` slot.
-    const current = doc.getExtNamespace(addr, 'editor');
+    const ext = doc.getExt(addr) ?? {};
+    const current = ext.editor;
     const next = { ...(current ?? {}) };
     for (const [key, value] of Object.entries(patch)) {
         if (value === undefined)
@@ -34,7 +32,12 @@ export function patchEditorExt(doc, addr, patch) {
             next[key] = value;
     }
     if (Object.keys(next).length > 0)
-        doc.storeExtNamespace(addr, 'editor', next);
-    else if (current)
-        doc.removeExtNamespace(addr, 'editor');
+        doc.storeExt(addr, { ...ext, editor: next });
+    else if (current) {
+        const { editor: _editor, ...rest } = ext;
+        if (Object.keys(rest).length > 0)
+            doc.storeExt(addr, rest);
+        else
+            doc.removeExt(addr);
+    }
 }

package/dist/visual/hold.js

@@ -2,7 +2,7 @@
 // the layout, and what fills the viewport as a section collapses is that section's own
 // content, whose top never moves.
 import { flushSync } from 'svelte';
-import { rungMs } from './motion.js';
+import { rungMs, rungStyle } from '../core/rungs.js';
 /**
  * Run `change` and keep `anchor` inside the fold for the length of the move.
  *
@@ -26,7 +26,7 @@ export function holdInView(anchor, change) {
     flushSync();
     const reveal = () => anchor.scrollIntoView({ block: 'nearest', behavior: 'instant' });
     reveal();
-    const rung = rungMs(getComputedStyle(anchor), '--_qm-duration-slow');
+    const rung = rungMs(rungStyle(anchor), '--_qm-duration-slow');
     if (rung === undefined)
         return;
     const until = performance.now() + rung;

package/dist/visual/icons/nodes.d.ts

@@ -116,6 +116,9 @@ export declare const ICONS: {
     readonly minus: readonly [readonly ["path", {
         readonly d: "M5 12h14";
     }]];
+    readonly check: readonly [readonly ["path", {
+        readonly d: "M20 6 9 17l-5-5";
+    }]];
 };
 /** The closed set. A name that is not here is a compile error at the call site,
  *  which is what a string key buys over thirteen imported components. */

package/dist/visual/icons/nodes.js

@@ -63,5 +63,6 @@ export const ICONS = {
         ['path', { d: 'M3 6h18' }],
         ['path', { d: 'M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2' }]
     ],
-    minus: [['path', { d: 'M5 12h14' }]]
+    minus: [['path', { d: 'M5 12h14' }]],
+    check: [['path', { d: 'M20 6 9 17l-5-5' }]]
 };

package/dist/visual/index.js

@@ -25,7 +25,6 @@ export { createField } from '../core/codec/index.js';
 // it. The empty body's per-card hook is the `bodyPlaceholder` key inside it.
 export { DEFAULT_VISUAL_STRINGS } from './strings.js';
 // The `$ext.editor` write unit. A consumer seeding editor-side chrome
-// state (a card title, the tips channel) goes through this rather than
-// `storeExtNamespace`, which replaces the namespace and takes the sibling keys with
-// it.
+// state (a card title, the tips channel) goes through this rather than `storeExt`,
+// which replaces the whole map and takes every sibling with it.
 export { patchEditorExt } from './ext.js';

package/dist/visual/leaves.d.ts

@@ -1,4 +1,12 @@
+import type { PathStep } from '@quillmark/wasm';
 import type { FieldController } from '../core/codec/index.js';
+/**
+ * What a landing at depth hands back: the box the arrival wash blooms in, now or once
+ * the row it had to open has rendered. A row two closed boxes down does not exist
+ * until the row above it opens and flushes, so the innermost box is a promise wherever
+ * the walk had to open something on the way.
+ */
+export type LandingBox = HTMLElement | undefined | Promise<HTMLElement | undefined>;
 /**
  * A mounted field's landing handle: focus it, and the element the arrival wash blooms
  * inside ({@link import('../core/bloom.js').bloomInside}).
@@ -10,22 +18,27 @@ import type { FieldController } from '../core/codec/index.js';
 export interface FieldControl {
     focus(): void;
     /**
-     * Land in element `index` of a control that has elements, at USV `pos` where the
-     * row's control can take one; resolving the index to the element's session id at
-     * the call, with {@link focus}'s own answer for an index past the live list. Absent
-     * on every control without elements.
+     * Land at `steps` inside a control that has an inside — an array's element, an
+     * object's property, a variant's cell, a matrix's member, and any of them under any
+     * other — at USV `pos` where the leaf the walk ends in can take one. Each rung
+     * resolves its own step at the call (an index to a session id, a key to a mounted
+     * cell) and hands the rest to the control it opened, so nothing positional is
+     * carried. A step the tree does not hold falls back to that rung's own
+     * {@link focus}: the field is right and the row is gone. Absent on every control
+     * with no inside.
      *
      * A landing, not a focus: an absent `pos` is the placement rung, exactly as on
-     * `Landing`, and what a `pos` means is the row control's, the same way focusing is.
-     * The place rides the call because the registry stays parent-keyed: a per-element
-     * key is positional, in a registry whose doctrine is dodging positional churn.
+     * `Landing`, and what a `pos` means is the leaf's, the same way focusing is. The
+     * place rides the call because the registry stays parent-keyed: a per-element key is
+     * positional, in a registry whose doctrine is dodging positional churn.
      *
-     * Returns the element's own box, which is what the wash blooms in: the address
-     * named one row, and a wash over the whole repeater says the field where the click
-     * said the row. `undefined` is the fallback the index past the live list took, and
-     * reads as {@link el}.
+     * Returns the innermost row the address named, which is what the wash blooms in: a
+     * box wider than the one the click resolved says the field where the pick said the
+     * row. `undefined` is a landing that named no row — a property under a field-level
+     * subform, or the fallback an index past the live list took — and reads as
+     * {@link el}.
      */
-    focusElement?(index: number, pos?: number): HTMLElement | undefined;
+    focusPath?(steps: readonly PathStep[], pos?: number): LandingBox;
     readonly el: HTMLElement;
 }
 /**

package/dist/visual/links.d.ts

@@ -9,6 +9,10 @@ import type { Command, EditorState } from 'prosemirror-state';
  * A rooted value is left alone, being the spelling that asks for the embedding
  * page, and so is anything already carrying a scheme the link mark renders.
  *
+ * `localhost:5173` names a host too, and `SCHEME` reads its host as the scheme: a
+ * colon followed by a port is a host with a port, so it takes the host prefix rather
+ * than the refusal a scheme nothing renders gets.
+ *
  * `''` for a blank value and for a scheme the mark renders inert, both being nothing
  * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
  * own exit rather than storing a link that draws as plain text.

package/dist/visual/links.js

@@ -1,4 +1,4 @@
-import { rendersHref } from '../core/codec/index.js';
+import { rendersHref, storableUrl } from '../core/codec/index.js';
 /** A scheme: a letter, then letters, digits, `+`, `-` or `.`, then `:` (RFC 3986). */
 const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 /** Rooted at the page rather than at a host: an absolute path, a query, a fragment,
@@ -6,6 +6,9 @@ const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 const ROOTED = /^[/#?]/;
 /** A bare mail address: one `@`, no scheme and no path. */
 const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
+/** A host carrying a port, which spells a scheme to `SCHEME` and is not one: what
+ *  follows the colon is digits, and no scheme the mark renders takes a port. */
+const HOST_PORT = /^[a-z0-9.-]+:\d+([/?#]|$)/i;
 /**
  * The href a typed value stands for. A value with no scheme names a host, and
  * stored verbatim it is a relative href resolving against whatever page the editor
@@ -16,15 +19,23 @@ const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
  * A rooted value is left alone, being the spelling that asks for the embedding
  * page, and so is anything already carrying a scheme the link mark renders.
  *
+ * `localhost:5173` names a host too, and `SCHEME` reads its host as the scheme: a
+ * colon followed by a port is a host with a port, so it takes the host prefix rather
+ * than the refusal a scheme nothing renders gets.
+ *
  * `''` for a blank value and for a scheme the mark renders inert, both being nothing
  * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
  * own exit rather than storing a link that draws as plain text.
  */
 export function normalizeHref(raw) {
-    const value = raw.trim();
-    if (!value || !rendersHref(value))
+    const value = storableUrl(raw.trim());
+    if (!value)
+        return '';
+    if (!rendersHref(value) && !HOST_PORT.test(value))
         return '';
-    if (SCHEME.test(value) || ROOTED.test(value))
+    if (SCHEME.test(value) && rendersHref(value))
+        return value;
+    if (ROOTED.test(value))
         return value;
     return ADDRESS.test(value) ? `mailto:${value}` : `https://${value}`;
 }

package/dist/visual/motion.d.ts

@@ -3,11 +3,20 @@ import type { AnimationConfig } from 'svelte/animate';
  *  position for its whole length, so anything that measures the node's box waits on
  *  these rather than reading the one a transform is holding. */
 export declare function reorderTrips(node: HTMLElement): Animation[];
-/** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
- *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
- *  empty). No rung, no motion: a fallback here would be the scale restated in the one
- *  place `check:style` cannot read. */
-export declare function rungMs(style: CSSStyleDeclaration, rung: string): number | undefined;
+/**
+ * The reorder gesture's arming window, for a keyed list that takes the trip. The
+ * reconcile that moves a slot is the trip, and every other reconcile that happens to
+ * move one is not; so the command arms the gesture and the frame it lands in disarms
+ * it, `animate:` asking at apply time, a microtask after the mutation and well inside
+ * that frame. `armed` is a getter rather than a value, so the flag stays out of the
+ * template and needs no reactivity for it. `cancel` is for the surface's teardown.
+ */
+export interface ReorderArm {
+    arm(): void;
+    armed(): boolean;
+    cancel(): void;
+}
+export declare function reorderArm(): ReorderArm;
 /**
  * Slide a keyed slot from where it was to where it now is.
  *

package/dist/visual/motion.js

@@ -4,6 +4,7 @@
 // cannot see (the rects either side of the reconciliation) and WAAPI paints the trip,
 // the same seam `core/bloom.ts` takes to keep a duration in the derivation while a
 // script runs the animation.
+import { rungMs, rungStyle } from '../core/rungs.js';
 /** Marks this module's runs, so a second reorder cancels the first rather than layering
  *  a second transform over it. */
 const RUN_ID = 'qm-reorder';
@@ -15,16 +16,17 @@ export function reorderTrips(node) {
         return [];
     return node.getAnimations().filter((run) => run.id === RUN_ID);
 }
-/** A duration rung off `style`, in ms; `undefined` where the derivation is out of reach
- *  (an unstyled root, or jsdom, where `getComputedStyle` reports custom properties as
- *  empty). No rung, no motion: a fallback here would be the scale restated in the one
- *  place `check:style` cannot read. */
-export function rungMs(style, rung) {
-    const raw = style.getPropertyValue(rung).trim();
-    const n = Number.parseFloat(raw);
-    if (!Number.isFinite(n))
-        return undefined;
-    return raw.endsWith('ms') ? n : n * 1000;
+export function reorderArm() {
+    let reordering = false;
+    let frame = 0;
+    return {
+        arm() {
+            reordering = true;
+            frame = requestAnimationFrame(() => (reordering = false));
+        },
+        armed: () => reordering,
+        cancel: () => cancelAnimationFrame(frame)
+    };
 }
 /**
  * Slide a keyed slot from where it was to where it now is.
@@ -45,7 +47,7 @@ export function reorder(node, { from, to }, armed) {
     // rung the derivation mints.
     if (!armed() || typeof node.animate !== 'function')
         return {};
-    const style = getComputedStyle(node);
+    const style = rungStyle(node);
     const duration = rungMs(style, '--_qm-duration-slow');
     const easing = style.getPropertyValue('--_qm-ease-reverse').trim();
     if (duration === undefined || !easing)

package/dist/visual/strings.d.ts

@@ -16,27 +16,37 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     cardTitle: string;
     /** The trailing strip's visible words, which are also every strip's accessible
      * name; the plus rides the wording. One string over
-     * one kind and many: the trigger seeds A card, and which kind is the menu's word
+     * one kind and many: the trigger seeds a card, and which kind is the menu's word
      * to say or the schema's to have already settled. */
     addCard: string;
     arrayAdd: string;
     arrayRemove: string;
-    /** The tag on the unset sentinel's row, which is what tells it from the member it
-     *  ghosts ({@link EnumField}). */
-    enumUnsetTag: string;
+    /** The reorder pair on an `object` row, accessible names: the buttons are glyphs. */
+    arrayMoveUp: string;
+    arrayMoveDown: string;
+    /**
+     * A row control's accessible name, the action and the row it acts on: `Remove
+     * Authors 2`. The action alone stays the tooltip. Parametric, so word order stays
+     * the translator's.
+     */
+    arrayRowAction: (action: string, row: string) => string;
     /**
-     * What stands where a subform declines to recurse — a nested `array` or `object`
-     * property, whose own figure would nest a field past the depth this one draws —
-     * and where to edit that property instead. The whole sentence, since a translator
-     * orders the kind within it.
+     * The count beside the add chip on an array declaring `max:`, the carrier a
+     * disabled chip has no other way to state: `2 / 3`. Parametric, so a translator
+     * spells the separator.
      */
-    nestedUnsupported: (kind: string) => string;
+    arrayCount: (count: number, max: number) => string;
     /**
-     * A collapsed array element whose first text property is empty: the label and the
+     * A collapsed array element with nothing to summarize itself by: the label and the
      * 1-based index, which is what its accessible name already says. Parametric, so
      * word order stays the translator's.
      */
     elementUntitled: (label: string, index: number) => string;
+    /** The tag on the unset sentinel's row, which is what tells it from the member it
+     *  ghosts ({@link EnumField}). */
+    enumUnsetTag: string;
+    /** The count in the matrix's label row: how many of the roster are held. */
+    matrixHeld: (held: number, total: number) => string;
     /** The required marker's accessible name; the glyph itself is a `*`. */
     fieldRequired: string;
     formatGroup: string;
@@ -64,6 +74,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     retypeLabel: string;
     retypePlaceholder: string;
     noCardKinds: string;
+    /** The body leaf's accessible name: no label names it, the body being the one
+     *  surface in a card that is paper ({@link Card}). */
+    bodyLabel: string;
     /**
      * The flat built-in invitation: the package's own words, kept to the one thing
      * true of every body so it claims nothing about the card it sits in.
@@ -91,9 +104,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
  * - **`edit::field_coercion_failed`**: re-words from the app's own control state, the
  *   refused value being in neither document (unchanged on throw) nor schema.
  * - **`parse::yaml_error_with_location`, `invalid_structure`**: does not re-word. No
- *   `path`, and `args` carries the location (`blockIndex`, `line`) and nothing else,
- *   engine prose riding under no key: the parser's own text, its column and its caret
- *   snippet exist only inside `message`.
+ *   `path`; `args` names the block (`blockIndex`) and `location` places the failure in
+ *   the document's own coordinates, engine prose riding under no key: the parser's own
+ *   text, its column and its caret snippet exist only inside `message`.
  * - **`LiveSession.warnings`**: does not re-word. Backend text, an external feed.
  *
  * The last two are the boundary's shape, not a gap in it, so the fallback arm is

package/dist/visual/strings.js

@@ -30,9 +30,13 @@ export const DEFAULT_VISUAL_STRINGS = {
     addCard: '+ Add Card',
     arrayAdd: '+ Add',
     arrayRemove: 'Remove',
-    enumUnsetTag: 'default',
-    nestedUnsupported: (kind) => `A nested ${kind} — edit this field in the source view.`,
+    arrayMoveUp: 'Move up',
+    arrayMoveDown: 'Move down',
+    arrayRowAction: (action, row) => `${action} ${row}`,
+    arrayCount: (count, max) => `${count} / ${max}`,
     elementUntitled: (label, index) => `${label} ${index}`,
+    enumUnsetTag: 'default',
+    matrixHeld: (held, total) => `${held} of ${total} held`,
     fieldRequired: 'required',
     formatGroup: 'Formatting',
     formatBold: 'Bold (Mod-B)',
@@ -55,6 +59,7 @@ export const DEFAULT_VISUAL_STRINGS = {
     retypeLabel: 'Change to',
     retypePlaceholder: 'Choose a type…',
     noCardKinds: 'This document declares no card types — delete this card to remove it.',
+    bodyLabel: 'Body',
     bodyGhost: 'Write…',
     bodyPlaceholder: () => undefined
 };