@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/text/live-split-rebalance.js

@@ -0,0 +1,239 @@
+/**
+ * The live-mode split rewrite (live-mode.md § 4.4 close-and-reopen): Enter inside a construct
+ * closes it before the cut and reopens it after, so neither half strands a run the reader never
+ * saw. Bytes stay candidates until the parser agrees; null leaves `splitNode`'s byte-literal cut.
+ */
+import { constructContentRange, constructKinds, getContentRange, inlineDescendants, isProseKind, parseInline } from '../../../core/inline';
+import { CONTENT_VISIBILITY, paintsOnlyChrome, renderedText } from '../../../core/inline/visibility';
+import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
+import { soleProseReparse } from './screen-diff';
+// ── The rewrite ──────────────────────────────────────────────────────────────
+export const rebalanceLiveSplit = (node, offset, firstRaw, secondRaw, linkRef) => {
+    const read = readSplitBytes(node, offset, firstRaw, secondRaw);
+    if (read === null)
+        return null;
+    const resolver = linkRef?.current;
+    const inlines = parseInline(read.raw, read.contentStart, read.contentEnd, resolver);
+    // Chrome standing over nothing is all on screen (live-mode.md § 4.1), so closing and reopening
+    // it moves delimiters the reader is looking at: the byte-literal cut stands.
+    if (paintsOnlyChrome(inlines, read.raw))
+        return null;
+    const moved = wholeConstructEdge(inlines, offset);
+    const at = moved ?? offset;
+    const bytes = moved === null ? read : { ...read, cut: moved };
+    const chain = splittableChainAt(inlines, at);
+    // An empty chain with the cut where the caller put it is a cut no construct touches, and the
+    // byte-literal halves are already right; a MOVED cut is a rewrite in its own right.
+    if (chain === null || (chain.length === 0 && moved === null))
+        return null;
+    const seam = seamParts(bytes, chain, at);
+    const candidates = [
+        assemble(bytes, seam),
+        assembleSpaceOutside(bytes, seam),
+        assembleDroppingTerminalTrivia(bytes, seam)
+    ];
+    for (const candidate of candidates) {
+        // The dropped bytes are the verification's business, not the caller's: what it gets back
+        // is the two halves, whatever the candidate had to state to earn them.
+        if (candidate !== null && parsesBack(bytes, seam, candidate, resolver)) {
+            return { firstRaw: candidate.firstRaw, secondRaw: candidate.secondRaw };
+        }
+    }
+    return null;
+};
+/**
+ * Read the caller's two halves back against the original, so a cut this rewrite did not make (a
+ * container body-write rule, a suffix move, a consumed line ending) surfaces as a failed anchor.
+ */
+function readSplitBytes(node, offset, firstRaw, secondRaw) {
+    if (!isProseKind(node.kind))
+        return null;
+    const raw = node.raw;
+    const { start, end } = getContentRange(node);
+    if (offset <= start || offset >= end)
+        return null;
+    if (!firstRaw.startsWith(raw.slice(0, offset)))
+        return null;
+    for (let cut = offset; cut <= offset + 2 && cut < end; cut++) {
+        const body = raw.slice(cut, end);
+        if (!secondRaw.startsWith(body))
+            continue;
+        return {
+            raw,
+            contentStart: start,
+            contentEnd: end,
+            cut,
+            firstResidue: firstRaw.slice(offset),
+            secondResidue: secondRaw.slice(body.length)
+        };
+    }
+    return null;
+}
+/**
+ * The edge a cut moves to rather than landing inside a childless never-extend construct: two
+ * halves of a URL are not two URLs, and half an escape is a literal backslash, so the whole
+ * construct goes to the half the caret was nearer (live-mode.md § 4.4). Null where the cut lands
+ * in no such construct. Innermost wins, as everywhere else.
+ */
+function wholeConstructEdge(inlines, offset) {
+    let found = null;
+    for (const node of inlineDescendants(inlines)) {
+        const childless = node.kind !== 'text' && constructContentRange(node) === null;
+        const takesWhole = childless && getInlineConstructPolicy(node.kind)?.edgeAffinity === 'never-extend';
+        if (takesWhole && offset > node.start && offset < node.end) {
+            found = offset - node.start <= node.end - offset ? node.start : node.end;
+        }
+    }
+    return found;
+}
+/**
+ * Every construct holding `offset`, outermost first — or null when one of them declines. A kind
+ * with no policy row, one whose split behavior is plain and one whose content bounds are unknown
+ * cannot be cut open, and cutting the constructs inside one would strand its pair. Exported for
+ * the depth pin, which has to reach it with a tree no split this deep could be rendered at.
+ */
+export function splittableChainAt(inlines, offset) {
+    const chain = [];
+    const holds = (node) => holdsOffset(node, offset);
+    for (const node of inlineDescendants(inlines, holds)) {
+        if (!holds(node))
+            continue;
+        const content = constructContentRange(node);
+        if (!content)
+            return null;
+        if (getInlineConstructPolicy(node.kind)?.splitBehavior !== 'close-and-reopen')
+            return null;
+        chain.push({
+            kind: node.kind,
+            start: node.start,
+            end: node.end,
+            contentStart: content.start,
+            contentEnd: content.end
+        });
+    }
+    return chain;
+}
+/**
+ * Whether a cut at `offset` lands in this construct. One with children is content-INCLUSIVE so
+ * its edges reach the chain (the handover cases); a childless one is strict-interior, its edges
+ * being ordinary seams. Text is content, and nothing under it is a construct either.
+ */
+function holdsOffset(node, offset) {
+    if (node.kind === 'text')
+        return false;
+    const content = constructContentRange(node);
+    return content
+        ? offset >= content.start && offset <= content.end
+        : offset > node.start && offset < node.end;
+}
+/**
+ * Innermost first, so a closer written before its enclosing one nests the halves as the original
+ * did. A side with no content takes the whole construct: a pair enclosing nothing is residue live
+ * may never write.
+ */
+function seamParts(bytes, chain, offset) {
+    let leftEnd = offset;
+    let rightStart = bytes.cut;
+    let closers = '';
+    let openers = '';
+    const closed = [];
+    const reopened = [];
+    for (const link of [...chain].reverse()) {
+        if (leftEnd === link.contentStart)
+            leftEnd = link.start;
+        else {
+            closers += bytes.raw.slice(link.contentEnd, link.end);
+            closed.push(link.kind);
+        }
+        if (rightStart === link.contentEnd)
+            rightStart = link.end;
+        else {
+            openers = bytes.raw.slice(link.start, link.contentStart) + openers;
+            reopened.push(link.kind);
+        }
+    }
+    return {
+        head: bytes.raw.slice(0, leftEnd),
+        closers,
+        openers,
+        tail: bytes.raw.slice(rightStart, bytes.contentEnd),
+        closed,
+        reopened
+    };
+}
+const assemble = (bytes, seam) => ({
+    firstRaw: seam.head + seam.closers + bytes.firstResidue,
+    secondRaw: seam.openers + seam.tail + bytes.secondResidue
+});
+/**
+ * The same seam with a boundary space handed to the plain text beside it. Markdown opens and
+ * closes a run against a word, never whitespace, so a space left inside kills the construct; a
+ * space's formatting is invisible, so moving it is the reading that parses and looks unchanged.
+ */
+function assembleSpaceOutside(bytes, seam) {
+    const trailing = seam.closers !== '' && seam.head.endsWith(' ');
+    const leading = seam.openers !== '' && seam.tail.startsWith(' ');
+    if (!trailing && !leading)
+        return null;
+    return {
+        firstRaw: (trailing ? seam.head.slice(0, -1) + seam.closers + ' ' : seam.head + seam.closers) +
+            bytes.firstResidue,
+        secondRaw: (leading ? ' ' + seam.openers + seam.tail.slice(1) : seam.openers + seam.tail) +
+            bytes.secondResidue
+    };
+}
+/**
+ * The seam with a whitespace-only tail dropped rather than handed to either half. A block's
+ * TERMINAL whitespace is a hard break with no following line, so it paints nothing, and
+ * live-mode.md § 4.5 licenses live to drop what it never showed.
+ */
+function assembleDroppingTerminalTrivia(bytes, seam) {
+    if (seam.openers !== '' || seam.tail === '' || seam.tail.trim() !== '')
+        return null;
+    return {
+        firstRaw: seam.head + seam.closers + bytes.firstResidue,
+        secondRaw: bytes.secondResidue,
+        droppedTail: seam.tail
+    };
+}
+/**
+ * A candidate answers every question below or it is not written. Exported for the verification
+ * test, which has to reach it with a candidate no producer here would build.
+ */
+export function parsesBack(bytes, seam, candidate, resolver) {
+    const first = soleProseBlock(candidate.firstRaw, resolver);
+    const second = soleProseBlock(candidate.secondRaw, resolver);
+    if (first === null || second === null)
+        return false;
+    // Each half must be a block the RELOAD keeps. Empty is one; whitespace-only is not, since the
+    // document reads those bytes as blank trivia and the pair comes back a different shape.
+    if (isWhitespaceOnly(first.visible) || isWhitespaceOnly(second.visible))
+        return false;
+    if (!seam.closed.every((kind) => first.kinds.has(kind)))
+        return false;
+    if (!seam.reopened.every((kind) => second.kinds.has(kind)))
+        return false;
+    // The render oracle below counts characters while CSS collapses a terminal run to nothing, so
+    // the "screen never showed it" rule is read here rather than trusted from the producer.
+    if (candidate.droppedTail !== undefined && candidate.droppedTail.trim() !== '')
+        return false;
+    const whole = renderedText(parseInline(bytes.raw, bytes.contentStart, bytes.contentEnd, resolver), bytes.raw, CONTENT_VISIBILITY);
+    if (!whole.startsWith(first.visible))
+        return false;
+    // The line ending the cut landed on is the one character a split legitimately consumes; a
+    // dropped tail is the only other, and the candidate names those bytes rather than the check
+    // inferring them.
+    const rest = whole.slice(first.visible.length);
+    const tail = second.visible + (candidate.droppedTail ?? '');
+    return rest === tail || rest === '\n' + tail || rest === '\r\n' + tail;
+}
+const isWhitespaceOnly = (visible) => visible !== '' && visible.trim() === '';
+function soleProseBlock(raw, resolver) {
+    const sole = soleProseReparse(raw, resolver);
+    if (sole === null)
+        return null;
+    return {
+        visible: renderedText(sole.nodes, sole.block.raw, CONTENT_VISIBILITY),
+        kinds: constructKinds(sole.nodes)
+    };
+}

