@quillmark/svelte 0.11.0 → 0.13.0

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/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/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

@@ -21,24 +21,40 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     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;
+    /** What an unset optional cell (`t?`) ghosts at rest: the `none` it prints
+     *  unanswered, in the product's words. */
+    optionalGhost: string;
+    /** Under a prose leaf holding more structure than it can edit (paragraphs, a list,
+     *  an island in a one-line cell), which it draws read-only rather than flatten. */
+    proseHeld: string;
     formatGroup: string;
     formatBold: string;
     formatEmphasis: string;
@@ -74,7 +90,8 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     bodyGhost: string;
     /**
      * Per-CARD wording, in place of {@link VisualStrings.bodyGhost}; `undefined`
-     * takes it. Pure and uncached ({@link BodyPlaceholder}).
+     * takes it. A body `default:` and the kind's `body.example` both outrank it
+     * (`resolveBodyGhost`). Pure and uncached ({@link BodyPlaceholder}).
      */
     bodyPlaceholder: BodyPlaceholder;
 }

package/dist/visual/strings.js

@@ -30,10 +30,16 @@ 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',
+    optionalGhost: 'None',
+    proseHeld: 'Holds more than this field can edit here.',
     formatGroup: 'Formatting',
     formatBold: 'Bold (Mod-B)',
     formatEmphasis: 'Emphasis (Mod-I)',

package/dist/visual/structure.d.ts

@@ -1,6 +1,9 @@
-import type { PayloadItem, QuillCardSchema, QuillFieldSchema, ResolvedField, Resolved } from '@quillmark/wasm';
+import { type Content, type PathStep, type PayloadItem, type QuillCardSchema, type QuillFieldSchema, type QuillFieldType, type ResolvedField, type Resolved } from '@quillmark/wasm';
 /** The control a field type maps to (VISUAL_EDITOR §"Structure mirrors the schema"). */
