@quillmark/svelte 0.3.2 → 0.4.1

package/README.md

@@ -200,7 +200,7 @@ onPick: (at) => visualEditor.setCaret(at);
 onCaretMove: preview.focusPosition;
 ```
 
-A pick carries a caret where the compile tracks the content under the point, and the field alone where it tracks only the placement — a scalar the plate prints without tracking. `setCaret` takes both: an absent `pos` reveals and focuses the field, which is the whole of what a click on plate-placed ink can mean. The address may name an array element (`main.references.0`), which lands on that row.
+A pick carries a caret where the compile tracks the content under the point, and the field alone where it tracks only the placement — a scalar the plate prints without tracking. `setCaret` takes both: an absent `pos` reveals and focuses the field, which is the whole of what a click on plate-placed ink can mean. The address may name an array element (`main.keywords[0]`), which lands on that row.
 
 A consumer holding an `Addr` of its own maps it with `fieldPathForAddr` (from `@quillmark/svelte/core`). The playground app's split-pane route is the full reference shell: one session, both bridge directions, the preview following edits, and diagnostics routed inline.
 

package/THEMING.md

@@ -54,8 +54,8 @@ The poles take a colour, not `transparent` or `inherit`: the raised surfaces, th
 | `--qm-bg`        | `#fff` / `#272729`                     | Base surface: a card, and the preview's sheet. Fields, the popover and the column behind the cards each step off it.                                           |
 | `--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`    | `#c5221f`                              | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
-| `--qm-warning`   | `#b25000`                              | Warning diagnostics.                                                                                                                                           |
+| `--qm-danger`    | `#c5221f` / `#ff9c94`                  | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
+| `--qm-warning`   | `#b25000` / `#e0b44c`                  | 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. |
@@ -80,7 +80,7 @@ Declared before our sheet it fixes the order outright; declared after, `qm` is a
 
 Ink steps `fg → bg` and the borders and hover fills step `bg → fg`, mixed in **oklab**, so inverting the two poles inverts all of them together.
 
-**Planes are the exception**, and deliberately: the raised plane is the brighter one in both schemes, which is what makes a card read as a card rather than as a differently-tinted page. So the column under the cards sinks from `--qm-bg` toward shadow and a floating surface rises from it toward light, and neither reads the ink pole. Each direction takes a step sized to the scheme it is in, which is why pinning a dark palette while your `color-scheme` still says light leaves the column barely off its cards — the one case §"Make it yours" tells you to pin the scheme alongside the poles.
+**Planes are the exception**, and deliberately: the raised plane is the brighter one in both schemes, which is what makes a card read as a card rather than as a differently-tinted page. So the column under the cards sinks from `--qm-bg` toward shadow and a floating surface rises from it toward light, and neither reads the ink pole. How far each steps is a function of the card's own lightness — a dark card has to spend more before the plane above it reads as lifted — so a palette pinned at neither pole takes a proportionate step without being told which scheme it is in.
 
 Which way the poles default is **your `color-scheme`**, not the operating system's. Declare the scheme your app is in and the surface lands on it, along with native chrome, which reads the same property:
 
@@ -106,7 +106,11 @@ Setting the poles yourself wins over the default in both schemes, so a fixed pal
 }
 ```
 
-A palette **pinned against** your own scheme is the one case needing a second line: the surfaces follow your dials, but native chrome follows `color-scheme`, so 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.
+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.
+
+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.
+
+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.
 
 No JS runs and no media query: the derivation resolves through the cascade at paint time, so there is no `dark` prop and no mode toggle. The consumer's palette decides.
 
@@ -121,7 +125,7 @@ import '@quillmark/svelte/preset';
 ```html
 <body class="qm-page">
 	<p class="qm-label">quill</p>
-	<pre class="qm-readout">usaf_memo@0.2.0</pre>
+	<pre class="qm-readout">specimen@1.0.0</pre>
 </body>
 ```
 
@@ -198,4 +202,4 @@ The derived surface scale (surface / border / ink rungs, the blur radius, the po
 
 ## Requirements
 
-`@layer`, `color-mix()` and `light-dark()`: Baseline since 2022, 2023 and 2024 respectively. `@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.
+`@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.

package/dist/core/address.d.ts

@@ -63,7 +63,7 @@ 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.references.0`, which {@link elementAddrForFieldPath}
+ * 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.
  *