package/dist/components/blocks/text/marker-completion.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The space that finishes a container's marker. An opener firing on the bare marker byte
+ * (`>`) mints the container before the space arrives, so that space belongs to the marker
+ * and not to the empty child the caret landed in. Declared by the container
+ * (`contentStartSpace`), never by kind name here.
+ */
+import type { NodeView } from '../../../core/node-views';
+export interface MarkerCompletion {
+    /**
+     * Claim a bare space at `caretOffset` for the container's marker, or decline it to the
+     * content. `parent` is the block's NEAREST ancestor container — a nested quote completes at
+     * its own depth — or null at the document root. One claim per child: a claimed space writes
+     * nothing, so only this memory tells press 2 from press 1, and press 2 is the only way to
+     * type a leading space inside an empty quoted line.
+     */
+    claimSpace(node: NodeView, parent: NodeView | null, caretOffset: number): boolean;
+}
+export declare function createMarkerCompletion(): MarkerCompletion;

package/dist/components/blocks/text/marker-completion.js

@@ -0,0 +1,29 @@
+/**
+ * The space that finishes a container's marker. An opener firing on the bare marker byte
+ * (`>`) mints the container before the space arrives, so that space belongs to the marker
+ * and not to the empty child the caret landed in. Declared by the container
+ * (`contentStartSpace`), never by kind name here.
+ */
+import { displayLength } from '../../../core/lines';
+import { isProseKind } from '../../../core/inline';
+import { tryGetBlockKindDescriptor } from '../../../schema/block-kind-descriptor';
+export function createMarkerCompletion() {
+    // The node, not a bare flag: a surface re-used for another child — or the same child re-minted
+    // by a commit's copy-path-on-write — owes a fresh completion.
+    let claimedFor = null;
+    return {
+        claimSpace(node, parent, caretOffset) {
+            if (caretOffset !== 0 || !parent)
+                return false;
+            if (!isProseKind(node.kind) || displayLength(node.raw) !== 0)
+                return false;
+            if (tryGetBlockKindDescriptor(parent.kind)?.contentStartSpace !== 'complete-marker') {
+                return false;
+            }
+            if (claimedFor === node)
+                return false;
+            claimedFor = node;
+            return true;
+        }
+    };
+}

