@quillmark/svelte 0.0.0

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

@@ -0,0 +1,103 @@
+/** One `<svg>` child: the element to make, and the attributes to set on it. */
+export type IconNode = readonly (readonly [string, Record<string, string>])[];
+export declare const ICONS: {
+    readonly 'chevron-right': readonly [readonly ["path", {
+        readonly d: "m9 18 6-6-6-6";
+    }]];
+    readonly 'chevron-down': readonly [readonly ["path", {
+        readonly d: "m6 9 6 6 6-6";
+    }]];
+    readonly 'chevron-up': readonly [readonly ["path", {
+        readonly d: "m18 15-6-6-6 6";
+    }]];
+    readonly bold: readonly [readonly ["path", {
+        readonly d: "M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8";
+    }]];
+    readonly italic: readonly [readonly ["line", {
+        readonly x1: "19";
+        readonly x2: "10";
+        readonly y1: "4";
+        readonly y2: "4";
+    }], readonly ["line", {
+        readonly x1: "14";
+        readonly x2: "5";
+        readonly y1: "20";
+        readonly y2: "20";
+    }], readonly ["line", {
+        readonly x1: "15";
+        readonly x2: "9";
+        readonly y1: "4";
+        readonly y2: "20";
+    }]];
+    readonly underline: readonly [readonly ["path", {
+        readonly d: "M6 4v6a6 6 0 0 0 12 0V4";
+    }], readonly ["line", {
+        readonly x1: "4";
+        readonly x2: "20";
+        readonly y1: "20";
+        readonly y2: "20";
+    }]];
+    readonly strikethrough: readonly [readonly ["path", {
+        readonly d: "M16 4H9a3 3 0 0 0-2.83 4";
+    }], readonly ["path", {
+        readonly d: "M14 12a4 4 0 0 1 0 8H6";
+    }], readonly ["line", {
+        readonly x1: "4";
+        readonly x2: "20";
+        readonly y1: "12";
+        readonly y2: "12";
+    }]];
+    readonly code: readonly [readonly ["path", {
+        readonly d: "m16 18 6-6-6-6";
+    }], readonly ["path", {
+        readonly d: "m8 6-6 6 6 6";
+    }]];
+    readonly link: readonly [readonly ["path", {
+        readonly d: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71";
+    }], readonly ["path", {
+        readonly d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71";
+    }]];
+    readonly hash: readonly [readonly ["line", {
+        readonly x1: "4";
+        readonly x2: "20";
+        readonly y1: "9";
+        readonly y2: "9";
+    }], readonly ["line", {
+        readonly x1: "4";
+        readonly x2: "20";
+        readonly y1: "15";
+        readonly y2: "15";
+    }], readonly ["line", {
+        readonly x1: "10";
+        readonly x2: "8";
+        readonly y1: "3";
+        readonly y2: "21";
+    }], readonly ["line", {
+        readonly x1: "16";
+        readonly x2: "14";
+        readonly y1: "3";
+        readonly y2: "21";
+    }]];
+    readonly info: readonly [readonly ["circle", {
+        readonly cx: "12";
+        readonly cy: "12";
+        readonly r: "10";
+    }], readonly ["path", {
+        readonly d: "M12 16v-4";
+    }], readonly ["path", {
+        readonly d: "M12 8h.01";
+    }]];
+    readonly plus: readonly [readonly ["path", {
+        readonly d: "M5 12h14";
+    }], readonly ["path", {
+        readonly d: "M12 5v14";
+    }]];
+    readonly x: readonly [readonly ["path", {
+        readonly d: "M18 6 6 18";
+    }], readonly ["path", {
+        readonly d: "m6 6 12 12";
+    }]];
+};
+/** The closed set. A name that is not here is a compile error at the call site,
+ *  which is what a string key buys over thirteen imported components. */
+export type IconName = keyof typeof ICONS;

package/dist/visual/icons/nodes.js

