@quillmark/svelte 0.5.0 → 0.6.0

package/README.md

@@ -60,6 +60,12 @@ const session = await new Engine().open(quill, doc);
 
 Opening a document that names a **different** quill is the same sequence, in order: resolve the new ref, `engine.open(quill, next)`, swap the props, then free the replaced handles that were yours to free. `<VisualEditor>` re-keys itself on the new `doc` (see below); `<Preview>` swaps by remount (`{#key session}`).
 
+## What a document is trusted to be
+
+**A `Document` may be one its reader did not write** — an import, a shared file, a row from a multi-tenant store — and two properties hold over one regardless. Markdown becomes typed nodes and then DOM, never a markup string: this package has no `{@html}`, no `innerHTML` and no `eval`, so a document's text cannot become tags. And a link renders as one only for `http`, `https`, `mailto`, `tel`, `ftp`, or a value naming no scheme at all; every other scheme draws as an inert span, on the editable surface and in the tips card that paints `$ext.editor.tips` outside any `contenteditable`. That gate is the render's rather than the model's, so a refused href stays on the mark and round-trips: opening a document never edits it.
+
+What stays yours is the text edge and the ref. The markdown is the host's at both ends, and `doc.quillRef` is the **document's** own — a stored file names the quill that opens it, so the ref → `Quill` mapping above is what bounds which templates it can reach.
+
 ## Preview
 
 `createPreview` supplies the layer the session omits: viewport, DOM, DPR, click mapping. It is a pure view: it never calls `session.apply`; you drive the edit and hand it the resulting `ChangeSet`.
@@ -152,7 +158,7 @@ The package ships English and a seam to replace it. `strings` is keyed and **par
 		addCard: '+ Ajouter une carte'
 	}}
 	formatDiagnostic={(d) =>
-		d.code === 'validation::must_fill' ? `${d.path} est obligatoire` : undefined}
+		d.code === 'validation::type_mismatch' ? `${d.path} : type incorrect` : undefined}
 />
 ```
 
@@ -184,7 +190,7 @@ function recompileNow() {
 }
 ```
 
-`session.warnings` is a **getter on a handle Svelte does not track**: pull it per apply, or the editor shows the previous compile's diagnostics.
+`session.warnings` is a **getter on a handle Svelte does not track**: pull it per apply, or the editor shows the previous compile's errors.
 
 This shell layer is deliberately yours: the debounce value, what applies at once, and which surfaces refresh are host policy, so the package ships no scheduler over them. Three obligations ride with that: an edit of your own (an import, an undo, a direct `doc` write) recompiles by the same calls, since nothing polls the document; a compile owes the diagnostics re-read above, since nothing polls the session; and teardown clears the timer **before** freeing the handles, so a pending recompile never touches a freed session.
 

package/THEMING.md

@@ -4,11 +4,11 @@
 
 There are three depths to that. An app mounting into an unstyled page stops at the first; an app with a plate of its own starts at the second:
 
-|                   | You write             | You get                                                 |
-| ----------------- | --------------------- | ------------------------------------------------------- |
-| **Drop it in**    | nothing               | a mounted surface that looks right in a bare `<div>`    |
-| **Make it yours** | ten custom properties | the whole surface rescaled and recolored to your brand  |
-| **Match ours**    | one CSS import        | the page around the surface, drawn the way we draw ours |
+|                   | You write              | You get                                                 |
+| ----------------- | ---------------------- | ------------------------------------------------------- |
+| **Drop it in**    | nothing                | a mounted surface that looks right in a bare `<div>`    |
+| **Make it yours** | nine custom properties | the whole surface rescaled and recolored to your brand  |
+| **Match ours**    | one CSS import         | the page around the surface, drawn the way we draw ours |
 
 ## Drop it in
 
@@ -24,11 +24,11 @@ Nothing to import and nothing to set. The package pulls its own stylesheet, and
 
 **Placing and sizing**: each surface carries a stable root class (`.qm-editor`, `.qm-preview`), so you can place it from your own stylesheet without a wrapper. Each also takes a `class` prop that merges onto the same element, which is the better handle when you have one to give.
 
