@quillmark/svelte 0.1.1 → 0.3.0

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

@@ -1,11 +1,10 @@
-import { type DocPath } from '../core/address.js';
-import type { ContentHit } from '@quillmark/wasm';
+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 './controls.css';
 declare const VisualEditorInner: import("svelte").Component<VisualEditorProps, {
-    setCaret: (hit: ContentHit) => Promise<void>;
+    setCaret: (at: Landing) => Promise<void>;
     getActiveLeaf: () => FieldController | undefined;
     focusField: (field: DocPath) => Promise<void>;
     insertCard: (kind: string, at?: number) => CardId | undefined;

package/dist/visual/controls.css

@@ -4,7 +4,7 @@
  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
+ 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.
@@ -17,41 +17,42 @@
 
 @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
+	 rule rather than a pair of rungs each control assembles. `--_qm-ring`
+	 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
+	 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: var(--_qm-ring);
 		outline-offset: var(--_qm-ring-offset);
 	}
 
-	/* THE TYPE HALF, for both recipe families at once. A UA control inherits neither
+	/* 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:
+	 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,
+	 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
+	 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
+	 The list is wider than either recipe's chrome: a prose leaf withholds the box
 	 and still reads the ramp, so `.qm-prose` is
-	 here and not below.
+	 here and not below. The body leaf steps off this rung onto `--_qm-text-paper`
+	 from its own block (`ProseField`).
 
 	 `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. */
+	 declared in the rules below and would be dropped in silence above them. */
 	.qm-control-box,
 	.qm-input,
 	.qm-prose,
@@ -63,22 +64,24 @@
 
 	/* 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
+	 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.
+	 Leading sits on the wide list rather than on the box's own, because a box's
+	 height is an inset rung plus a line box and nothing else: a leaf and the
+	 input beside it agree on height exactly as long as they agree on leading and on
+	 size, which is the whole of what "by construction" buys. The body leaf keeps the
+	 leading and steps off the size, which costs it nothing: it draws no box and
+	 stands in no row.
 
-	 COLOUR is the trap one property over: `font` does not carry it either, so an
+	 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
+	 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,
@@ -88,12 +91,15 @@
 		color: var(--_qm-ink);
 		caret-color: currentColor;
 	}
+	/* The box is A fill and not an edge (ARCHITECTURE §Styling), and the fill is the
+	 well rung: a field is a hole cut into the card rather than a plane of its own,
+	 and with no edge to carry it the step is the whole of what says so. */
 	.qm-control-box,
 	.qm-input {
-		padding: var(--_qm-space) var(--_qm-space-2);
-		border: var(--_qm-border-width) solid var(--_qm-border);
+		padding: var(--_qm-inset-control);
+		border: none;
 		border-radius: var(--_qm-radius-inner);
-		background: var(--_qm-surface);
+		background: var(--_qm-surface-well);
 	}
 	/* What a form control adds over the box: it does not fill its row on its own. */
 	.qm-input {
@@ -118,26 +124,26 @@
 
 	 `--_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
+	 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,
+	 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
+	 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
+	 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,
+	 size. A caller whose button carries a label restates the rung it wants from its
+	 own block: the tips foot takes the label rung, which is that surface's decision,
 	 not the family's. */
 	.qm-icon-btn,
 	.qm-add-affordance {
@@ -172,7 +178,7 @@
 	}
 
 	/* 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
+	 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. */
@@ -187,36 +193,77 @@
 		color: var(--_qm-ink);
 	}
 
+	/* The press floor, for a trigger standing in a line of text or a band of gutter
+	 rather than in a row of its own, whose drawn box is therefore smaller than the target
+	 it owes. A target is a region of the screen and a box is paint; separating them is
+	 what lets both be right at once. The target is the box or the floor, whichever is
+	 larger, which is what `width: 100%` under a `min-width` says. Unpainted, so it
+	 enlarges the press and not the mark, and out of the accessibility tree by
+	 construction: a pseudo-element has no node.
+
+	 The family's floor comes off in the same rule, carrying this class being what giving
+	 it up means. It sits after both families for that: same specificity, so source order
+	 decides. */
+	.qm-tap-floor {
+		position: relative;
+		min-width: 0;
+		min-height: 0;
+	}
+	.qm-tap-floor::after {
+		content: '';
+		position: absolute;
+		top: 50%;
+		left: 50%;
+		width: 100%;
+		min-width: var(--_qm-tap-min);
+		height: var(--_qm-tap-min);
+		transform: translate(-50%, -50%);
+	}
+
 	/* 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
+	 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
+	 `[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. */
+	 highlight the keyboard cannot reach. It fills with the accent held rather than
+	 the hover rung: the mark is a cursor a keyboard drives, so it has to read at a
+	 glance from across the list, where a hover only has to confirm the pointer
+	 already under it.
+
+	 The resting fill is the recipe's too: an item drawn on a `<button>` carries a UA
+	 fill to take back, and a component's scoped block is unlayered, so a caller taking
+	 it back outranks this layer and erases the highlight with it. Transparent here
+	 leaves the caller nothing to declare.
+
+	 A floating surface is the one place a hairline is still load-bearing: it hangs
+	 over content the surface did not choose, so there is no plane under it for a
+	 tone to step off (ARCHITECTURE §Styling). It takes the raised rung as well, which
+	 is a real step in dark and nothing in light, where the edge is the whole of it. */
 	.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);
+		background: var(--_qm-surface-raised);
 		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);
