@quillmark/svelte 0.2.0 → 0.3.1

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,13 +17,13 @@
 
 @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`
-	 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,
@@ -32,27 +32,27 @@
 		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: a prose leaf withholds the box
 	 and still reads the ramp, so `.qm-prose` is
-	 here and not below. The BODY leaf steps off this rung onto `--_qm-text-paper`
+	 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,
@@ -64,24 +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 an inset rung plus a line box plus two hairlines: a leaf and the
+	 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,
@@ -91,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-inset-control);
-		border: var(--_qm-border-width) solid var(--_qm-border);
+		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 {
@@ -121,25 +124,25 @@
 
 	 `--_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
+	 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,
@@ -175,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. */
@@ -190,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
@@ -227,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

package/dist/visual/diagnostics.d.ts

@@ -1,9 +1,9 @@
 import type { Diagnostic } from '@quillmark/wasm';
-/** A field's routing address, and `/core`'s `Addr` structurally: an `Addr` IS a
+/** 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`
+ * 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 {
@@ -13,8 +13,8 @@ export interface FieldKey {
 /** Canonical string key for a `FieldKey`: the routing `Map`'s key space. */
 export declare function fieldKeyToString(k: FieldKey): string;
 /**
- * Resolve a positional `FieldKey` (an ABSOLUTE document-array index, straight off
- * `addrForFieldPath`) 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
@@ -29,7 +29,7 @@ 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, `addrForFieldPath`
+ * 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`.

package/dist/visual/diagnostics.js

@@ -4,8 +4,8 @@ export function fieldKeyToString(k) {
     return `${k.card ?? 'main'}:${k.field ?? '$body'}`;
 }
 /**
- * Resolve a positional `FieldKey` (an ABSOLUTE document-array index, straight off
- * `addrForFieldPath`) 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
@@ -20,7 +20,7 @@ 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, `addrForFieldPath`
+ * 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`.

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

@@ -4,6 +4,11 @@ export declare const ICONS: {
     readonly 'chevron-right': readonly [readonly ["path", {
         readonly d: "m9 18 6-6-6-6";
     }]];
+    readonly 'arrow-right': readonly [readonly ["path", {
+        readonly d: "M5 12h14";
+    }], readonly ["path", {
+        readonly d: "m12 5 7 7-7 7";
+    }]];
     readonly 'chevron-down': readonly [readonly ["path", {
         readonly d: "m6 9 6 6 6-6";
     }]];
@@ -97,6 +102,20 @@ export declare const ICONS: {
     }], readonly ["path", {
         readonly d: "m6 6 12 12";
     }]];
+    readonly 'trash-2': readonly [readonly ["path", {
+        readonly d: "M10 11v6";
+    }], readonly ["path", {
+        readonly d: "M14 11v6";
+    }], readonly ["path", {
+        readonly d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6";
+    }], readonly ["path", {
+        readonly d: "M3 6h18";
+    }], readonly ["path", {
+        readonly d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2";
+    }]];
+    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

@@ -8,6 +8,10 @@
 // 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' }]],
+    'arrow-right': [
+        ['path', { d: 'M5 12h14' }],
+        ['path', { d: 'm12 5 7 7-7 7' }]
+    ],
     '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' }]],
@@ -51,5 +55,13 @@ export const ICONS = {
     x: [
         ['path', { d: 'M18 6 6 18' }],
         ['path', { d: 'm6 6 12 12' }]
-    ]
+    ],
+    'trash-2': [
+        ['path', { d: 'M10 11v6' }],
+        ['path', { d: 'M14 11v6' }],
+        ['path', { d: 'M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6' }],
+        ['path', { d: 'M3 6h18' }],
+        ['path', { d: 'M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2' }]
+    ],
+    minus: [['path', { d: 'M5 12h14' }]]
 };

package/dist/visual/index.js

@@ -3,13 +3,13 @@
 // 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
+// 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
@@ -19,10 +19,10 @@ 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

@@ -10,11 +10,11 @@ import type { FieldController } from '../core/codec/index.js';
 export interface FieldControl {
     focus(): void;
     /**
-     * Focus element `index` of a control that HAS elements, resolving the index to the
+     * 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
+     * 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.
      */
@@ -24,7 +24,7 @@ export interface FieldControl {
 /**
  * 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
+ * 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.

package/dist/visual/leaves.js

@@ -14,7 +14,7 @@ export function createLeafRegistry() {
         unregisterControl(key) {
             controls.delete(key);
         },
-        // The prose map is read SECOND: a controller is a control, so a leaf answers a
+        // 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) {

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;
+};

package/dist/visual/props.d.ts

@@ -6,7 +6,7 @@ import type { FormatDiagnostic, VisualStringsInput } from './strings.js';
 export interface VisualEditorProps {
     doc: Document;
     /**
-     * The schema this document is edited against. BORROWED for the surface's lifetime,
+     * The schema this document is edited against. Borrowed for the surface's lifetime,
      * whoever handed it over: a quill from `@quillmark/quiver`'s `getQuill` is the
      * quiver's, shared with every other caller for that ref, and freeing it hands the
      * next caller a freed handle. A host wanting one of its own mints it from
@@ -26,16 +26,16 @@ export interface VisualEditorProps {
      * 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
+     * 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
+     * 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
+     * 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.
      *
@@ -47,7 +47,7 @@ export interface VisualEditorProps {
      */
     onChange?: (change: EditorChange) => void;
     /**
-     * Failures the editor RECOVERED from: a commit the boundary refused (also
+     * 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
@@ -71,15 +71,15 @@ export interface VisualEditorProps {
     /**
      * How an `enumOptionAllowed: false` option draws: `'disable'` (the default) greys
      * it in place, `'hide'` leaves it out of the list. One policy for the surface, not
-     * a per-option verdict, and the SELECTED value is drawn under either (disabled
+     * a per-option verdict, and the selected value is drawn under either (disabled
      * when refused), so the control always shows what the document says
      * (VISUAL_EDITOR §"Enum policy").
      */
     enumDisallowed?: 'hide' | 'disable';
     /**
      * 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
+     * English. Several are accessible names rather than decoration, so this is what
+     * a product shipping in another language replaces. The empty body's per-card
      * wording is the `bodyPlaceholder` key here rather than a prop of its own.
      */
     strings?: VisualStringsInput;