@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/schema/container-raw.js

@@ -1,15 +1,22 @@
 /**
- * Ancestry dispatch for container raw rebuilds — looks up
- * `descriptor.rebuildRaw`, so plugin containers participate by declaring one.
+ * Rebuilds container `raw` up a node's ancestors, looking up `descriptor.rebuildRaw`, so a
+ * plugin container joins in by declaring one. A container's metadata follows its rebuilt bytes
+ * (`docs/design/editor.md` § The container `raw` contract).
  */
+import { describeMetadataDivergence } from '../core/metadata-parity';
+import { readBlocks } from '../core/parser';
+import { ownTrailingLineEnding, trimTrailingLineEnding } from '../core/lines';
+import { assignChildIdsDeep, idsAcrossReread } from '../block-id';
+import { perfEnabled, recordContainerKindReparse, recordOpenerLineRead } from '../perf/instruments';
 import { tryGetBlockKindDescriptor } from './block-kind-descriptor';
+import { isBlockOpenerRegistered } from './block-openers';
 /**
- * Rebuild `raw` for every container along `path`, innermost first. The leaf at the tail of
- * `path` is NOT rebuilt — callers mutate its raw before calling. Empty path rebuilds `root`.
+ * Rebuild `raw` for every container along `path`, innermost first. The leaf at the end of `path`
+ * is not rebuilt: callers change its raw before calling. An empty path rebuilds `root`.
  */
