@quillmark/svelte 0.19.0 → 0.20.0

package/NOTICE

@@ -11,8 +11,10 @@ chevron-right, arrow-right, chevron-down, chevron-up, bold, italic, underline,
 strikethrough, code, link, hash, info, plus, x, trash-2, minus, check, calendar
 and calendar-check.
 
-`core/codec/table-view.ts` holds a plus and four text-alignment glyphs derived
-from an earlier release of the same project.
+`core/codec/table-view.ts` holds grip-horizontal, grip-vertical, align-left,
+align-center, align-right, align-start-horizontal, align-center-horizontal,
+align-end-horizontal and panel-top, derived from an earlier release of the same
+project.
 
 ISC License
 

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

@@ -18,9 +18,18 @@ export declare function insertDivider(): Command;
  *  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. */
+ *  above where `7. ` opens one. */
 export declare function wrapInList(ordered: boolean, attrs?: Attrs | null, joinBefore?: (node: PMNode) => boolean): Command;
+/**
+ * A list pick, at whatever caret the writer has. `atHead` is the shorthand's guard,
+ * where a prefix firing mid-sentence would eat a dash; a pick is a gesture at the caret.
+ *
+ * At the end of a non-empty block it opens a fresh empty item below it, Enter then `- `
+ * as one gesture. Anywhere else it wraps the whole block, the smaller surprise: a writer
+ * who meant to split presses Enter first. It passes no `joinBefore`, so it continues
+ * whatever list is above.
+ */
+export declare function pickList(ordered: 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

package/dist/core/codec/blocks.js

@@ -137,28 +137,59 @@ export function wrapInQuote() {
     };
 }
 /** `- ` / `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. */
+ *  above where `7. ` opens one. */
 export function wrapInList(ordered, attrs = null, joinBefore) {
+    return (state, dispatch) => atHead(state) && wrapBlock(state, dispatch, ordered, attrs, joinBefore);
+}
+/**
+ * A list pick, at whatever caret the writer has. `atHead` is the shorthand's guard,
+ * where a prefix firing mid-sentence would eat a dash; a pick is a gesture at the caret.
+ *
+ * At the end of a non-empty block it opens a fresh empty item below it, Enter then `- `
+ * as one gesture. Anywhere else it wraps the whole block, the smaller surprise: a writer
+ * who meant to split presses Enter first. It passes no `joinBefore`, so it continues
+ * whatever list is above.
+ */
+export function pickList(ordered) {
     return (state, dispatch) => {
-        const { paragraph, list_item: item } = state.schema.nodes;
+        const { $from, empty } = state.selection;
+        if (!empty || !$from.parent.isTextblock)
+            return false;
+        const size = $from.parent.content.size;
+        if (!size || $from.parentOffset < size)
+            return wrapBlock(state, dispatch, ordered, null);
+        const { paragraph } = 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))
+        if (!list || !paragraph)
             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))
+        const at = $from.after();
+        const tr = state.tr.insert(at, paragraph.create());
+        if (!wrapAt(tr, at + 1, list, null))
             return false;
-        dispatch?.(tr);
+        dispatch?.(tr.setSelection(Selection.near(tr.doc.resolve(at + 1))));
         return true;
     };
 }
+/** Wrap the caret's whole block in a list, wherever in the block the caret sits: the
+ *  wrap opens at the block's head, so it joins the list above as the shorthand's does. */
+function wrapBlock(state, dispatch, ordered, attrs, joinBefore) {
+    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 || openingAnItem($from, item))
+        return false;
+    const pos = $from.start();
+    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

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

@@ -10,8 +10,9 @@ import { Plugin, type Command } from 'prosemirror-state';
  */
 export declare function linebreakPlugin(schema: Schema): Plugin;
 /**
- * The line-break link of the body's key chains: `{}` for the inline schemas, which
- * declare no break node. A `richtext(inline)` field is one line by construction
+ * The line-break link of the body's key chains, and a table cell's Shift-Enter
+ * (`table-view.ts`): `{}` for the inline schemas, which declare no break node. A
+ * `richtext(inline)` field is one line by construction
  * (`Content::is_inline`), so there the key is swallowed beside Enter (`field.ts`)
  * rather than answered here.
  */

package/dist/core/codec/breaks.js

@@ -81,8 +81,9 @@ function insertBreak(schema) {
     };
 }
 /**
- * The line-break link of the body's key chains: `{}` for the inline schemas, which
- * declare no break node. A `richtext(inline)` field is one line by construction
+ * The line-break link of the body's key chains, and a table cell's Shift-Enter
+ * (`table-view.ts`): `{}` for the inline schemas, which declare no break node. A
+ * `richtext(inline)` field is one line by construction
  * (`Content::is_inline`), so there the key is swallowed beside Enter (`field.ts`)
  * rather than answered here.
  */

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

@@ -27,10 +27,14 @@ export declare function fitsInline(rt: Content): boolean;
  *  next commit heals (CODEC §Inline mode): upstream's `isPlain`, asked of the content
  *  with them set aside. */
 export declare function fitsPlain(rt: Content): boolean;
-/** Whether `rt` decodes under the schema a leaf so declared mounts, losing nothing its
- *  first commit would store: {@link fitsInline} narrowed, {@link fitsPlain} plain, and
- *  anything on the block schema. What a leaf held over the rest reads. */
+/** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
+ *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
+ *  store; on the block schema anything but an element or a task item ({@link editable}),
+ *  and an island where the leaf mounts no island view (`islands`), which draws as its
+ *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
+ *  reads. */
 export declare function fitsLeaf(rt: Content, leaf: {
     inline: boolean;
     plaintext: boolean;
+    islands: boolean;
 }): boolean;

package/dist/core/codec/decode.js

@@ -94,13 +94,23 @@ export function fitsInline(rt) {
 export function fitsPlain(rt) {
     return core().isPlain({ ...rt, marks: [] });
 }
-/** Whether `rt` decodes under the schema a leaf so declared mounts, losing nothing its
- *  first commit would store: {@link fitsInline} narrowed, {@link fitsPlain} plain, and
- *  anything on the block schema. What a leaf held over the rest reads. */
+/** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
+ *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
+ *  store; on the block schema anything but an element or a task item ({@link editable}),
+ *  and an island where the leaf mounts no island view (`islands`), which draws as its
+ *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
+ *  reads. */
 export function fitsLeaf(rt, leaf) {
     if (leaf.inline)
         return fitsInline(rt);
-    return !leaf.plaintext || fitsPlain(rt);
+    if (leaf.plaintext)
+        return fitsPlain(rt);
+    return (leaf.islands || rt.islands.length === 0) && rt.lines.every(editable);
+}
+/** Whether every container on `line` is one the block schema edits: an element, and a
+ *  task item's `checked`, decode to no node, so the first commit would drop them. */
+function editable(line) {
+    return line.containers.every((c) => c.container === 'quote' || (c.container === 'list_item' && c.attrs.checked === undefined));
 }
 /** Inline decode: one paragraph, containers and islands stripped. */
 function decodeInline(rt, schema, lineTexts, starts, marks, cursor) {
@@ -182,6 +192,21 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
             i = j;
             continue;
         }
+        if (here.container === 'element') {
+            // No node holds an element, and a leaf holding one is held (`fitsLeaf`), so
+            // what it wraps draws in place, read-only.
+            const key = containerKey(here);
+            let j = i + 1;
+            while (j < leaves.length) {
+                const c = atDepth(leaves[j], depth);
+                if (!c || containerKey(c) !== key)
+                    break;
+                j++;
+            }
+            out.push(...groupBlocks(schema, leaves.slice(i, j), depth + 1, marks, cursor));
+            i = j;
+            continue;
+        }
         // The quote, and the whole of what is left: `satisfies` is the exhaustiveness
         // check, so a container added upstream is a compile error here rather than a
         // blockquote it is not. A wrapper over the run of leaves carrying the identical
@@ -216,11 +241,12 @@ function ordinalAt(leaf, depth) {
 function instanceOf(c) {
     return c.instance ?? 0;
 }
-/** Identity of a container for run gathering: its name and its `instance`, NUL-joined
- * as `markKey` joins a mark's. `list_item` carries its own run rule, so the quote is
- * what keys here. */
+/** Identity of a container for run gathering: its name, its `instance` and an element's
+ * attributes, NUL-joined as `markKey` joins a mark's. `list_item` carries its own run
+ * rule, so the quote and the element are what key here. */
 function containerKey(c) {
-    return `${c.container}\u0000${instanceOf(c)}`;
+    const attrs = c.container === 'element' ? JSON.stringify(c.attrs) : '';
+    return `${c.container}\u0000${instanceOf(c)}\u0000${attrs}`;
 }
 /** A single leaf block node from its segments. Exhaustive over the closed line
  *  vocabulary, so a kind added upstream is a compile error rather than a silent

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

@@ -4,7 +4,7 @@ import { EditorView } from 'prosemirror-view';
 import type { Document, Content, Addr, Quill } from '@quillmark/wasm';
 import type { EditorErrorHandler } from '../errors.js';
 import { type TableChromeStrings } from './table-view.js';
-import { type SlashState } from './slash.js';
+import { type SlashState, type SlashStrings } from './slash.js';
 /** Options for {@link createField}. */
 export interface CreateFieldOpts {
     doc: Document;
@@ -26,7 +26,8 @@ export interface CreateFieldOpts {
      * Fired when the leaf holds or releases, and at mount when it mounts held. A leaf
      * declaring `inline`, or a `plaintext` one, is held over a value its schema cannot
      * hold (`fitsLeaf`, upstream's `isInline` and `isPlain`): the decode would join lines
-     * and drop containers and islands for the first commit to store. A held leaf draws
+     * and drop containers and islands for the first commit to store. Any leaf is held
+     * over an element or a task item, which no node holds. A held leaf draws
      * its content on the block schema, read-only, and commits nothing. Judged of the value
      * each mount and re-hydrate reads, so {@link FieldController.applyExternal} is what
      * re-evaluates it.
@@ -49,6 +50,9 @@ export interface CreateFieldOpts {
      * it holds no island and no block to convert.
      */
     onSlash?(state: SlashState | undefined): void;
+    /** The slash surface's wording, read per decoration pass. Absent leaves the
+     *  package's English; read only beside {@link onSlash}, the hint being the menu's. */
+    slashStrings?: () => SlashStrings;
     /** Accessible name → `aria-label` on the `contenteditable`. For a leaf nothing
      * else names: an array element (the field label plus its 1-based index), the
      * card body (no visible label at all). A leaf with a field label takes
@@ -190,9 +194,9 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
  * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
  * the rest of the stack leaves, then the markdown-shorthand input rules, the field
- * keymap over the base keymap, and last the three that answer to a block leaf's own
- * shapes: the gap cursor, {@link pastAtomPlugin}, and the island paste pass
- * (`islands.ts`).
+ * keymap over the base keymap, and last the ones that answer to a block leaf's own
+ * shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass (`islands.ts`),
+ * the table paste (`table-paste.ts`) and the markdown paste (`markdown-paste.ts`).
  *
  * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
  * schema the shorthand rules build nothing (each is guarded on its mark type) and the
@@ -204,6 +208,8 @@ export declare function proseLeafPlugins(schema: Schema, opts: {
     /** 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;
+    /** The empty line's hint, read live; drawn only beside `slash`. */
+    slashHint?: () => string | undefined;
     noInputRules?: boolean;
     /** Read live, not captured: the ghost can move after mount
      *  ({@link FieldController.setPlaceholder}), and a re-hydration rebuilds this

package/dist/core/codec/field.js

@@ -31,8 +31,10 @@ import { inputRulesPlugin } from './inputrules.js';
 import { linebreakPlugin } from './breaks.js';
 import { bodyKeymap } from './keymap.js';
 import { blockSchema, isBlockSchema, leafSchema, plainSchema } from './schema.js';
+import { markdownPastePlugin } from './markdown-paste.js';
+import { tablePastePlugin } from './table-paste.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
-import { focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
+import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
 /** Plugin-held anchor positions (PM coords), mapped through every edit's `StepMap`
  * and mutated by an {@link AnchorEdit} meta (an insert/remove at a selection).
@@ -160,7 +162,7 @@ export function createField(opts) {
     // Judged of the value being mounted rather than read off a diagnostic: a routed set
     // can predate the value it arrives with, and `validation::not_plain` stands in for
     // `not_inline` on a `plaintext(inline)` field.
-    const holds = (rt) => !fitsLeaf(rt, { inline, plaintext });
+    const holds = (rt) => !fitsLeaf(rt, { inline, plaintext, islands: true });
     let held = holds(reconciler.last);
     const named = proseAttributes(opts) ?? {};
     const defaultNamed = { ...named, 'data-default': '' };
@@ -263,6 +265,7 @@ export function createField(opts) {
             plugins: proseLeafPlugins(schema, {
                 inline,
                 slash,
+                slashHint: () => (opts.slashStrings?.() ?? DEFAULT_SLASH_STRINGS).slashHint,
                 noInputRules: opts.noInputRules,
                 // Always installed, so a leaf that mounts without a ghost can still be
                 // given one later; the plugin draws nothing while the text is empty.
@@ -502,9 +505,9 @@ export function createField(opts) {
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
  * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
  * the rest of the stack leaves, then the markdown-shorthand input rules, the field
- * keymap over the base keymap, and last the three that answer to a block leaf's own
- * shapes: the gap cursor, {@link pastAtomPlugin}, and the island paste pass
- * (`islands.ts`).
+ * keymap over the base keymap, and last the ones that answer to a block leaf's own
+ * shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass (`islands.ts`),
+ * the table paste (`table-paste.ts`) and the markdown paste (`markdown-paste.ts`).
  *
  * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
  * schema the shorthand rules build nothing (each is guarded on its mark type) and the
@@ -514,15 +517,15 @@ export function createField(opts) {
 export function proseLeafPlugins(schema, opts) {
     const list = [history(), ...(opts.afterHistory ?? []), linebreakPlugin(schema)];
     if (opts.slash)
-        list.push(slashPlugin(opts.slash));
+        list.push(slashPlugin(opts.slash, opts.slashHint));
     if (!opts.noInputRules)
         list.push(inputRulesPlugin(schema));
     list.push(keymap(editorKeymap(schema, opts.inline, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // All three answer to something only the block schema holds: any other leaf is
+    // Each answers to something only the block schema holds: any other leaf is
     // textblocks alone, with no island and no gap to put a cursor in.
     if (isBlockSchema(schema))
-        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), markdownPastePlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
     if (opts.placeholder)

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

@@ -13,7 +13,7 @@ export { pmToContent, contentEdit, lower } from './encode.js';
 export type { ContentEdit } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 export type { LineIndex } from './positions.js';
-export { createReconciler, contentEqual } from './reconcile.js';
+export { createReconciler, contentEqual, valueEqual } from './reconcile.js';
 export type { Reconciler } from './reconcile.js';
 export { inputRulesPlugin } from './inputrules.js';
 export { bodyKeymap } from './keymap.js';

package/dist/core/codec/index.js

@@ -36,7 +36,7 @@ export { decode, fitsInline, fitsLeaf, fitsPlain, renderContent, usvLength } fro
 export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 // Reconciliation gate.
-export { createReconciler, contentEqual } from './reconcile.js';
+export { createReconciler, contentEqual, valueEqual } from './reconcile.js';
 // Input rules (`createField` mounts them unless `noInputRules`/`plaintext`).
 export { inputRulesPlugin } from './inputrules.js';
 // The body leaf's structural keys: `createField` binds the composed chains

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

@@ -47,7 +47,9 @@ export declare function islandMinter(doc: PMNode): () => string;
  *  command placing exactly one island wants. */
 export declare function mintIslandId(doc: PMNode): string;
 /**
- * The paste's island pass: an id the field already holds is re-minted on the way in.
+ * The paste's island pass: an id the field already holds is re-minted on the way in, and
+ * an island arriving with none, a table read off foreign markup (`table-paste.ts`), takes
+ * its first.
  *
  * An id is an identity in the content and unique across the field, so two islands
  * wearing one is a projection the store has no shape for. A copy rather than a cut is

package/dist/core/codec/islands.js

@@ -170,9 +170,10 @@ export function mintIslandId(doc) {
 function isIsland(node) {
     return node.type.name === 'island_block' || node.type.name === 'island_inline';
 }
-/** `fragment` with every island whose id is already `taken` re-minted, or `null` where
- *  none was: an untouched paste stays the slice it arrived as. Every surviving id joins
- *  the set, so a slice carrying one id twice comes apart in the same pass. */
+/** `fragment` with every island whose id is empty or already `taken` minted afresh, or
+ *  `null` where none was: an untouched paste stays the slice it arrived as. Every
+ *  surviving id joins the set, so a slice carrying one id twice comes apart in the same
+ *  pass. */
 function remintIslands(fragment, taken, mint) {
     const out = [];
     let changed = false;
@@ -184,7 +185,7 @@ function remintIslands(fragment, taken, mint) {
             return;
         }
         let id = node.attrs.id;
-        if (taken.has(id)) {
+        if (!id || taken.has(id)) {
             do
                 id = mint();
             while (taken.has(id));
@@ -196,7 +197,9 @@ function remintIslands(fragment, taken, mint) {
     return changed ? Fragment.fromArray(out) : null;
 }
 /**
- * The paste's island pass: an id the field already holds is re-minted on the way in.
+ * The paste's island pass: an id the field already holds is re-minted on the way in, and
+ * an island arriving with none, a table read off foreign markup (`table-paste.ts`), takes
+ * its first.
  *
  * An id is an identity in the content and unique across the field, so two islands
  * wearing one is a projection the store has no shape for. A copy rather than a cut is

package/dist/core/codec/markdown-paste.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * A block leaf's markdown paste, consulted after the table paste: ProseMirror hands text
+ * over only where the clipboard holds no HTML, whose DOM parse reads the source's own
+ * structure, so HTML wins. A paste as plain text keeps the text. An island the parse
+ * builds arrives under the id `importMarkdown` minted, which the paste's island pass
+ * re-mints where the field holds it (`islands.ts`).
+ */
+export declare function markdownPastePlugin(): Plugin;

package/dist/core/codec/markdown-paste.js

@@ -0,0 +1,49 @@
+// Markdown on the clipboard as text lands parsed in a block leaf (CODEC §"Markdown at the
+// edges"). A line opening a block is the shape a draft written in Notepad or copied out of
+// an LLM chat carries, and text holding one runs through `importMarkdown` and `decode`, so
+// the paste stores what the source editor stores of the same text. Text holding none stays
+// literal: a sentence with a dash in it, or a `**` with no block around it, keeps every
+// character.
+import { Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { core } from '../lifecycle.js';
+import { decode } from './decode.js';
+import { blockSchema } from './schema.js';
+/** A line opening a block markdown spells and prose does not: a bullet or an ordered item at
+ *  any indent, and within CommonMark's three spaces an ATX heading, a quote, a fence, or a
+ *  pipe table's delimiter row. */
+const BLOCK_HEAD = new RegExp([
+    String.raw `^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]`,
+    String.raw `^ {0,3}(?:#{1,6}|>)(?:[ \t]|$)`,
+    '^ {0,3}(?:```|~~~)',
+    String.raw `^ {0,3}(?=[^\n]*\|)\|?(?:[ \t]*:?-+:?[ \t]*\|)*[ \t]*:?-+:?[ \t]*\|?[ \t]*$`
+].join('|'), 'm');
+/**
+ * A block leaf's markdown paste, consulted after the table paste: ProseMirror hands text
+ * over only where the clipboard holds no HTML, whose DOM parse reads the source's own
+ * structure, so HTML wins. A paste as plain text keeps the text. An island the parse
+ * builds arrives under the id `importMarkdown` minted, which the paste's island pass
+ * re-mints where the field holds it (`islands.ts`).
+ */
+export function markdownPastePlugin() {
+    return new Plugin({
+        props: {
+            // A falsy return declines, handing the text to ProseMirror's own split into
+            // paragraphs; the prop's type has no spelling for it.
+            clipboardTextParser: ((text, _context, plain) => {
+                if (plain || !BLOCK_HEAD.test(text))
+                    return null;
+                const { importMarkdown } = core();
+                let rt;
+                try {
+                    rt = importMarkdown(text).content;
+                }
+                catch {
+                    // Nesting past the store's depth is refused; the literal text holds it.
+                    return null;
+                }
+                return new Slice(decode(rt, blockSchema).content, 0, 0);
+            })
+        }
+    });
+}

package/dist/core/codec/prose.css

@@ -223,6 +223,22 @@ li.ProseMirror-selectednode::after {
 	text-overflow: ellipsis;
 }
 
+/* The slash menu's hint (`slash.ts`, `slashHint`), drawn as the ghost is, on the one
+   empty line the caret holds. Only while the leaf has the focus: the decoration follows
+   the selection, which an unfocused leaf keeps. Upright, being chrome about the key
+   rather than an invitation in the document's voice, and never over a ghost, which is
+   the leaf's own word for the same empty line. */
+.ProseMirror-focused .qm-slash-hint:not(.qm-prose-placeholder)[data-slash-hint]::after {
+	content: attr(data-slash-hint);
+	display: block;
+	margin-top: -1lh;
+	white-space: nowrap;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	color: var(--_qm-ink-label);
+	pointer-events: none;
+}
+
 /* ── The table island ────────────────────────────────────────────────────────
 
    The one construct in this file with chrome in it. The rest of the stylesheet
@@ -371,7 +387,7 @@ li.ProseMirror-selectednode::after {
    What differs is which edge each hangs off and what it draws. The grips take the
    leading edges, where a line begins; the add bars take the trailing ones, past where
    the axis ends. Position is the whole of what says which is which: the grip's marks are
-   the only glyph on the island, and they say draggable rather than which control this
+   the only glyph in the band, and they say draggable rather than which control this
    is. */
 :is(.qm-table-grip, .qm-table-add) {
 	position: absolute;
@@ -503,6 +519,98 @@ li.ProseMirror-selectednode::after {
 	outline-offset: var(--_qm-ring-offset);
 }
 
+/* A weighted table spans the leaf, laid out fixed, so the stored weights are the
+   proportions its columns draw, as the page's fractional columns span the text block
+   (`table-view.ts` §`weigh`). An auto-fit table keeps its content's width. */
+.qm-table-frame[data-weighted] {
+	width: 100%;
+}
+.qm-table-frame[data-weighted] .qm-table {
+	width: 100%;
+	table-layout: fixed;
+}
+
+/* A column border's handle: in the band, astride the border after its header cell, the
+   band's height. It draws a rule along the border while the pointer is on it or while
+   it is being dragged, and nothing at rest. */
+.qm-table-resize {
+	position: absolute;
+	z-index: 1;
+	bottom: 100%;
+	right: calc(var(--_qm-space-3) / -2);
+	display: flex;
+	justify-content: center;
+	width: var(--_qm-space-3);
+	height: var(--_qm-tap-min);
+	cursor: col-resize;
+	/* The pointer owns this gesture, not the page's scroll: a border drags. */
+	touch-action: none;
+}
+.qm-table-resize::before {
+	content: '';
+	width: var(--_qm-ring-width);
+	border-radius: var(--_qm-radius-pill);
+	background: var(--_qm-accent);
+	opacity: 0;
+	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
+}
+.qm-table-resize:is(:hover, [data-active])::before {
+	opacity: 1;
+}
+
+/* The held column's alignment cluster, hung off its header cell and floating over the
+   first row, the band's top edge being the grips'. Up only while its column is held and
+   absent otherwise (`table-view.ts` §`alignCluster`), so the reveal is `hidden` rather
+   than the band's opacity. It floats over content it did not choose, so the edge and
+   `--_qm-lift` separate it and the raised rung joins them in dark (ARCHITECTURE
+   §Styling). The pressed toggle takes the selected grip's tint and accent: it names the
+   held column's alignment the way the grip names the held line. */
+.qm-table-align {
+	position: absolute;
+	z-index: 2;
+	top: 100%;
+	inset-inline: 0;
+	width: max-content;
+	margin-inline: auto;
+	display: flex;
+	border: var(--_qm-border-width) solid var(--_qm-border);
+	border-radius: var(--_qm-radius-inner);
+	background: var(--_qm-surface-raised);
+	box-shadow: var(--_qm-lift);
+}
+.qm-table-align[hidden] {
+	display: none;
+}
+/* The header toggle hangs under the first row's last cell, flush with the grid's
+   trailing edge, clear of whatever a held row raises over its first. */
+.qm-table-align[data-header] {
+	margin-inline: auto 0;
+}
+.qm-table-align-option {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	width: var(--_qm-tap-min);
+	height: var(--_qm-tap-min);
+	padding: 0;
+	border: none;
+	border-radius: var(--_qm-radius-inner);
+	background: none;
+	color: var(--_qm-ink);
+	cursor: pointer;
+}
+.qm-table-align-option:hover {
+	background: var(--_qm-surface-hover);
+}
+.qm-table-align-option[aria-pressed='true'] {
+	background: var(--_qm-accent-tint);
+	color: var(--_qm-accent);
+}
+.qm-table-align-option svg {
+	width: var(--_qm-glyph-control);
+	height: var(--_qm-glyph-control);
+}
+
 /* A drag in flight. The lifted line reads as picked up by tone, never a shadow:
    elevation is a surface rung here, which says the same thing at both poles. The drop
    rule is the accent, the ink the surface keeps for a state rather than for text. */

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

@@ -3,8 +3,7 @@ import type { NodeType } 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). */
+ *  containers, no islands, and the full mark set (a `richtext(inline)` field). */
 export declare const inlineSchema: Schema<string, string>;
 /**
  * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
@@ -16,6 +15,13 @@ export declare const inlineSchema: Schema<string, string>;
  * carrying (CODEC §Inline mode).
  */
 export declare const plaintextSchema: Schema<string, never>;
+/**
+ * A table cell: the inline schema plus `hard_break`, which a `TableCell` stores as a
+ * `\n` in its `text`. Still one paragraph, so Enter has no block to split; a break is
+ * Shift-Enter's (`breaks.ts`). Declaring the break routes `decode` through the plain
+ * path, which folds a cell's `continues` lines into that one paragraph.
+ */
+export declare const cellSchema: Schema<"hard_break", string>;
 /**
  * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
  * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free