+		background: transparent;
 		cursor: pointer;
 		user-select: none;
 	}
 	.qm-menu-item[data-highlighted] {
-		background: var(--_qm-surface-hover);
+		background: var(--_qm-accent-tint);
 	}
 
-	/* A floating surface that is READ rather than picked from: the selection popover
+	/* 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
@@ -224,7 +271,7 @@
 	 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
+	 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
@@ -244,10 +291,10 @@
 		-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);
+		animation: qm-pop-in var(--_qm-duration-fast) var(--_qm-ease-reverse);
 	}
 	.qm-popover-surface[data-ending-style] {
-		animation: qm-pop-out var(--_qm-duration-fast) var(--_qm-ease-depart);
+		animation: qm-pop-out var(--_qm-duration-fast) var(--_qm-ease-reverse);
 	}
 	@keyframes qm-pop-in {
 		from {

package/dist/visual/diagnostics.d.ts

@@ -1,9 +1,11 @@
 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). */
+/** A field's routing address, and `/core`'s `Addr` structurally: an `Addr` is a
+ * positional `FieldKey`, so `addrForFieldPath` is the path→key walk and routing
+ * carries no second copy of the grammar. `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;
@@ -11,18 +13,8 @@ export interface FieldKey {
 /** 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`
+ * Resolve a positional `FieldKey` (an absolute document-array index, straight off
+ * `addrForFieldPath`) 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
@@ -37,10 +29,10 @@ export interface RoutedDiagnostic {
 }
 /**
  * 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`.
+ * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
+ * and `resolveCardKey` in a single pass. An entry drops rather than mis-routes when
+ * it carries no `path`, when the path names no single commit address (a nested /
+ * array-element one), or when its absolute card index is out of the live `cardIds`.
  */
 export declare function routeAndResolve(diagnostics: Diagnostic[] | undefined, cardIds: readonly string[]): RoutedDiagnostic[];
 /**

package/dist/visual/diagnostics.js

@@ -4,20 +4,8 @@ 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`
+ * Resolve a positional `FieldKey` (an absolute document-array index, straight off
+ * `addrForFieldPath`) 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
@@ -32,17 +20,17 @@ export function resolveCardKey(key, cardIds) {
 }
 /**
  * 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`.
+ * editor's stable-id keying: the one door producers #1/#3 take, `addrForFieldPath`
+ * and `resolveCardKey` in a single pass. An entry drops rather than mis-routes when
+ * it carries no `path`, when the path names no single commit address (a nested /
+ * array-element one), 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 key = addrForFieldPath(d.path);
         const resolved = key && resolveCardKey(key, cardIds);
         if (resolved)
             out.push({ key: resolved, diagnostic: d });

package/dist/visual/domid.js

@@ -1,17 +1,17 @@
 // 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
+// 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
+// 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
+ * 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) {

package/dist/visual/ext.d.ts

@@ -1,7 +1,7 @@
 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
+ * 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

package/dist/visual/ext.js

@@ -1,6 +1,6 @@
 /**
  * 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
+ * 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

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

@@ -97,6 +97,9 @@ export declare const ICONS: {
     }], readonly ["path", {
         readonly d: "m6 6 12 12";
     }]];
+    readonly minus: readonly [readonly ["path", {
+        readonly d: "M5 12h14";
+    }]];
 };
 /** 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. */

