@quillmark/svelte 0.12.0 → 0.14.0

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`. */

package/dist/visual/structure.js

@@ -1,10 +1,11 @@
 // The schema × payload join, done by the editor (VISUAL_EDITOR §Structure). Pure
 // functions only (no runes, no Document reads) so the ordering, control
-// dispatch, group layout, title interpolation, and session-identity bookkeeping
+// dispatch, group layout, titles, ghosts, and session-identity bookkeeping
 // are unit-testable in isolation (tests/visual/structure.test.ts). The reactive
 // orchestration (revision counter, live doc reads) lives in VisualEditor.svelte;
 // this module is the projection math it feeds.
 import { VARIANT_DISCRIMINANT_KEY } from '@quillmark/wasm';
+import { core } from '../core/lifecycle.js';
 /** The container controls: the ones a nested address walks into and a deep
  *  diagnostic routes through. */
 export function isContainer(kind) {
@@ -33,36 +34,112 @@ export const NO_RESOLVED_ROWS = { fields: [], body: null };
 export function resolvedByCardIndex(resolved) {
     return new Map((resolved?.cards ?? []).map((c) => [c.index, { fields: c.fields, body: c.body }]));
 }
-/** 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 function ghostDefault(row) {
     return row?.source === 'default' ? row.value : undefined;
 }
 /** 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 function stringifyGhost(ghost) {
     return ghost != null && typeof ghost !== 'object' ? String(ghost) : 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 function resolveBodyGhost(resolvedDefault, custom, builtIn) {
-    return resolvedDefault || custom || builtIn;
+export function resolveBodyGhost(resolvedDefault, example, custom, builtIn) {
+    return resolvedDefault || example || custom || builtIn;
+}
+/** Whether a cell is optional: a `t?` type, which renders `none` unanswered and so
+ *  never declares a `default:` (canon `SCHEMAS.md` §"Optional cells"). */
+export function optionalCell(f) {
+    return f.type.endsWith('?');
+}
+/** 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 function baseType(f) {
+    return (optionalCell(f) ? f.type.slice(0, -1) : f.type);
+}
+/**
+ * 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 function declaredGhost(v, markdown) {
+    const text = stringifyGhost(v)?.trim();
+    if (!text)
+        return undefined;
+    return (markdown ? core().importMarkdown(text).text.trim() : text) || 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 function printedText(v) {
+    const text = stringifyGhost(v);
+    return text?.trim() ? text : 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 function declaredContent(v, markdown) {
+    const text = printedText(v);
+    if (text === undefined)
+        return undefined;
+    if (markdown)
+        return core().importMarkdown(text);
+    return {
+        text,
+        lines: text
+            .split('\n')
+            .map((_, i) => i === 0
+            ? { containers: [], kind: 'para' }
+            : { containers: [], kind: 'para', continues: true }),
+        marks: [],
+        islands: []
+    };
+}
+/**
+ * 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 function exampleGhost(f) {
+    const kind = controlKind(f);
+    if (kind !== 'text' && kind !== 'prose')
+        return undefined;
+    const markdown = baseType(f) === 'richtext';
+    if (declaredGhost(f.default, markdown) !== undefined)
+        return undefined;
+    return declaredGhost(f.example, markdown);
+}
+/** 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 function mountKey(name, f) {
+    return `${name}\u0000${f.type}\u0000${f.inline === true}\u0000${f.items?.type ?? ''}\u0000${f.items?.inline === true}`;
 }
 /** 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 function controlKind(f) {
-    switch (f.type) {
+    switch (baseType(f)) {
         case 'richtext':
         case 'plaintext':
             return 'prose';
@@ -237,37 +314,34 @@ function stepInto(schema, step) {
 }
 // ── Row summaries and layouts ────────────────────────────────────────────────
 /** 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 function shortCell(sub) {
     const kind = controlKind(sub);
     if (kind === 'prose')
-        return sub.type === 'plaintext' || !!sub.inline;
+        return !!sub.inline;
     return (kind === 'text' || kind === 'enum' || kind === 'number' || kind === 'boolean' || kind === 'date');
 }
 /**
- * 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.
+ * The first short text cell's words — the first `string`, or inline `richtext` /
+ * `plaintext`, in declaration order — read through {@link titleText}; `undefined` where
+ * there is no such cell or it is empty. The cell is picked by the schema alone, so an
+ * instance is named by one cell whatever the others hold. What names an instance from
+ * its own values: a collapsed row, and a card whose kind declares no `title`.
  */
-export function rowSummary(items, row) {
-    const values = (row ?? {});
-    const template = items?.ui?.title;
-    if (template && template.trim()) {
-        const shown = interpolateTitle(template, values).trim();
-        if (shown)
-            return shown;
-    }
-    for (const [k, sub] of Object.entries(items?.properties ?? {})) {
+function firstShortText(cells, values) {
+    const named = Object.entries(cells ?? {}).find(([, sub]) => {
         const kind = controlKind(sub);
-        if (kind !== 'text' && !(kind === 'prose' && shortCell(sub)))
-            continue;
-        const text = titleText(ownValue(values, k)).trim();
-        if (text)
-            return text;
-    }
-    return undefined;
+        return kind === 'text' || (kind === 'prose' && shortCell(sub));
+    });
+    if (!named)
+        return undefined;
+    return titleText(ownValue(values, named[0])).trim() || undefined;
+}
+/** A collapsed row's own words ({@link firstShortText}); `undefined` while the row has
+ *  nothing to say for itself. */
+export function rowSummary(items, row) {
+    return firstShortText(items?.properties, (row ?? {}));
 }
 /**
  * The layout an array takes: `'table'` where the array's own `ui.layout` asks for it
@@ -316,14 +390,18 @@ export function commitDiscriminant(value, member) {
 }
 /**
  * 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 function obliged(schema) {
-    return schema.type !== 'object' && schema.type !== 'matrix' && schema.default === undefined;
+    return (schema.type !== 'object' &&
+        schema.type !== 'matrix' &&
+        !optionalCell(schema) &&
+        schema.default === undefined);
 }
-/** `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 function humanize(name) {
     const spaced = name.replace(/_/g, ' ').trim();
     return spaced ? spaced[0].toUpperCase() + spaced.slice(1) : spaced;
@@ -336,11 +414,11 @@ export function fieldModels(cardSchema) {
         control: controlKind(schema),
         group: schema.ui?.group,
         compact: !!schema.ui?.compact,
-        label: schema.ui?.title ?? humanize(name),
+        label: schema.title ?? humanize(name),
         description: schema.description,
         required: obliged(schema),
         inline: !!schema.inline,
-        plaintext: schema.type === 'plaintext'
+        plaintext: baseType(schema) === 'plaintext'
     }));
 }
 /**
@@ -485,11 +563,7 @@ export function fieldValues(items) {
             values[p.key] = p.value;
     return values;
 }
-/** Interpolate a `{field}` card-title template against live field values. */
-export function interpolateTitle(template, values) {
-    return template.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => titleText(ownValue(values, name)));
-}
-/** A value by own key: a template or a declaration can name `constructor`. */
+/** A value by own key: a declaration can name `constructor`. */
 function ownValue(values, name) {
     return Object.hasOwn(values, name) ? values[name] : undefined;
 }
@@ -508,25 +582,25 @@ export function titleText(v) {
     const member = v[VARIANT_DISCRIMINANT];
     return typeof member === 'string' ? member : '';
 }
-/** The field names a `{field}` title reads. */
-export function titleFields(template) {
-    if (!template)
-        return [];
-    return [...template.matchAll(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g)].map((m) => m[1]);
+/** 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 function kindTitle(cardSchema, kind) {
+    const t = cardSchema?.title;
+    return t && t.trim() ? t : humanize(kind);
 }
 /**
- * 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 function cardTitle(cardSchema, kind, values, extTitle) {
     if (extTitle && extTitle.trim())
         return extTitle;
-    const t = cardSchema?.ui?.title;
+    const t = cardSchema?.title;
     if (t && t.trim())
-        return interpolateTitle(t, values);
-    return humanize(kind);
+        return t;
+    return firstShortText(cardSchema?.fields, values) ?? humanize(kind);
 }
 /** Whether a card kind renders a body leaf: gated by `body.enabled !== false`. */
 export function bodyEnabled(cardSchema) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.12.0",
+	"version": "0.14.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.115.0-0",
+		"@quillmark/wasm": ">=0.116.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {