@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/text/live-join-seam.js

@@ -0,0 +1,327 @@
+/**
+ * The live-mode join rewrite (live-mode.md § 4.5): a literal concatenation surfaces the runs a
+ * truncation left unpaired and the closer/opener pair a split's inverse abuts around nothing. Both
+ * are dropped here and nowhere else, and only once the joined block re-parses to ONE prose block
+ * showing what the two sides showed.
+ */
+import { constructContentRange, getContentRange, inlineDescendants, isProseKind, parseInline } from '../../../core/inline';
+import { CONTENT_VISIBILITY, paintsOnlyChrome, renderedText } from '../../../core/inline/visibility';
+import { trimTrailingLineEnding } from '../../../core/lines';
+import { parse } from '../../../core/parser';
+import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
+import { soleProseReparse } from './screen-diff';
+// ── The rewrite ──────────────────────────────────────────────────────────────
+export const cleanLiveJoinSeam = (join) => {
+    const resolver = join.linkRef?.current;
+    const left = readSide(join.start, 'before', resolver);
+    const right = readSide(join.end, 'after', resolver);
+    if (left === null || right === null)
+        return null;
+    // Nothing stands on the seam, so the literal join is already the answer — and the ordinary
+    // Backspace between two plain paragraphs pays no parse for it.
+    if (!standsOnSeam(left) && !standsOnSeam(right))
+        return null;
+    if (!anchorsOnMerged(join, left, right))
+        return null;
+    // The caller splices `typed` at the seam once this returns, so the bytes verified below are the
+    // bytes written: a typed run changes the flanking a kept delimiter pairs against.
+    const typed = join.typed ?? '';
+    const shown = shownAfterJoin(left, right, typed);
+    const pairs = abuttingPairSpans(join, left, right);
+    // Least destructive first: keep the runs the two sides can still pair across the seam, and fall
+    // back to dropping every stranded one. Identical readings render once.
+    const readings = [unpairedSpans(join, left, right), everyDanglingSpan(join, left, right)];
+    const spanSets = readings.map((dangling) => [...dangling, ...pairs]);
+    const candidates = (sameSpans(spanSets[0], spanSets[1]) ? [spanSets[0]] : spanSets).map((spans) => {
+        const raw = withoutSpans(join.mergedRaw, spans);
+        const seam = join.seam - droppedBefore(spans, join.seam);
+        return {
+            spans,
+            raw,
+            seam,
+            read: readCandidate(raw.slice(0, seam) + typed + raw.slice(seam), resolver, join)
+        };
+    });
+    // § 4.1's other half: a run the leanest reading keeps can be one the cut left enclosing nothing,
+    // and a pair over nothing passes the screen check. Least destructive is read among the rest.
+    const floor = Math.min(...candidates.map(({ read }) => read?.residue ?? Infinity));
+    for (const { raw: candidate, seam, read } of candidates) {
+        if (read === null || read.visible !== shown || read.residue > floor)
+            continue;
+        // A candidate that changed nothing IS the literal join: declining says so, and keeps the
+        // caller off a rewrite path it does not need.
+        if (candidate === join.mergedRaw)
+            return null;
+        // The split half's terminal-trivia rule, on the join: a whitespace-only survivor paints
+        // nothing and reloads as blank trivia, a different shape than the block written.
+        const display = trimTrailingLineEnding(candidate);
+        if (display !== '' && display.trim() === '') {
+            return { raw: candidate.slice(display.length), seam: 0 };
+        }
+        return { raw: candidate, seam };
+    }
+    return null;
+};
+/** Every byte a reading drops ahead of the seam moves the caret's landing with it. */
+const droppedBefore = (spans, seam) => spans
+    .filter((span) => span.end <= seam)
+    .reduce((total, span) => total + span.end - span.start, 0);
+const standsOnSeam = (side) => side.dangling.length > 0 || side.touching.length > 0;
+const sameSpans = (a, b) => a.length === b.length && a.every((span, i) => span.start === b[i].start && span.end === b[i].end);
+/**
+ * Read one endpoint's surviving bytes and the constructs its cut leaves at the seam. Null where
+ * the cleanup has no business running: a non-prose kind, an offset outside the content, or a cut
+ * through a family that declares no close-and-reopen, whose bytes mean nothing apart.
+ */
+function readSide(endpoint, keep, resolver) {
+    const { node, offset } = endpoint;
+    if (!isProseKind(node.kind))
+        return null;
+    const content = getContentRange(node);
+    if (offset < content.start || offset > content.end)
+        return null;
+    const inlines = parseInline(node.raw, content.start, content.end, resolver);
+    // Chrome standing over nothing is all on screen (live-mode.md § 4.1), so a run surviving this
+    // cut is bytes the reader saw, not a stranded one: the literal join stands.
+    if (paintsOnlyChrome(inlines, node.raw))
+        return null;
+    const { ranged, atomic } = classifyConstructs(inlines);
+    // Neither an atomic construct's interior nor the middle of a delimiter run leaves halves any
+    // reading of the seam can repair. Live's caret cannot land there; a plugin's can.
+    if (atomic.some((span) => offset > span.start && offset < span.end))
+        return null;
+    if (ranged.some((c) => splitsARun(c, offset)))
+        return null;
+    // Dangling is about the PARTNER, so content-range containment is not the test: a cut at a
+    // construct's content start leaves its opener behind just as one in the middle does.
+    const dangling = ranged.filter((c) => keep === 'before'
+        ? c.content.start <= offset && offset < c.node.end
+        : c.node.start < offset && offset <= c.content.end);
+    if (dangling.some((c) => !isRejoinable(c.kind)))
+        return null;
+    return {
+        raw: node.raw,
+        content,
+        cut: offset,
+        inlines,
+        dangling,
+        touching: touchingChain(ranged, offset, keep)
+    };
+}
+/** Text is content, not a construct, and nothing under it is one either — the descent predicate
+ *  the two censuses below share. */
+const isConstruct = (node) => node.kind !== 'text';
+/** Constructs with a content range (outermost first) apart from those without one, whose bytes
+ *  the seam can only step around. */
+function classifyConstructs(inlines) {
+    const ranged = [];
+    const atomic = [];
+    for (const node of inlineDescendants(inlines, isConstruct)) {
+        if (node.kind === 'text')
+            continue;
+        const content = constructContentRange(node);
+        if (!content) {
+            atomic.push({ start: node.start, end: node.end });
+            continue;
+        }
+        ranged.push({ kind: node.kind, node: { start: node.start, end: node.end }, content });
+    }
+    return { ranged, atomic };
+}
+const splitsARun = (c, at) => (at > c.node.start && at < c.content.start) || (at > c.content.end && at < c.node.end);
+/** Whether the family declares its delimiters cuttable and rejoinable at all (live-mode.md § 4.4). */
+function isRejoinable(kind) {
+    return getInlineConstructPolicy(kind)?.splitBehavior === 'close-and-reopen';
+}
+/**
+ * The nested chain of closers ending at `cut` (or openers starting there), peeled outermost
+ * first: `**a *b***` cut at its end gives the strong, then the emphasis its closer wraps. This is
+ * the shape `live-split-rebalance` writes, read back.
+ */
+function touchingChain(constructs, cut, keep) {
+    const chain = [];
+    let at = cut;
+    for (;;) {
+        const link = constructs.find((c) => keep === 'before' ? c.node.end === at : c.node.start === at);
+        if (!link || !isRejoinable(link.kind))
+            return chain;
+        chain.push(link);
+        at = keep === 'before' ? link.content.end : link.content.start;
+    }
+}
+/** Whether the merged bytes are still the two sides' bytes end to end — a normalizer that
+ *  rewrote either one moves every offset below, so the cleanup stands down instead. */
+function anchorsOnMerged(join, left, right) {
+    return (join.mergedRaw.slice(0, join.seam) === left.raw.slice(0, left.cut) &&
+        join.mergedRaw.startsWith(right.raw.slice(right.cut, right.content.end), join.seam));
+}
+// ── The spans a join may drop ────────────────────────────────────────────────
+/** A left-side span is already in merged coordinates; a right-side one shifts by the seam. */
+const rightSpan = (join, right, span) => ({
+    start: join.seam + span.start - right.cut,
+    end: join.seam + span.end - right.cut
+});
+const openerRun = (c) => ({ start: c.node.start, end: c.content.start });
+const closerRun = (c) => ({ start: c.content.end, end: c.node.end });
+/** Whether two constructs are written with the same delimiters — the byte-level test for "these
+ *  are one construct's two halves", which kind equality alone cannot make (`__a__` vs `**a**`). */
+const sameDelimiters = (left, lc, right, rc) => left.raw.slice(lc.node.start, lc.content.start) ===
+    right.raw.slice(rc.node.start, rc.content.start) &&
+    left.raw.slice(lc.content.end, lc.node.end) === right.raw.slice(rc.content.end, rc.node.end);
+/**
+ * The runs a truncation stranded that the join does NOT put back together: the left's opener
+ * chain and the right's closer chain, minus the leading pairs whose kinds line up — those two
+ * halves make one construct across the seam, which is what the reader had.
+ */
+function unpairedSpans(join, left, right) {
+    let paired = 0;
+    while (paired < left.dangling.length &&
+        paired < right.dangling.length &&
+        left.dangling[paired].kind === right.dangling[paired].kind) {
+        paired++;
+    }
+    return [
+        ...left.dangling.slice(paired).map(openerRun),
+        ...right.dangling.slice(paired).map((c) => rightSpan(join, right, closerRun(c)))
+    ];
+}
+/** The fallback reading: every stranded run goes, so the joined text stands as plain content. */
+function everyDanglingSpan(join, left, right) {
+    return [
+        ...left.dangling.map(openerRun),
+        ...right.dangling.map((c) => rightSpan(join, right, closerRun(c)))
+    ];
+}
+/**
+ * The closer/opener pair a split's inverse brings back to back: same kinds nested the same way,
+ * written with the same bytes, enclosing nothing between them. Whole chain or nothing — dropping
+ * an outer pair while an inner one stays would leave both halves' runs unbalanced.
+ */
+function abuttingPairSpans(join, left, right) {
+    const closing = left.touching;
+    const opening = right.touching;
+    if (closing.length === 0 || closing.length !== opening.length)
+        return [];
+    for (let i = 0; i < closing.length; i++) {
+        if (closing[i].kind !== opening[i].kind)
+            return [];
+        if (!sameDelimiters(left, closing[i], right, opening[i]))
+            return [];
+    }
+    return [
+        { start: closing[closing.length - 1].content.end, end: left.cut },
+        rightSpan(join, right, {
+            start: right.cut,
+            end: opening[opening.length - 1].content.start
+        })
+    ];
+}
+function withoutSpans(raw, spans) {
+    let out = '';
+    let at = 0;
+    for (const span of [...spans].sort((a, b) => a.start - b.start)) {
+        if (span.start < at)
+            continue;
+        out += raw.slice(at, span.start);
+        at = span.end;
+    }
+    return out + raw.slice(at);
+}
+// ── Verification ─────────────────────────────────────────────────────────────
+/**
+ * What the reader is owed: what each side ALREADY SHOWED of the bytes that survive. Read off the
+ * pre-join parse, never off the joined halves — either of those bakes the defect this checks for
+ * into its own expectation.
+ */
+const shownAfterJoin = (left, right, typed) => visibleSide(left, 'before') + typed + visibleSide(right, 'after');
+/**
+ * What a reader sees, asked of the thing that paints it: the render path's own DOM with every
+ * marker span dropped. The clip decides only WHERE the bytes stop; a construct the cut crosses
+ * contributes its content, since its delimiter runs paint nothing either way — which `readSide`
+ * has already established by declining a side whose chrome paints.
+ */
+function visibleSide(side, keep) {
+    return renderedText(clipNodes(side.inlines, side.cut, keep), side.raw, CONTENT_VISIBILITY);
+}
+/**
+ * The `keep` side of `level`, rebuilt: a construct the cut crosses hands its place to its own
+ * clipped children. Exported for the depth pin, which has to reach the rebuild with a tree no
+ * side this deep could be rendered at.
+ */
+export function clipNodes(level, cut, keep) {
+    const before = keep === 'before';
+    // A crossed construct is emitted as its children, in its own place, so the pre-order's
+    // emission order is the rebuilt list's order.
+    const crossed = (node) => isConstruct(node) && node.start < cut && node.end > cut;
+    const out = [];
+    for (const node of inlineDescendants(level, crossed)) {
+        if (before ? node.end <= cut : node.start >= cut) {
+            out.push(node);
+            continue;
+        }
+        if (before ? node.start >= cut : node.end <= cut)
+            continue;
+        if (node.kind === 'text') {
+            out.push({ ...node, ...(before ? { end: cut } : { start: cut }) });
+            continue;
+        }
+        const content = constructContentRange(node);
+        if (!content)
+            continue;
+        if (node.children && node.children.length > 0)
+            continue;
+        // A code span carries its content as bytes rather than children, so the surviving part of
+        // it is that byte range read as text — which is exactly what the span paints.
+        const start = before ? content.start : Math.max(content.start, cut);
+        const end = before ? Math.min(content.end, cut) : content.end;
+        if (end > start)
+            out.push({ kind: 'text', start, end });
+    }
+    return out;
+}
+/**
+ * The candidate read back as the caller will install it: what it shows, and how many constructs its
+ * row unwraps are left standing over nothing. Null where a join produces something the caller cannot
+ * install — two blocks, a kind with no inline content, or a body the container would re-read.
+ */
+function readCandidate(raw, resolver, join) {
+    if (!keepsContainerMarker(join.ambientPrefix ?? '', raw))
+        return null;
+    const sole = soleProseReparse(raw, resolver);
+    if (sole === null)
+        return null;
+    const { block, nodes } = sole;
+    return {
+        visible: renderedText(nodes, block.raw, CONTENT_VISIBILITY),
+        // Chrome standing over nothing is all on screen (§ 4.1), so a block that paints hides no pair.
+        residue: paintsOnlyChrome(nodes, block.raw) ? 0 : countResidue(nodes, block.raw)
+    };
+}
+/**
+ * Whether the container still reads its own marker off the candidate. The item's marker is not in
+ * these bytes but absorbs from them, so a body the cut left starting with a space reloads under a
+ * WIDER marker than the live tree holds — the load/save cycle would then change the tree.
+ */
+function keepsContainerMarker(prefix, raw) {
+    if (prefix === '')
+        return true;
+    const blocks = parse(prefix + raw, { scope: 'fragment' }).children;
+    if (blocks.length !== 1)
+        return false;
+    return blocks[0].marker === prefix;
+}
+/** Constructs the reader would meet as nothing at all: no painted byte, and a row that unwraps
+ *  them when emptied rather than leaving delimiters over nothing. */
+function countResidue(nodes, raw) {
+    let found = 0;
+    for (const node of inlineDescendants(nodes, isConstruct)) {
+        if (node.kind === 'text')
+            continue;
+        if (node.end > node.start &&
+            renderedText([node], raw, CONTENT_VISIBILITY) === '' &&
+            getInlineConstructPolicy(node.kind)?.autoUnwrapOnEmpty === true) {
+            found++;
+        }
+    }
+    return found;
+}

