@quillmark/svelte 0.0.0

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

@@ -0,0 +1,17 @@
+import { type DocPath } from '../core/address.js';
+import type { ContentHit } from '@quillmark/wasm';
+import type { VisualEditorProps } from './props.js';
+import type { CardId } from './signals.js';
+import type { FieldController } from '../core/codec/index.js';
+import './controls.css';
+declare const VisualEditorInner: import("svelte").Component<VisualEditorProps, {
+    setCaret: (hit: ContentHit) => Promise<void>;
+    getActiveLeaf: () => FieldController | undefined;
+    focusField: (field: DocPath) => Promise<void>;
+    insertCard: (kind: string, at?: number) => CardId | undefined;
+    removeCard: (cardId: CardId) => void;
+    moveCard: (cardId: CardId, dir: -1 | 1) => void;
+    setKind: (cardId: CardId, kind: string) => void;
+}, "">;
+type VisualEditorInner = ReturnType<typeof VisualEditorInner>;
+export default VisualEditorInner;

package/dist/visual/controls.css

@@ -0,0 +1,272 @@
+/* The control recipes more than one component draws: the focus ring, the box a
+ typed value sits in, and the square icon button. They live here rather than per
+ component because Svelte scopes a `<style>` block to the component that owns the
+ markup: a component that carries a shared class without also carrying its rule
+ ships unstyled, and nothing raises it.
+
+ NOT in `core/theme.css`: that file is the DERIVATION (public dials in, the
+ private `--_qm-*` scale out) and it mints values. This file mints none; every
+ declaration reads a rung, exactly as a component's own block must; `check:style`
+ holds that over `.css` too.
+
+ `@layer qm.chrome` is the second layer `theme.css` declares. Layered rules lose
+ to unlayered ones, which is the point twice over: a consumer's stylesheet beats
+ the chrome without `!important`, and a component's own scoped block still
+ overrides its shared base: `.qm-card-delete` recolours a `.qm-icon-btn`, and
+ `.qm-json` adds the monospace face over `.qm-input`, with no specificity fight. */
+
+@layer qm.chrome {
+	/* The themed focus ring in place of the raw UA outline, as a
+	 RULE rather than a pair of rungs each control assembles. `--_qm-ring-focus`
+	 fixes the VALUE; which properties draw a ring, and on what state, is the other
+	 half of the decision, and `check:style` sees a minted literal but never a
+	 divergent rule. A control opts in by carrying the marker class.
+
+	 Two selectors, because focus lands in two places. Usually on the control
+	 itself; but the date field's focus lives on a SEGMENT, so it rings the field
+	 around it: a per-segment ring flickers across the field as the caret walks
+	 it. That is the only distinction, and this pair is the whole of it. */
+	.qm-focus-ring:focus-visible,
+	.qm-focus-ring-within:focus-within {
+		outline: var(--_qm-ring-focus);
+		outline-offset: var(--_qm-ring-offset);
+	}
+
+	/* THE TYPE HALF, for both recipe families at once. A UA control inherits neither
+	 family nor size, so a control or a button that declares none renders in the UA
+	 face at the UA size: `--qm-font`, a documented dial, stopping short of the
+	 package's own surfaces with nothing raised, since an absence mints no literal
+	 for `check:style`. `font: inherit` first, then the BODY rung off the ramp:
+	 inheriting the size lands the surface on the host page's body size, a rung the
+	 scale never minted and one a consumer moves by restyling their page rather than
+	 by turning `--qm-font-size`.
+
+	 ONE rule over both families rather than the same two declarations in each,
+	 because the drift a copy invites here is a box and the button beside it reading
+	 DIFFERENT rungs, which no gate can see: `check:style`'s type axis holds that
+	 each side reads a rung, never that both read the same one.
+
+	 The list is wider than either recipe's chrome: the body leaf withholds the box
+	 and still reads the ramp, so `.qm-prose` is
+	 here and not below.
+
+	 `font` is a shorthand carrying `line-height`, so each family's leading is
+	 declared in the rules BELOW and would be dropped in silence above them. */
+	.qm-control-box,
+	.qm-input,
+	.qm-prose,
+	.qm-icon-btn,
+	.qm-add-affordance {
+		font: inherit;
+		font-size: var(--_qm-text-body);
+	}
+
+	/* A typed value's box (every scalar control and every prose leaf): the text and
+	 numeric inputs, the array's JSON textarea, the enum trigger, the date field, and
+	 the inline richtext leaves. ONE rule, because a
+	 leaf that agrees with the input beside it "by construction" has to draw the same
+	 declarations, not a copy of them: five hand-kept copies agree until one is
+	 edited, and nothing raises it (no literal is minted, so `check:style` stays
+	 green while a control renders subtly the wrong height).
+
+	 LEADING sits on the wide list rather than on the box's own, because a box's
+	 height is a padding rung plus a line box plus two hairlines: a leaf and the
+	 input beside it agree on height exactly as long as they agree on leading, which
+	 is the whole of what "by construction" buys.
+
+	 COLOUR is the trap one property over: `font` does not carry it either, so an
+	 input or trigger left off this line falls to the UA's own text colour: a second
+	 black sitting beside the card's ink rather than the rung it renders on.
+	 `caret-color` is pinned to `currentColor` rather than left at its `auto`
+	 initial, which resolves the same way: the prose leaf's caret IS its focus
+	 indicator, the outline dropped in its favour (`ProseField`), so it tracks
+	 this rule's own ink deliberately. */
+	.qm-control-box,
+	.qm-input,
+	.qm-prose {
+		line-height: var(--_qm-leading-body);
+		color: var(--_qm-ink);
+		caret-color: currentColor;
+	}
+	.qm-control-box,
+	.qm-input {
+		padding: var(--_qm-space) var(--_qm-space-2);
+		border: var(--_qm-border-width) solid var(--_qm-border);
+		border-radius: var(--_qm-radius-inner);
+		background: var(--_qm-surface);
+	}
+	/* What a form control adds over the box: it does not fill its row on its own. */
+	.qm-input {
+		width: 100%;
+		box-sizing: border-box;
+	}
+	/* The native placeholder is the ghost rung, not the UA's own grey: a text or
+	   number control's placeholder is the resolved `default:` (Field's `defaultStr`)
+	   and reads as shown-never-written the same way the prose leaf's empty-state
+	   ghost does (`ProseField`). */
+	.qm-input::placeholder {
+		color: var(--_qm-ink-ghost);
+	}
+
+	/* The second recipe, and it is not the box above: a field is a box because you
+	 type into it, a button is not a box because you press it. No resting border and
+	 no resting fill; the
+	 surface arrives on hover, off the rung the enum listbox already highlights with.
+	 Deliberately no `color`: the callers disagree on purpose (the card delete is
+	 `--_qm-danger`, the array remove inherits its row's ink), and a base colour here
+	 would flatten that distinction rather than share a recipe.
+
+	 `--_qm-tap-min` is WCAG 2.5.8's floor, read rather than re-expressed per
+	 control: `min-*` is outside every `check:style` axis, so a second expression of
+	 the same threshold has nothing watching it. `box-sizing` is what makes it a BOX
+	 floor: a `<button>` takes border-box from the UA sheet and a plain element does
+	 not, so a control on this recipe that is not a button clears the threshold on its
+	 CONTENT box and stands a padding taller than the button beside it. Declared here,
+	 the floor means the same height whatever element carries it; and a caller that
+	 stretches one of these to its row gets a width the padding sits inside.
+
+	 Both button families are named here rather than opting in through a marker: a
+	 glyph button and an add affordance are not SOMETIMES flat, so a class they could
+	 be built without is a class one of them will eventually miss.
+
+	 The type half is the shared rule above, which both families are named in; what
+	 diverges is the LEADING. Where the box's height is a line box, a button's is
+	 `--_qm-tap-min`: a label is one line and a glyph is not text at all, so the line
+	 box collapses onto its content (`1`) and the floor decides, rather than two
+	 height sources competing. That is the same structural `1` a glyph row takes,
+	 which is why it is here and not on one family, and it is what keeps a button off
+	 the host page's leading the way the size rung keeps it off the host page's body
+	 size. A caller whose button carries a LABEL restates the rung it wants from its
+	 own block: the tips foot takes the meta rung, which is that surface's decision,
+	 not the family's. */
+	.qm-icon-btn,
+	.qm-add-affordance {
+		line-height: 1;
+		box-sizing: border-box;
+		min-width: var(--_qm-tap-min);
+		min-height: var(--_qm-tap-min);
+		border: none;
+		background: transparent;
+		border-radius: var(--_qm-radius-inner);
+		cursor: pointer;
+		transition: background-color var(--_qm-duration-fast) var(--_qm-ease-reverse);
+	}
+	.qm-icon-btn:hover:not(:disabled),
+	.qm-add-affordance:hover:not(:disabled) {
+		background: var(--_qm-surface-hover);
+	}
+	.qm-icon-btn:disabled,
+	.qm-add-affordance:disabled {
+		opacity: var(--_qm-opacity-idle);
+		cursor: default;
+	}
+
+	/* A glyph button: card reorder/delete, array remove, the field label's guidance
+	 marker, the tips card's foot. */
+	.qm-icon-btn {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		gap: var(--_qm-space-half);
+		padding: var(--_qm-space-half) var(--_qm-space);
+	}
+
+	/* An add affordance: the between-card trigger and the array foot's. A pill rather
+	 than the inner radius, because it FILLS on hover instead of tinting ink: both rest
+	 unfilled on `--_qm-opacity-idle`, so a hover shifting ink alone would have little
+	 to shift. The recede ladder itself stays with each caller: it is driven by their
+	 own hover/focus state. */
+	.qm-add-affordance {
+		border-radius: var(--_qm-radius-pill);
+		color: var(--_qm-ink-label);
+		transition:
+			opacity var(--_qm-duration-fast) var(--_qm-ease-reverse),
+			background-color var(--_qm-duration-fast) var(--_qm-ease-reverse);
+	}
+	.qm-add-affordance:hover {
+		color: var(--_qm-ink);
+	}
+
+	/* A floating list of choices: the enum's listbox and the card stack's kind menu.
+	 Both portal into the nearest `[data-qm-root]`, and both are PICKED FROM, so the
+	 surface (its edge, its inset, its ink) and the item (its pad, its radius, the
+	 rung a highlight fills with) are one recipe rather than two that agree until one
+	 is edited. What a caller adds over it is its own: the enum sizes itself off its
+	 trigger and weights the stored value.
+
+	 `[data-highlighted]` is bits-ui's mark and it is the ONLY hover lane: an item
+	 under the pointer and an item under the keyboard cursor are one state to a menu,
+	 so the primitive marks both and a `:hover` rule beside it would paint a second
+	 highlight the keyboard cannot reach. */
+	.qm-menu-surface {
+		padding: var(--_qm-space-half);
+		border: var(--_qm-border-width) solid var(--_qm-border);
+		border-radius: var(--_qm-radius);
+		background: var(--_qm-surface);
+		font-size: var(--_qm-text-body);
+		color: var(--_qm-ink);
+	}
+	.qm-menu-item {
+		padding: var(--_qm-space) var(--_qm-space-2);
+		border-radius: var(--_qm-radius-inner);
+		cursor: pointer;
+		user-select: none;
+	}
+	.qm-menu-item[data-highlighted] {
+		background: var(--_qm-surface-hover);
+	}
+
+	/* A floating surface that is READ rather than picked from: the selection popover
+	 and the field label's guidance. The theme surface mixed toward transparent
+	 behind a backdrop blur, so the page reads faintly through it and the surface
+	 rung stays the mix base, which is what keeps `--qm-bg` tinting it. The lists
+	 above stay opaque instead: a row of choices reads through a blur worse than a
+	 row of glyphs does.
+
+	 The raise and the dismissal are the recipe's too, one existence↔absence trip
+	 taken twice, which is why the class goes on the PRESENCE
+	 node (bits-ui's own content element, reached through its `child` snippet)
+	 rather than on a pill inside it: the node's animations are what the primitive
+	 waits on before unmounting, and an animation one level in is a fade it never
+	 sees. Both frames are the inner box's own; floating-ui's outer wrapper, whose
+	 transform is doing the positioning, is untouched. What a caller adds over this
+	 is its own inset, its measure, and its type.
+
+	 `data-ending-style` is the primitive's mark for the leaving half. The ink is
+	 not all that leaves with it: a surface fading out is not a thing to click or to
+	 read. That half is the caller's `inert` rather than a rule here, because the
+	 primitive styles the same node inline with `pointer-events: auto`, which no
+	 layered rule outranks; the attribute settles it without a cascade fight and
+	 takes the leaving surface out of the tab order and the a11y tree with it. */
+	.qm-popover-surface {
+		background: var(--_qm-surface-popover);
+		backdrop-filter: blur(var(--_qm-blur));
+		-webkit-backdrop-filter: blur(var(--_qm-blur));
+		border: var(--_qm-border-width) solid var(--_qm-border);
+		border-radius: var(--_qm-radius);
+		animation: qm-pop-in var(--_qm-duration-fast) var(--_qm-ease-arrive);
+	}
+	.qm-popover-surface[data-ending-style] {
+		animation: qm-pop-out var(--_qm-duration-fast) var(--_qm-ease-depart);
+	}
+	@keyframes qm-pop-in {
+		from {
+			opacity: 0;
+			transform: scale(0.94);
+		}
+		to {
+			opacity: 1;
+			transform: none;
+		}
+	}
+	@keyframes qm-pop-out {
+		from {
+			opacity: 1;
+			transform: none;
+		}
+		to {
+			opacity: 0;
+			transform: scale(0.94);
+		}
+	}
+}

package/dist/visual/diagnostics.d.ts

@@ -0,0 +1,52 @@
+import type { Diagnostic } from '@quillmark/wasm';
+/** A field's routing address. `card` is `undefined` for the main card; a
+ * composable card slot is a stable session id (the editor's own bookkeeping)
+ * once resolved, or an ABSOLUTE document-array index straight off a parsed
+ * `DocPath` (resolve via {@link resolveCardKey} before merging with id-keyed
+ * sources). `field` `undefined` addresses the body (the field-less leaf). */
+export interface FieldKey {
+    card?: string | number;
+    field?: string;
+}
+/** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
+export declare function fieldKeyToString(k: FieldKey): string;
+/**
+ * Route a canonical `DocPath` (a `Diagnostic.path`, or a `ContentHit` /
+ * `FieldRegion` field address; one grammar) to a `FieldKey`, `card` the ABSOLUTE
+ * document-array index. `/core`'s `addrForFieldPath` IS this walk — an `Addr` is a
+ * positional `FieldKey` — so routing reads the one public inverse rather than a
+ * second copy of the grammar that drifts from it. `undefined` for a path naming no
+ * single commit address (a nested / array-element path, a field-rooted one, a
+ * malformed one).
+ */
+export declare function parsePath(path: string): FieldKey | undefined;
+/**
+ * Resolve a positional `FieldKey` (an ABSOLUTE document-array index, straight off
+ * {@link parsePath}) to the editor's stable-id keying using the LIVE `cardIds`
+ * array: re-resolved fresh on every call (never cached), the same "resolve only
+ * at the point of use" discipline `cardIndexOf` applies to writes (VISUAL_EDITOR
+ * §"The address is the spine"). A key already id-keyed (`card` a string) or main
+ * (`card` undefined) passes through unchanged. `undefined` when the index is out
+ * of the current card array: the diagnostic is dropped rather than mis-routed.
+ */
+export declare function resolveCardKey(key: FieldKey, cardIds: readonly string[]): FieldKey | undefined;
+/** One diagnostic paired with the `FieldKey` it targets. */
+export interface RoutedDiagnostic {
+    key: FieldKey;
+    diagnostic: Diagnostic;
+}
+/**
+ * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
+ * editor's stable-id keying: the ONE door producers #1/#3 take, `parsePath` and
+ * `resolveCardKey` in a single pass. An entry drops rather than mis-routes when it
+ * carries no `path`, when `parsePath` cannot place it (a nested / array-element
+ * address), or when its absolute card index is out of the live `cardIds`.
+ */
+export declare function routeAndResolve(diagnostics: Diagnostic[] | undefined, cardIds: readonly string[]): RoutedDiagnostic[];
+/**
+ * Merge N routed groups into `Map<fieldKeyToString(key), Diagnostic[]>`.
+ * Dedupes an identical `(severity, message)` pair landing on the same key from
+ * more than one group (e.g. the same warning present in both `validate()` and
+ * an external feed); within a key, errors sort before warnings.
+ */
+export declare function mergeDiagnostics(...groups: RoutedDiagnostic[][]): Map<string, Diagnostic[]>;

