@quillmark/svelte 0.12.0 → 0.13.0

package/dist/visual/TextField.svelte

@@ -1,12 +1,17 @@
 <!--
- A `string` field → text input. Commits a non-empty edit live (on input) via the
- parent's typed `writer.set`, so the preview tracks typing. A cleared field is the
- unset rung of the commitment ladder (VISUAL_EDITOR §"Structure mirrors the schema"): it
- commits `undefined` (the parent removes the field, ghosted `default:` renders):
- but at `change` (blur), not per keystroke, so select-all-and-retype doesn't flash
- the field through its default between the delete and the first typed char.
- Trade-off (recorded in VISUAL_EDITOR): an explicit empty string over a non-empty
- default is inexpressible from the UI: clear and unset collapse to one gesture.
+ A `string` field → text input. Commits every edit live (on input) via the parent's
+ typed `writer.set`, so the preview tracks typing.
+
+ An unset field whose `default:` prints holds that default as its text, at the
+ default rung (theme.css): the value it prints, drawn as one and a step off a written
+ one. Nothing is written until an edit, which writes the whole text as authored: the
+ default taken, whatever the edit left of it. Tabbing through writes nothing; a
+ keystroke typed and removed pins the default.
+
+ An emptied input writes what empty means for this field (VISUAL_EDITOR §"The
+ commitment ladder"): `""` over a default that prints, the only answer that prints empty there;
+ the unset rung elsewhere, where unset already prints nothing and the field stays
+ unanswered, and an optional cell returns to `none`.
 -->
 <script lang="ts">
 	import { syncedLocal } from './synced.svelte.js';
@@ -14,7 +19,14 @@
 
 	interface Props {
 		value: string | undefined;
+		/** The resolved `default:` where it prints: the text an unset field holds. */
+		fallback?: string;
+		/** Words at rest about an unset field that holds no text: the `None` an optional
+		 * cell prints. */
 		placeholder?: string;
+		/** An unset field's `example:` (`exampleGhost`): drawn wherever the field holds no
+		 * text, and in `placeholder`'s stead while the input holds the focus. */
+		example?: string;
 		/** Accessible name for an input nothing else names: an array element, whose
 		 * name is the field label plus its 1-based index. A field's own input takes
 		 * `id` instead and is named by the `<label for>` beside it. */
@@ -29,11 +41,17 @@
 		 * array repeater's Enter/Backspace (`ArrayField`). */
 		onKey?: (e: KeyboardEvent) => void;
 	}
-	let { value, placeholder, label, id, describedBy, onCommit, onKey }: Props = $props();
+	let { value, fallback, placeholder, example, label, id, describedBy, onCommit, onKey }: Props =
+		$props();
 
-	// Local input state synced to `value`: own-typing stays local, only an external
-	// change reconciles back in (see `syncedLocal`).
-	const local = syncedLocal(() => value ?? '');
+	// Local input state synced to `value`, or to the default an unset field holds:
+	// own-typing stays local, only an external change reconciles back in (see
+	// `syncedLocal`).
+	const local = syncedLocal(() => value ?? fallback ?? '');
+	const defaulted = $derived(value == null && !!fallback && local.value === fallback);
+
+	let focused = $state(false);
+	const ghost = $derived(focused ? (example ?? placeholder) : (placeholder ?? example));
 
 	let inputEl: HTMLInputElement | undefined = $state();
 	/** Take the caret: what a parent placing focus on this control calls. */
@@ -48,16 +66,15 @@
 	type="text"
 	value={local.value}
 	{id}
-	{placeholder}
+	placeholder={ghost}
+	data-default={defaulted ? '' : undefined}
 	aria-label={id ? undefined : label}
 	aria-describedby={describedBy}
 	onkeydown={onKey}
+	onfocus={() => (focused = true)}
+	onblur={() => (focused = false)}
 	oninput={(e) => {
 		local.value = (e.currentTarget as HTMLInputElement).value;
-		// Live-commit a non-empty edit; defer a cleared field to `change` (see header).
-		if (local.value !== '') onCommit(local.value);
-	}}
-	onchange={() => {
-		if (local.value === '') onCommit(undefined);
+		onCommit(local.value !== '' ? local.value : fallback ? '' : undefined);
 	}}
 />

package/dist/visual/TextField.svelte.d.ts

@@ -1,7 +1,14 @@
 import './controls.css';
 interface Props {
     value: string | undefined;
+    /** The resolved `default:` where it prints: the text an unset field holds. */
+    fallback?: string;
+    /** Words at rest about an unset field that holds no text: the `None` an optional
+     * cell prints. */
     placeholder?: string;
+    /** An unset field's `example:` (`exampleGhost`): drawn wherever the field holds no
+     * text, and in `placeholder`'s stead while the input holds the focus. */
+    example?: string;
     /** Accessible name for an input nothing else names: an array element, whose
      * name is the field label plus its 1-based index. A field's own input takes
      * `id` instead and is named by the `<label for>` beside it. */

package/dist/visual/VariantField.svelte

@@ -116,6 +116,7 @@
 		value={discriminant}
 		values={schema.values ?? []}
 		fallback={ghostMember}
+		blankTitle={schema.ui?.blank_title}
 		{id}
 		{describedBy}
 		onCommit={(v) => onCommit(commitDiscriminant(value, v))}

package/dist/visual/VisualEditorInner.svelte

@@ -50,20 +50,21 @@
 		IdSeq,
 		controlKind,
 		isContainer,
+		shortCell,
 		schemaAt,
 		fieldModels,
 		groupOrder,
 		groupSections,
 		groupLabel,
 		cardTitle,
-		titleFields,
+		kindTitle,
 		fieldValues,
 		bodyEnabled,
-		humanize,
 		provenanceMap,
 		resolvedByCardIndex,
 		ghostDefault,
-		stringifyGhost,
+		declaredGhost,
+		titleText,
 		resolveBodyGhost,
 		NO_RESOLVED_ROWS,
 		type CardModel,
@@ -286,24 +287,22 @@
 		onChange?.({ source: 'prose', cardId, path: pathFor(plain) });
 	}
 
-	/** A card's header after a prose commit to a field its `{field}` title names: the
-	 *  one piece of the model that lane changes, held beside the model and dropped on
-	 *  the next bump, which rebuilds it from the document. The kind is the derived
-	 *  tree's ({@link liveKinds}), so the document is read only for a title that
-	 *  names the field. */
+	/** A header named by the card's own values, after a prose commit to one that can name
+	 *  it: the one piece of the model that lane moves, held beside the model and dropped
+	 *  on the next bump, which rebuilds it from the document. The card is read only for a
+	 *  one-line prose field of a kind declaring no `title` (`cardTitle`). */
 	let liveTitles = $state<Record<CardId, string>>({});
 	function refreshTitle(addr: Addr, cardId: CardId): void {
 		const { card: at, field } = addr;
-		if (field == null) return;
-		const shown = at == null ? model.main : model.cards[at];
-		if (!shown) return;
-		const cardSchema = at == null ? quill.schema.main : quill.schema.card_kinds?.[shown.kind];
-		if (!titleFields(cardSchema?.ui?.title).includes(field)) return;
-		const live = at == null ? doc.main : doc.cards[at];
-		if (!live) return;
+		if (at == null || field == null) return;
+		const shown = model.cards[at];
+		const cardSchema = shown && quill.schema.card_kinds?.[shown.kind];
+		if (!cardSchema || cardSchema.title?.trim()) return;
+		const sub = Object.hasOwn(cardSchema.fields, field) ? cardSchema.fields[field] : undefined;
+		if (!sub || !shortCell(sub)) return;
 		liveTitles = {
 			...liveTitles,
-			[cardId]: cardTitle(cardSchema, shown.kind, fieldValues(live.payloadItems), undefined)
+			[cardId]: cardTitle(cardSchema, shown.kind, fieldValues(doc.card(at).payloadItems), undefined)
 		};
 	}
 	function titled(c: CardModel): CardModel {
@@ -328,11 +327,11 @@
 		const keyStr = fieldKeyToString(key);
 		try {
 			if (value === undefined) {
-				// The unset rung of the commitment ladder (VISUAL_EDITOR §"Structure mirrors
-				// the schema"): removing the field leaves the engine's authored › `default:`
-				// › blank-fill resolve to render the default, where writing one bakes a
-				// snapshot the schema cannot track (canon SCHEMAS.md: the engine never
-				// persists a default; nor do we). Removal writes no value, so there is
+				// The unset rung (VISUAL_EDITOR §"The commitment ladder"): removing the field
+				// leaves the engine's authored › `default:` › blank-fill resolve to render the
+				// default, where writing one bakes a snapshot the schema cannot track (canon
+				// SCHEMAS.md: the engine never writes a default; the editor writes one only
+				// as the edit that takes it). Removal writes no value, so there is
 				// nothing for a schema to conform and the lane is the quill-free one.
 				if (isMain) {
 					doc.removeField(name);
@@ -612,7 +611,8 @@
 			// still across a re-derive because the function does.
 			bodyGhost: hasBody
 				? resolveBodyGhost(
-						stringifyGhost(ghostDefault(rows.body ?? undefined)),
+						titleText(ghostDefault(rows.body ?? undefined)) || undefined,
+						declaredGhost(cardSchema?.body?.example, true),
 						merged.bodyPlaceholder?.({ cardId: id, kind, isMain }),
 						merged.bodyGhost
 					)
@@ -858,7 +858,7 @@
 	<div class="qm-primary">
 		<Card
 			bind:this={mainCard}
-			card={titled(model.main)}
+			card={model.main}
 			{doc}
 			{quill}
 			isFirst={true}
@@ -957,7 +957,7 @@
 							<div class="qm-menu-surface" data-qm-root>
 								{#each kinds as k (k)}
 									<DropdownMenu.Item class="qm-menu-item" onSelect={() => addCard(atIndex, k)}
-										>{humanize(k)}</DropdownMenu.Item
+										>{kindTitle(quill.schema.card_kinds?.[k], k)}</DropdownMenu.Item
 									>
 								{/each}
 							</div>

package/dist/visual/controls.css

@@ -105,14 +105,25 @@
 	width: 100%;
 	box-sizing: border-box;
 }
-/* The native placeholder is the label rung, not the UA's own grey: a text or
-   number control's placeholder is the resolved `default:` (Field's `defaultStr`),
-   which is content and reads at a content's contrast. What says shown-never-written
-   is the step from the `ink` a written value takes, the same step the prose leaf's
-   empty state reads (`ProseField`). */
+/* An unset field's text where its `default:` prints (`TextField`, `NumberField`, a
+   prose leaf): the value, at the default rung, so it reads as an answer and never as a
+   written one. The first edit writes it and the rung goes with the attribute. */
+:where(.qm-input[data-default], .ProseMirror[data-default]) {
+	color: var(--_qm-ink-default);
+}
+/* The native placeholder is the label rung, not the UA's own grey: what an input
+   ghosts is words about a value it does not hold — an `example:`, `None` — which is
+   content and reads at a content's contrast, the same step the prose leaf's ghost
+   reads (`prose.css`). */
 :where(.qm-input)::placeholder {
 	color: var(--_qm-ink-label);
 }
+/* The note a held prose leaf draws inside its box, under the text it is about. */
+:where(.qm-prose-held-note) {
+	display: block;
+	font-size: var(--_qm-text-label);
+	color: var(--_qm-ink-label);
+}
 
 /* The second recipe, and it is not the box above: a field is a box because you
  type into it. A button rests with no fill; the surface arrives on hover, off the

package/dist/visual/strings.d.ts

@@ -49,6 +49,12 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     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;
@@ -84,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

@@ -38,6 +38,8 @@ export const DEFAULT_VISUAL_STRINGS = {
     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,4 +1,4 @@
-import { type PathStep, type PayloadItem, type QuillCardSchema, type QuillFieldSchema, type ResolvedField, type 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' | 'matrix';
 /** The container controls: the ones a nested address walks into and a deep
@@ -14,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. */
@@ -56,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>;
@@ -70,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;
 }
@@ -104,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
@@ -139,14 +138,53 @@ 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. */
@@ -214,15 +252,11 @@ export declare function matrixDeclares(matrix: QuillFieldSchema, id: string): bo
  */
 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 `plaintext` leaf is inline at the codec whatever it declares. */
+ *  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: `items.ui.title` interpolated with the row's values
- * where the schema declares one, else the first short text cell in declaration order
- * — a `string`, or an inline `richtext` / `plaintext` — read through {@link titleText};
- * `undefined` while the row has nothing to say for itself. `title` sits on `items.ui`,
- * describing a row, where `layout` sits on the array's own `ui`, describing the array.
- */
+/** 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';
@@ -254,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 and a matrix are 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[];
@@ -319,20 +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; 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`. */