package/dist/components/blocks/text/pending-mark-insert.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The bytes an insertion produces while marks are pending. A mark resolves against the caret's
+ * construct chain (live-mode.md § 4.3): a kind the chain lacks WRAPS the insertion, a kind it
+ * carries escapes it. Flanking rules mean a splice that READS right can PARSE wrong
+ * (`**hello**X** world**` renders literal stars), so every candidate is re-parsed and checked.
+ */
+import type { AnyInlineKind, InlineNode } from '../../../core/nodes';
+import { type InlineMarkKind } from '../../../schema/inline-construct-policy';
+export interface MarkedInsertion {
+    /** The block's whole display bytes after the insertion. */
+    raw: string;
+    /** Where the caret lands — after the inserted text, inside whatever now wraps it. */
+    caret: number;
+}
+/**
+ * The insertion `text` at `caretOffset` makes under `marks`. Null when the marks name nothing to
+ * do, or when no candidate parses back to what was asked — markdown cannot express every
+ * combination at every caret, and a byte that types plain beats one that shows delimiters.
+ */
+export declare function resolveMarkedInsertion(display: string, caretOffset: number, text: string, marks: ReadonlySet<InlineMarkKind>, inlines: readonly InlineNode[]): MarkedInsertion | null;
+export interface ChainNode {
+    kind: AnyInlineKind;
+    /** The mark a chord can toggle, or null for a construct no chord addresses. */
+    mark: InlineMarkKind | null;
+    start: number;
+    end: number;
+    contentStart: number;
+    contentEnd: number;
+}
+/**
+ * EVERY construct holding `offset`, outermost first: one missing from the chain is missing from
+ * `intended`, which is what lets a candidate destroy it unnoticed. A construct with children is
+ * content-INCLUSIVE, a childless one STRICT-interior, its edges being ordinary insertion points.
+ * Exported for the depth pin, which has to reach it with a tree no insertion this deep could be
+ * rendered at.
+ */
+export declare function constructChainAt(offset: number, inlines: readonly InlineNode[]): ChainNode[];