package/dist/visual/icons/nodes.js

@@ -51,5 +51,6 @@ export const ICONS = {
     x: [
         ['path', { d: 'M18 6 6 18' }],
         ['path', { d: 'm6 6 12 12' }]
-    ]
+    ],
+    minus: [['path', { d: 'M5 12h14' }]]
 };

package/dist/visual/index.d.ts

@@ -1,3 +1,4 @@
+import '../core/theme.css';
 export { default as VisualEditor } from './VisualEditor.svelte';
 export type { VisualEditorProps } from './props.js';
 export { createField } from '../core/codec/index.js';

package/dist/visual/index.js

@@ -3,19 +3,26 @@
 // 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.
+// 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.
+// The theme derivation, which every control on this surface reads through `var()`.
+// Imported at the barrel because a subpath is what a consumer gets: this surface
+// reaches modules inside `core/` and never its entry, so a sheet hanging off that
+// entry arrives only for a consumer importing `/core` for some other reason. The
+// sheet rather than the entry, because the barrel needs the derivation and not
+// `init`. `check:deps` (rule 4) walks this file's own graph and holds the reach.
+import '../core/theme.css';
 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
+// 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.
+// it. The empty body's per-card 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

package/dist/visual/leaves.d.ts

@@ -0,0 +1,47 @@
+import type { FieldController } from '../core/codec/index.js';
+/**
+ * A mounted field's landing handle: focus it, and the element the arrival wash blooms
+ * inside ({@link import('../core/bloom.js').bloomInside}).
+ *
+ * A `FieldController` is one, which is what lets the two lanes share a lookup; `Field`
+ * builds the same shape over a form control off the handoff a label click already
+ * takes, so `focusField` and a label cannot land in different places.
+ */
+export interface FieldControl {
+    focus(): void;
+    /**
+     * Focus element `index` of a control that has elements, resolving the index to the
+     * element's session id at the call; {@link focus}'s own answer for an index past
+     * the live list. Absent on every control without elements.
+     *
+     * The granularity rides the call because the registry stays parent-keyed: a
+     * per-element key is positional, in a registry whose doctrine is dodging
+     * positional churn.
+     */
+    focusElement?(index: number): void;
+    readonly el: HTMLElement;
+}
+/**
+ * The registry the editor holds and the mounted tree writes into.
+ *
+ * A lane is dropped by its own owner, which is what the symmetric pairs are for: a
+ * card retyped to a kind that declares the same field name at another type swaps the
+ * control under one leaf key without remounting `Field`, so the leaving control and
+ * the arriving prose leaf both touch that key with no order between them to rely on.
+ */
+export interface LeafRegistry {
+    /** A prose leaf, by its controller: the landing handle and the codec seam at once. */
+    registerProse(key: string, controller: FieldController): void;
+    unregisterProse(key: string): void;
+    /** A form control: the landing lane only, having no codec half to offer. */
+    registerControl(key: string, control: FieldControl): void;
+    unregisterControl(key: string): void;
+    /** The landing handle at `key`, whichever lane holds it. */
+    control(key: string): FieldControl | undefined;
+    /** The codec seam at `key`, `undefined` for a form control. */
+    prose(key: string): FieldController | 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;

package/dist/visual/leaves.js

@@ -0,0 +1,31 @@
+export function createLeafRegistry() {
+    const controls = new Map();
+    const proses = new Map();
+    return {
+        registerProse(key, controller) {
+            proses.set(key, controller);
+        },
+        unregisterProse(key) {
+            proses.delete(key);
+        },
+        registerControl(key, control) {
+            controls.set(key, control);
+        },
+        unregisterControl(key) {
+            controls.delete(key);
+        },
+        // The prose map is read second: a controller is a control, so a leaf answers a
+        // landing without a second entry, and a key the two lanes overlap on during a
+        // retype resolves to the form control the tree is currently rendering.
+        control(key) {
+            return controls.get(key) ?? proses.get(key);
+        },
+        prose(key) {
+            return proses.get(key);
+        },
+        clear() {
+            controls.clear();
+            proses.clear();
+        }
+    };
+}

package/dist/visual/links.d.ts

@@ -0,0 +1,24 @@
+import type { Command, EditorState } from 'prosemirror-state';
+/**
+ * The href a typed value stands for. A value with no scheme names a host, and
+ * stored verbatim it is a relative href resolving against whatever page the editor
+ * is embedded in, so it takes `https://`. A bare address takes `mailto:` instead,
+ * the host prefix reading `jane@example.com` as `example.com` with `jane` for
+ * userinfo — a wrong destination this normalization would itself have minted.
+ *
+ * A rooted value is left alone, being the spelling that asks for the embedding
+ * page, and so is anything already carrying a scheme. `''` for a blank value, which
+ * is nothing to apply.
+ */
+export declare function normalizeHref(raw: string): string;
+/**
+ * The href under the selection: the first link mark it touches, `''` where it
+ * touches none. A selection may span several links; the prompt holds one value, so
+ * the first is both what it seeds with and what an apply writes over the whole
+ * range.
+ */
+export declare function hrefInSelection(state: EditorState): string;
+/** Write `href` over the selection, replacing whatever link it already carries. */
+export declare function setLink(href: string): Command;
+/** Drop every link the selection carries. */
+export declare const clearLink: Command;

package/dist/visual/links.js

@@ -0,0 +1,67 @@
+/** A scheme: a letter, then letters, digits, `+`, `-` or `.`, then `:` (RFC 3986). */
+const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/** Rooted at the page rather than at a host: an absolute path, a query, a fragment,
+ *  or a protocol-relative host. Every one of them means relative on purpose. */
+const ROOTED = /^[/#?]/;
+/** A bare mail address: one `@`, no scheme and no path. */
+const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
+/**
+ * The href a typed value stands for. A value with no scheme names a host, and
+ * stored verbatim it is a relative href resolving against whatever page the editor
+ * is embedded in, so it takes `https://`. A bare address takes `mailto:` instead,
+ * the host prefix reading `jane@example.com` as `example.com` with `jane` for
+ * userinfo — a wrong destination this normalization would itself have minted.
+ *
+ * A rooted value is left alone, being the spelling that asks for the embedding
+ * page, and so is anything already carrying a scheme. `''` for a blank value, which
+ * is nothing to apply.
+ */
+export function normalizeHref(raw) {
+    const value = raw.trim();
+    if (!value || SCHEME.test(value) || ROOTED.test(value))
+        return value;
+    return ADDRESS.test(value) ? `mailto:${value}` : `https://${value}`;
+}
+/**
+ * The href under the selection: the first link mark it touches, `''` where it
+ * touches none. A selection may span several links; the prompt holds one value, so
+ * the first is both what it seeds with and what an apply writes over the whole
+ * range.
+ */
+export function hrefInSelection(state) {
+    const type = state.schema.marks.link;
+    if (!type)
+        return '';
+    const { from, to } = state.selection;
+    let href = '';
+    state.doc.nodesBetween(from, to, (node) => {
+        if (href)
+            return false;
+        const mark = type.isInSet(node.marks);
+        if (mark)
+            href = String(mark.attrs.href ?? '');
+    });
+    return href;
+}
+/** Write `href` over the selection, replacing whatever link it already carries. */
+export function setLink(href) {
+    return (state, dispatch) => {
+        const type = state.schema.marks.link;
+        const { from, to, empty } = state.selection;
+        if (!type || empty || !href)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.removeMark(from, to, type).addMark(from, to, type.create({ href })));
+        return true;
+    };
+}
+/** Drop every link the selection carries. */
+export const clearLink = (state, dispatch) => {
+    const type = state.schema.marks.link;
+    const { from, to, empty } = state.selection;
+    if (!type || empty || !state.doc.rangeHasMark(from, to, type))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.removeMark(from, to, type));
+    return true;
+};