-**Taking the column back**: your CSS is unlayered and ours is not (below), so `padding: 0` or a `background` of your own on `.qm-editor` wins outright. Nothing is locked.
+**Taking the column back**: our selectors compute at specificity zero (below), so `padding: 0` or a `background` of your own on `.qm-editor` wins outright. Nothing is locked.
 
 ## Make it yours
 
-The whole contract is **ten CSS custom properties**. They are dials, not a palette: each derives a closed private scale that every component reads, so one override rescales or recolors the whole surface. Set them on any ancestor of a mounted surface (the app, or one pane):
+The whole contract is **nine CSS custom properties**. They are dials, not a palette: each derives a closed private scale that every component reads, so one override rescales or recolors the whole surface. Set them on any ancestor of a mounted surface (the app, or one pane):
 
 ```css
 .my-editor {
@@ -43,7 +43,7 @@ The whole contract is **ten CSS custom properties**. They are dials, not a palet
 
 `--qm-bg` and `--qm-fg` are the two a themed host sets before any brand decision. Their defaults are a self-consistent neutral for a bare mounting site, not a guess at your page.
 
-`--qm-bg` is the **card**, not the column behind it: the plane a document is written on, which is also the sheet the preview paints. Everything else is a step off it, and the column the cards sit in is a step down, so a mounted editor draws its own ground and the cards read as islands on it. Give it the tone you want a card to be — white, in most light themes — and let the column fall out. If you want the column to meet your page instead, set a `background` of your own on `.qm-editor`; your CSS is unlayered and wins.
+`--qm-bg` is the **card**, not the column behind it: the plane a document is written on, which is also the sheet the preview paints. Everything else is a step off it, and the column the cards sit in is a step down, so a mounted editor draws its own ground and the cards read as islands on it. Give it the tone you want a card to be — white, in most light themes — and let the column fall out. If you want the column to meet your page instead, set a `background` of your own on `.qm-editor`; any rule of yours wins.
 
 The poles take a colour, not `transparent` or `inherit`: the raised surfaces, the borders and the muted inks are each a `color-mix` against `--qm-bg`, so a transparent pole makes every one of them translucent instead of letting your page through. Hand over the value your page is painted with and the derivation steps off it.
 
@@ -55,7 +55,6 @@ The poles take a colour, not `transparent` or `inherit`: the raised surfaces, th
 | `--qm-fg`        | `#1c1c1c` / `#d7dadc`                  | Base ink. Body text, labels, and borders step off it.                                                                                                          |
 | `--qm-accent`    | `#71717a` / `#a1a1aa`                  | Focus rings, active marks, the preview's active field box. The surface spends no hue of its own, so this is the one it wears.                                  |
 | `--qm-danger`    | `#9e1518` / `#f9786c`                  | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
-| `--qm-warning`   | `#926510` / `#fdc776`                  | Warning diagnostics.                                                                                                                                           |
 | `--qm-font`      | `ui-sans-serif, system-ui, sans-serif` | The editor surface's font family. Controls and buttons take it too, in place of the UA face.                                                                   |
 | `--qm-font-mono` | `ui-monospace, monospace`              | The monospace face: the JSON array control, the tips card.                                                                                                     |
 | `--qm-font-size` | `0.875rem`                             | Chrome text: every control's size, the anchor the ramp derives up (title) and down (label/meta) from, and the anchor a document body sits one small step over. |
@@ -66,15 +65,12 @@ Give a length dial a length: `--qm-space: 4` is a valid custom property and an i
 
 ### Your CSS beats ours
 
-The surfaces' own rules live in the `qm` cascade layer, so **unlayered CSS of yours beats them outright**, at any specificity and without `!important`. Nothing to declare; this is the case most apps are in.
+The rules behind every class the surfaces promise you — `.qm-editor`, `.qm-preview`, `.qm-pane` — are wrapped in `:where()` and sit in no cascade layer, as are the derivation and the shared control recipes under them. So **each computes at specificity zero**, and two things follow:
 
-If your app uses cascade layers of its own, layer order decides it, and layer order is first-declaration order across the document — which makes it the bundler's, not yours. Name our layer first in one statement of your own, anywhere in your CSS, and it stops mattering:
+- **Any rule of yours wins**, at any specificity and without `!important`. A bare `.qm-editor { … }` does it; so does a bare `input`.
+- **No layer of yours can reach them**, because unlayered rules outrank every layer. A reset in a layer — Tailwind v4's preflight in `@layer base` is the common one — cannot strip the controls however your bundler orders the sheets. There is no layer statement to write and no sheet order to get right.
 