package/dist/components/blocks/text/pending-mark-insert.js

@@ -0,0 +1,188 @@
+/**
+ * The bytes an insertion produces while marks are pending. A mark resolves against the caret's
+ * construct chain (live-mode.md § 4.3): a kind the chain lacks WRAPS the insertion, a kind it
+ * carries escapes it. Flanking rules mean a splice that READS right can PARSE wrong
+ * (`**hello**X** world**` renders literal stars), so every candidate is re-parsed and checked.
+ */
+import { constructContentRange, constructKinds, inlineDescendants, parseInline } from '../../../core/inline';
+import { CONTENT_VISIBILITY, renderedText } from '../../../core/inline/visibility';
+import { getInlineConstructPolicy, getInlineMarkPolicy, listInlineMarks } from '../../../schema/inline-construct-policy';
+import { insertsExactly } from './screen-diff';
+/**
+ * The insertion `text` at `caretOffset` makes under `marks`. Null when the marks name nothing to
+ * do, or when no candidate parses back to what was asked — markdown cannot express every
+ * combination at every caret, and a byte that types plain beats one that shows delimiters.
+ */
+export function resolveMarkedInsertion(display, caretOffset, text, marks, inlines) {
+    if (marks.size === 0 || text.length === 0)
+        return null;
+    const chain = constructChainAt(caretOffset, inlines);
+    const removed = chain.filter((node) => node.mark !== null && marks.has(node.mark));
+    const applied = listInlineMarks()
+        .map((entry) => entry.kind)
+        .filter((kind) => marks.has(kind) && !chain.some((node) => node.mark === kind));
+    const removedKinds = new Set(removed.map((node) => node.kind));
+    // What must enclose the inserted text afterwards: every construct the caret was inside minus
+    // the ones this chord removes, plus the ones it adds. Non-markable ancestors are in it too —
+    // that is what stops an escape from carrying the byte out of a link it was inside.
+    const intended = new Set([
+        ...chain.map((node) => node.kind).filter((kind) => !removedKinds.has(kind)),
+        ...applied
+    ]);
+    const before = { visible: visibleText(display), kinds: constructKinds(inlines) };
+    for (const candidate of candidateInsertions(display, caretOffset, text, chain, removed, intended)) {
+        if (parsesAsIntended(candidate, text, intended, before)) {
+            return { raw: candidate.raw, caret: candidate.textAt + text.length };
+        }
+    }
+    return null;
+}
+/**
+ * In preference order: the in-place rewrite first, because a split keeps the user's text where
+ * they put it; then stepping outside the removed construct, nearer edge first.
+ */
+function* candidateInsertions(display, caretOffset, text, chain, removed, intended) {
+    if (removed.length === 0) {
+        // Nothing is escaped, so every construct the caret sits in still provides its kind.
+        yield spliceWrapped(display, caretOffset, text, marksToWrite(intended, chain));
+        return;
+    }
+    const outermost = removed[0];
+    const depth = chain.indexOf(outermost);
+    const escaped = chain.slice(depth);
+    const outside = chain.slice(0, depth);
+    const payload = marksToWrite(intended, outside);
+    // A link or a widget between the caret and the construct being escaped cannot be cut open: its
+    // closer is not a mirror of its opener the way a mark's is, and splicing inside one writes
+    // literal bytes into content. Only stepping outside is available there.
+    if (escaped.every((node) => isSymmetricPair(node.kind))) {
+        yield splitOpen(display, caretOffset, text, escaped, payload);
+    }
+    const nearerIsStart = caretOffset - outermost.contentStart <= outermost.contentEnd - caretOffset;
+    const sides = nearerIsStart ? [outermost.start, outermost.end] : [outermost.end, outermost.start];
+    for (const at of sides)
+        yield spliceWrapped(display, at, text, payload);
+}
+/** The marks the insertion must declare for itself: the intended ones its surroundings do not
+ *  already provide, outermost first. Rows rather than kinds, so nothing downstream can look a
+ *  marker up and miss. */
+function marksToWrite(intended, provided) {
+    return listInlineMarks().filter(({ kind }) => intended.has(kind) && !provided.some((node) => node.kind === kind));
+}
+function spliceWrapped(display, at, text, payload) {
+    const openers = payload.map((entry) => entry.mark.markerBytes).join('');
+    const closers = [...payload]
+        .reverse()
+        .map((entry) => entry.mark.markerBytes)
+        .join('');
+    return {
+        raw: display.slice(0, at) + openers + text + closers + display.slice(at),
+        textAt: at + openers.length
+    };
+}
+/** Close every escaped construct before the insertion and reopen it after — the split that keeps
+ *  the user's text where they put it. An empty half would leave a pair enclosing nothing, the
+ *  invisible `****` residue live mode must never mint, so that side steps outside the run. */
+function splitOpen(display, caretOffset, text, escaped, payload) {
+    let leftEnd = caretOffset;
+    let rightStart = caretOffset;
+    let closers = '';
+    let openers = '';
+    for (const node of [...escaped].reverse()) {
+        if (leftEnd === node.contentStart)
+            leftEnd = node.start;
+        else
+            closers += display.slice(node.contentEnd, node.end);
+        if (rightStart === node.contentEnd)
+            rightStart = node.end;
+        else
+            openers = display.slice(node.start, node.contentStart) + openers;
+    }
+    const inner = spliceWrapped('', 0, text, payload);
+    return {
+        raw: display.slice(0, leftEnd) + closers + inner.raw + openers + display.slice(rightStart),
+        textAt: leftEnd + closers.length + inner.textAt
+    };
+}
+/**
+ * Three questions, and a candidate answers all of them or it is not written. Did the mark TAKE —
+ * do exactly the intended constructs enclose the inserted text? Did every construct the block
+ * already held SURVIVE — a delimiter run shared between two pairings rebinds under any splice, and
+ * the loser is a construct nobody asked to spend. And is the rewrite invisible otherwise?
+ */
+function parsesAsIntended(candidate, text, intended, before) {
+    const nodes = parseInline(candidate.raw, 0, candidate.raw.length);
+    const around = enclosingKinds(nodes, candidate.textAt, candidate.textAt + text.length);
+    if (around.size !== intended.size)
+        return false;
+    for (const kind of intended)
+        if (!around.has(kind))
+            return false;
+    const after = constructKinds(nodes);
+    for (const kind of before.kinds)
+        if (!after.has(kind))
+            return false;
+    return insertsExactly(before.visible, visibleText(candidate.raw, nodes), text);
+}
+/** The construct kinds covering `[start, end)`; `text` is content, not a construct. */
+function enclosingKinds(nodes, start, end) {
+    const covers = (node) => node.start <= start && end <= node.end;
+    const kinds = new Set();
+    for (const node of inlineDescendants(nodes, covers)) {
+        if (covers(node) && node.kind !== 'text')
+            kinds.add(node.kind);
+    }
+    return kinds;
+}
+/** What a reader sees, asked of the thing that actually paints it: only the render path knows
+ *  which bytes a kind paints as markers (G4.33), so no private walk over the parse. The content
+ *  reading, not the block's own: the first byte typed into content-empty chrome folds it away, and
+ *  the diff above would read that fold as bytes lost. This arm only ADDS bytes, so no reading of
+ *  it licenses dropping one the reader saw. */
+function visibleText(raw, parsed) {
+    return renderedText(parsed ?? parseInline(raw, 0, raw.length), raw, CONTENT_VISIBILITY);
+}
+/** Read off the kind's row rather than a second list, so a new format joins in one place. */
+function markOf(kind) {
+    return getInlineMarkPolicy(kind) ? kind : null;
+}
+/** Whether a construct's closer mirrors its opener, so a split can close and reopen it. The policy
+ *  table answers, not this module's mark list: the rule is the table's to change. */
+function isSymmetricPair(kind) {
+    return getInlineConstructPolicy(kind)?.edgeAffinity === 'symmetric-pair';
+}
+/**
+ * EVERY construct holding `offset`, outermost first: one missing from the chain is missing from
+ * `intended`, which is what lets a candidate destroy it unnoticed. A construct with children is
+ * content-INCLUSIVE, a childless one STRICT-interior, its edges being ordinary insertion points.
+ * Exported for the depth pin, which has to reach it with a tree no insertion this deep could be
+ * rendered at.
+ */
+export function constructChainAt(offset, inlines) {
+    const holds = (node) => holdsOffset(node, offset);
+    const chain = [];
+    for (const node of inlineDescendants(inlines, holds)) {
+        if (!holds(node))
+            continue;
+        const content = constructContentRange(node);
+        chain.push({
+            kind: node.kind,
+            mark: markOf(node.kind),
+            start: node.start,
+            end: node.end,
+            contentStart: content?.start ?? node.start,
+            contentEnd: content?.end ?? node.end
+        });
+    }
+    return chain;
+}
+/** Whether `offset` sits inside this construct, on the reading the chain doc states. Text is
+ *  content, and nothing under it is a construct either. */
+function holdsOffset(node, offset) {
+    if (node.kind === 'text')
+        return false;
+    const content = constructContentRange(node);
+    return content
+        ? offset >= content.start && offset <= content.end
+        : offset > node.start && offset < node.end;
+}