@@ -0,0 +1,55 @@
+// The chrome's glyph geometry, as the element tuples an `<svg>` carries: a tag and
+// its attributes, against the 24×24 frame `Icon.svelte` draws. Every glyph the
+// Svelte chrome shows is here; `core/codec/table-view.ts` holds its own set, that
+// being the one place chrome is built without Svelte.
+//
+// Verbatim from lucide 1.28.0 — the version is stated because a glyph that drifts
+// from upstream is otherwise invisible, and because the notices in `NOTICE` are the
+// ones that release carries (ISC, and MIT for the Feather-derived ten).
+export const ICONS = {
+    'chevron-right': [['path', { d: 'm9 18 6-6-6-6' }]],
+    'chevron-down': [['path', { d: 'm6 9 6 6 6-6' }]],
+    'chevron-up': [['path', { d: 'm18 15-6-6-6 6' }]],
+    bold: [['path', { d: 'M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8' }]],
+    italic: [
+        ['line', { x1: '19', x2: '10', y1: '4', y2: '4' }],
+        ['line', { x1: '14', x2: '5', y1: '20', y2: '20' }],
+        ['line', { x1: '15', x2: '9', y1: '4', y2: '20' }]
+    ],
+    underline: [
+        ['path', { d: 'M6 4v6a6 6 0 0 0 12 0V4' }],
+        ['line', { x1: '4', x2: '20', y1: '20', y2: '20' }]
+    ],
+    strikethrough: [
+        ['path', { d: 'M16 4H9a3 3 0 0 0-2.83 4' }],
+        ['path', { d: 'M14 12a4 4 0 0 1 0 8H6' }],
+        ['line', { x1: '4', x2: '20', y1: '12', y2: '12' }]
+    ],
+    code: [
+        ['path', { d: 'm16 18 6-6-6-6' }],
+        ['path', { d: 'm8 6-6 6 6 6' }]
+    ],
+    link: [
+        ['path', { d: 'M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71' }],
+        ['path', { d: 'M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71' }]
+    ],
+    hash: [
+        ['line', { x1: '4', x2: '20', y1: '9', y2: '9' }],
+        ['line', { x1: '4', x2: '20', y1: '15', y2: '15' }],
+        ['line', { x1: '10', x2: '8', y1: '3', y2: '21' }],
+        ['line', { x1: '16', x2: '14', y1: '3', y2: '21' }]
+    ],
+    info: [
+        ['circle', { cx: '12', cy: '12', r: '10' }],
+        ['path', { d: 'M12 16v-4' }],
+        ['path', { d: 'M12 8h.01' }]
+    ],
+    plus: [
+        ['path', { d: 'M5 12h14' }],
+        ['path', { d: 'M12 5v14' }]
+    ],
+    x: [
+        ['path', { d: 'M18 6 6 18' }],
+        ['path', { d: 'm6 6 12 12' }]
+    ]
+};

package/dist/visual/index.d.ts

@@ -0,0 +1,9 @@
+export { default as VisualEditor } from './VisualEditor.svelte';
+export type { VisualEditorProps } from './props.js';
+export { createField } from '../core/codec/index.js';
+export type { CreateFieldOpts, FieldController } from '../core/codec/index.js';
+export { DEFAULT_VISUAL_STRINGS } from './strings.js';
+export type { VisualStrings, VisualStringsInput, FormatDiagnostic } from './strings.js';
+export type { BodyPlaceholder, BodyPlaceholderContext } from './structure.js';
+export { patchEditorExt } from './ext.js';
+export type { ActiveLeaf, CardId, ChangeSource, EditorChange } from './signals.js';

package/dist/visual/index.js

@@ -0,0 +1,24 @@
+// `@quillmark/svelte/visual`: the WYSIWYG surface.
+//
+// The federated VisualEditor: a thin Svelte composition over many small editors.
+// Each content leaf is the codec's `createField` prose leaf; scalar fields are
+// form controls; structure/cards are the editor's own. Depends on `/core` and the
+// codec. RELATIVE imports (not `$lib`): svelte-package ships this as-is.
+//
+// The barrel carries what a consumer story wants, and nothing else: a symbol
+// earns its line when a caller outside the package needs it, and grows one when
+// that caller arrives, not before.
+export { default as VisualEditor } from './VisualEditor.svelte';
+// The prose leaf: the vanilla mount API a non-Svelte consumer (or a custom
+// surface) builds on.
+export { createField } from '../core/codec/index.js';
+// What the surface SAYS, and how it words a diagnostic. `strings` is keyed and
+// partial (unset keys take the package's English) and `DEFAULT_VISUAL_STRINGS` is
+// that English, exported so a consumer can compose against it rather than restate
+// it. The empty body's per-kind hook is the `bodyPlaceholder` key inside it.
+export { DEFAULT_VISUAL_STRINGS } from './strings.js';
+// The `$ext.editor` write unit. A consumer seeding editor-side chrome
+// state (a card title, the tips channel) goes through this rather than
+// `storeExtNamespace`, which replaces the namespace and takes the sibling keys with
+// it.
+export { patchEditorExt } from './ext.js';