package/dist/visual/diagnostics.js

@@ -0,0 +1,83 @@
+import { addrForFieldPath } from '../core/address.js';
+/** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
+export function fieldKeyToString(k) {
+    return `${k.card ?? 'main'}:${k.field ?? '$body'}`;
+}
+/**
+ * Route a canonical `DocPath` (a `Diagnostic.path`, or a `ContentHit` /
+ * `FieldRegion` field address; one grammar) to a `FieldKey`, `card` the ABSOLUTE
+ * document-array index. `/core`'s `addrForFieldPath` IS this walk — an `Addr` is a
+ * positional `FieldKey` — so routing reads the one public inverse rather than a
+ * second copy of the grammar that drifts from it. `undefined` for a path naming no
+ * single commit address (a nested / array-element path, a field-rooted one, a
+ * malformed one).
+ */
+export function parsePath(path) {
+    return addrForFieldPath(path);
+}
+/**
+ * Resolve a positional `FieldKey` (an ABSOLUTE document-array index, straight off
+ * {@link parsePath}) to the editor's stable-id keying using the LIVE `cardIds`
+ * array: re-resolved fresh on every call (never cached), the same "resolve only
+ * at the point of use" discipline `cardIndexOf` applies to writes (VISUAL_EDITOR
+ * §"The address is the spine"). A key already id-keyed (`card` a string) or main
+ * (`card` undefined) passes through unchanged. `undefined` when the index is out
+ * of the current card array: the diagnostic is dropped rather than mis-routed.
+ */
+export function resolveCardKey(key, cardIds) {
+    if (typeof key.card !== 'number')
+        return key;
+    const id = key.card >= 0 && key.card < cardIds.length ? cardIds[key.card] : undefined;
+    return id != null ? { card: id, field: key.field } : undefined;
+}
+/**
+ * Route a path-keyed producer's raw `Diagnostic[]` (validate / external) to the
+ * editor's stable-id keying: the ONE door producers #1/#3 take, `parsePath` and
+ * `resolveCardKey` in a single pass. An entry drops rather than mis-routes when it
+ * carries no `path`, when `parsePath` cannot place it (a nested / array-element
+ * address), or when its absolute card index is out of the live `cardIds`.
+ */
+export function routeAndResolve(diagnostics, cardIds) {
+    const out = [];
+    for (const d of diagnostics ?? []) {
+        if (!d.path)
+            continue;
+        const key = parsePath(d.path);
+        const resolved = key && resolveCardKey(key, cardIds);
+        if (resolved)
+            out.push({ key: resolved, diagnostic: d });
+    }
+    return out;
+}
+/** Severity ordering: errors sort before warnings within a field's list (never dropped, just ranked: VISUAL_EDITOR §Diagnostics "nothing gates" extends to nothing hides). */
+const SEVERITY_RANK = { error: 0, warning: 1 };
+/**
+ * Merge N routed groups into `Map<fieldKeyToString(key), Diagnostic[]>`.
+ * Dedupes an identical `(severity, message)` pair landing on the same key from
+ * more than one group (e.g. the same warning present in both `validate()` and
+ * an external feed); within a key, errors sort before warnings.
+ */
+export function mergeDiagnostics(...groups) {
+    const byKey = new Map();
+    const seen = new Set();
+    for (const group of groups) {
+        for (const { key, diagnostic } of group) {
+            const k = fieldKeyToString(key);
+            // Collision-proof key: JSON-encode the triple so arbitrary `message` text
+            // can never merge two distinct triples into one (a real diagnostic dropped).
+            const dedupeKey = JSON.stringify([k, diagnostic.severity, diagnostic.message]);
+            if (seen.has(dedupeKey))
+                continue;
+            seen.add(dedupeKey);
+            const arr = byKey.get(k);
+            if (arr)
+                arr.push(diagnostic);
+            else
+                byKey.set(k, [diagnostic]);
+        }
+    }
+    for (const arr of byKey.values()) {
+        arr.sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]);
+    }
+    return byKey;
+}