package/dist/components/blocks/text/live-selection-edit.d.ts

@@ -0,0 +1,68 @@
+/**
+ * What a native ranged edit writes in live mode. The range it targets can span delimiter runs the
+ * user never saw and contenteditable takes those literally, so the edit is re-expressed as a JOIN
+ * of what survives on either side and crosses the shared seam (live-mode.md § 4.5). Every editable
+ * prose surface routes its `beforeinput` through {@link resolveLiveRangeEdit}, so a gesture family
+ * cannot reach the bytes by being absent from a list.
+ */
+import type { NodeView } from '../../../core/node-views';
+import type { PresentationMode } from '../../../presentation-mode';
+import type { InlineResolverRef } from '../../../schema/inline-construct-policy';
+export interface SelectionEdit {
+    /** The block's whole bytes after the edit, trailing line ending included. */
+    raw: string;
+    caret: number;
+}
+/** The raw-offset readers a native ranged edit needs from its surface. */
+export interface LiveEditCursor {
+    rawRangeOf(range: AbstractRange): {
+        start: number;
+        end: number;
+    } | null;
+    getRawSelection(): {
+        start: number;
+        end: number;
+    } | null;
+}
+/** Rewrite the block's bytes, or SWALLOW the press: an input this seam owns whose payload it may
+ *  not read writes nothing, since the engine's version would splice the hidden runs literally. */
+export type LiveRangeEdit = LiveRangeRewrite | {
+    kind: 'swallow';
+};
+export interface LiveRangeRewrite {
+    kind: 'rewrite';
+    range: {
+        start: number;
+        end: number;
+    };
+    raw: string;
+    caret: number;
+}
+/**
+ * What a prose surface does with a `beforeinput` in live mode. Null wherever the press is not this
+ * seam's or the seam has nothing to clean — there the engine's own edit is already right, and
+ * leaving it native keeps its grapheme and IME behavior.
+ */
+export declare function resolveLiveRangeEdit(e: InputEvent, node: NodeView, cursor: LiveEditCursor, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix?: string): LiveRangeEdit | null;
+/**
+ * The whole surface arm around {@link resolveLiveRangeEdit}: stand down while a source reveal has
+ * outrun the CST, resolve, preventDefault what the seam owns, then swallow or hand the rewrite to
+ * the surface's own `commit`. Shared so a new precondition lands on every surface at once.
+ */
+export declare function applyLiveRangeEdit(e: InputEvent, node: NodeView, cursor: LiveEditCursor, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string, isRevealing: () => boolean, commit: (edit: LiveRangeRewrite) => void): boolean;
+/**
+ * The bytes replacing `[start, end)` with `typed`, or null when the seam had nothing to clean.
+ * Exported for the callers that already hold a range of their own (the composition commit, the
+ * gesture fuzzer) rather than an event to read one off.
+ */
+export declare function resolveSelectionEdit(node: NodeView, selection: {
+    start: number;
+    end: number;
+}, typed: string, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix?: string): SelectionEdit | null;
+/** The delete of `[start, end)` a destructive gesture installs: the seam's cleaned rewrite where
+ *  it has one, else the literal display splice with the caret at the cut — the fallback's one
+ *  home, so no arm carrying it can drift. */
+export declare function deleteRangeRaw(node: NodeView, range: {
+    start: number;
+    end: number;
+}, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, ambientPrefix: string): SelectionEdit;