package/dist/visual/motion.d.ts

@@ -0,0 +1,18 @@
+import type { AnimationConfig } from 'svelte/animate';
+/**
+ * Slide a keyed slot from where it was to where it now is.
+ *
+ * `armed` is why this is the reorder and not every reconcile: `animate:` fires wherever
+ * a slot's rect moved, and a card growing under the caret moves every slot below it,
+ * which is a layout change with no trip in it and one that would draw those slots over
+ * the content that displaced them for the length of the run. So the reorder command
+ * arms the gesture and the frame it lands in disarms it, which is the admission test
+ * read off the endpoints: two positions in the list, not two positions on the page.
+ *
+ * Both endpoints are rest states, so the curve is `--_qm-ease-reverse` (a second click
+ * lands mid-slide) and the rung is `slow` (the trip moves the stack around it).
+ */
+export declare function reorder(node: HTMLElement, { from, to }: {
+    from: DOMRect;
+    to: DOMRect;
+}, armed: () => boolean): AnimationConfig;

package/dist/visual/motion.js

@@ -0,0 +1,53 @@
+// The card stack's reorder trip: a slot's position ↔ position in a
+// keyed list, the one row of the mechanism table no CSS rule can serve, because the
+// two frames belong to different elements. Svelte's `animate:` supplies the halves CSS
+// 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.
+/** 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';
+/** 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. */
+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;
+}
+/**
+ * Slide a keyed slot from where it was to where it now is.
+ *
+ * `armed` is why this is the reorder and not every reconcile: `animate:` fires wherever
+ * a slot's rect moved, and a card growing under the caret moves every slot below it,
+ * which is a layout change with no trip in it and one that would draw those slots over
+ * the content that displaced them for the length of the run. So the reorder command
+ * arms the gesture and the frame it lands in disarms it, which is the admission test
+ * read off the endpoints: two positions in the list, not two positions on the page.
+ *
+ * Both endpoints are rest states, so the curve is `--_qm-ease-reverse` (a second click
+ * lands mid-slide) and the rung is `slow` (the trip moves the stack around it).
+ */
+export function reorder(node, { from, to }, armed) {
+    // The returned config is empty by design, in both exits and the run below: Svelte
+    // samples a config's keyframes through a JS easing function, and this curve is a
+    // rung the derivation mints and `check:style` holds.
+    if (!armed() || typeof node.animate !== 'function')
+        return {};
+    const style = getComputedStyle(node);
+    const duration = rungMs(style, '--_qm-duration-slow');
+    const easing = style.getPropertyValue('--_qm-ease-reverse').trim();
+    if (duration === undefined || !easing)
+        return {};
+    for (const running of node.getAnimations())
+        if (running.id === RUN_ID)
+            running.cancel();
+    node.animate([
+        { transform: `translate(${from.left - to.left}px, ${from.top - to.top}px)` },
+        { transform: 'none' }
+    ], { duration, easing, id: RUN_ID });
+    return {};
+}

package/dist/visual/props.d.ts