-```css
-@layer qm, app;
-```
-
-Declared before our sheet it fixes the order outright; declared after, `qm` is already first and `app` appends behind it. Either way your layer lands after ours and wins. `qm` is the contract; the sub-layers under it (`qm.scale`, `qm.chrome`) are ours to re-cut.
+One thing still outranks us: an **unlayered** blanket reset of your own (`* { padding: 0 }` in no layer) ties at specificity zero and wins on source order. Put it in a layer, where Tailwind, Bootstrap and Open Props already put theirs, and it stops reaching us.
 
 ### The surface follows your colour scheme
 
@@ -106,9 +102,9 @@ Setting the poles yourself wins over the default in both schemes, so a fixed pal
 }
 ```
 
-That cuts both ways for the status hues: `--qm-danger` and `--qm-warning` each default to a pair calibrated against the card at both poles, and one pinned value replaces both arms, so a red measured against white carries into the dark scheme unmeasured. Pin them under your own scheme rule (`.dark { --qm-danger: … }`) where the colour your app means by error is itself scheme-aware.
+That cuts both ways for the status hue: `--qm-danger` defaults to a pair calibrated against the card at both poles, and one pinned value replaces both arms, so a red measured against white carries into the dark scheme unmeasured. Pin it under your own scheme rule (`.dark { --qm-danger: … }`) where the colour your app means by error is itself scheme-aware.
 
-A palette **pinned against** your own scheme still wants a second line, for a smaller reason than it used to be: the planes read your card's lightness, so the surface itself lands right either way, but the poles' own defaults, the status hues and native chrome all still read `color-scheme`. Pin it with them (`.my-editor { color-scheme: dark }`). Skip that line and what the browser paints — the selection highlight, the scrollbar, the spinner — stays on whichever scheme the host inherits, and a status hue you left to us is measured against the wrong card.
+A palette **pinned against** your own scheme still wants a second line, for a smaller reason than it used to be: the planes read your card's lightness, so the surface itself lands right either way, but the poles' own defaults, the status hue and native chrome all still read `color-scheme`. Pin it with them (`.my-editor { color-scheme: dark }`). Skip that line and what the browser paints — the selection highlight, the scrollbar, the spinner — stays on whichever scheme the host inherits, and a status hue you left to us is measured against the wrong card.
 
 Pinning **one mount** rather than a page is the `style` prop, which lands on the same root: `<Preview style="color-scheme: dark" />`. There is no `scheme` prop, and deliberately — an inline declaration of ours would be the one thing your own CSS could not beat.
 
@@ -131,7 +127,7 @@ import '@quillmark/svelte/preset';
 
 This is the stylesheet our own apps import: the playground and studio draw with these rules and nothing else, so what you get is what we ship, not a reduction of it.
 
-It carries a `--qmh-*` scale for the page, derived from the same ten dials and calibrated against the surfaces' own steps, so a plate of yours and a card of ours agree about which way "raised" goes. Turning a dial moves both.
+It carries a `--qmh-*` scale for the page, derived from the same nine dials and calibrated against the surfaces' own steps, so a plate of yours and a card of ours agree about which way "raised" goes. Turning a dial moves both.
 
 | Class         | What it is                                                                                                                           |
 | ------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
@@ -139,7 +135,7 @@ It carries a `--qmh-*` scale for the page, derived from the same ten dials and c
 | `.qm-panel`   | The plate your controls and readouts sit on: one rung off the page, a hairline, a corner.                                            |
 | `.qm-label`   | A run of chrome type: a section label, the name over a value.                                                                        |
 | `.qm-readout` | A value read back out of the session, monospace and tabular. `<pre class="qm-readout">` is the block form.                           |
-| `.qm-status`  | A phase line. `.qm-status-error` and `.qm-status-warn` are the two it fails to.                                                      |
+| `.qm-status`  | A phase line. `.qm-status-error` is the one it fails to.                                                                             |
 | `.qm-control` | A boxed button or select, which is what a host's controls are and the package's are not.                                             |
 | `.qm-measure` | A reading column at the width a passage wants.                                                                                       |
 
@@ -181,18 +177,17 @@ The narrow shape is one mount at a time, not two of them stacked: half a narrow
 
 The shape is shared; the look of a band is not. Your wordmark, your nav and the depth of your head are the most app-specific things on the screen, and a preset that drew them would hand every tool built on this the same face, so they read `--qmh-*` like everything else and you write the rules. `.qm-split`'s gap is a default rather than a fact about splitting: close it to `0` and carry a hairline on one pane if you want the two mounts to meet instead of stand apart.
 
-It is **unlayered**, so your own rules beat it by ordinary precedence, exactly as they beat the surfaces. It is also opt-in and side-effect free until imported: nothing that styles your document arrives with a component.
+It is **unlayered** and at ordinary specificity, so your own rules beat it by ordinary precedence. It is also opt-in and side-effect free until imported: nothing that styles your document arrives with a component.
 
-One rule in it earns its place regardless of whether you take the rest, and you want it if you draw a focus ring of your own:
+One rule in it earns its place regardless of whether you take the rest, and you want it if you draw a focus ring of your own — cut the mounted surfaces out of the blanket:
 
 ```css