-export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object' | 'matrix';
+/** The container controls: the ones a nested address walks into and a deep
+ *  diagnostic routes through. */
+export declare function isContainer(kind: ControlKind): boolean;
 /** One field, projected: its schema, the control it renders as, and its layout hints. */
 export interface FieldModel {
     name: string;
@@ -11,7 +14,7 @@ export interface FieldModel {
     /** `ui.compact`: asks to share a row with adjacent compacts. A request, not a
      * guarantee: `placeFields` declines it for the shapes that grow (see `packable`). */
     compact: boolean;
-    /** Display label: `ui.title` when set, else the humanized field name. */
+    /** Display label: `title` when set, else the humanized field name. */
     label: string;
     /** Schema `description`: authoring help rendered beside the label,
      * undefined when the field declares none. Chrome-only; never gates. */
@@ -53,7 +56,8 @@ export interface CardModel {
     unschemable: boolean;
     /** Raw `$ext.editor.title` override (composable cards). */
     titleOverride: string;
-    /** Schema-resolved title used as the rename placeholder (composable cards). */
+    /** The header an unrenamed card shows ({@link cardTitle} below its rename rung),
+     *  which the rename input ghosts (composable cards). */
     titlePlaceholder: string;
     /** Field name → current stored value (absent fields missing). */
     values: Record<string, unknown>;
@@ -67,12 +71,11 @@ export interface CardModel {
     sections: GroupSection[];
     hasBody: boolean;
     /**
-     * The empty-body ghost, or undefined when the card renders no body. Never
-     * empty for a card that does: the resolved body `default:` when there is one,
-     * else the consumer's wording, else the built-in invitation
-     * ({@link resolveBodyGhost}). A body leaf therefore always has something in it
-     * to write into, which the inline fields deliberately do not: their ghost is
-     * the resolved default, and an invented one would read as a value.
+     * The empty-body ghost, or undefined when the card renders no body. Never empty
+     * for a card that does ({@link resolveBodyGhost}), so a body leaf always has
+     * something in it to write into, which a field at rest deliberately does not: it
+     * draws what prints or what its quill declares, and an invented ghost would read as
+     * a value.
      */
     bodyGhost?: string;
 }
@@ -101,15 +104,14 @@ export declare const NO_RESOLVED_ROWS: ResolvedCardRows;
  * form).
  */
 export declare function resolvedByCardIndex(resolved: Resolved | undefined): Map<number, ResolvedCardRows>;
-/** The ghost a field shows when unset: the resolved `default:` value the render
- * would use (`source === 'default'`), else undefined: an `authored` field shows
- * its value, a `zero` field has no default to ghost. */
+/** What an unset field shows of its `default:`: the resolved value the render would
+ * use (`source === 'default'`), else undefined: an `authored` field shows its value,
+ * a `blank` field has no default to show. */
 export declare function ghostDefault(row: ResolvedField | undefined): unknown;
 /** A ghost value's string form, or undefined for null/object (only text ghosts
- * render a placeholder). The one text-ghost projection: a scalar field's
- * placeholder and a body leaf's both read `stringifyGhost ∘
- * ghostDefault`, since a richtext body resolves to a text render: the correct
- * thing to display as a placeholder (FIELD_PROVENANCE). */
+ * render a placeholder). A scalar's resolved default reads through it; a content
+ * field's resolves as `Content`, which a prose leaf reads by its text instead
+ * ({@link titleText}). */
 export declare function stringifyGhost(ghost: unknown): string | undefined;
 /** What a {@link BodyPlaceholder} is told about the body it words. The card's
  *  identity, not its chrome: `cardId` is what per-card wording keys off, `kind` keys
@@ -136,21 +138,137 @@ export interface BodyPlaceholderContext {
  */
 export type BodyPlaceholder = (ctx: BodyPlaceholderContext) => string | undefined;
 /**
- * The empty body's ghost: the resolved body `default:`, else the consumer's
- * wording, else the flat built-in. The `default:` wins because it is the only one
- * of the three that describes the render: it promises what prints if nothing is
- * written, and wording placed over it would make that promise unreadable. The
- * other two are invitations, and an invitation belongs only where there is no
- * promise.
+ * The empty body's ghost: the resolved body `default:`, else the kind's
+ * `body.example`, else the consumer's wording, else the flat built-in. The
+ * `default:` wins because it is the only one that describes the render: it promises
+ * what prints if nothing is written, and wording placed over it would make that
+ * promise unreadable. The rest are invitations, and an invitation belongs only where
+ * there is no promise; the quill's own comes first, being the one an agent working
+ * from the blueprint sees too.
  */
-export declare function resolveBodyGhost(resolvedDefault: string | undefined, custom: string | undefined, builtIn: string): string;
+export declare function resolveBodyGhost(resolvedDefault: string | undefined, example: string | undefined, custom: string | undefined, builtIn: string): string;
+/** Whether a cell is optional: a `t?` type, which renders `none` unanswered and so
+ *  never declares a `default:` (canon `SCHEMAS.md` §"Optional cells"). */
+export declare function optionalCell(f: QuillFieldSchema): boolean;
+/** The type a cell's control reads: the declared one, an optional cell's `?` stripped.
+ *  The `?` moves the render floor and nothing else, so every read of a type is this. */
+export declare function baseType(f: QuillFieldSchema): QuillFieldType;
+/**
+ * A value the schema declares, as ghost text: a `default:`, an `example:` or a
+ * `body.example`. Markdown — a `richtext` value — ghosts as the text it renders, one
+ * block to a line, as a resolved default does ({@link titleText}); anything else as
+ * itself. `undefined` for a blank or a non-scalar.
+ */
+export declare function declaredGhost(v: unknown, markdown: boolean): string | undefined;
+/**
+ * A scalar `default:` as the text an unset control holds, where it prints: as
+ * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
+ * nothing a reader sees, so a control holds none and draws its example instead.
+ */
+export declare function printedText(v: unknown): string | undefined;
+/**
+ * A declared content literal as the `Content` it holds: a `richtext` one's markdown
+ * imported, a `plaintext` one's text taken literally, one paragraph whose later lines
+ * continue it, as the literal codec reads a stored one. What a cell's static
+ * `default:` stands in its leaf as, where no resolved row reaches it. `undefined` for
+ * a blank or a non-scalar.
+ */
+export declare function declaredContent(v: unknown, markdown: boolean): Content | undefined;
+/**
+ * The `example:` an unset free-text cell ghosts: a `string`, `plaintext` or `richtext`
+ * whose `default:` prints nothing. Every other type takes none. A default that prints
+ * dominates, standing in the control as the value it is; a type-empty one, the
+ * skippable marker, prints nothing and leaves the example the only thing to draw.
+ */
+export declare function exampleGhost(f: QuillFieldSchema): string | undefined;
+/** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
+ *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
+ *  name remounts the field, where a kept leaf would commit on the old schema. */
+export declare function mountKey(name: string, f: QuillFieldSchema): string;
 /** Map a field schema to its control (precedence: prose › enum › text › …).
  * An array's element control is this over `items`: a missing `items` is a text
  * element. */
 export declare function controlKind(f: QuillFieldSchema): ControlKind;
-/** The discriminant cell of a variant container (`VARIANT_DISCRIMINANT_KEY` upstream,
- *  which the boundary does not export). Reserved: no variant may declare it. */
-export declare const VARIANT_DISCRIMINANT = "value";
+/** The discriminant cell of a variant container, off the boundary's own constant: it
+ *  crosses inside untyped container data with no type to read it off, so a literal here
+ *  would be a second spelling of a reserved key. No variant may declare it. */
+export declare const VARIANT_DISCRIMINANT: "value";
+/** The tick cell of a matrix member, the second reserved key beside the discriminant.
+ *  The boundary synthesizes it on every member and exports no constant for it, so this
+ *  is where the package spells it once (canon `SCHEMAS.md` §Matrix). */
+export declare const MATRIX_HELD = "held";
+/** One member of the roster: its id and its title. */
+export interface MatrixMember {
+    id: string;
+    title: string;
+}
+/** The roster's members, in declaration order. Own keys only: a schema map is indexed
+ *  by a document-supplied id, and `'toString' in members` is true of every roster. */
+export declare function matrixMembers(roster: Record<string, string> | undefined): MatrixMember[];
+/** A member's stored payload, off the sparse map by own key: a document key can be
+ *  spelled `constructor`. */
+export declare function memberValue(map: Record<string, unknown> | undefined, id: string): unknown;
+/**
+ * Whether a stored member is held. A bare scalar is the tick and a mapping is the member
+ * object, whose `held` cell resolves as every absent cell does, to its `default:` of
+ * `false` (canon `SCHEMAS.md` §Matrix): an absent key is unheld, a bare `true` is held,
+ * and a member object is held only where its `held` cell says so. The spellings the
+ * engine coerces to false — `false`, `0`, `"false"`, `null` — read false here; every other
+ * present scalar reads held, so a document the engine would refuse still draws the tick
+ * its spelling claims.
+ */
+export declare function matrixHeld(stored: unknown): boolean;
+/** A member's columns: the member object with its `held` cell taken out, `{}` for the
+ *  bare and absent spellings. What the columns subform takes as its value. */
+export declare function matrixColumns(stored: unknown): Record<string, unknown>;
+/**
+ * The map after one member moves: `next` written under `id`, or the key dropped where
+ * `next` is `undefined`; a map left holding nothing is an unset field. Every other
+ * member rides through in the spelling the document had, so a stored `cyber_200: true`
+ * stays `true` while its neighbour is edited.
+ */
+export declare function commitMember(map: Record<string, unknown> | undefined, id: string, next: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+/**
+ * The member a tick or an edit writes. Held with columns is the member object with an
+ * explicit `held: true`; unheld keeps the columns under `held: false`, so tick, type,
+ * untick, retick loses nothing; unheld with no columns is `undefined`, the key dropped.
+ * Which columns are blank is the engine's rule and not restated here: a column control
+ * that clears drops its key (`ObjectField`), so a member emptied by hand arrives with no
+ * columns and only then leaves the map.
+ */
+export declare function memberWrite(held: boolean, columns: Record<string, unknown>): Record<string, unknown> | undefined;
+/** The `object` a matrix member desugars to, for the schema walk: `held` beside the
+ *  declared columns. Composed here because the boundary serializes the roster alone. */
+export declare function matrixMemberSchema(matrix: QuillFieldSchema): QuillFieldSchema;
+/** Whether `id` is on the roster. */
+export declare function matrixDeclares(matrix: QuillFieldSchema, id: string): boolean;
+/**
+ * The schema at `steps` under `field`, or `undefined` where the schema declares no such
+ * place: an index under an `array`, a key under an `object`'s properties, a member id
+ * under a `matrix` and a key under that member, a cell of any world (or the
+ * discriminant) under a variant-bearing `enum`. The editor's copy of the boundary's
+ * `schema_at`, held here because the landing lane checks an address against the schema
+ * before it asks the mounted tree for it (VISUAL_EDITOR §Surface).
+ */
+export declare function schemaAt(field: QuillFieldSchema, steps: readonly PathStep[]): QuillFieldSchema | undefined;
+/** Whether a cell is one line tall by declaration: the shape a table column and a row
+ *  summary can hold. A prose cell is one where it declares `inline`, `richtext` or
+ *  `plaintext` alike. */
+export declare function shortCell(sub: QuillFieldSchema): boolean;
+/** A collapsed row's own words ({@link firstShortText}); `undefined` while the row has
+ *  nothing to say for itself. */
+export declare function rowSummary(items: QuillFieldSchema | undefined, row: unknown): string | undefined;
+/** How an `array` draws its elements. */
+export type ArrayLayout = 'list' | 'table';
+/**
+ * The layout an array takes: `'table'` where the array's own `ui.layout` asks for it
+ * and every cell of the row is short (a block prose cell declines it, at load width and
+ * every width after), else `'list'`. That every column is a leaf is the loader's
+ * contract (`quill::table_column_not_flat`); whether a leaf fits a cell is the surface's
+ * answer (canon `SCHEMAS.md`): a table composes by position, so a row that would stack
+ * inside a cell is not one.
+ */
+export declare function arrayLayout(field: QuillFieldSchema): ArrayLayout;
 /**
  * Which world's cells to draw: the authored discriminant when the container carries
  * one, else the ghosted default's member — an unset field renders its `default:`, so a
@@ -170,12 +288,13 @@ export declare function variantCells(schema: QuillFieldSchema, member: string |
 export declare function commitDiscriminant(value: Record<string, unknown> | undefined, member: string | undefined): Record<string, unknown> | undefined;
 /**
  * Whether the schema obliges a cell: `default:`'s absence, which is the whole of the
- * obligation (DOCUMENT_MODEL). A typed dictionary is exempt — a namespace declares no
- * `default:` at all, and `validate` anchors obligation on the leaves under it, so
- * reading one off the container would mark every subform required.
+ * obligation (DOCUMENT_MODEL). Exempt are the cells whose absence of one says nothing:
+ * a typed dictionary and a matrix, since a namespace declares no `default:` at all and
+ * `validate` anchors obligation on the leaves under it; and an optional cell, which can
+ * declare none, its unanswered render being `none`.
  */
 export declare function obliged(schema: QuillFieldSchema): boolean;
-/** `foo_bar` → `Foo bar`: the label fallback when a field declares no `ui.title`. */
+/** `foo_bar` → `Foo bar`: the label fallback when a field declares no `title`. */
 export declare function humanize(name: string): string;
 /** Project a card schema's `fields` map (declaration = key order) into models. */
 export declare function fieldModels(cardSchema: QuillCardSchema): FieldModel[];
@@ -235,19 +354,19 @@ export interface PlacedField {
 export declare function placeFields(fields: FieldModel[]): PlacedField[];
 /** A card's field values by key, off its payload items. */
 export declare function fieldValues(items: readonly PayloadItem[]): Record<string, unknown>;
-/** Interpolate a `{field}` card-title template against live field values. */
-export declare function interpolateTitle(template: string, values: Record<string, unknown>): string;
 /** A field value as title text. A parsed field rests as the authored string and a
  *  committed one as `Content`, whose `text` is the same words; a scalar reads as
- *  itself and any other container as nothing. */
+ *  itself; a variant container reads as its discriminant member, the one cell of it
+ *  that names the world; any other container as nothing. */
 export declare function titleText(v: unknown): string;
-/** The field names a `{field}` title reads. */
-export declare function titleFields(template: string | undefined): string[];
+/** A card kind's name: its schema `title`, else the humanized kind. What names a kind
+ *  before there is an instance of it: the add menu, the retype select. */
+export declare function kindTitle(cardSchema: QuillCardSchema | undefined, kind: string): string;
 /**
- * Resolve a card instance's header title: the per-instance `$ext.editor.title`
- * override wins; else the schema `ui.title` (literal or `{field}` template
- * interpolated); else the humanized kind. Empty overrides fall through so a
- * cleared rename reverts to the schema title.
+ * A card instance's header: the per-instance `$ext.editor.title` rename; else the
+ * kind's schema `title`, which names every instance alike; else the instance's own
+ * first short text cell ({@link firstShortText}); else the humanized kind. Empty
+ * renames fall through, so a cleared rename reverts to what the schema says.
  */
 export declare function cardTitle(cardSchema: QuillCardSchema | undefined, kind: string, values: Record<string, unknown>, extTitle: string | undefined): string;
 /** Whether a card kind renders a body leaf: gated by `body.enabled !== false`. */