@@ -0,0 +1,77 @@
+import type { Document, Quill, Addr, Diagnostic } from '@quillmark/wasm';
+import type { Place } from '../core/address.js';
+import type { EditorErrorHandler } from '../core/errors.js';
+import type { ActiveLeaf, EditorChange } from './signals.js';
+import type { FormatDiagnostic, VisualStringsInput } from './strings.js';
+export interface VisualEditorProps {
+    doc: Document;
+    quill: Quill;
+    /**
+     * The active leaf: its canonical `DocPath` and the session key of the card holding
+     * it, which is what a host tracking the active card keeps across a reorder
+     * (`CardId`).
+     */
+    onActiveLeafChange?: (active: ActiveLeaf) => void;
+    /**
+     * A caret move in the active leaf, carrying the canonical `DocPath` the
+     * preview also speaks: `onCaretMove={preview.focusPosition}` is the whole
+     * editor→preview bridge, no translation and no `doc.cards` read on the
+     * keystroke path (the editor mints the path off its derived card tree, which
+     * already holds every kind).
+     *
+     * A SELECTION signal, not a change signal: an arrow key fires it and commits
+     * nothing. One keystroke fires `onChange` first and this second, so the edit
+     * has landed by the time the caret names where it is.
+     *
+     * A PLACE, so consecutive duplicates do not arrive: landing the caret where it
+     * already sits reports nothing, and a place left and returned to reports twice.
+     */
+    onCaretMove?: (at: Place) => void;
+    /**
+     * EVERY edit that lands on the document: a prose commit, a scalar/array/object
+     * write, a card operation. The signal a host recompiles off; `source` is what
+     * moved, for a host that wants a structure op to recompile at once and a
+     * keystroke to wait for the burst to settle.
+     */
+    onChange?: (change: EditorChange) => void;
+    /**
+     * Failures the editor RECOVERED from: a commit the boundary refused (also
+     * pinned as a diagnostic on its field), a card operation that threw, a
+     * `validate`/`resolve` that threw, a prose commit that fell back. None of them
+     * stop editing; without this hook each is a `console.error` an app cannot
+     * route. Reaches the prose leaves too, so one handler covers the surface.
+     */
+    onError?: EditorErrorHandler;
+    /**
+     * External diagnostics, routed by `.path` and merged with `quill.validate`
+     * and local commit errors (VISUAL_EDITOR §Diagnostics).
+     */
+    diagnostics?: Diagnostic[];
+    /**
+     * Consumer policy hook: given a field `addr` and an enum option,
+     * return `false` to mark that option unavailable. A disallowed option renders
+     * DISABLED (never stripped), so an already-authored value stays visible and its
+     * stored payload is untouched: the schema is unchanged, this is runtime policy.
+     * Absent → every schema option is offered (the default, zero behavior change).
+     */
+    enumOptionAllowed?: (addr: Addr, value: string) => boolean;
+    /**
+     * Every word the surface says, keyed and partial: unset keys take the package's
+     * English. Several are ACCESSIBLE NAMES rather than decoration, so this is what
+     * a product shipping in another language replaces. The empty body's per-kind
+     * wording is the `bodyPlaceholder` key here rather than a prop of its own.
+     */
+    strings?: VisualStringsInput;
+    /**
+     * A boundary `Diagnostic` → the text shown under its field. Returning
+     * `undefined` takes the diagnostic's own message, which is the arm the parse and
+     * render lanes need: their parameters exist only inside that English string.
+     */
+    formatDiagnostic?: FormatDiagnostic;
+    /** Appended to the root's own class: the surface is a mounted element the
+     * consumer positions, so it needs a handle for layout it owns. */
+    class?: string;
+    /** Merged onto the root. Free because the derivation moved off this attribute
+     *  and onto `data-qm-root` (core/theme.css). */
+    style?: string;
+}

package/dist/visual/props.js

@@ -0,0 +1 @@
+export {};

package/dist/visual/signals.d.ts

