@quillmark/svelte 0.19.0 → 0.20.1

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

@@ -1,10 +1,14 @@
 import type { Content } from '@quillmark/wasm';
 interface Props {
-    /** This leaf's content, read at mount (the parent's boundary read), `undefined`
-     * where nothing is stored. A thunk rather than a value: the parent re-derives
-     * per revision and this leaf takes its state once, so a value prop would be a
-     * boundary read per leaf per render, all but one of them discarded. */
+    /** This leaf's content (the parent's boundary read), `undefined` where nothing is
+     * stored: read at mount and wherever {@link value} moves. A thunk rather than a
+     * value: the parent re-derives per revision, and a value prop would be a
+     * boundary read per leaf per render, all but the moved one discarded. */
     content: () => Content | undefined;
+    /** This leaf's value as the parent's re-derive delivers it, stored form and all:
+     * compared with the last one delivered, never drawn, so a move is what re-reads
+     * {@link content}. */
+    value?: unknown;
     /** The default an unset leaf holds, where it prints: drawn at the default rung,
      * and handed up whole with the first edit in it, as `createField` takes one. */
     fallback?: Content;

package/dist/visual/VisualEditorInner.svelte

@@ -46,7 +46,7 @@
 	import type { VisualEditorProps } from './props.js';
 	import { mergeStrings, setWording } from './strings.js';
 	import type { CardId, ChangeSource } from './signals.js';
-	import type { FieldController } from '../core/codec/index.js';
+	import type { FieldController, LeafViews } from '../core/codec/index.js';
 	import {
 		IdSeq,
 		controlKind,
@@ -79,11 +79,11 @@
 		type RoutedDiagnostic
 	} from './diagnostics.js';
 	import { fieldDomIds, groupPanelId } from './domid.js';
-	import { createLeafRegistry, type FieldControl } from './leaves.js';
+	import { createLeafRegistry, type ActiveProse, type FieldControl } from './leaves.js';
 	import { reorder, reorderArm, reorderTrips } from './motion.js';
 	import { tipsChannel } from './tips.js';
-	import { cardChecklists, setChecklists } from './checklists.js';
 	import { patchEditorExt } from './ext.js';
+	import { raiseGuidance } from './guidance.js';
 	import Card from './Card.svelte';
 	import TipsCard from './TipsCard.svelte';
 	import FormatPopover from './FormatPopover.svelte';
@@ -654,20 +654,6 @@
 		};
 	});
 