package/dist/visual/domid.d.ts

@@ -0,0 +1,21 @@
+/** The three names one field spends in the DOM. */
+export interface FieldDomIds {
+    /** The control's own id: a `<label for>` target where the control is labelable. */
+    control: string;
+    /** The label's own id: the `aria-labelledby` target where `for` cannot reach. */
+    label: string;
+    /** Where the `description` text is parked for `aria-describedby`. */
+    description: string;
+}
+export declare function fieldDomIds(uid: string, leafKey: string): FieldDomIds;
+/**
+ * A group panel's own id: what its header's `aria-controls` names, and the only
+ * name in the DOM that is a card's rather than a field's. `card` follows the leaf
+ * key's convention (`undefined` is the main card), so a panel and the fields
+ * inside it carry the same card token.
+ *
+ * The `-g-` infix cannot land on a field id: a field's is the escaped
+ * `card:field`, whose separator escapes to `-3a-`, and the two differ at exactly
+ * that position for every card token the id space mints.
+ */
+export declare function groupPanelId(uid: string, card: string | undefined, group: string): string;

package/dist/visual/domid.js

@@ -0,0 +1,36 @@
+// A field's DOM ids. The DOM needs three names per field (the control a `<label
+// for>` points at, the label an `aria-labelledby` control points back to, and the
+// parked description an `aria-describedby` reads) and they are derived from the
+// leaf key so the DOM shares the ONE per-field identity space the registry and
+// diagnostics already collapse to (`fieldKeyToString`), rather than minting a
+// second.
+//
+// `uid` is the editor instance's own (`$props.id()`, stable across SSR and
+// hydration). The leaf-key space is unique per EDITOR, not per document: two
+// `VisualEditor`s on a page both hold `main:subject`, and a duplicate `id` makes
+// `for` resolve to whichever mounted first.
+/**
+ * `id` syntax admits far less than a leaf key spends (`main:subject`, `$body`).
+ * The escape is INJECTIVE (`-` introduces it, so `-` escapes itself), which a
+ * plain replace-with-dash is not: `a:b` and `a-b` would collapse onto one id.
+ */
+function escapeId(key) {
+    return key.replace(/[^A-Za-z0-9_]/g, (c) => `-${c.codePointAt(0).toString(16)}-`);
+}
+export function fieldDomIds(uid, leafKey) {
+    const base = `qm-${uid}-${escapeId(leafKey)}`;
+    return { control: base, label: `${base}-label`, description: `${base}-desc` };
+}
+/**
+ * A group panel's own id: what its header's `aria-controls` names, and the only
+ * name in the DOM that is a card's rather than a field's. `card` follows the leaf
+ * key's convention (`undefined` is the main card), so a panel and the fields
+ * inside it carry the same card token.
+ *
+ * The `-g-` infix cannot land on a field id: a field's is the escaped
+ * `card:field`, whose separator escapes to `-3a-`, and the two differ at exactly
+ * that position for every card token the id space mints.
+ */
+export function groupPanelId(uid, card, group) {
+    return `qm-${uid}-${escapeId(card ?? 'main')}-g-${escapeId(group)}`;
+}