@@ -0,0 +1,59 @@
+import type { DocPath } from '../core/address.js';
+/**
+ * Which lane an edit came down. The three differ in COST, not in meaning: prose
+ * arrives per keystroke and wants a debounce, a structure op arrives once per
+ * gesture and does not. A host that recompiles the same way for all three never
+ * reads it.
+ */
+export type ChangeSource = 
+/** A content commit from a prose leaf's own edit. */
+'prose'
+/** A scalar/array/object write through the typed writer, or a field cleared. */
+ | 'field'
+/** A card operation: add, move, remove, retype, rename, tips dismissal. */
+ | 'structure';
+/**
+ * A card's SESSION key: the editor's own identity for a card instance, `'main'` for
+ * the main card and an opaque `IdSeq` id (`structure.ts`) for a composable one. It
+ * rides beside every address the surface emits, because no address survives a
+ * reorder: `Addr` and `DocPath` are both positional, so a host holding
+ * `cards.indorsement[2].from` names a different card after one `moveCard`, and
+ * silently. The key does not move.
+ *
+ * SESSION-SCOPED BY CONSTRUCTION. Nothing document-side backs it (the document model
+ * carries no card handle): it is minted at mount and dies with the surface, so it
+ * does not survive a reload and a host persisting one is persisting a session key.
+ *
+ * THE EDITOR OWNS STRUCTURAL MUTATION for the session. The keys track the inserts,
+ * moves and removals the editor performs; a host that mutates the card array behind
+ * it (its own `doc.insertCard`) desyncs them, and the answer is to re-seed the
+ * surface rather than expect the keys to follow. There is nothing document-side to
+ * reconcile against, so this is a contract rather than a mechanism.
+ */
+export type CardId = string;
+/** An edit that LANDED on the document, and which lane it came down. */
+export interface EditorChange {
+    source: ChangeSource;
+    /**
+     * Where it landed, in the canonical `DocPath` the preview and every diagnostic
+     * already speak: a FIELD for the prose and field lanes, the CARD itself
+     * (`cards.<kind>[i]`) for a structure op, where the change is the card rather than
+     * anything inside it. Absent for a card removal and a tips dismissal, which are
+     * the stack's change rather than a leaf's.
+     */
+    path?: DocPath;
+    /**
+     * Which card it landed in ({@link CardId}). Present for a removal, whose `path`
+     * is not: the index is meaningless once the card is gone, and the key is the only
+     * handle a host tracking cards has left to drop. Absent only for the tips
+     * dismissal, which is document-level chrome and names no card.
+     */
+    cardId?: CardId;
+}
+/** The leaf that has focus: where it sits, and which card holds it. */
+export interface ActiveLeaf {
+    /** The leaf's own address, the same `DocPath` a `Place`, a `ContentHit` and a
+     *  `Diagnostic` name a field with. */
+    field: DocPath;
+    cardId: CardId;
+}

package/dist/visual/signals.js

@@ -0,0 +1 @@
+export {};

package/dist/visual/strings.d.ts