-	// The document's checklists, which an open matrix's add box searches whole
-	// (`checklists.ts`): off the model, so a list in a closed group or another card is
-	// reached without being mounted.
-	const lists = $derived(
-		cardChecklists(
-			[model.main, ...model.cards],
-			(c) => c.titleOverride || c.titlePlaceholder,
-			(c, field) => pathFor(makeAddr(c.id, c.isMain, field)),
-			(c, field) => fieldKeyToString({ card: c.isMain ? undefined : c.id, field }),
-			(c, field, next) => commitScalar(c.id, c.isMain, field, next)
-		)
-	);
-	setChecklists({ list: () => lists, land: (path) => void focusField(path) });
-
 	// ── Public entry points ─────────────────────────────────────────────────────
 	/**
 	 * Resolve a preview {@link Landing} to a mounted leaf and land in it.
@@ -694,12 +680,18 @@
 		const box = await land(found, at.granularity === 'segment' ? undefined : at.pos);
 		if (span.alive) bloomInside(box);
 	}
-	/** The active leaf's controller: the formatting popover's observation seam.
-	 *  `undefined` for a focused form control, which holds no marks to toggle. */
-	export function getActiveLeaf(): FieldController | undefined {
+	/** The active prose leaf: the formatting popover's observation seam. The active
+	 *  field's controller where it registered one, else the by-value leaf focused last
+	 *  under it (`leaves.ts`); `undefined` for a form control, which holds no marks to
+	 *  toggle. */
+	export function getActiveLeaf(): ActiveProse | undefined {
 		if (!activeAddr) return undefined;
 		const card = activeAddr.card != null ? activeCardId : undefined;
-		return leaves.prose(fieldKeyToString({ card, field: activeAddr.field }));
+		const key = fieldKeyToString({ card, field: activeAddr.field });
+		const controller = leaves.prose(key);
+		if (controller) return { views: controller as FieldController & LeafViews, controller };
+		const views = leaves.value(key);
+		return views && { views };
 	}
 
 	/**
@@ -856,7 +848,15 @@
 	}
 </script>
 
-<div class="qm-editor {className ?? ''}" {style} data-qm-root bind:this={rootEl}>
+<!-- The keydown is a control's, bubbled: the root resolves which description it raises. -->
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div
+	class="qm-editor {className ?? ''}"
+	{style}
+	data-qm-root
+	bind:this={rootEl}
+	onkeydown={raiseGuidance}
+>
 	<!-- `main` and the tips card are one block in the stack: the tips card tucks under
 	 `main`'s bottom corners, so the two share a seam rather than a gutter and the
 	 wrapper is what holds them to it. -->

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

@@ -1,10 +1,10 @@
 import { type DocPath, type Landing } from '../core/address.js';
 import type { VisualEditorProps } from './props.js';
 import type { CardId } from './signals.js';
-import type { FieldController } from '../core/codec/index.js';
+import { type ActiveProse } from './leaves.js';
 declare const VisualEditorInner: import("svelte").Component<VisualEditorProps, {
     setCaret: (at: Landing) => Promise<void>;
-    getActiveLeaf: () => FieldController | undefined;
+    getActiveLeaf: () => ActiveProse | undefined;
     focusField: (field: DocPath) => Promise<void>;
     insertCard: (kind: string, at?: number) => CardId | undefined;
     removeCard: (cardId: CardId) => void;

package/dist/visual/checklists.d.ts

@@ -1,82 +1,3 @@
 import type { QuillFieldSchema } from '@quillmark/wasm';
-import type { DocPath } from '../core/address.js';
-import { type CardModel, type MatrixMember } from './structure.js';
-/** One matrix of the document, as the add box reaches it. */
-export interface Checklist {
-    /** The field's leaf key: how a mounted matrix tells itself from the rest. */
-    key: string;
-    /** The field's path, the prefix a member's landing address extends. */
-    path: DocPath;
-    /** What a result from this list reads under: the field's label, and the card's
-     *  where the field is not the main card's. */
-    label: string;
-    schema: QuillFieldSchema;
-    /** The held set as it prints: the stored map, else the declared `default:`. */
-    value: Record<string, unknown> | undefined;
-    /** Commit the whole map, as the field's own control does. */
-    commit: (next: Record<string, unknown> | undefined) => void;
-}
-export interface ChecklistIndex {
-    list: () => readonly Checklist[];
-    /** Reveal and focus a member by its address. */
-    land: (path: DocPath) => void;
-}
-export declare function setChecklists(index: ChecklistIndex): void;
-/** The index under a mounted editor; `undefined` off-tree. */
-export declare function checklists(): ChecklistIndex | undefined;
 /** The value a matrix prints: the stored map, else a mapping `default:`. */
 export declare function matrixPrinted(value: unknown, schema: QuillFieldSchema): Record<string, unknown> | undefined;
-/** Every card-level matrix of the cards, in document order. */
-export declare function cardChecklists(cards: readonly CardModel[], cardLabel: (card: CardModel) => string, path: (card: CardModel, field: string) => DocPath | undefined, leafKey: (card: CardModel, field: string) => string, commit: (card: CardModel, field: string, next: Record<string, unknown> | undefined) => void): Checklist[];
-/** Every item a matrix can show: the roster in declaration order, then the items its
- *  map adds, in id order. */
-export declare function checklistItems(schema: QuillFieldSchema, value: Record<string, unknown> | undefined): MatrixMember[];
-/** One option of an add box. */
-export interface AddOption {
-    /** Stable across one query's options: the option element's id suffix. */
-    key: string;
-    title: string;
-    /** Words after the title: the list a result stands in, its held state. */
-    note?: string;
-    /** The option that adds what was typed, rather than a result. */
-    add?: boolean;
-    /** A result the typed words name outright, which Enter takes unarrowed: an add box
-     *  whose best result is weaker takes its add option instead. */
-    strong?: boolean;
-    /** What the owner reads back off a chosen option. */
-    payload?: unknown;
-}
-/** One search result: an item of some checklist, `list` naming which. */
-export interface ChecklistHit<L> {
-    list: L;
-    id: string;
-    title: string;
-    held: boolean;
-    score: number;
-    /** Every query word claimed a title word whole or as its opening. */
-    strong: boolean;
-}
-/**
- * How well `query` names `title`, or `undefined` for not at all. Each query word claims
- * a title word — whole, as its opening, or as an abbreviation of it (`flt cc` names
- * `Flight CC`) — the stronger claims taken first, so `c cc` names `CC Candidate`; a
- * word left over may claim a run of words whose openings it spells (`fcc`, `jqo`). The
- * title the query spells outright ranks first, then one it opens.
- */
-export declare function matchTitle(query: string, title: string): {
-    score: number;
-    strong: boolean;
-} | undefined;
-/** {@link matchTitle}'s score, `0` for no match. */
-export declare function matchScore(query: string, title: string): number;
-/** What a search reads of one list: its items and their ticks. */
-export interface Searchable<L> {
-    list: L;
-    schema: QuillFieldSchema;
-    value: Record<string, unknown> | undefined;
-}
-/**
- * The items across `lists` that `query` names, best first; a tie keeps the order of
- * `lists`, then of each list's items.
- */
-export declare function searchChecklists<L>(query: string, lists: readonly Searchable<L>[], limit?: number): ChecklistHit<L>[];

package/dist/visual/checklists.js

@@ -1,20 +1,3 @@
-/**
- * The document's checklists, and the search an open matrix's add box runs over them
- * (VISUAL_EDITOR §"The matrix"). The editor root publishes every card-level matrix off
- * the model it derives, so a list in a collapsed group or another card is searched
- * as surely as the one the author is typing in. A matrix mounted off-tree, or nested
- * in a container, is not indexed and searches its own items alone.
- */
-import { getContext, setContext } from 'svelte';
-import { addedItems, matrixHeld, matrixMembers, memberValue } from './structure.js';
-const KEY = Symbol('qm-checklists');
-export function setChecklists(index) {
-    setContext(KEY, index);
-}
-/** The index under a mounted editor; `undefined` off-tree. */
-export function checklists() {
-    return getContext(KEY);
-}
 /** The value a matrix prints: the stored map, else a mapping `default:`. */
 export function matrixPrinted(value, schema) {
     const map = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
@@ -22,150 +5,3 @@ export function matrixPrinted(value, schema) {
         : undefined;
     return value == null ? map(schema.default) : map(value);
 }
-/** Every card-level matrix of the cards, in document order. */
-export function cardChecklists(cards, cardLabel, path, leafKey, commit) {
-    const out = [];
-    for (const card of cards) {
-        if (card.unschemable)
-            continue;
-        for (const section of card.sections)
-            for (const f of section.fields) {
-                if (f.control !== 'matrix')
-                    continue;
-                const at = path(card, f.name);
-                if (at == null)
-                    continue;
-                out.push({
-                    key: leafKey(card, f.name),
-                    path: at,
-                    label: card.isMain ? f.label : `${f.label} · ${cardLabel(card)}`,
-                    schema: f.schema,
-                    value: matrixPrinted(card.values[f.name], f.schema),
-                    commit: (next) => commit(card, f.name, next)
-                });
-            }
-    }
-    return out;
-}
-/** Every item a matrix can show: the roster in declaration order, then the items its
- *  map adds, in id order. */
-export function checklistItems(schema, value) {
-    return [...matrixMembers(schema.members), ...addedItems(schema, value)];
-}
-/** Lowercase, unaccented words, any script: `Exec / Aide / CAG` → `exec aide cag`. */
-function words(s) {
-    return s
-        .normalize('NFKD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase()
-        .split(/[^\p{L}\p{N}]+/u)
-        .filter(Boolean);
-}
-/** `flt` in `flight`: every letter in order, the first letters equal. */
-function abbreviates(token, word) {
-    if (token[0] !== word[0])
-        return false;
-    let i = 0;
-    for (const c of word)
-        if (c === token[i])
-            i++;
-    return i === token.length;
-}
-/** How a query word claims one title word: whole (3), as its opening (2), as an
- *  abbreviation (1), or not (0). */
-function claim(token, word) {
-    return word === token ? 3 : word.startsWith(token) ? 2 : abbreviates(token, word) ? 1 : 0;
-}
-/** The end of the run of free words from `i` whose openings spell `token` in order —
- *  `fcc` over `flight cc`, `jqo` over `joint qualified officer` — or `-1`. */
-function runFrom(token, w, free, i) {
-    if (i >= w.length || !free[i])
-        return -1;
-    for (let k = Math.min(token.length, w[i].length); k > 0; k--) {
-        if (!w[i].startsWith(token.slice(0, k)))
-            continue;
-        if (k === token.length)
-            return i + 1;
-        const end = runFrom(token.slice(k), w, free, i + 1);
-        if (end >= 0)
-            return end;
-    }
-    return -1;
-}
-/**
- * How well `query` names `title`, or `undefined` for not at all. Each query word claims
- * a title word — whole, as its opening, or as an abbreviation of it (`flt cc` names
- * `Flight CC`) — the stronger claims taken first, so `c cc` names `CC Candidate`; a
- * word left over may claim a run of words whose openings it spells (`fcc`, `jqo`). The
- * title the query spells outright ranks first, then one it opens.
- */
-export function matchTitle(query, title) {
-    const q = words(query);
-    const w = words(title);
-    if (!q.length || !w.length)
-        return undefined;
-    const free = w.map(() => true);
-    const left = q.map(() => true);
-    let score = 0;
-    let strong = true;
-    for (const level of [3, 2, 1])
-        q.forEach((token, t) => {
-            if (!left[t])
-                return;
-            const at = w.findIndex((word, i) => free[i] && claim(token, word) === level);
-            if (at < 0)
-                return;
-            free[at] = left[t] = false;
-            score += level;
-            if (level === 1)
-                strong = false;
-        });
-    for (let t = 0; t < q.length; t++) {
-        if (!left[t])
-            continue;
-        let found = false;
-        for (let i = 0; i < w.length && !found; i++) {
-            const end = runFrom(q[t], w, free, i);
-            if (end - i < 2)
-                continue;
-            for (let k = i; k < end; k++)
-                free[k] = false;
-            found = true;
-        }
-        if (!found)
-            return undefined;
-        score += 1;
-        strong = false;
-    }
-    const typed = q.join(' ');
-    const whole = w.join(' ');
-    return { score: score + (whole === typed ? 3 : whole.startsWith(typed) ? 1 : 0), strong };
-}
-/** {@link matchTitle}'s score, `0` for no match. */
-export function matchScore(query, title) {
-    return matchTitle(query, title)?.score ?? 0;
-}
-/**
- * The items across `lists` that `query` names, best first; a tie keeps the order of
- * `lists`, then of each list's items.
- */
-export function searchChecklists(query, lists, limit = 8) {
-    const hits = [];
-    for (const { list, schema, value } of lists)
-        for (const item of checklistItems(schema, value)) {
-            const match = matchTitle(query, item.title);
-            if (match)
-                hits.push({
-                    list,
-                    id: item.id,
-                    title: item.title,
-                    held: matrixHeld(memberValue(value, item.id)),
-                    ...match
-                });
-        }
-    return hits
-        .map((h, i) => [h, i])
-        .sort(([a, i], [b, j]) => b.score - a.score || i - j)
-        .slice(0, limit)
-        .map(([h]) => h);
-}

package/dist/visual/guidance.d.ts

@@ -0,0 +1,15 @@
+/** `Mod-/`, read off `key` so a layout that shifts to reach `/` still matches; either
+ *  modifier stands for `Mod`. */
+export declare function isGuidanceKey(e: KeyboardEvent): boolean;
+/**
+ * The guidance trigger for the description nearest `from`: the innermost element
+ * carrying `aria-describedby` whose ids name a parked description with a trigger
+ * beside it. A trigger points at its own parked node through that same attribute,
+ * which is the relation read here; ids that are not a description (an array's count,
+ * a prose leaf's note) are skipped, and an undescribed property falls through to the
+ * group around it.
+ */
+export declare function guidanceTrigger(from: Element, root: Element): HTMLElement | undefined;
+/** Root keydown: the key raises (or lowers) the nearest guidance. A trigger's `click()`
+ *  is an activation with no pointer behind it, which `FieldHint` toggles on. */
+export declare function raiseGuidance(e: KeyboardEvent): void;

package/dist/visual/guidance.js

@@ -0,0 +1,37 @@
+// The guidance key: `Mod-/` on a control raises the description that control carries,
+// the keyboard's way in to a `FieldHint` whose glyph is out of the tab order.
+/** `Mod-/`, read off `key` so a layout that shifts to reach `/` still matches; either
+ *  modifier stands for `Mod`. */
+export function isGuidanceKey(e) {
+    return e.key === '/' && (e.ctrlKey || e.metaKey) && !e.altKey && !e.isComposing;
+}
+/**
+ * The guidance trigger for the description nearest `from`: the innermost element
+ * carrying `aria-describedby` whose ids name a parked description with a trigger
+ * beside it. A trigger points at its own parked node through that same attribute,
+ * which is the relation read here; ids that are not a description (an array's count,
+ * a prose leaf's note) are skipped, and an undescribed property falls through to the
+ * group around it.
+ */
+export function guidanceTrigger(from, root) {
+    for (let el = from.closest('[aria-describedby]'); el;) {
+        for (const id of el.getAttribute('aria-describedby').split(/\s+/)) {
+            const trigger = root.querySelector(`.qm-field-hint[aria-describedby="${id}"]`);
+            if (trigger)
+                return trigger;
+        }
+        el = el.parentElement?.closest('[aria-describedby]') ?? null;
+    }
+    return undefined;
+}
+/** Root keydown: the key raises (or lowers) the nearest guidance. A trigger's `click()`
+ *  is an activation with no pointer behind it, which `FieldHint` toggles on. */
+export function raiseGuidance(e) {
+    if (!isGuidanceKey(e) || !(e.target instanceof Element))
+        return;
+    const trigger = guidanceTrigger(e.target, e.currentTarget);
+    if (!trigger)
+        return;
+    e.preventDefault();
+    trigger.click();
+}

package/dist/visual/leaves.d.ts

@@ -1,5 +1,5 @@
 import type { PathStep } from '@quillmark/wasm';
-import type { FieldController } from '../core/codec/index.js';
+import type { FieldController, LeafViews } 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
@@ -60,8 +60,34 @@ export interface LeafRegistry {
     control(key: string): FieldControl | undefined;
     /** The codec seam at `key`, `undefined` for a form control. */
     prose(key: string): FieldController | undefined;
+    /** A by-value prose leaf under the field at `key`, by its views, on its focus. */
+    focusValue(key: string, leaf: LeafViews): void;
+    /** Dropped only by the leaf it names, so a leaf leaving takes no sibling's entry. */
+    releaseValue(key: string, leaf: LeafViews): void;
+    /** The by-value leaf focused last under `key`. */
+    value(key: string): LeafViews | undefined;
     /** Drop everything: the surface going away as a whole, where a leaf's cleanup
      *  order relative to the parent's is Svelte's business. */
     clear(): void;
 }
 export declare function createLeafRegistry(): LeafRegistry;
+/**
+ * The active prose leaf as the formatting popover reaches it: the views a selection is
+ * read from and a mark toggled at, and the controller where the leaf is a field's. A
+ * by-value leaf has none, its anchors being dropped on the parent's value write, so the
+ * anchor verbs the controller carries have nothing to act on there.
+ */
+export interface ActiveProse {
+    views: LeafViews;
+    controller?: FieldController;
+}
+/** The by-value lane with a field's key bound: what a leaf under that field announces
+ *  itself through, knowing no key of its own. */
+export interface ValueLeafSeat {
+    focus(leaf: LeafViews): void;
+    release(leaf: LeafViews): void;
+}
+/** Seat every by-value leaf under the calling field, at any depth of its containers. */
+export declare function seatValueLeaves(seat: ValueLeafSeat): void;
+/** The seat under a mounted field; `undefined` off-tree. */
+export declare function valueLeafSeat(): ValueLeafSeat | undefined;

package/dist/visual/leaves.js

@@ -1,6 +1,32 @@
+// The leaf registry: what a landing verb resolves a `DocPath` to, and the seam the
+// mounted tree registers itself into (VISUAL_EDITOR §"Focus and the preview bridge").
+//
+// Two lanes behind one lookup. Every mounted field registers a {@link FieldControl} —
+// take the caret, and a box to bloom — which is the whole of what a reveal and a
+// focus need, and the whole of what a form control has. A prose leaf registers its
+// `FieldController` instead: a superset, carrying the codec seam (a caret at a USV
+// offset, the formatting popover's observation) that no `<input>` answers. So
+// `control` covers every field and `prose` covers the leaves that have one, and the
+// verbs ask for the half they use: `focusField` never needs the codec, and
+// `getActiveLeaf` returns nothing for a focused text input rather than raising a
+// formatting toolbar over one.
+//
+// A by-value prose leaf (`ProseValue`) is in neither lane: it is not addressable, and
+// every element of an array and every cell of a row shares its field's key. It
+// announces its views on focus into a third lane under that key, which holds the one
+// focused last and is the popover's alone: `getActiveLeaf` falls back to it where the
+// active field registered no controller, and a landing never reads it.
+//
+// A registry rather than a DOM query, for the reason `Card.revealLeaf` is a call: a
+// control's focus is its own (a PM view restores a selection, a date field lands on
+// its first segment, an array lands on its first element or its add affordance), so
+// the surface holds the answers it already gives a label click instead of re-deriving
+// them from markup.
+import { getContext, setContext } from 'svelte';
 export function createLeafRegistry() {
     const controls = new Map();
     const proses = new Map();
+    const values = new Map();
     return {
         registerProse(key, controller) {
             proses.set(key, controller);
@@ -23,9 +49,29 @@ export function createLeafRegistry() {
         prose(key) {
             return proses.get(key);
         },
+        focusValue(key, leaf) {
+            values.set(key, leaf);
+        },
+        releaseValue(key, leaf) {
+            if (values.get(key) === leaf)
+                values.delete(key);
+        },
+        value(key) {
+            return values.get(key);
+        },
         clear() {
             controls.clear();
             proses.clear();
+            values.clear();
         }
     };
 }
+const SEAT = Symbol('qm-value-leaf');
+/** Seat every by-value leaf under the calling field, at any depth of its containers. */
+export function seatValueLeaves(seat) {
+    setContext(SEAT, seat);
+}
+/** The seat under a mounted field; `undefined` off-tree. */
+export function valueLeafSeat() {
+    return getContext(SEAT);
+}

package/dist/visual/strings.d.ts

@@ -50,12 +50,6 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** An open matrix's add box at rest, naming the list it adds to: `Add to Staff…`. The box
      *  draws its own `+`. `list` is empty for a matrix mounted with no label. */
     matrixAdd: (list: string) => string;
-    /** The add box's last option, which adds what was typed as an item of this list. */
-    matrixAddNew: (title: string) => string;
-    /** Beside a result from another list: the list it would be ticked in. */
-    matrixIn: (list: string) => string;
-    /** Beside a result already held: picking it lands on it and ticks nothing. */
-    matrixHeldTag: string;
     /** An added item's title input, named for the list it stands in and its 1-based
      *  place among the added items; also what an untitled item is called. */
     matrixItemTitle: (list: string, index: number) => string;
@@ -69,8 +63,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     /** 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. */
+    /** Under a prose leaf holding more structure than it can edit (paragraphs, a list or
+     *  an island in a one-line leaf, an island in any subform cell), which it draws
+     *  read-only rather than lose. */
     proseHeld: string;
     formatGroup: string;
     formatBold: string;

package/dist/visual/strings.js

@@ -38,9 +38,6 @@ export const DEFAULT_VISUAL_STRINGS = {
     enumUnsetTag: 'default',
     matrixHeld: (held, total) => `${held} of ${total} held`,
     matrixAdd: (list) => (list ? `Add to ${list}…` : 'Add…'),
-    matrixAddNew: (title) => `Add “${title}”`,
-    matrixIn: (list) => `in ${list}`,
-    matrixHeldTag: 'held',
     matrixItemTitle: (list, index) => `${list ? `${list} item` : 'Item'} ${index}`,
     matrixRemove: (title) => `Remove ${title}`,
     dateToday: 'Today',

package/dist/visual/structure.js

@@ -105,7 +105,7 @@ export function declaredContent(v, markdown) {
     if (text === undefined)
         return undefined;
     if (markdown)
-        return core().importMarkdown(text);
+        return core().importMarkdown(text).content;
     return {
         text,
         lines: text

package/dist/visual/tips.js

@@ -39,7 +39,7 @@ export function tipsChannel(raw) {
 export function renderTip(markdown, onError) {
     const { importMarkdown } = core();
     try {
-        return renderContent(importMarkdown(markdown), inlineSchema);
+        return renderContent(importMarkdown(markdown).content, inlineSchema);
     }
     catch (e) {
         reportError(onError, {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.19.0",
+	"version": "0.20.1",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -69,23 +69,23 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json --fail-on-warnings"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.123.0-0",
+		"@quillmark/wasm": ">=0.124.0-0",
 		"svelte": "^5.33.0"
 	},
 	"dependencies": {
 		"@internationalized/date": "^3.12.2",
 		"bits-ui": "^2.19.0",
 		"esm-env": "^1.2.2",
-		"prosemirror-commands": "1.7.1",
-		"prosemirror-gapcursor": "1.3.2",
-		"prosemirror-history": "1.5.0",
+		"prosemirror-commands": "1.7.2",
+		"prosemirror-gapcursor": "1.4.1",
+		"prosemirror-history": "1.5.1",
 		"prosemirror-inputrules": "1.5.1",
 		"prosemirror-keymap": "1.2.3",
-		"prosemirror-model": "1.25.11",
+		"prosemirror-model": "1.25.12",
 		"prosemirror-schema-list": "1.5.1",
 		"prosemirror-state": "1.4.4",
-		"prosemirror-transform": "1.12.0",
-		"prosemirror-view": "1.42.1"
+		"prosemirror-transform": "1.12.2",
+		"prosemirror-view": "1.42.6"
 	},
 	"devDependencies": {
 		"@sveltejs/package": "^3.0.0",