-[data-qm-root] :focus-visible {
-	outline: revert-layer;
-	outline-offset: revert-layer;
+:focus-visible:not(:where([data-qm-root], [data-qm-root] *)) {
+	outline: 2px solid; /* your ring, on your page */
 }
 ```
 
-A blanket `:focus-visible` of yours is unlayered, so it beats `@layer qm.chrome`, including on the controls that already draw a ring. `revert-layer` hands those back to ours and leaves yours everywhere else.
+A blanket `:focus-visible` of yours outranks ours, including on the controls that already draw one, so a ring written for the controls that draw none repaints the ones that do. The cut-out leaves yours everywhere else, and `:not(:where(…))` contributes no specificity, so your rule ranks exactly as it would without it.
 
 ## What is deliberately not public
 
@@ -202,4 +197,4 @@ The derived surface scale (surface / border / ink rungs, the blur radius, the po
 
 ## Requirements
 
-`@layer`, `color-mix()`, `light-dark()` and relative colour syntax (`oklab(from …)`): Baseline since 2022, 2023, 2024 and 2024 respectively — the last is what lets a plane step by the card's own lightness. `@property` is the one feature the surface does not require: where it is missing, an invalid length dial collapses the surface rather than falling back.
+`:where()`, `color-mix()`, `light-dark()` and relative colour syntax (`oklab(from …)`): Baseline since 2021, 2023, 2024 and 2024 respectively — the last is what lets a plane step by the card's own lightness. `@property` is the one feature the surface does not require: where it is missing, an invalid length dial collapses the surface rather than falling back.

package/dist/core/address.d.ts

@@ -63,14 +63,28 @@ export declare function cardPath(index: number, kinds: readonly string[]): DocPa
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath}
- * takes instead), a field-rooted one, or a malformed one. A bare card and a `.body`
- * terminal both land on the field-less `{card: i}` the body leaf answers to.
+ * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * {@link nearestAddrForFieldPath} take instead), a field-rooted one, or a malformed
+ * one. A bare card and a `.body` terminal both land on the field-less `{card: i}`
+ * the body leaf answers to.
  *
  * Needs no `kinds`: the path carries the absolute index, and the kind in it is
  * decoration the `Addr` has no room for.
  */
 export declare function addrForFieldPath(path: DocPath): Addr | undefined;
+/**
+ * The nearest ancestor a commit address can name: {@link addrForFieldPath} where the
+ * path has one, else the root and its first field. `main.contact.email` and
+ * `main.keywords[0]` land on their field, any deeper nesting on the top-level field
+ * it hangs off. `undefined` where those two segments name nothing — a field-rooted
+ * (config-space) or malformed path.
+ *
+ * An `Addr` reaches a root and one field, so two segments is the whole search: a
+ * deeper prefix is unaddressable by arity alone. Addressability being `Addr`'s reach
+ * rather than the grammar's is what makes the truncation a consumer's to make
+ * (VISUAL_EDITOR §Diagnostics).
+ */
+export declare function nearestAddrForFieldPath(path: DocPath): Addr | undefined;
 /**
  * An array element's address, split: `main.keywords[0]` lands here, and anything
  * {@link addrForFieldPath} can name — or whose trailing segment is not an index —

package/dist/core/address.js

@@ -37,9 +37,10 @@ export function cardPath(index, kinds) {
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath}
- * takes instead), a field-rooted one, or a malformed one. A bare card and a `.body`
- * terminal both land on the field-less `{card: i}` the body leaf answers to.
+ * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * {@link nearestAddrForFieldPath} take instead), a field-rooted one, or a malformed
+ * one. A bare card and a `.body` terminal both land on the field-less `{card: i}`
+ * the body leaf answers to.
  *
  * Needs no `kinds`: the path carries the absolute index, and the kind in it is
  * decoration the `Addr` has no room for.
@@ -48,6 +49,22 @@ export function addrForFieldPath(path) {
     const segs = segsOf(path);
     return segs && addrForSegs(segs);
 }
+/**
+ * The nearest ancestor a commit address can name: {@link addrForFieldPath} where the
+ * path has one, else the root and its first field. `main.contact.email` and
+ * `main.keywords[0]` land on their field, any deeper nesting on the top-level field
+ * it hangs off. `undefined` where those two segments name nothing — a field-rooted
+ * (config-space) or malformed path.
+ *
+ * An `Addr` reaches a root and one field, so two segments is the whole search: a
+ * deeper prefix is unaddressable by arity alone. Addressability being `Addr`'s reach
+ * rather than the grammar's is what makes the truncation a consumer's to make
+ * (VISUAL_EDITOR §Diagnostics).
+ */
+export function nearestAddrForFieldPath(path) {
+    const segs = segsOf(path);
+    return segs && addrForSegs(segs.slice(0, 2));
+}
 /**
  * An array element's address, split: `main.keywords[0]` lands here, and anything
  * {@link addrForFieldPath} can name — or whose trailing segment is not an index —

package/dist/core/codec/blocks.d.ts

@@ -0,0 +1,37 @@
+import type { Attrs, Node as PMNode } from 'prosemirror-model';
+import type { Command, EditorState, Transaction } from 'prosemirror-state';
+/** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
+ *  shape the content holds and `importMarkdown` produces from `- # title`. */
+export declare function toHeading(level: number): Command;
+/** A fence. The exit paragraph after it is the one a block island mints for the same
+ *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
+ *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
+ *  stays in the fence, not in the exit it minted. */
+export declare function toCodeBlock(): Command;
+/** `---`. A divider is a whole block, so this replaces its textblock rather than
+ *  retyping one: `horizontal_rule` holds no content to retype into, and an empty block
+ *  is the whole of what it may replace — anything else in one is a paragraph being
+ *  edited, which a replace would eat. */
+export declare function insertDivider(): Command;
+/** `> `. No item guard: what this wraps an item's first block in is a container the
+ *  content holds, where a list wrapping one mints an item whose only content is an
+ *  item. */
+export declare function wrapInQuote(): Command;
+/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
+ *  above where `7. ` opens one. A pick passes none and continues whatever list is
+ *  above it. */
+export declare function wrapInList(ordered: boolean, attrs?: Attrs | null, joinBefore?: (node: PMNode) => boolean): Command;
+/**
+ * Run `command` in place of the text at `[from, to)`: one transaction carrying the
+ * delete and the command's own steps. One rather than two because two would be two
+ * commits, two undo steps and two recompiles for one gesture; the command is built
+ * against the state the delete leaves, which is exactly what its steps were computed
+ * for.
+ *
+ * `null` is a command that declined, and nothing is consumed: the shorthand stays the
+ * text it was typed as.
+ */
+export declare function consuming(state: EditorState, from: number, to: number, command: Command): {
+    tr: Transaction;
+    produced: Transaction;
+} | null;

package/dist/core/codec/blocks.js

@@ -0,0 +1,163 @@
+import { Selection } from 'prosemirror-state';
+import { canJoin, findWrapping } from 'prosemirror-transform';
+/** The head of a textblock: where a shorthand fires, and where a pick lands once its
+ *  run is consumed. */
+function atHead(state) {
+    const { $from, empty } = state.selection;
+    return empty && $from.parent.isTextblock && $from.parentOffset === 0;
+}
+/** Whether the caret's parent holds `type` in its block's place. `setBlockType` and
+ *  `replaceWith` both mint the shape without asking. */
+function fits($from, type) {
+    return $from.node(-1).canReplaceWith($from.index(-1), $from.indexAfter(-1), type);
+}
+/**
+ * The head of an item that already exists: where a list shorthand is the text an author
+ * typed rather than a shorthand at all.
+ *
+ * Firing there wraps the item's own paragraph in a fresh list, minting an item whose
+ * only content is another item — a level with nothing on it. Tab is the indent gesture
+ * and lands the shape a nesting is supposed to have, under the previous sibling. A
+ * later block of the item is not this case: wrapping a continuation paragraph is how a
+ * sub-list opens under text.
+ */
+function openingAnItem($from, item) {
+    if (!item || $from.depth < 2)
+        return false;
+    return $from.node(-1).type === item && $from.index(-1) === 0;
+}
+function retype(name, attrs) {
+    return (state, dispatch) => {
+        const type = state.schema.nodes[name];
+        const { $from } = state.selection;
+        if (!type || !atHead(state) || !fits($from, type))
+            return false;
+        dispatch?.(state.tr.setBlockType($from.pos, $from.pos, type, attrs));
+        return true;
+    };
+}
+/** `wrappingInputRule`'s body: wrap the block range at `pos`, then join a preceding
+ *  sibling of the same type — the one boundary the wrap itself opens (`lists.ts`
+ *  §cleanup: command-local, never a global pass). */
+function wrapAt(tr, pos, type, attrs, joinBefore) {
+    const range = tr.doc.resolve(pos).blockRange();
+    const wrapping = range && findWrapping(range, type, attrs);
+    if (!range || !wrapping)
+        return false;
+    tr.wrap(range, wrapping);
+    const before = tr.doc.resolve(pos - 1).nodeBefore;
+    if (before &&
+        before.type === type &&
+        canJoin(tr.doc, pos - 1) &&
+        (!joinBefore || joinBefore(before))) {
+        tr.join(pos - 1);
+    }
+    return true;
+}
+/** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
+ *  shape the content holds and `importMarkdown` produces from `- # title`. */
+export function toHeading(level) {
+    return retype('heading', { level });
+}
+/** A fence. The exit paragraph after it is the one a block island mints for the same
+ *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
+ *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
+ *  stays in the fence, not in the exit it minted. */
+export function toCodeBlock() {
+    return (state, dispatch) => {
+        const { code_block: code, paragraph } = state.schema.nodes;
+        const { $from } = state.selection;
+        if (!code || !paragraph || !atHead(state) || !fits($from, code))
+            return false;
+        const tr = state.tr.setBlockType($from.pos, $from.pos, code);
+        const at = tr.doc.resolve($from.pos).after();
+        if (!tr.doc.nodeAt(at))
+            tr.insert(at, paragraph.create());
+        dispatch?.(tr);
+        return true;
+    };
+}
+/** `---`. A divider is a whole block, so this replaces its textblock rather than
+ *  retyping one: `horizontal_rule` holds no content to retype into, and an empty block
+ *  is the whole of what it may replace — anything else in one is a paragraph being
+ *  edited, which a replace would eat. */
+export function insertDivider() {
+    return (state, dispatch) => {
+        const { horizontal_rule: rule, paragraph } = state.schema.nodes;
+        const { $from } = state.selection;
+        if (!rule || !paragraph || !atHead(state) || !fits($from, rule))
+            return false;
+        if ($from.parent.content.size !== 0)
+            return false;
+        const from = $from.before();
+        const tr = state.tr.replaceWith(from, $from.after(), rule.create());
+        const at = from + 1;
+        if (!tr.doc.nodeAt(at))
+            tr.insert(at, paragraph.create());
+        tr.setSelection(Selection.near(tr.doc.resolve(at), 1));
+        dispatch?.(tr);
+        return true;
+    };
+}
+/** `> `. No item guard: what this wraps an item's first block in is a container the
+ *  content holds, where a list wrapping one mints an item whose only content is an
+ *  item. */
+export function wrapInQuote() {
+    return (state, dispatch) => {
+        const quote = state.schema.nodes.blockquote;
+        const { $from } = state.selection;
+        if (!quote || !atHead(state))
+            return false;
+        const tr = state.tr;
+        if (!wrapAt(tr, $from.pos, quote, null))
+            return false;
+        dispatch?.(tr);
+        return true;
+    };
+}
+/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
+ *  above where `7. ` opens one. A pick passes none and continues whatever list is
+ *  above it. */
+export function wrapInList(ordered, attrs = null, joinBefore) {
+    return (state, dispatch) => {
+        const { paragraph, list_item: item } = state.schema.nodes;
+        const list = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
+        const { $from } = state.selection;
+        if (!list || !paragraph || !atHead(state) || openingAnItem($from, item))
+            return false;
+        const pos = $from.pos;
+        const tr = state.tr;
+        // A paragraph item wherever this fires: `# ` inside the item is the gesture that
+        // mints `list_item > heading`, and a wrap keeping the heading is a second door onto
+        // that shape. Positions survive the retype — same content, same size.
+        if ($from.parent.type !== paragraph)
+            tr.setBlockType(pos, pos, paragraph);
+        if (!wrapAt(tr, pos, list, attrs, joinBefore))
+            return false;
+        dispatch?.(tr);
+        return true;
+    };
+}
+/**
+ * Run `command` in place of the text at `[from, to)`: one transaction carrying the
+ * delete and the command's own steps. One rather than two because two would be two
+ * commits, two undo steps and two recompiles for one gesture; the command is built
+ * against the state the delete leaves, which is exactly what its steps were computed
+ * for.
+ *
+ * `null` is a command that declined, and nothing is consumed: the shorthand stays the
+ * text it was typed as.
+ */
+export function consuming(state, from, to, command) {
+    const tr = state.tr.delete(from, to);
+    let produced;
+    command(state.apply(tr), (t) => {
+        produced = t;
+    });
+    if (!produced)
+        return null;
+    for (const step of produced.steps)
+        tr.step(step);
+    tr.setSelection(Selection.fromJSON(tr.doc, produced.selection.toJSON()));
+    return { tr, produced };
+}

package/dist/core/codec/field.js

@@ -19,7 +19,6 @@ import { keymap } from 'prosemirror-keymap';
 import { EditorState, NodeSelection, Plugin, PluginKey, Selection, TextSelection } from 'prosemirror-state';
 import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
 import { reportError, errorMessage } from '../errors.js';
-import { tableClipboardPlugin } from './clipboard.js';
 import { decode } from './decode.js';
 import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 import { lower, pmToContent, contentEdit } from './encode.js';
@@ -407,11 +406,10 @@ export function proseLeafPlugins(schema, opts) {
         list.push(inputRulesPlugin(schema));
     list.push(keymap(editorKeymap(schema, opts.inline, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // All three answer to something only a block leaf holds: an inline leaf is one
-    // textblock with no island, no gap to put a cursor in, and nowhere for a pasted
-    // table to land.
+    // Both answer to something only a block leaf holds: an inline leaf is one textblock
+    // with no island and no gap to put a cursor in.
     if (!opts.inline)
-        list.push(gapCursor(), pastAtomPlugin(), tableClipboardPlugin(schema));
+        list.push(gapCursor(), pastAtomPlugin());
     if (opts.placeholder)
         list.push(placeholderPlugin(opts.placeholder));
     return list;

package/dist/core/codec/index.d.ts

@@ -9,7 +9,7 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 export type { SlashState, SlashStrings } from './slash.js';
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks, rendersHref } from './schema.js';
 export { decode, renderContent, usvLength } from './decode.js';
 export { pmToContent, contentEdit, lower } from './encode.js';
 export type { ContentEdit } from './encode.js';

package/dist/core/codec/index.js

@@ -21,8 +21,9 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 // the pixels (`visual/SlashMenu.svelte` is the only off-barrel caller).
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 // Schemas (the decode/encode target; the VisualEditor mounts them). `hasMarks` is
-// what a mark surface asks before offering itself over a leaf.
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+// what a mark surface asks before offering itself over a leaf, and `rendersHref` the
+// link gate the prompt re-asks on submit (`visual/links.ts`).
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks, rendersHref } from './schema.js';
 // Decode / encode / positions (tests + VisualEditor).
 //
 // The barrel carries what has an off-barrel caller, and nothing else. A symbol