@@ -0,0 +1,123 @@
+import type { Diagnostic } from '@quillmark/wasm';
+import { type SlashStrings, type TableChromeStrings } from '../core/codec/index.js';
+import type { BodyPlaceholder } from './structure.js';
+/**
+ * The island and the insert menu's keys come from the CODEC, which owns both models
+ * (a NodeView inside the leaf, and the trigger the leaf's keymap drives). Extending
+ * rather than restating them is what keeps one English list: a consumer overrides an
+ * island handle's name beside the card controls' and the codec still has a default
+ * for a leaf mounted directly.
+ */
+export interface VisualStrings extends TableChromeStrings, SlashStrings {
+    cardMoveUp: string;
+    cardMoveDown: string;
+    cardDelete: string;
+    /** The card-title input's accessible name. */
+    cardTitle: string;
+    /** The multi-kind trigger, which names no kind because it opens a menu of them. */
+    addCard: string;
+    /** The single-kind trigger, whose accessible name IS the kind it seeds. */
+    addCardOfKind: (kind: string) => string;
+    /** The trailing strip's VISIBLE words, which are also its accessible name; the
+     * glyph rides the wording, as the array foot's does. A pair of their own rather
+     * than a prefix over the two above, because a language reading the mark as one
+     * phrase has nothing to prefix. */
+    addCardMark: (kind: string) => string;
+    addCardMarkAny: string;
+    arrayAdd: string;
+    arrayRemove: string;
+    /** The required marker's accessible name; the glyph itself is a `*`. */
+    fieldRequired: string;
+    formatGroup: string;
+    formatBold: string;
+    formatEmphasis: string;
+    formatUnderline: string;
+    formatStrikethrough: string;
+    formatCode: string;
+    formatLink: string;
+    /** The anchor button's accessible name. */
+    formatAnchor: string;
+    /** Its hover title, which says what an anchor IS; the name above only says what. */
+    formatAnchorTitle: string;
+    linkPlaceholder: string;
+    linkApply: string;
+    linkCancel: string;
+    tipsLabel: string;
+    tipsDismiss: string;
+    tipsNext: string;
+    tipsDot: (index: number, count: number) => string;
+    /** The whole sentence, since a translator orders the kind within it. */
+    unknownKind: (kind: string) => string;
+    retypeLabel: string;
+    retypePlaceholder: string;
+    noCardKinds: string;
+    /**
+     * The flat built-in invitation: the package's own words, kept to the one thing
+     * true of every body so it claims nothing about the card it sits in.
+     */
+    bodyGhost: string;
+    /**
+     * Per-KIND wording, in place of {@link VisualStrings.bodyGhost}; `undefined`
+     * takes it. Consulted once per kind per session and cached by the editor, so a
+     * hook that samples a set at random still reads as one deliberate string.
+     * Impurity is expected, and the cache is what contains it.
+     */
+    bodyPlaceholder: BodyPlaceholder;
+}
+/**
+ * The hook that turns a boundary `Diagnostic` into displayed text.
+ *
+ * A formatter reads the whole `Diagnostic`, including `args`: the facts `message`
+ * interpolates, keyed by name. What it can re-word tracks what that type carries per
+ * lane (VISUAL_EDITOR §Diagnostics for why each lands where it does):
+ *
+ * - **`validation::enum_violation`, `type_mismatch`, `format_violation`,
+ *   `must_fill`**: the CONSTRAINT re-words from the quill's schema at `path`, the
+ *   offending VALUE from `args` (`value` / `sourceToken` / `actual`, the engine
+ *   testifying to what it saw) and never from the document at `path`: validation
+ *   runs post-coercion, so the validator read a value the document does not hold and
+ *   a sentence built from `path` names a spelling the user never typed.
+ * - **`edit::field_coercion_failed`**: re-words from the app's own control state, the
+ *   refused value being in neither document (unchanged on throw) nor schema.
+ * - **`parse::yaml_error_with_location`, `invalid_structure`**: does not re-word. No
+ *   `path`, and `args` carries the LOCATION (`blockIndex`, `line`) and nothing else,
+ *   engine prose riding under no key: the parser's own text, its column and its caret
+ *   snippet exist only inside `message`.
+ * - **`LiveSession.warnings`**: does not re-word. Backend text, an external feed.
+ *
+ * The last two are the boundary's shape, not a gap in it, so the fallback arm is
+ * permanent: returning `undefined` renders `d.message` unchanged. `code` is optional
+ * at this pin, so that arm is reachable by TYPE and not only in principle.
+ *
+ * Displayed text is that message or this replacement and nothing beside it: `hint` is
+ * the tail of the message it accompanies, so rendering it too ships a two-language
+ * diagnostic.
+ */
+export type FormatDiagnostic = (d: Diagnostic) => string | undefined;
+/** The package's English. Every key, so the merge below is total. */
+export declare const DEFAULT_VISUAL_STRINGS: VisualStrings;
+/** A consumer's wording: any subset, the rest the package's. */
+export type VisualStringsInput = Partial<VisualStrings>;
+/** Fill a partial override to the whole key set. */
+export declare function mergeStrings(custom: VisualStringsInput | undefined): VisualStrings;
+/**
+ * Everything the surface says, as the tree reads it. Getters rather than values,
+ * so a consumer swapping locale mid-session re-renders rather than freezing the
+ * wording at mount. The two seams travel together because a product needs both or
+ * neither: wording it cannot apply to the diagnostics beside it is half a
+ * translation.
+ */
+export interface Wording {
+    readonly strings: VisualStrings;
+    readonly formatDiagnostic: FormatDiagnostic | undefined;
+}
+export declare function setWording(channel: Wording): void;
+/**
+ * The wording for a component under a mounted editor. Falls to the package's
+ * English off-tree, so a component rendered outside the editor (a test, a consumer
+ * composing one directly) still has every key.
+ */
+export declare function wording(): Wording;
+/** A diagnostic's displayed text: the consumer's formatter, or its message. The
+ *  fallback arm is permanent, not a courtesy ({@link FormatDiagnostic}). */
+export declare function diagnosticText(d: Diagnostic, format: FormatDiagnostic | undefined): string;