@@ -72,16 +72,10 @@ export declare function cardPath(index: number, kinds: readonly string[]): DocPa
  */
 export declare function addrForFieldPath(path: DocPath): Addr | undefined;
 /**
- * An array element's address, split. `main.references.0` and `main.references[0]`
- * both land here; anything {@link addrForFieldPath} can name, and anything whose
- * trailing segment is not an index, does not.
- *
- * Both spellings, because the boundary mints one and formats the other: `regions()`
- * and `positionAt` emit `main.references.0`, which `parseDocPath` reads as a field
- * literally named `"0"`, while `formatDocPath` spells the index segment
- * `main.references[0]`. A trailing all-digits field name is therefore an index that
- * lost its brackets — but only under a field the schema declares an array, the
- * caller's guard to apply: this module holds the grammar and no schema.
+ * 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 —
+ * does not. `regions()`, `positionAt` and `formatDocPath` all spell the index
+ * segment bracketed, so there is one spelling to read and none to bridge.
  */
 export declare function elementAddrForFieldPath(path: DocPath): ElementAddr | undefined;
 /** An array element's address: the array's `Addr`, and which element of it. */

package/dist/core/address.js

@@ -37,7 +37,7 @@ 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.references.0`, which {@link elementAddrForFieldPath}
+ * 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.
  *
@@ -49,32 +49,21 @@ export function addrForFieldPath(path) {
     return segs && addrForSegs(segs);
 }
 /**
- * An array element's address, split. `main.references.0` and `main.references[0]`
- * both land here; anything {@link addrForFieldPath} can name, and anything whose
- * trailing segment is not an index, does not.
- *
- * Both spellings, because the boundary mints one and formats the other: `regions()`
- * and `positionAt` emit `main.references.0`, which `parseDocPath` reads as a field
- * literally named `"0"`, while `formatDocPath` spells the index segment
- * `main.references[0]`. A trailing all-digits field name is therefore an index that
- * lost its brackets — but only under a field the schema declares an array, the
- * caller's guard to apply: this module holds the grammar and no schema.
+ * 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 —
+ * does not. `regions()`, `positionAt` and `formatDocPath` all spell the index
+ * segment bracketed, so there is one spelling to read and none to bridge.
  */
 export function elementAddrForFieldPath(path) {
     const segs = segsOf(path);
     if (!segs)
         return undefined;
     const last = segs[segs.length - 1];
-    const index = last?.seg === 'index'
-        ? last.index
-        : last?.seg === 'field' && /^\d+$/.test(last.name)
-            ? Number(last.name)
-            : undefined;
-    if (index == null)
+    if (last?.seg !== 'index')
         return undefined;
     const field = addrForSegs(segs.slice(0, -1));
     // A body has no elements: the parent must name a field.
-    return field?.field != null ? { field, index } : undefined;
+    return field?.field != null ? { field, index: last.index } : undefined;
 }
 /** `parseDocPath`, with a malformed path as `undefined` rather than a throw. The gate
  *  is read outside the try: an uninitialized core is not a malformed path, and would

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

@@ -4,10 +4,6 @@ import type { Content } from '@quillmark/wasm';
 export declare function codePoints(s: string): string[];
 /** USV length of `s` (code points, not UTF-16 units). */
 export declare function usvLength(s: string): number;
-interface DecodeOpts {
-    /** Strip all marks (a `plaintext` field). */
-    plaintext?: boolean;
-}
 /**
  * A `Content` as read-only DOM: decode under `schema`, then the nodes' own `toDOM`.
  * The rendering half of the codec's job with no editing attached (no PM view, no
@@ -18,7 +14,6 @@ interface DecodeOpts {
  * `DOMSerializer.fromSchema` memoizes on the schema, so repeat calls build no
  * serializer.
  */
-export declare function renderContent(rt: Content, schema: Schema, opts?: DecodeOpts): Node;
+export declare function renderContent(rt: Content, schema: Schema): Node;
 /** Decode a `Content` to a PM document under `schema`. */
-export declare function decode(rt: Content, schema: Schema, opts?: DecodeOpts): PMNode;
-export {};
+export declare function decode(rt: Content, schema: Schema): PMNode;

package/dist/core/codec/decode.js

@@ -10,7 +10,7 @@
 import { DOMSerializer } from 'prosemirror-model';
 import { ISLAND_SLOT } from './islands.js';
 import { descriptorOf, markKey, pmMarkFromContent } from './marks.js';
-import { isInlineSchema } from './schema.js';
+import { hasMarks, isInlineSchema } from './schema.js';
 import { isAnchorMark, isCodeLine, isHeadingLine, isListItemContainer } from '@quillmark/wasm';
 /** Code points of `s` (USV units): the iteration granularity the content speaks. */
 export function codePoints(s) {
@@ -33,11 +33,11 @@ export function usvLength(s) {
  * `DOMSerializer.fromSchema` memoizes on the schema, so repeat calls build no
  * serializer.
  */
-export function renderContent(rt, schema, opts = {}) {
-    return DOMSerializer.fromSchema(schema).serializeFragment(decode(rt, schema, opts).content);
+export function renderContent(rt, schema) {
+    return DOMSerializer.fromSchema(schema).serializeFragment(decode(rt, schema).content);
 }
 /** Decode a `Content` to a PM document under `schema`. */
-export function decode(rt, schema, opts = {}) {
+export function decode(rt, schema) {
     const lineTexts = rt.text.split('\n');
     // Per-line USV start: line i begins after all earlier lines and their `\n`s.
     const starts = [];
@@ -46,7 +46,11 @@ export function decode(rt, schema, opts = {}) {
         starts.push(acc);
         acc += usvLength(lineTexts[i]) + 1; // +1 for the `\n` boundary
     }
-    const marks = opts.plaintext ? [] : rt.marks.filter((m) => !isAnchorMark(m));
+    // A mark-free schema (`plaintextSchema`) has nothing to apply them with, and a
+    // plaintext field that acquired one anyway — an older build's popover, a hand-
+    // written document — is exactly the content that must open and then heal on the
+    // next commit, not throw here.
+    const marks = hasMarks(schema) ? rt.marks.filter((m) => !isAnchorMark(m)) : [];
     const cursor = { i: 0, rt };
     if (isInlineSchema(schema)) {
         return decodeInline(rt, schema, lineTexts, starts, marks, cursor);

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

@@ -16,7 +16,8 @@ export interface CreateFieldOpts {
     container: HTMLElement;
     /** Constrained single-textblock schema (a `richtext(inline)` field). */
     inline?: boolean;
-    /** Inline + marks/islands stripped (a `plaintext` field). Implies `inline`. */
+    /** The mark-free inline schema (a `plaintext` field): literal text, no formatting
+     *  and no anchors. Implies `inline`. */
     plaintext?: boolean;
     /** Suppress the markdown-shorthand input rules. */
     noInputRules?: boolean;
@@ -145,15 +146,13 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * last the two that answer to a caret or a selection beside a block: the gap cursor
  * and {@link pastAtomPlugin}.
  *
- * A `plaintext` field carries no marks (decode strips them, the keymap suppresses
- * Mod-b/i/u), so it also skips the input rules: `inlineSchema` still declares the
- * mark types, so a `**bold**` rule would apply a strong mark and eat the literal
- * delimiters. The inline schema has no block nodes, so those rules are the only
- * ones it would add: skip all.
+ * Every mark-shaped plugin reads the schema rather than a flag: over
+ * `plaintextSchema` the shorthand rules build nothing (each is guarded on its mark
+ * type) and the toggles bind no key, so a `**bold**` keeps the delimiters its author
+ * typed without a second rule saying so.
  */
 export declare function proseLeafPlugins(schema: Schema, opts: {
     inline: boolean;
-    plaintext: boolean;
     /** The slash menu's report channel; absent mounts no menu and leaves
      *  Enter/Escape/the arrows to the links below (`keymap.ts`). */
     slash?: (state: SlashState | undefined) => void;

package/dist/core/codec/field.js

@@ -27,7 +27,7 @@ import { anchorsFromContent } from './marks.js';
 import { createReconciler } from './reconcile.js';
 import { inputRulesPlugin } from './inputrules.js';
 import { bodyKeymap } from './keymap.js';
-import { blockSchema, inlineSchema } from './schema.js';
+import { blockSchema, inlineSchema, plaintextSchema } from './schema.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
 import { focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
@@ -108,7 +108,10 @@ export function createField(opts) {
     const { doc, addr, container } = opts;
     const inline = !!opts.inline || !!opts.plaintext;
     const plaintext = !!opts.plaintext;
-    const schema = inline ? inlineSchema : blockSchema;
+    // The declared type picks the schema, and the schema is the whole of what
+    // `plaintext` suppresses: no mark types to toggle, to paste in, or to mint a
+    // shorthand with (`schema.ts`).
+    const schema = plaintext ? plaintextSchema : inline ? inlineSchema : blockSchema;
     // Bound once and held: the reader is a `{quill, doc}` pair that reads live, so
     // every read below sees the commit before it.
     const reader = opts.quill.reader(doc);
@@ -176,7 +179,7 @@ export function createField(opts) {
         }
     });
     function buildState(rt) {
-        const pmDoc = decode(rt, schema, { plaintext });
+        const pmDoc = decode(rt, schema);
         const anchors = plaintext ? [] : anchorsFromContent(rt);
         // Seed anchor plugin positions in PM coords via a fresh index over pmDoc.
         const seedIndex = buildLineIndex(pmDoc);
@@ -188,7 +191,6 @@ export function createField(opts) {
             doc: pmDoc,
             plugins: proseLeafPlugins(schema, {
                 inline,
-                plaintext,
                 slash,
                 noInputRules: opts.noInputRules,
                 // Always installed, so a leaf that mounts without a ghost can still be
@@ -368,19 +370,18 @@ export function createField(opts) {
  * last the two that answer to a caret or a selection beside a block: the gap cursor
  * and {@link pastAtomPlugin}.
  *
- * A `plaintext` field carries no marks (decode strips them, the keymap suppresses
- * Mod-b/i/u), so it also skips the input rules: `inlineSchema` still declares the
- * mark types, so a `**bold**` rule would apply a strong mark and eat the literal
- * delimiters. The inline schema has no block nodes, so those rules are the only
- * ones it would add: skip all.
+ * Every mark-shaped plugin reads the schema rather than a flag: over
+ * `plaintextSchema` the shorthand rules build nothing (each is guarded on its mark
+ * type) and the toggles bind no key, so a `**bold**` keeps the delimiters its author
+ * typed without a second rule saying so.
  */
 export function proseLeafPlugins(schema, opts) {
     const list = [history(), ...(opts.afterHistory ?? [])];
     if (opts.slash)
         list.push(slashPlugin(opts.slash));
-    if (!opts.noInputRules && !opts.plaintext)
+    if (!opts.noInputRules)
         list.push(inputRulesPlugin(schema));
-    list.push(keymap(editorKeymap(schema, opts.inline, opts.plaintext, !!opts.slash)));
+    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
@@ -460,7 +461,8 @@ function placeholderPlugin(read) {
 }
 /**
  * The field's keymap: history, mark toggles, and the body's structural keys; Enter
- * suppressed inline.
+ * suppressed inline. The toggles are bound per mark type the schema declares, so a
+ * plaintext leaf leaves Mod-b/i/u to the browser.
  *
  * Tab forks on the leaf's role, not on the caret's position. An inline/plaintext
  * leaf is a form field: Tab stays unbound, so field navigation is open for a shell
@@ -468,20 +470,18 @@ function placeholderPlugin(read) {
  * is structural, a chain each nested surface prepends to (`keymap.ts`). One key
  * never means two things within one surface.
  */
-function editorKeymap(schema, inline, plaintext, slash) {
+function editorKeymap(schema, inline, slash) {
     const map = {
         'Mod-z': undo,
         'Mod-y': redo,
         'Shift-Mod-z': redo
     };
-    if (!plaintext) {
-        if (schema.marks.strong)
-            map['Mod-b'] = toggleMark(schema.marks.strong);
-        if (schema.marks.em)
-            map['Mod-i'] = toggleMark(schema.marks.em);
-        if (schema.marks.underline)
-            map['Mod-u'] = toggleMark(schema.marks.underline);
-    }
+    if (schema.marks.strong)
+        map['Mod-b'] = toggleMark(schema.marks.strong);
+    if (schema.marks.em)
+        map['Mod-i'] = toggleMark(schema.marks.em);
+    if (schema.marks.underline)
+        map['Mod-u'] = toggleMark(schema.marks.underline);
     if (inline) {
         // One textblock only: swallow Enter so no second block is attempted.
         map['Enter'] = () => true;

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 } from './schema.js';
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks } 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

@@ -20,8 +20,9 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 // The slash menu: the codec owns the model and the picks, the chrome the words and
 // 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).
-export { blockSchema, inlineSchema } from './schema.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';
 // Decode / encode / positions (tests + VisualEditor).
 //
 // The barrel carries what has an off-barrel caller, and nothing else. A symbol

package/dist/core/codec/inputrules.js

@@ -5,6 +5,13 @@
 // block rule with no guard of its own reuses `wrappingInputRule`, and the rest mirror
 // an upstream body around one. These produce transactions the codec already lowers:
 // they add no new lowering surface.
+//
+// A rule declines only where what it would mint is unrepresentable, or is a shape
+// another gesture owns — never on how a quill renders it. What a quill typesets is not
+// knowable here (a quill this build has not seen is the open-sets case, CODEC §"Open
+// sets"), and a construct that arrives through `importMarkdown` must stay authorable or
+// a document opens carrying a shape the editor refuses to make. So one guard survives:
+// `- ` / `1. ` at the head of an existing item, where Tab owns the nesting.
 import { InputRule, inputRules, wrappingInputRule } from 'prosemirror-inputrules';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 import { Selection } from 'prosemirror-state';
@@ -43,12 +50,10 @@ function markInputRule(regexp, markType, delimLen) {
  * `wrappingInputRule` (whose body this mirrors), plus one normalization: a
  * `heading` being wrapped becomes a `paragraph` first.
  *
- * `list_item` is `block+`, so `list_item > heading` is *representable* and a bare
- * wrap mints it (a shape no quill renders): the reference quill derives an item's
- * numbering and indent from the container path and typesets the item's blocks as
- * body paragraphs (`usaf_memo`'s `render-body`), where a heading resolves to
- * nothing. This is the wrap-side route into that shape; the `# ` rule guards the
- * other, in {@link markdownInputRules}.
+ * `list_item` is `block+`, so `list_item > heading` is *representable*, and `# `
+ * inside the item is the gesture that mints it ({@link markdownInputRules}). A wrap
+ * keeping the heading would be a second door onto that shape, so `- ` / `1. ` mint a
+ * paragraph item wherever they fire.
  *
  * `item` is the second guard, and it is about the gesture rather than the shape: the
  * rule declines at the start of an item's own first block ({@link openingAnItem}).