package/dist/components/blocks/text/screen-diff.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What a live rewrite claims it did to the SCREEN, as two predicates over the painter's before and
+ * after readings (live-mode.md § 2), plus the sole-prose reparse a candidate must survive first.
+ * Shared, so the verification arms ask the same questions of the same shapes rather than each
+ * carrying its own walk.
+ */
+import type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
+import type { CstNode, InlineNode } from '../../../core/nodes';
+/** Whether `after` is `before` with `text` spliced in at one place and nothing else moved. */
+export declare function insertsExactly(before: string, after: string, text: string): boolean;
+/** Whether `after` is `before` with exactly `removed` gone from one place — the whole claim a cut
+ *  makes to the reader, asked of the bytes the parser produced rather than the ones it was given. */
+export declare function removesExactly(before: string, after: string, removed: string): boolean;
+/** A candidate's admission gate: its bytes reload as exactly ONE prose block, whose inline tree the
+ *  caller then reads its own oracle over. Null declines — a reload that splits or re-kinds the
+ *  block is not what the caller is about to install. */
+export declare function soleProseReparse(raw: string, resolver?: LinkReferenceResolver): {
+    block: CstNode;
+    nodes: InlineNode[];
+} | null;

package/dist/components/blocks/text/screen-diff.js

@@ -0,0 +1,39 @@
+/**
+ * What a live rewrite claims it did to the SCREEN, as two predicates over the painter's before and
+ * after readings (live-mode.md § 2), plus the sole-prose reparse a candidate must survive first.
+ * Shared, so the verification arms ask the same questions of the same shapes rather than each
+ * carrying its own walk.
+ */
+import { getContentRange, isProseKind, parseInline } from '../../../core/inline';
+import { parse } from '../../../core/parser';
+/** Whether `after` is `before` with `text` spliced in at one place and nothing else moved. */
+export function insertsExactly(before, after, text) {
+    if (after.length !== before.length + text.length)
+        return false;
+    let at = 0;
+    while (at < before.length && before[at] === after[at])
+        at++;
+    return (after.slice(at, at + text.length) === text && after.slice(at + text.length) === before.slice(at));
+}
+/** Whether `after` is `before` with exactly `removed` gone from one place — the whole claim a cut
+ *  makes to the reader, asked of the bytes the parser produced rather than the ones it was given. */
+export function removesExactly(before, after, removed) {
+    if (after.length !== before.length - removed.length)
+        return false;
+    let at = 0;
+    while (at < after.length && before[at] === after[at])
+        at++;
+    return (before.slice(at, at + removed.length) === removed &&
+        after.slice(at) === before.slice(at + removed.length));
+}
+/** A candidate's admission gate: its bytes reload as exactly ONE prose block, whose inline tree the
+ *  caller then reads its own oracle over. Null declines — a reload that splits or re-kinds the
+ *  block is not what the caller is about to install. */
+export function soleProseReparse(raw, resolver) {
+    const blocks = parse(raw, { scope: 'fragment' }).children;
+    if (blocks.length !== 1 || !isProseKind(blocks[0].kind))
+        return null;
+    const block = blocks[0];
+    const range = getContentRange(block);
+    return { block, nodes: parseInline(block.raw, range.start, range.end, resolver) };
+}