package/dist/visual/ext.d.ts

@@ -0,0 +1,19 @@
+import type { Document, CardAddr } from '@quillmark/wasm';
+/**
+ * Merge `patch` into `$ext.editor` on the card `addr` targets (absent `card` =
+ * main). A key whose patch value is `undefined` is DROPPED; every other key in the
+ * namespace is carried through untouched.
+ *
+ * **The namespace is the write unit.** `storeExtNamespace` replaces the namespace
+ * it targets (preserving sibling namespaces, but not sibling keys) so a writer
+ * that stores only its own key silently destroys the others, and
+ * `removeExtNamespace` destroys all of them. `tips` and `title` are siblings here,
+ * so a namespace-replacing dismissal would wipe every renamed card's title. Routing
+ * every writer through this function is what makes that unexpressible rather than
+ * merely documented: key N+1 inherits the merge instead of re-deriving it.
+ *
+ * The drop is an explicit `delete`, not a stored `undefined`: whether a JS
+ * `undefined` survives the wasm-bindgen crossing is not a property worth depending
+ * on.
+ */
+export declare function patchEditorExt(doc: Document, addr: CardAddr, patch: Record<string, unknown>): void;

package/dist/visual/ext.js

@@ -0,0 +1,29 @@
+/**
+ * Merge `patch` into `$ext.editor` on the card `addr` targets (absent `card` =
+ * main). A key whose patch value is `undefined` is DROPPED; every other key in the
+ * namespace is carried through untouched.
+ *
+ * **The namespace is the write unit.** `storeExtNamespace` replaces the namespace
+ * it targets (preserving sibling namespaces, but not sibling keys) so a writer
+ * that stores only its own key silently destroys the others, and
+ * `removeExtNamespace` destroys all of them. `tips` and `title` are siblings here,
+ * so a namespace-replacing dismissal would wipe every renamed card's title. Routing
+ * every writer through this function is what makes that unexpressible rather than
+ * merely documented: key N+1 inherits the merge instead of re-deriving it.
+ *
+ * The drop is an explicit `delete`, not a stored `undefined`: whether a JS
+ * `undefined` survives the wasm-bindgen crossing is not a property worth depending
+ * on.
+ */
+export function patchEditorExt(doc, addr, patch) {
+    // `getExtNamespace` reads just this namespace rather than serializing the whole
+    // card to fish out one `$ext` slot.
+    const next = { ...(doc.getExtNamespace(addr, 'editor') ?? {}) };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    doc.storeExtNamespace(addr, 'editor', next);
+}