package/dist/visual/strings.js

@@ -0,0 +1,80 @@
+// Every word the visual surface says, in one place, so a product shipping in
+// another language can replace them. Keyed and PARTIAL: a consumer sets the keys
+// it has translations for and the rest take the package's English, which is what
+// makes wording an override rather than a fork.
+//
+// Several of these are ACCESSIBLE NAMES rather than decoration — the card
+// controls, the add trigger, the required marker — so an untranslated surface is
+// not merely inconsistent, it reads the wrong language to a screen reader. That is
+// why this exists as a seam and not as a list of literals to grep for.
+//
+// A key is a plain string where the text is fixed and a function where it is not:
+// a parametric string cannot be assembled from fragments and stay translatable,
+// since the word order is the translator's to choose.
+//
+// The strings reach the tree through CONTEXT, not props. They are ambient,
+// read-only, and wanted eight components deep (a card's controls, a field's
+// required marker, the formatting popover, the tips card); threading them by hand
+// would put a `strings` prop on every component between the root and each leaf,
+// which is a prop that means nothing to any of them.
+import { getContext, setContext } from 'svelte';
+import { DEFAULT_SLASH_STRINGS, DEFAULT_TABLE_STRINGS } from '../core/codec/index.js';
+/** The package's English. Every key, so the merge below is total. */
+export const DEFAULT_VISUAL_STRINGS = {
+    ...DEFAULT_TABLE_STRINGS,
+    ...DEFAULT_SLASH_STRINGS,
+    cardMoveUp: 'Move up',
+    cardMoveDown: 'Move down',
+    cardDelete: 'Delete card',
+    cardTitle: 'Card title',
+    addCard: 'Add card',
+    addCardOfKind: (kind) => `Add ${kind}`,
+    addCardMark: (kind) => `+ Add ${kind}`,
+    addCardMarkAny: '+ Add Card',
+    arrayAdd: '+ Add',
+    arrayRemove: 'Remove',
+    fieldRequired: 'required',
+    formatGroup: 'Formatting',
+    formatBold: 'Bold (Mod-B)',
+    formatEmphasis: 'Emphasis (Mod-I)',
+    formatUnderline: 'Underline (Mod-U)',
+    formatStrikethrough: 'Strikethrough',
+    formatCode: 'Code',
+    formatLink: 'Link',
+    formatAnchor: 'Anchor',
+    formatAnchorTitle: 'Anchor — an identity handle over the selection',
+    linkPlaceholder: 'https://…',
+    linkApply: 'Apply',
+    linkCancel: 'Cancel',
+    tipsLabel: 'Editor tips',
+    tipsDismiss: 'Dismiss',
+    tipsNext: 'Next',
+    tipsDot: (index, count) => `Tip ${index} of ${count}`,
+    unknownKind: (kind) => `Unrecognized card type ${kind}. Its content is preserved.`,
+    retypeLabel: 'Change to',
+    retypePlaceholder: 'Choose a type…',
+    noCardKinds: 'This document declares no card types — delete this card to remove it.',
+    bodyGhost: 'Write…',
+    bodyPlaceholder: () => undefined
+};
+/** Fill a partial override to the whole key set. */
+export function mergeStrings(custom) {
+    return custom ? { ...DEFAULT_VISUAL_STRINGS, ...custom } : DEFAULT_VISUAL_STRINGS;
+}
+const KEY = Symbol('qm.wording');
+export function setWording(channel) {
+    setContext(KEY, channel);
+}
+/**
+ * The wording for a component under a mounted editor. Falls to the package's
+ * English off-tree, so a component rendered outside the editor (a test, a consumer
+ * composing one directly) still has every key.
+ */
+export function wording() {
+    return (getContext(KEY) ?? { strings: DEFAULT_VISUAL_STRINGS, formatDiagnostic: undefined });
+}
+/** A diagnostic's displayed text: the consumer's formatter, or its message. The
+ *  fallback arm is permanent, not a courtesy ({@link FormatDiagnostic}). */
+export function diagnosticText(d, format) {
+    return (format ? format(d) : undefined) ?? d.message;
+}