-export function rebuildAncestryRaw(root, path) {
+export function rebuildAncestryRaw(root, path, grammar) {
     if (path.length === 0) {
-        rebuildContainerRaw(root);
+        rebuildContainerRaw(root, grammar);
         return;
     }
     const containers = [];
@@ -19,25 +26,147 @@ export function rebuildAncestryRaw(root, path) {
         containers.push(current);
     }
     for (let i = containers.length - 1; i >= 0; i--) {
-        rebuildContainerRaw(containers[i]);
+        rebuildContainerRaw(containers[i], grammar);
     }
-    rebuildContainerRaw(root);
+    rebuildContainerRaw(root, grammar);
 }
 /**
- * Dispatch via the kind's descriptor `rebuildRaw`; throws on a leaf. Callers walking ancestry
- * chains use {@link rebuildContainerRawIfContainer} instead.
+ * Calls the `rebuildRaw` on the kind's descriptor, then re-reads the metadata a moved outer line
+ * may carry; throws on a leaf.
  */
-export function rebuildContainerRaw(node) {
+export function rebuildContainerRaw(node, grammar) {
     const rebuild = tryGetBlockKindDescriptor(node.kind)?.rebuildRaw;
     if (!rebuild) {
-        throw new Error(`rebuildContainerRaw: kind "${node.kind}" has no rebuildRaw — only container kinds are valid`);
+        throw new Error(`rebuildContainerRaw: kind "${node.kind}" has no rebuildRaw; only container kinds are valid`);
     }
+    const rawBefore = node.raw;
     rebuild(node);
+    const reading = followBytes(node, rawBefore, grammar);
+    // No position to put a new node at, so the node takes its reading in place.
+    if (reading.outcome === 'reread')
+        takeReread(node, reading.node);
 }
 /**
- * Rebuild `raw` when `node` has a rebuildRaw on its descriptor; no-op otherwise. `changed` is
- * the one-child hint (`child-spans.ts`); a rebuilder ignoring it re-derives the whole raw.
+ * The chain rebuild's step, which re-derives kind and metadata itself once it knows whether an
+ * outer line moved; a rebuild outside the chain uses {@link rebuildContainerRaw}.
  */
 export function rebuildContainerRawIfContainer(node, changed) {
     tryGetBlockKindDescriptor(node.kind)?.rebuildRaw?.(node, changed);
 }
+const KEPT = { outcome: 'kept' };
+/** Reads `node`'s bytes as a reload would after a rewrite from `rawBefore`, taking in place the
+ *  metadata they give it: the one place that knows which lines a kind's metadata comes from. */
+export function followBytes(node, rawBefore, grammar, options = {}) {
+    const contract = tryGetBlockKindDescriptor(node.kind)?.containerContract;
+    if (options.whole)
+        return rereadWhole(node, contract, grammar);
+    const openerMoved = firstLine(rawBefore) !== firstLine(node.raw);
+    // A closing line's ending counts: an opaque container can keep it in metadata.
+    const closerMoved = closingLine(rawBefore) !== closingLine(node.raw);
+    if (contract === 'opaque' && (closerMoved || (openerMoved && !options.titleRowOnly))) {
+        return rereadWhole(node, contract, grammar);
+    }
+    if (!openerMoved)
+        return KEPT;
+    const strip = contract === 'strip';
+    if (!strip && !isBlockOpenerRegistered(node.kind))
+        return KEPT;
+    const opened = soleNodeOfKind(readOpenerLine(node.raw, grammar), node.kind);
+    // A strip container's metadata is all on its first line, so that line alone re-reads it.
+    if (opened) {
+        const same = !strip || describeMetadataDivergence(node, opened) === null;
+        return same ? KEPT : rereadWhole(node, contract, grammar);
+    }
+    // A first line that opens another kind changes the reading, for a kind whose opener says so.
+    return isBlockOpenerRegistered(node.kind) ? rereadWhole(node, contract, grammar) : KEPT;
+}
+/**
+ * What the grammar opens `line` as, read in isolation: asked of the opener registry and never
+ * a kind list, so a kind registered later is covered the day it registers.
+ */
+export function lineOpensAs(line, grammar) {
+    return readBlocks(`${line}\n`, { grammar, scope: 'fragment' }).children[0]?.kind ?? 'paragraph';
+}
+const closingLine = (raw) => lastLine(raw) + ownTrailingLineEnding(raw);
+function readOpenerLine(raw, grammar) {
+    if (perfEnabled())
+        recordOpenerLineRead();
+    return readBlocks(`${firstLine(raw)}\n`, { grammar, scope: 'fragment' }).children;
+}
+/** The one node of `kind` that `blocks` are, or the sole child of the one block wrapping it (a
+ *  list item reads back inside a list), or null. */
+function soleNodeOfKind(blocks, kind) {
+    if (blocks.length !== 1)
+        return null;
+    if (blocks[0].kind === kind)
+        return blocks[0];
+    const wrapped = blocks[0].children;
+    return wrapped?.length === 1 && wrapped[0].kind === kind ? wrapped[0] : null;
+}
+function rereadWhole(node, contract, grammar) {
+    const blocks = parseContainerRaw(node.raw, grammar);
+    const reread = soleNodeOfKind(blocks, node.kind);
+    if (!reread)
+        return { outcome: 'diverged', blocks };
+    // A strip container's metadata is its line prefix, which decides how every child line reads.
+    if (contract === 'strip' && !sameChildren(node, reread))
+        return { outcome: 'reread', node: reread };
+    takeMetadata(node, reread);
+    return KEPT;
+}
+function sameChildren(live, reread) {
+    const children = live.children ?? [];
+    const rereadChildren = reread.children ?? [];
+    return ((live.innerSuffix ?? '') === (reread.innerSuffix ?? '') &&
+        children.length === rereadChildren.length &&
+        children.every((child, i) => {
+            const other = rereadChildren[i];
+            return (child.kind === other.kind &&
+                child.leadingTrivia === other.leadingTrivia &&
+                child.raw === other.raw);
+        }));
+}
+/**
+ * Takes the metadata a parse of `node`'s own bytes derived, so the next rebuild reads what a
+ * reload would. False when the parse isn't one block of the node's kind, and nothing is taken.
+ */
+export function adoptParsedMetadata(node, parsed) {
+    if (parsed.length !== 1 || parsed[0].kind !== node.kind)
+        return false;
+    takeMetadata(node, parsed[0]);
+    return true;
+}
+function takeMetadata(node, reread) {
+    // Unchanged metadata keeps its object, since every reader of it re-runs when the object changes.
+    if (describeMetadataDivergence(node, reread) === null)
+        return;
+    // A fresh object from the parse, so no undo entry shares it.
+    node.metadata = reread.metadata;
+}
+/** A node's reading taken into the node itself: a child the re-read left alone keeps its id. */
+function takeReread(node, reread) {
+    const children = reread.children ?? [];
+    node.childIds = idsAcrossReread(node.children ?? [], node.childIds, children);
+    node.metadata = reread.metadata;
+    node.children = children;
+    node.innerPrefix = reread.innerPrefix;
+    node.innerSuffix = reread.innerSuffix;
+    node.childSpans = undefined;
+    assignChildIdsDeep(node);
+}
+/** One parse of a container's own bytes, the cost the kind and metadata re-derive pay. */
+export function parseContainerRaw(raw, grammar) {
+    if (perfEnabled())
+        recordContainerKindReparse(raw.length);
+    return readBlocks(raw, { grammar, scope: 'fragment' }).children;
+}
+export function firstLine(raw) {
+    const nl = raw.indexOf('\n');
+    return nl < 0 ? raw : raw.slice(0, nl);
+}
+/** The container's closing line: its last line carrying bytes, without the ending. */
+export function lastLine(raw) {
+    const body = trimTrailingLineEnding(raw);
+    const nl = body.lastIndexOf('\n');
+    return nl < 0 ? body : body.slice(nl + 1);
+}

package/dist/schema/container-rebuilders.d.ts

@@ -1,32 +1,34 @@
 /**
- * Per-container-kind raw rebuilders. Separate from container-raw.ts (the ancestry dispatch) so
- * the built-in registrations can declare rebuildRaw directly: this file reaches no registry,
- * while the dispatch must import one, and same-file would cycle. The strip and concat shapes
- * live in child-spans.ts; each kind here contributes only its own per-line syntax.
+ * Per-container-kind raw rebuilders. Kept apart from `container-raw.ts`, which walks a node's
+ * ancestors, so the built-in registrations can declare `rebuildRaw` directly: this file imports
+ * no registry, that walk must, and one file holding both would cycle. The two shared rebuild
+ * shapes live in `child-spans.ts`; each kind here adds only its own per-line syntax.
  */
 import type { CstNode } from '../core/nodes';
+import type { NodeView } from '../core/node-views';
+import { type LineEnding } from '../core/lines';
 import { type ChildRawChange } from './child-spans';
 /** Rebuild a blockquote's `raw`: `> ` on content lines, `>` on blank lines. */
 export declare function rebuildBlockquoteRaw(node: CstNode, changed?: ChildRawChange): void;
 /**
- * Rebuild a list item's `raw`: marker on the first line, indentation on continuations. Blank
- * lines stay unindented — GFM loose-list form.
+ * Rebuild a list item's `raw`: marker on the first line, indentation on continuations. Separator
+ * lines stay bare, but a blank line at the body's end is indented to stay in the item.
  */
 export declare function rebuildListItemRaw(node: CstNode, changed?: ChildRawChange): void;
 export declare function rebuildListRaw(node: CstNode, changed?: ChildRawChange): void;
-/** `| c0 | c1 | ... |` plus the row's own ending (single-space padding). */
+/** `| c0 | c1 | ... |` plus the row's own ending (single-space padding). The table's rebuild,
+ *  which writes the table's bytes, gives every row the table's ending. */
 export declare function rebuildTableRowRaw(node: CstNode): void;
+/** The ending a table's lines take: a table spans its header and delimiter lines at least, so its
+ *  bytes hold the document's ending. */
+export declare function tableLineEnding(table: NodeView): LineEnding;
 /**
- * The same bytes under an ending the row does not own: a row minted by a structural op has no
- * authored one, so the TABLE dictates it. Split from the descriptor-shaped rebuilder above
- * because `rebuildRaw`'s second parameter is the changed-child hint.
+ * The row's bytes with the table's line ending, since a row a structural edit created has none of
+ * its own. The surplus cells, which GFM does not render, follow the rendered ones.
  */
 export declare function writeTableRow(node: CstNode, lineEnding: string): void;
 /**
- * Header + synthesized canonical delimiter + body rows. Every row is rebuilt before assembly, so
- * the whole table normalizes to canonical padding on first structural mutation rather than
- * landing half-padded. The table's own ending drives every emitted line (G4.20): a row minted by
- * a structural op has no authored ending, so per-row detection would strand it on LF in a CRLF
- * table.
+ * Every row is rebuilt, so the first structural edit normalizes the whole table's padding. The last
+ * line of a table that ends the document with no line ending stays open, whichever row holds it.
  */
 export declare function rebuildTableRaw(node: CstNode): void;

package/dist/schema/container-rebuilders.js

@@ -1,11 +1,11 @@
 /**
- * Per-container-kind raw rebuilders. Separate from container-raw.ts (the ancestry dispatch) so
- * the built-in registrations can declare rebuildRaw directly: this file reaches no registry,
- * while the dispatch must import one, and same-file would cycle. The strip and concat shapes
- * live in child-spans.ts; each kind here contributes only its own per-line syntax.
+ * Per-container-kind raw rebuilders. Kept apart from `container-raw.ts`, which walks a node's
+ * ancestors, so the built-in registrations can declare `rebuildRaw` directly: this file imports
+ * no registry, that walk must, and one file holding both would cycle. The two shared rebuild
+ * shapes live in `child-spans.ts`; each kind here adds only its own per-line syntax.
  */
 import { metadataOf } from '../core/nodes';
-import { trailingLineEnding } from '../core/lines';
+import { firstLineEnding, ownTrailingLineEnding } from '../core/lines';
 import { rebuildConcatRaw, rebuildStripRaw } from './child-spans';
 // ── Blockquote ───────────────────────────────────────────────────────────────
 /** Rebuild a blockquote's `raw`: `> ` on content lines, `>` on blank lines. */
@@ -17,8 +17,8 @@ export function rebuildBlockquoteRaw(node, changed) {
 const quoteLine = (text) => (text === '' ? '>' : '> ' + text);
 // ── List ─────────────────────────────────────────────────────────────────────
 /**
- * Rebuild a list item's `raw`: marker on the first line, indentation on continuations. Blank
- * lines stay unindented — GFM loose-list form.
+ * Rebuild a list item's `raw`: marker on the first line, indentation on continuations. Separator
+ * lines stay bare, but a blank line at the body's end is indented to stay in the item.
  */
 export function rebuildListItemRaw(node, changed) {
     if (!node.children || !node.metadata)
@@ -27,10 +27,10 @@ export function rebuildListItemRaw(node, changed) {
     const marker = meta.marker ?? '- ';
     const taskMarker = meta.taskMarker ?? '';
     const indent = ' '.repeat(marker.length);
-    rebuildStripRaw(node, (text, first) => {
+    rebuildStripRaw(node, (text, first, trailingBlank) => {
         if (first)
             return marker + taskMarker + text;
-        return text === '' ? '' : indent + text;
+        return text === '' && !trailingBlank ? '' : indent + text;
     }, changed);
 }
 export function rebuildListRaw(node, changed) {
@@ -39,39 +39,47 @@ export function rebuildListRaw(node, changed) {
     rebuildConcatRaw(node, changed);
 }
 // ── Table ────────────────────────────────────────────────────────────────────
-/** `| c0 | c1 | ... |` plus the row's own ending (single-space padding). */
+/** `| c0 | c1 | ... |` plus the row's own ending (single-space padding). The table's rebuild,
+ *  which writes the table's bytes, gives every row the table's ending. */
 export function rebuildTableRowRaw(node) {
-    writeTableRow(node, trailingLineEnding(node.raw));
+    writeTableRow(node, ownTrailingLineEnding(node.raw));
+}
+/** The ending a table's lines take: a table spans its header and delimiter lines at least, so its
+ *  bytes hold the document's ending. */
+export function tableLineEnding(table) {
+    return firstLineEnding(table.raw) ?? '\n';
 }
 /**
- * The same bytes under an ending the row does not own: a row minted by a structural op has no
- * authored one, so the TABLE dictates it. Split from the descriptor-shaped rebuilder above
- * because `rebuildRaw`'s second parameter is the changed-child hint.
+ * The row's bytes with the table's line ending, since a row a structural edit created has none of
+ * its own. The surplus cells, which GFM does not render, follow the rendered ones.
  */
 export function writeTableRow(node, lineEnding) {
     if (!node.children)
         return;
-    const cells = node.children.map((c) => c.raw);
+    const surplus = node.metadata ? (metadataOf(node, 'tableRow').surplusCells ?? []) : [];
+    const cells = [...node.children.map((c) => c.raw), ...surplus];
     node.raw = '| ' + cells.join(' | ') + ' |' + lineEnding;
 }
 /**
- * Header + synthesized canonical delimiter + body rows. Every row is rebuilt before assembly, so
- * the whole table normalizes to canonical padding on first structural mutation rather than
- * landing half-padded. The table's own ending drives every emitted line (G4.20): a row minted by
- * a structural op has no authored ending, so per-row detection would strand it on LF in a CRLF
- * table.
+ * Every row is rebuilt, so the first structural edit normalizes the whole table's padding. The last
+ * line of a table that ends the document with no line ending stays open, whichever row holds it.
  */
 export function rebuildTableRaw(node) {
     if (!node.children)
         return;
     const meta = metadataOf(node, 'table');
-    const lineEnding = trailingLineEnding(node.raw);
+    const lineEnding = tableLineEnding(node);
+    const openTail = ownTrailingLineEnding(node.raw) === '';
     for (const row of node.children)
         writeTableRow(row, lineEnding);
     const headerRow = node.children[0];
     const bodyRows = node.children.slice(1);
+    const lastBodyRow = bodyRows.at(-1);
+    if (openTail && lastBodyRow)
+        writeTableRow(lastBodyRow, '');
     const delimiterCells = meta.alignments.map(formatAlignmentCell).join(' | ');
-    const delimiterLine = '| ' + delimiterCells + ' |' + lineEnding;
+    const delimiterEnding = openTail && !lastBodyRow ? '' : lineEnding;
+    const delimiterLine = '| ' + delimiterCells + ' |' + delimiterEnding;
     let raw = (headerRow?.raw ?? '') + delimiterLine;
     for (const r of bodyRows)
         raw += r.raw;

package/dist/schema/context-actions.d.ts

@@ -1,31 +1,43 @@
 /**
- * The block context menu's vocabulary: what a right-click on a block of a given kind offers.
- * A kind's own providers come first, then the ones registered for every kind (`'*'`: the
- * editor's copy, replace and remove rows). Providers are consulted on every open, so they read
- * the block as it is. The defaults register at bootstrap; a plugin registers through the barrel.
+ * What a right-click on a block of a given kind offers. A kind's own providers come first, then
+ * the ones registered for every kind (`'*'`: the editor's copy, replace and remove rows).
+ * Providers run on every open, so they see the block as it is. The defaults register at startup;
+ * a plugin registers through the public barrel.
  */
 export declare const EVERY_KIND = "*";
 import type { NodeView } from '../core/node-views';
+import type { LineEnding } from '../core/lines';
+import type { PluginActivation } from './plugin-activation';
 export interface BlockActionContext {
     node: NodeView;
     /** The block's path from the document root. Top-level blocks only, for now. */
     path: number[];
-    /** Remove the block. */
     deleteBlock(): Promise<void>;
-    /** Replace the block's bytes wholesale; the result reparses to whatever those bytes are. */
+    /** Replace the block's bytes wholesale as one undo entry of its own, every line break written
+     *  in the document's ending; the result reparses to whatever those bytes are. */
     replaceRaw(raw: string): Promise<void>;
+    /** The document's line ending, for a line rebuilt from the block's own bytes. */
+    lineEnding: LineEnding;
+    /** Pasted text through the paste transforms of the plugins this editor lists, as a paste
+     *  into the editor would see it. */
+    transformPaste(text: string): string;
 }
 export interface BlockContextAction {
     id: string;
     label: string;
-    /** A glyph name the menu knows (`components/menu/MenuIcon.svelte`); absent draws none. */
+    /** An icon name the menu knows (`src/lib/menu-icons.ts`); absent draws none. */
     icon?: string;
     danger?: boolean;
     run(ctx: BlockActionContext): void | Promise<void>;
 }
-export type BlockContextActionProvider = (node: NodeView, path: number[]) => BlockContextAction[];
-/** Add a provider for `kind`, or for every kind with `EVERY_KIND`. Several may stack. */
-export declare function registerBlockContextActions(kind: string, provider: BlockContextActionProvider): void;
-export declare function blockContextActionsFor(node: NodeView, path: number[]): BlockContextAction[];
-/** Test-only. */
-export declare function __resetBlockContextActionsForTests(): void;
+/** `noun` is what the menu calls the block ("code block", "image"), for a row's label. */
+export type BlockContextActionProvider = (node: NodeView, path: number[], noun: string) => BlockContextAction[];
+/**
+ * Add a provider for `kind`, or every kind with `EVERY_KIND`, under a `name` unique to that kind
+ * (a taken name throws). A plugin's rows show only in the editors that list the plugin.
+ */
+export declare function registerBlockContextActions(kind: string, name: string, provider: BlockContextActionProvider): void;
+/** The editor's own rows: a provider the test reset keeps, owned by no plugin even when a
+ *  plugin's setup is what first reaches it. */
+export declare function registerBuiltinBlockContextActions(kind: string, name: string, provider: BlockContextActionProvider): void;
+export declare function blockContextActionsFor(node: NodeView, path: number[], activation: PluginActivation, noun: string): BlockContextAction[];

package/dist/schema/context-actions.js

@@ -1,23 +1,38 @@
 /**
- * The block context menu's vocabulary: what a right-click on a block of a given kind offers.
- * A kind's own providers come first, then the ones registered for every kind (`'*'`: the
- * editor's copy, replace and remove rows). Providers are consulted on every open, so they read
- * the block as it is. The defaults register at bootstrap; a plugin registers through the barrel.
+ * What a right-click on a block of a given kind offers. A kind's own providers come first, then
+ * the ones registered for every kind (`'*'`: the editor's copy, replace and remove rows).
+ * Providers run on every open, so they see the block as it is. The defaults register at startup;
+ * a plugin registers through the public barrel.
  */
 export const EVERY_KIND = '*';
-const providers = new Map();
-/** Add a provider for `kind`, or for every kind with `EVERY_KIND`. Several may stack. */
-export function registerBlockContextActions(kind, provider) {
-    const list = providers.get(kind) ?? [];
-    list.push(provider);
-    providers.set(kind, list);
+import { createPluginRegistry } from './plugin-registry';
+const providers = createPluginRegistry({
+    label: 'registerBlockContextActions',
+    isBuiltin: () => false
+});
+/**
+ * Add a provider for `kind`, or every kind with `EVERY_KIND`, under a `name` unique to that kind
+ * (a taken name throws). A plugin's rows show only in the editors that list the plugin.
+ */
+export function registerBlockContextActions(kind, name, provider) {
+    providers.register(providerKey(kind, name), { kind, provider }, providerConflict(kind, name));
+}
+/** The editor's own rows: a provider the test reset keeps, owned by no plugin even when a
+ *  plugin's setup is what first reaches it. */
+export function registerBuiltinBlockContextActions(kind, name, provider) {
+    providers.registerCore(providerKey(kind, name), { kind, provider }, providerConflict(kind, name));
+}
+export function blockContextActionsFor(node, path, activation, noun) {
+    const active = providers.entries(activation).map(([, entry]) => entry);
+    return [
+        ...active.filter((entry) => entry.kind === node.kind),
+        ...active.filter((entry) => entry.kind === EVERY_KIND)
+    ].flatMap(({ provider }) => provider(node, path, noun));
 }
-export function blockContextActionsFor(node, path) {
-    const own = providers.get(node.kind) ?? [];
-    const every = providers.get(EVERY_KIND) ?? [];
-    return [...own, ...every].flatMap((provider) => provider(node, path));
+// ── Internal ─────────────────────────────────────────────────────────────────
+function providerKey(kind, name) {
+    return `${kind} ${name}`;
 }
-/** Test-only. */
-export function __resetBlockContextActionsForTests() {
-    providers.clear();
+function providerConflict(kind, name) {
+    return `registerBlockContextActions: "${name}" is already registered for "${kind}". Providers are register-once.`;
 }

package/dist/schema/define-plugin-block.d.ts

@@ -1,15 +1,17 @@
 /**
- * The single-block plugin unit: declare-and-describe a kind, then bind its component, sparing a
- * one-kind plugin the register/define double-wrap and its setup ordering. A multi-kind plugin
- * stays on `definePlugin` directly. `kind` is the plain declared-kind NAME, branded lazily after
- * `register` runs — `declaredPluginKind` throws for a not-yet-declared name.
+ * The one-block plugin shortcut: declare and describe a kind, then attach its component, so a
+ * single-kind plugin does not have to wrap `definePlugin` itself and get the setup order right. A
+ * plugin with several kinds uses `definePlugin` directly. `kind` is the plain declared name,
+ * branded after `register` runs: `declaredPluginKind` throws for a name not yet declared.
  */
 import type { Component } from 'svelte';
 import { type EditorPlugin } from './plugin-install';
 import type { BlockComponentExports, BlockComponentProps } from '../block-component';
-export declare function definePluginBlock<P extends Partial<BlockComponentProps> & Record<string, unknown>>(config: {
+export declare function definePluginBlock<P extends Partial<BlockComponentProps> & Record<string, unknown>, Options extends object = Record<never, never>>(config: {
     name: string;
     kind: string;
     component: Component<P, BlockComponentExports>;
     register: () => void;
-}): EditorPlugin;
+    defaults?: Options;
+    parseOptions?(raw: unknown): Partial<Options>;
+}): EditorPlugin<Options>;

package/dist/schema/define-plugin-block.js

@@ -1,8 +1,8 @@
 /**
- * The single-block plugin unit: declare-and-describe a kind, then bind its component, sparing a
- * one-kind plugin the register/define double-wrap and its setup ordering. A multi-kind plugin
- * stays on `definePlugin` directly. `kind` is the plain declared-kind NAME, branded lazily after
- * `register` runs — `declaredPluginKind` throws for a not-yet-declared name.
+ * The one-block plugin shortcut: declare and describe a kind, then attach its component, so a
+ * single-kind plugin does not have to wrap `definePlugin` itself and get the setup order right. A
+ * plugin with several kinds uses `definePlugin` directly. `kind` is the plain declared name,
+ * branded after `register` runs: `declaredPluginKind` throws for a name not yet declared.
  */
 import { definePlugin } from './plugin-install';
 import { declaredPluginKind } from './plugin-kind';
@@ -10,6 +10,8 @@ import { registerBlockComponent, defineBlockComponent } from './block-component-
 export function definePluginBlock(config) {
     return definePlugin({
         name: config.name,
+        defaults: config.defaults,
+        parseOptions: config.parseOptions,
         setup() {
             config.register();
             registerBlockComponent(declaredPluginKind(config.kind), defineBlockComponent(config.component));

package/dist/schema/fenced-code-raw.d.ts

@@ -1,43 +1,56 @@
 /**
- * The fencedCode raw-write rule, declared on the kind as `normalizeRawWrite` and applied at every
- * write sink. RESTORE re-appends a closer a truncating write dropped and DROP removes one it
- * stranded, ESCALATE grows both runs past a body line that would read as the closer, SANITIZE
- * drops backticks from a backtick fence's info string (CommonMark §4.5) — all off the block's OWN
- * fence shape, which is why the pass takes a node. An authored open fence is exempt.
+ * The rule for writing a fenced block's bytes, declared on the kind as `rawWrite`: it restores or
+ * drops fence lines a write broke, grows the marker runs past a body line that would close them,
+ * and keeps backticks out of a backtick fence's info string, moving the caret with every byte. A
+ * fence the user is still typing (open, `authored`) is left alone.
  */
 import type { NodeView } from '../core/node-views';
+import type { WriteContext, WriteRule } from './block-kind-descriptor';
+import { type LineEnding } from '../core/lines';
 export interface FenceShape {
     marker: '`' | '~';
-    /** The block's own run length, from its metadata — not re-scanned from the write. */
+    /** The block's own marker-run length. A literal write re-reads it off the written opener. */
     length: number;
     closed: boolean;
 }
 /** Whether the written bytes are the user authoring the block's syntax, or content. */
-export type FenceWriteMode = 'authored' | 'literal';
+export type FenceWriteMode = WriteContext['mode'];
 export interface FenceWriteInput {
-    /** Display text about to be committed — raw without its trailing line ending. */
+    /** Display text about to be committed: raw without its trailing line ending. */
     display: string;
     /** Caret offset in `display`, mapped onto the reconciled bytes on the way out. */
     caret: number;
     fence: FenceShape;
     mode: FenceWriteMode;
+    /** The line ending a restored closer line takes: the block's own. */
+    ending: LineEnding;
 }
 export interface FenceWriteResult {
     display: string;
     caret: number;
 }
 export declare function fenceShapeOf(node: NodeView): FenceShape;
-export declare function reconcileFenceWrite(input: FenceWriteInput): FenceWriteResult;
+/** The fence write rule for a kind whose fence shape `shapeOf` reads off the block. */
+export declare function fenceRawWrite(shapeOf: (node: NodeView) => FenceShape): WriteRule;
+/** The built-in code block's rule, sized by its parsed metadata. */
+export declare const fencedCodeWrite: WriteRule;
+/**
+ * The shape of a fenced block that keeps no fence metadata, read off its own opener line. A
+ * plugin kind declares its rule as `fenceRawWrite(fenceShapeOfRaw)`.
+ */
+export declare function fenceShapeOfRaw(node: NodeView): FenceShape;
 /**
- * A whole fencedCode `raw` made legal — the kind's `normalizeRawWrite`. Literal by
- * construction: a sink reaching a node's bytes without its surface is never the author
- * typing the block's own syntax. The fence lines reconcile first, so ESCALATE measures a
- * body that ends where the closer does.
+ * The display text of a fenced block made legal, the caret carried along. The fence lines are
+ * fixed before the runs grow, so growing measures a body that ends where the closer does.
  */
-export declare function normalizeFencedRaw(raw: string, node: NodeView): string;
+export declare function reconcileFenceWrite(input: FenceWriteInput): FenceWriteResult;
 /**
- * The bytes with `info` written onto the opening fence line. Only that span moves, so the
- * indent, both marker runs, the body and the closer come through byte-identical. Null when
- * line 0 does not read as this block's opener at all.
+ * The bytes with `info` written onto the opener line, everything else byte-identical. Null when
+ * line 0 does not read as this block's opener.
  */
 export declare function writeFenceInfo(display: string, info: string, fence: FenceShape): string | null;
+/**
+ * `info` less what an info string may not hold: a line break, a backtick under a backtick fence,
+ * and a leading run of the fence's own marker, which would lengthen the fence (`~~~` plus `~x`).
+ */
+export declare function legalFenceInfo(info: string, marker: FenceShape['marker']): string;