package/dist/components/blocks/text/live-selection-edit.js

@@ -0,0 +1,120 @@
+/**
+ * What a native ranged edit writes in live mode. The range it targets can span delimiter runs the
+ * user never saw and contenteditable takes those literally, so the edit is re-expressed as a JOIN
+ * of what survives on either side and crosses the shared seam (live-mode.md § 4.5). Every editable
+ * prose surface routes its `beforeinput` through {@link resolveLiveRangeEdit}, so a gesture family
+ * cannot reach the bytes by being absent from a list.
+ */
+import { snapToScalarBoundary, trailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
+import { cleanJoinedRaw } from '../../../tree-operations/node-ops';
+/**
+ * What a prose surface does with a `beforeinput` in live mode. Null wherever the press is not this
+ * seam's or the seam has nothing to clean — there the engine's own edit is already right, and
+ * leaving it native keeps its grapheme and IME behavior.
+ */
+export function resolveLiveRangeEdit(e, node, cursor, presentationMode, linkRef, ambientPrefix = '') {
+    if (presentationMode !== 'live' || !rewritesTargetRange(e))
+        return null;
+    const range = pendingEditRange(e, cursor);
+    if (!range)
+        return null;
+    const insert = replacementText(e);
+    const edit = resolveSelectionEdit(node, range, insert ?? '', presentationMode, linkRef, ambientPrefix);
+    if (!edit)
+        return null;
+    return insert === null
+        ? { kind: 'swallow' }
+        : { kind: 'rewrite', range, raw: edit.raw, caret: edit.caret };
+}
+/**
+ * The whole surface arm around {@link resolveLiveRangeEdit}: stand down while a source reveal has
+ * outrun the CST, resolve, preventDefault what the seam owns, then swallow or hand the rewrite to
+ * the surface's own `commit`. Shared so a new precondition lands on every surface at once.
+ */
+export function applyLiveRangeEdit(e, node, cursor, presentationMode, linkRef, ambientPrefix, isRevealing, commit) {
+    if (isRevealing())
+        return false;
+    const edit = resolveLiveRangeEdit(e, node, cursor, presentationMode, linkRef, ambientPrefix);
+    if (!edit)
+        return false;
+    e.preventDefault();
+    if (edit.kind === 'rewrite')
+        commit(edit);
+    return true;
+}
+/**
+ * The bytes replacing `[start, end)` with `typed`, or null when the seam had nothing to clean.
+ * Exported for the callers that already hold a range of their own (the composition commit, the
+ * gesture fuzzer) rather than an event to read one off.
+ */
+export function resolveSelectionEdit(node, selection, typed, presentationMode, linkRef, ambientPrefix = '') {
+    // Both ends off any scalar interior before the slice: a half-pair here is unrecoverable
+    // bytes, not a recoverable edit. Snapping the same direction cannot invert the range.
+    const start = snapToScalarBoundary(node.raw, selection.start);
+    const end = snapToScalarBoundary(node.raw, selection.end);
+    if (start >= end)
+        return null;
+    const mergedRaw = node.raw.slice(0, start) + node.raw.slice(end);
+    // `typed` rides the seam rather than being spliced past it: the bytes the cleanup verifies have
+    // to be the bytes this returns, or the flanking it checked is not the flanking that ships.
+    const joined = cleanJoinedRaw({
+        mergedRaw,
+        seam: start,
+        start: { node, offset: start },
+        end: { node, offset: end },
+        linkRef,
+        typed,
+        ambientPrefix
+    }, presentationMode);
+    if (joined.raw === mergedRaw)
+        return null;
+    // The insert lands where the two sides now meet — the paste-at-a-cleaned-seam rule: cleanup
+    // runs in the DELETE half, and the commit's own re-parse settles what the new bytes make of it.
+    return {
+        raw: joined.raw.slice(0, joined.seam) + typed + joined.raw.slice(joined.seam),
+        caret: joined.seam + typed.length
+    };
+}
+/** The delete of `[start, end)` a destructive gesture installs: the seam's cleaned rewrite where
+ *  it has one, else the literal display splice with the caret at the cut — the fallback's one
+ *  home, so no arm carrying it can drift. */
+export function deleteRangeRaw(node, range, presentationMode, linkRef, ambientPrefix) {
+    const cleaned = resolveSelectionEdit(node, range, '', presentationMode, linkRef, ambientPrefix);
+    if (cleaned)
+        return cleaned;
+    const display = trimTrailingLineEnding(node.raw);
+    return {
+        raw: display.slice(0, range.start) + display.slice(range.end) + trailingLineEnding(node.raw),
+        caret: range.start
+    };
+}
+// ── Reading the event ────────────────────────────────────────────────────────
+/**
+ * The range the pending edit will rewrite. `getTargetRanges()` is the authority — a word or line
+ * delete at a COLLAPSED caret reports the run, not the caret — and is feature-detected because
+ * jsdom implements no such method.
+ */
+function pendingEditRange(e, cursor) {
+    const targets = typeof e.getTargetRanges === 'function' ? e.getTargetRanges() : [];
+    return targets.length > 0 ? cursor.rawRangeOf(targets[0]) : cursor.getRawSelection();
+}
+/**
+ * The inputs that rewrite the range they target: every delete family — word, line, drag, cut,
+ * forward, backward — plus the two that replace it with text. Paste and composition carry seams of
+ * their own; composing is excluded by the NAME and by the flag rather than by listing the two
+ * delete types today's engines spell, since `composition-seat.ts` owns that window end to end and a
+ * second resolution here writes the block twice.
+ */
+function rewritesTargetRange(e) {
+    if (e.isComposing || /composition/i.test(e.inputType))
+        return false;
+    return (e.inputType.startsWith('delete') ||
+        e.inputType === 'insertText' ||
+        e.inputType === 'insertReplacementText');
+}
+/** What an input writes over its range, or null for a payload this seam may not read: text riding
+ *  a `dataTransfer` would reach the commit's re-parse without the paste transforms (G4.11), and a
+ *  swallowed press is sounder than turning a replacement into a delete. */
+function replacementText(e) {
+    return e.inputType.startsWith('delete') ? '' : e.data;
+}

package/dist/components/blocks/text/live-split-rebalance.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
+import type { AnyInlineKind, InlineNode } from '../../../core/nodes';
+import { type LiveSplitRebalancer } from '../../../schema/inline-construct-policy';
+export declare const rebalanceLiveSplit: LiveSplitRebalancer;
+/** The original bytes, plus what each half carries beyond the content it took: the padding line
+ *  ending, or a structural suffix the split has already moved (a setext underline). */
+interface SplitBytes {
+    raw: string;
+    contentStart: number;
+    contentEnd: number;
+    /** Where the second half's content begins in `raw` — past a line ending the cut consumed. */
+    cut: number;
+    firstResidue: string;
+    secondResidue: string;
+}
+export interface ChainLink {
+    kind: AnyInlineKind;
+    start: number;
+    end: number;
+    contentStart: number;
+    contentEnd: number;
+}
+/**
+ * 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 declare function splittableChainAt(inlines: readonly InlineNode[], offset: number): ChainLink[] | null;
+interface SeamParts {
+    /** Bytes before the seam, the block's own marker prefix included. */
+    head: string;
+    closers: string;
+    openers: string;
+    /** Bytes after the seam, up to the block's content end. */
+    tail: string;
+    closed: AnyInlineKind[];
+    reopened: AnyInlineKind[];
+}
+interface RebalancedHalves {
+    firstRaw: string;
+    secondRaw: string;
+    /** Bytes this candidate left out, which the conservation check then expects to be missing. */
+    droppedTail?: string;
+}
+/**
+ * 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 declare function parsesBack(bytes: SplitBytes, seam: SeamParts, candidate: RebalancedHalves, resolver: LinkReferenceResolver | undefined): boolean;
+export {};