@@ -115,16 +120,13 @@ export function markdownInputRules(schema) {
     // Block shorthands (only where the schema has the node; the inline schema
     // omits them, so this stays a no-op there).
     if (schema.nodes.heading) {
-        // `textblockTypeInputRule`'s body plus one guard: inside a list item, `# `
-        // declines (null) and stays literal text, rather than minting the unrenderable
-        // `list_item > heading` {@link listWrappingRule} normalizes away on the wrap side.
+        // `textblockTypeInputRule`'s body. It fires inside a list item like anywhere else:
+        // `list_item > heading` is a shape the content holds and `importMarkdown` produces
+        // from `- # title`, so a rule that declined there would refuse to author what a
+        // document can arrive carrying.
         const heading = schema.nodes.heading;
         rules.push(new InputRule(/^(#{1,6})\s$/, (state, match, start, end) => {
             const $start = state.doc.resolve(start);
-            for (let d = $start.depth; d > 0; d--) {
-                if (item && $start.node(d).type === item)
-                    return null;
-            }
             if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), heading)) {
                 return null;
             }
@@ -166,12 +168,6 @@ export function markdownInputRules(schema) {
             if ($start.parentOffset !== 0 || $start.parent.content.size !== end - start) {
                 return null;
             }
-            // The `# ` rule's guard, for its reason: `list_item` is `block+`, so a
-            // divider inside an item is representable and renders to nothing.
-            for (let d = $start.depth; d > 0; d--) {
-                if (item && $start.node(d).type === item)
-                    return null;
-            }
             if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), rule)) {
                 return null;
             }