package/dist/visual/icons/Icon.svelte

@@ -0,0 +1,39 @@
+<script lang="ts">
+	// The one glyph renderer: a name off the closed set in `nodes.ts`, drawn against
+	// the shared frame. Stroke, fill and cap are the frame rather than props — a glyph
+	// that strokes differently from its neighbours is a decision no call site has, and
+	// `currentColor` is what puts the hue on the button's `color`, where the surface's
+	// hover and open transitions already reach it.
+	import { ICONS, type IconName } from './nodes.js';
+	import type { SVGAttributes } from 'svelte/elements';
+
+	interface Props extends Omit<SVGAttributes<SVGSVGElement>, 'name'> {
+		name: IconName;
+		/** The frame's edge, in px. The card controls pass none and take the default,
+		 *  then size the glyph from `--_qm-glyph-control` in CSS, where the header's
+		 *  right hang is measured against the same number. */
+		size?: number;
+	}
+	let { name, size = 24, ...rest }: Props = $props();
+</script>
+
+<!-- `aria-hidden` ahead of the spread, so it is the default rather than the rule: every
+	glyph in this package sits inside a button that carries the name, and a call site
+	that has one to say overrides it. -->
+<svg
+	xmlns="http://www.w3.org/2000/svg"
+	width={size}
+	height={size}
+	viewBox="0 0 24 24"
+	fill="none"
+	stroke="currentColor"
+	stroke-width="2"
+	stroke-linecap="round"
+	stroke-linejoin="round"
+	aria-hidden="true"
+	{...rest}
+>
+	{#each ICONS[name] as [tag, attrs]}
+		<svelte:element this={tag} {...attrs} />
+	{/each}
+</svg>

package/dist/visual/icons/Icon.svelte.d.ts

@@ -0,0 +1,12 @@
+import { type IconName } from './nodes.js';
+import type { SVGAttributes } from 'svelte/elements';
+interface Props extends Omit<SVGAttributes<SVGSVGElement>, 'name'> {
+    name: IconName;
+    /** The frame's edge, in px. The card controls pass none and take the default,
+     *  then size the glyph from `--_qm-glyph-control` in CSS, where the header's
+     *  right hang is measured against the same number. */
+    size?: number;
+}
+declare const Icon: import("svelte").Component<Props, {}, "">;
+type Icon = ReturnType<typeof Icon>;
+export default Icon;