package/dist/components/blocks/text/text-clipboard.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Clipboard handler bodies for TextEditableBlock; the component keeps the
+ * oncopy/oncut/onpaste bindings.
+ */
+import type { BlockEditActions } from '../../../action-contracts';
+import type { NodeView } from '../../../core/node-views';
+import type { DocumentGetter, LinkReferenceResolverRef, PasteImageHook } from '../../../editor-keys';
+import type { EditorEvents } from '../../../editor-events';
+import type { WidgetSelectionState } from '../../image/widget-selection-state.svelte';
+import type { AmbientCursorIO } from '../../../ambient/ambient-cursor';
+import type { CrossBlockHandlers } from '../../../selection/cross-block/dispatch';
+import type { PasteCommitCoordinator } from '../../../tree-operations/paste/paste-deps';
+import type { GrammarView } from '../../../schema/block-openers';
+import type { PluginActivation } from '../../../schema/plugin-activation';
+import type { SelectionState } from '../../../selection/selection-state.svelte';
+import type { StickyColumnState } from '../../../cursor/sticky-column';
+import type { EdgeAffinityState } from '../../../cursor/edge-affinity';
+import { type ClipboardCaretIO, type ClipboardHandlers, type RevealFold } from '../editable-surface';
+import type { PresentationMode } from '../../../presentation-mode';
+export interface TextClipboardDeps {
+    get node(): NodeView;
+    get index(): number;
+    get myPath(): number[];
+    /** Local caret reads go through `cursor`; `caret` is the narrower door the shared
+     *  clipboard seam anchors an image insertion with, a passthrough never read here. */
+    cursor: AmbientCursorIO;
+    caret: ClipboardCaretIO;
+    crossBlock: CrossBlockHandlers;
+    events: EditorEvents;
+    onPasteImage: PasteImageHook | undefined;
+    selection: SelectionState;
+    stickyColumn: StickyColumnState;
+    edgeAffinity: EdgeAffinityState;
+    blockEdit: BlockEditActions;
+    pasteCoordinator: PasteCommitCoordinator;
+    /** The instance grammar, so an unlisted plugin's opener never claims pasted bytes here. */
+    grammar: GrammarView | undefined;
+    /** The plugins this instance activated, so an unlisted plugin's paste transform stays out. */
+    activePlugins: PluginActivation;
+    getDoc: DocumentGetter;
+    widgetSelection: WidgetSelectionState;
+    setPendingCursor: (offset: number | null) => void;
+    /** Reading mode: cut degrades to copy, paste is inert. The events still fire
+     *  on a non-editable surface, so the gate lives in the handlers. */
+    isReadOnly: () => boolean;
+    /** Fold a live source-reveal before a clipboard mutation, so cut/paste run against
+     *  a CST consistent with the swapped DOM. Null when no reveal was open. */
+    foldRevealBeforeMutation: () => RevealFold | null;
+    /** True while an inline-widget source reveal is active on this block. */
+    isRevealing: () => boolean;
+    /** The effective mode the cut's join seam answers to (live-mode.md § 4.5); `undefined` reads
+     *  as not-live. */
+    getPresentationMode: () => PresentationMode | undefined;
+    /** The container prefix this block renders under, which the cut's seam reads its candidate
+     *  back through — an item body the cut left starting with a space reloads under a wider marker. */
+    getAmbientPrefix: () => string;
+    /** The block's live DOM as raw text, so a copy over a revealed (uncommitted) edit
+     *  yields what the user sees rather than the stale raw slice. */
+    readRevealedText: () => string;
+    get linkRef(): LinkReferenceResolverRef | undefined;
+}
+export interface TextClipboard extends ClipboardHandlers {
+    /**
+     * The block's own handler for a copy/cut/paste the editor root received: a selected widget
+     * clears the native selection, so a block with no text position for a caret to survive in
+     * gets its events at `<body>`, where no surface binding sees them.
+     */
+    claimRootClipboard(event: ClipboardEvent): void;
+}
+export declare function createTextClipboard(deps: TextClipboardDeps): TextClipboard;