@@ -195,6 +191,8 @@ export function markdownInputRules(schema) {
     if (schema.nodes.ordered_list && schema.nodes.paragraph) {
         rules.push(listWrappingRule(/^(\d+)\.\s$/, schema.nodes.ordered_list, schema.nodes.paragraph, item, (match) => ({ start: +match[1] }), (match, node) => node.childCount + node.attrs.start === +match[1]));
     }
+    // No item guard: a quote wrapping an item's own first block is a container the
+    // content holds, where a list wrapping one is an item whose only content is an item.
     if (schema.nodes.blockquote) {
         rules.push(wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote));
     }

package/dist/core/codec/prose.css

@@ -84,16 +84,17 @@ li.ProseMirror-selectednode::after {
    emits, minus the four the UA already renders correctly (`strong`, `em`, `u`, `s`)
    and the blockquote above.
 
-   Each rule answers to the reference quill rather than to a browser default or to a
+   Each rule answers to the leaf's own job rather than to a browser default or to a
    web editor's chrome, because the leaf sits beside a live preview of the same
-   content. `usaf_memo` sets `raw` in a monospace face and adds nothing; it renders a
-   heading as a bold run-in prepended to the following paragraph, with the level
-   never read; it gives a link no decoration at all. So a leaf shows that a span is
-   code and a line is a heading: never a prediction of the size paper will set it
-   at, which the package cannot know for a quill it has not seen.
+   content. A leaf shows *that* a span is code and a line is a heading: never a
+   prediction of the size paper will set it at, which the package cannot know for a
+   quill it has not seen. The reference quill is the case in point — it sets `raw` in
+   the face it bundles, scales a heading by its level and colours it, and gives a link
+   no decoration at all — and mirroring any of that here would be a guess about the
+   next quill.
 
    Scoping is by tag, and the schema does the rest: `h1`–`h6`, `hr` and the lists
-   cannot exist under the inline schema, so no rule for them can land on a `subject`
+   cannot exist under the inline schema, so no rule for them can land on an inline
    field however that field is mounted. The two marks are the exception: `code` and
    `link` are in both schemas, and a `plaintext` leaf strips them at decode while
    mounting a schema that still carries them, so a paste can put either in one. The

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

@@ -1,13 +1,22 @@
 import { Schema } from 'prosemirror-model';
 /** The full field schema: every block kind, container, mark, and island. */
 export declare const blockSchema: Schema<string, string>;
+/** The constrained inline schema: one paragraph, no block splitting, no
+ *  containers, no islands, and the full mark set (a `richtext(inline)` field, and
+ *  a table cell, which is the same content unit). */
+export declare const inlineSchema: Schema<string, string>;
 /**
- * The constrained inline schema: one paragraph, no block splitting, no
- * containers, no islands. `doc: "paragraph"` (exactly one child) is what makes an
- * Enter a no-op at the model level: there is no second block for a split to land.
- * Marks are present; `plaintext` fields strip them at decode and mount no
- * mark input (a schema-level distinction the field draws, per CODEC §Inline mode).
+ * The inline schema with no mark types at all: a `plaintext` field, whose value is
+ * literal text the boundary refuses to coerce back once it carries a mark.
+ *
+ * Declaring none is what makes that structural rather than a rule each path
+ * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
+ * a paste parses its marks away, and `decode` drops any a stray content arrives
+ * carrying (CODEC §Inline mode).
  */
-export declare const inlineSchema: Schema<"text" | "doc" | "paragraph", string>;
+export declare const plaintextSchema: Schema<string, never>;
+/** Whether `schema` can carry formatting at all: false for {@link plaintextSchema}
+ *  alone. What a mark command asks before it offers itself. */
+export declare function hasMarks(schema: Schema): boolean;
 /** True for the constrained inline schema (no block containers); decode branches on it. */
 export declare function isInlineSchema(schema: Schema): boolean;

package/dist/core/codec/schema.js

@@ -4,12 +4,13 @@
 // Each of the three open sets gets an inert carrier so an unrecognized value
 // survives a round-trip: the `unknown` mark, the paragraph's `unknown` attribute,
 // and the `unknown_container` node. `blockSchema` is the full field; `inlineSchema`
-// is the constrained single-textblock form for `richtext(inline)` / `plaintext`
-// (one paragraph, no block split, no containers, no islands): same decode/lower/
-// position machinery, narrower shape. Anchors are not marks here (decorations).
+// is the constrained single-textblock form for `richtext(inline)` (one paragraph,
+// no block split, no containers, no islands) and `plaintextSchema` is that one
+// without marks: same decode/lower/position machinery, narrower shape. Anchors are
+// not marks here (decorations).
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
-// ── Marks (shared by both schemas; plaintext mounts none) ───────────────────
+// ── Marks (the block and inline schemas share them; plaintext declares none) ─
 const marks = {
     // Order matters: it fixes mark-set sort order and parse precedence. `link`
     // last so it wraps outermost; `unknown` after it, non-exclusive so several
@@ -134,21 +135,33 @@ export const blockSchema = new Schema({
     nodes: { ...blockNodes, ...inlineLeafNodes },
     marks
 });
+// ── The constrained inline nodes (both inline schemas) ──────────────────────
+// `doc: "paragraph"` (exactly one child) is what makes an Enter a no-op at the
+// model level: there is no second block for a split to land.
+const inlineNodes = {
+    doc: { content: 'paragraph' },
+    paragraph: { content: 'inline*', toDOM: () => ['p', 0] },
+    text: { group: 'inline' }
+};
+/** The constrained inline schema: one paragraph, no block splitting, no
+ *  containers, no islands, and the full mark set (a `richtext(inline)` field, and
+ *  a table cell, which is the same content unit). */
+export const inlineSchema = new Schema({ nodes: inlineNodes, marks });
 /**
- * The constrained inline schema: one paragraph, no block splitting, no
- * containers, no islands. `doc: "paragraph"` (exactly one child) is what makes an
- * Enter a no-op at the model level: there is no second block for a split to land.
- * Marks are present; `plaintext` fields strip them at decode and mount no
- * mark input (a schema-level distinction the field draws, per CODEC §Inline mode).
+ * The inline schema with no mark types at all: a `plaintext` field, whose value is
+ * literal text the boundary refuses to coerce back once it carries a mark.
+ *
+ * Declaring none is what makes that structural rather than a rule each path
+ * restates: `toggleMark` has no type to apply, the mark input rules build nothing,
+ * a paste parses its marks away, and `decode` drops any a stray content arrives
+ * carrying (CODEC §Inline mode).
  */
-export const inlineSchema = new Schema({
-    nodes: {
-        doc: { content: 'paragraph' },
-        paragraph: { content: 'inline*', toDOM: () => ['p', 0] },
-        text: { group: 'inline' }
-    },
-    marks
-});
+export const plaintextSchema = new Schema({ nodes: inlineNodes, marks: {} });
+/** Whether `schema` can carry formatting at all: false for {@link plaintextSchema}
+ *  alone. What a mark command asks before it offers itself. */
+export function hasMarks(schema) {
+    return Object.keys(schema.marks).length > 0;
+}
 /** True for the constrained inline schema (no block containers); decode branches on it. */
 export function isInlineSchema(schema) {
     return !schema.nodes.blockquote;