@voithos-labs/aragonite 0.10.1

package/dist/tree-operations/children.js

@@ -0,0 +1,56 @@
+/**
+ * Container children mutations that keep `childIds` in lockstep, for out-of-commit-scope
+ * writes (discovered descendants/ancestors — see the `node-ops.ts` header). Inside a
+ * commit scope the StructuralChange descriptor owns id/ref sync; here a hand-rolled
+ * splice would let the parallel id array drift and break Svelte's keyed-each rendering.
+ * The same shape change invalidates `childSpans`, so both parallel arrays settle here.
+ */
+import { assignIds, generateBlockId } from '../block-id';
+import { dropChildSpans } from '../schema/child-spans';
+import { spliceMany } from './splice-many';
+export function pushChild(container, child) {
+    if (!container.children)
+        container.children = [];
+    // Lazy-init (unlike spliceChildren): pushes land in containers assembled mid-merge that
+    // may not have mounted yet, so the parallel array must exist or the new id is dropped.
+    if (!container.childIds)
+        container.childIds = assignIds(container.children);
+    container.children.push(child);
+    container.childIds.push(generateBlockId());
+    dropChildSpans(container);
+}
+/**
+ * Bring `childIds` back to `children`'s length after an in-place children swap. The
+ * surviving prefix keeps its ids — a blanket re-mint would remount every child under
+ * Svelte's keyed each, the identity the swapping branches exist to preserve. No-op when
+ * the array is absent; the mounting BlockList backfills it.
+ */
+export function resyncChildIds(container) {
+    dropChildSpans(container);
+    const ids = container.childIds;
+    if (!ids)
+        return;
+    if (!container.children) {
+        container.childIds = undefined;
+        return;
+    }
+    const count = container.children.length;
+    if (ids.length > count)
+        ids.length = count;
+    for (let i = ids.length; i < count; i++)
+        ids.push(generateBlockId());
+}
+export function spliceChildren(container, at, removeCount, items) {
+    if (!container.children)
+        container.children = [];
+    // No lazy-init here: containers without childIds get them from the mounting BlockList anyway.
+    if (container.childIds) {
+        // A replacement's head continues the slot it lands in, so it keeps that slot's id —
+        // `replacePreservingFirst`'s rule, which the in-commit-scope splice already carries.
+        const continues = removeCount > 0 && items.length > 0;
+        const ids = items.map((_, i) => i === 0 && continues ? container.childIds[at] : generateBlockId());
+        spliceMany(container.childIds, at, removeCount, ids);
+    }
+    spliceMany(container.children, at, removeCount, items);
+    dropChildSpans(container);
+}

package/dist/tree-operations/cleanup.d.ts

@@ -0,0 +1,10 @@
+import type { Document } from '../core/nodes';
+import type { SharingState } from './sharing';
+/**
+ * Walk up from `deletedPath`'s parent, removing containers emptied by the cleanup. Stops
+ * at `lcaPath` (the range operation's lowest common ancestor, `[]` for the document root)
+ * because containers at or above it still hold the start block and cannot legitimately be
+ * empty. Owns its spine — each level is unshared before its child is removed, or the
+ * splice lands on a node an undo entry still references (`unshare.ts` header).
+ */
+export declare function cascadeCleanupEmptyAncestors(doc: Document, deletedPath: number[], lcaPath: number[], sharing: SharingState): void;

package/dist/tree-operations/cleanup.js

@@ -0,0 +1,25 @@
+import { spliceChildrenSettled } from './node-ops';
+import { ensureUnsharedPath } from './unshare';
+/**
+ * Walk up from `deletedPath`'s parent, removing containers emptied by the cleanup. Stops
+ * at `lcaPath` (the range operation's lowest common ancestor, `[]` for the document root)
+ * because containers at or above it still hold the start block and cannot legitimately be
+ * empty. Owns its spine — each level is unshared before its child is removed, or the
+ * splice lands on a node an undo entry still references (`unshare.ts` header).
+ */
+export function cascadeCleanupEmptyAncestors(doc, deletedPath, lcaPath, sharing) {
+    let currentPath = deletedPath.slice(0, -1);
+    while (currentPath.length > lcaPath.length) {
+        const parentPath = currentPath.slice(0, -1);
+        const chain = ensureUnsharedPath(doc, parentPath, sharing);
+        const parent = chain[chain.length - 1] ?? doc;
+        if (!parent.children)
+            break;
+        const idx = currentPath[currentPath.length - 1];
+        const node = parent.children[idx];
+        if (!node || !node.children || node.children.length > 0)
+            break;
+        spliceChildrenSettled(parent, idx, 1, [], sharing);
+        currentPath = parentPath;
+    }
+}

package/dist/tree-operations/clone.d.ts

@@ -0,0 +1,5 @@
+import type { CstNode, Document } from '../core/nodes';
+import type { DocumentView, NodeView } from '../core/node-views';
+export declare function cloneDocument(doc: DocumentView): Document;
+export declare function cloneNode(node: NodeView): CstNode;
+export declare function cloneMetadata(meta: NonNullable<NodeView['metadata']>): NonNullable<CstNode['metadata']>;

package/dist/tree-operations/clone.js

@@ -0,0 +1,43 @@
+import { assertInvariant } from '../assert';
+import { checkCloneSafeMetadata } from '../invariants/node-shape';
+// ── Document ────────────────────────────────────────────────────────────────
+// A deep clone of a view is a fully owned mutable tree — the clone door (core/node-views.ts).
+export function cloneDocument(doc) {
+    return {
+        kind: 'document',
+        prefix: doc.prefix,
+        children: doc.children.map(cloneNode),
+        suffix: doc.suffix
+    };
+}
+// ── Node ────────────────────────────────────────────────────────────────────
+export function cloneNode(node) {
+    // `kind` is a runtime value spanning every arm, so no literal arm matches —
+    // the cast is the generic-clone door, mirroring copyNode's spread (unshare.ts).
+    const cloned = {
+        kind: node.kind,
+        leadingTrivia: node.leadingTrivia,
+        raw: node.raw
+    };
+    if (node.metadata) {
+        assertInvariant('clone-safe-metadata', () => checkCloneSafeMetadata(node));
+        cloned.metadata = cloneMetadata(node.metadata);
+    }
+    if (node.children) {
+        cloned.innerPrefix = node.innerPrefix;
+        cloned.children = node.children.map(cloneNode);
+        cloned.innerSuffix = node.innerSuffix;
+        if (node.childIds)
+            cloned.childIds = [...node.childIds];
+    }
+    return cloned;
+}
+// Snapshots must share no mutable reference with the live tree, or an in-place splice on
+// live metadata reaches the snapshot. One level deep suffices — G1.6 forbids deeper.
+export function cloneMetadata(meta) {
+    const out = {};
+    for (const [k, v] of Object.entries(meta)) {
+        out[k] = Array.isArray(v) ? [...v] : v;
+    }
+    return out;
+}

package/dist/tree-operations/container-lift.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lift a container's first child out while the container itself survives (Rule U2's other
+ * shape): the remainder keeps its kind and its `rebuildRaw` re-emits the syntax, so a marker
+ * held in metadata rides through. `blockquote.ts`'s `unwrapFirstChildFromQuote` is the shape
+ * where the opener lives on the first line and the lift drops it.
+ */
+import type { CstNode } from '../core/nodes';
+import type { NodeView } from '../core/node-views';
+export declare function liftFirstChildKeepingContainer(container: NodeView): CstNode[];

package/dist/tree-operations/container-lift.js

@@ -0,0 +1,29 @@
+/**
+ * Lift a container's first child out while the container itself survives (Rule U2's other
+ * shape): the remainder keeps its kind and its `rebuildRaw` re-emits the syntax, so a marker
+ * held in metadata rides through. `blockquote.ts`'s `unwrapFirstChildFromQuote` is the shape
+ * where the opener lives on the first line and the lift drops it.
+ */
+import { cloneNode } from './clone';
+import { rebuildContainerRaw } from '../schema/container-raw';
+import { assignIds } from '../block-id';
+export function liftFirstChildKeepingContainer(container) {
+    const children = container.children;
+    if (!children || children.length === 0)
+        return [];
+    const lifted = cloneNode(children[0]);
+    // The container's leading trivia is applied at the caller's splice point.
+    lifted.leadingTrivia = '';
+    if (children.length === 1)
+        return [lifted];
+    const remaining = cloneNode(container);
+    const remainingChildren = remaining.children.slice(1);
+    // The blank line that stood between the two children inside the container is the one that
+    // now stands between the lifted block and the container: conserved, never minted.
+    remaining.leadingTrivia = remainingChildren[0].leadingTrivia;
+    remainingChildren[0].leadingTrivia = '';
+    remaining.children = remainingChildren;
+    remaining.childIds = assignIds(remainingChildren);
+    rebuildContainerRaw(remaining);
+    return [lifted, remaining];
+}

package/dist/tree-operations/index.d.ts

@@ -0,0 +1,16 @@
+export type { NodeParent, MergeIntoPrevResult, MergeResult, SplitResult } from './node-ops';
+export { splitNode, assertSplitLanding, assertSingleNodeSink, mergeWithNext, mergeIntoPrevDeepLeaf, deleteNode, updateNodeContent, reclassifyContainer, focusTargetInReplacement, ensureEditableContainers, normalizeReplacementTrivia, emptyParagraph, paragraphNode, restoreSeparatorOnFill, dropDoubledSeparator, nodeAt } from './node-ops';
+export { unwrapFirstItemFromList, mergeListItemIntoPrevious } from './list/unwrap-merge';
+export { renumberOrderedList, normalizeItemMarkerToList } from './list/ordered-markers';
+export { isItemUserEmpty } from './list/empty-check';
+export { buildExitReplacement } from './list/exit-replacement';
+export { reconcileTaskMetadata } from './list/reconcile-task';
+export { unwrapFirstChildFromQuote } from './blockquote';
+export { liftFirstChildKeepingContainer } from './container-lift';
+export { insertEmptyRow, insertEmptyColumn, deleteRow, deleteColumn, cycleAlignment } from './table-mutations';
+export { copyRectangleAsSubTable } from './sub-table-copy';
+export type { CellPos } from './sub-table-copy';
+export { cascadeCleanupEmptyAncestors } from './cleanup';
+export { ensureUnsharedPath, ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedChildren, ensureUnsharedSubtree, rebuildOwnedContainer, rebuildUnsharedChain, rebuildUnsharedAncestry } from './unshare';
+export { buildPastedReplacement } from './paste/paste-replacement';
+export { cloneDocument, cloneNode } from './clone';

package/dist/tree-operations/index.js

@@ -0,0 +1,14 @@
+export { splitNode, assertSplitLanding, assertSingleNodeSink, mergeWithNext, mergeIntoPrevDeepLeaf, deleteNode, updateNodeContent, reclassifyContainer, focusTargetInReplacement, ensureEditableContainers, normalizeReplacementTrivia, emptyParagraph, paragraphNode, restoreSeparatorOnFill, dropDoubledSeparator, nodeAt } from './node-ops';
+export { unwrapFirstItemFromList, mergeListItemIntoPrevious } from './list/unwrap-merge';
+export { renumberOrderedList, normalizeItemMarkerToList } from './list/ordered-markers';
+export { isItemUserEmpty } from './list/empty-check';
+export { buildExitReplacement } from './list/exit-replacement';
+export { reconcileTaskMetadata } from './list/reconcile-task';
+export { unwrapFirstChildFromQuote } from './blockquote';
+export { liftFirstChildKeepingContainer } from './container-lift';
+export { insertEmptyRow, insertEmptyColumn, deleteRow, deleteColumn, cycleAlignment } from './table-mutations';
+export { copyRectangleAsSubTable } from './sub-table-copy';
+export { cascadeCleanupEmptyAncestors } from './cleanup';
+export { ensureUnsharedPath, ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedChildren, ensureUnsharedSubtree, rebuildOwnedContainer, rebuildUnsharedChain, rebuildUnsharedAncestry } from './unshare';
+export { buildPastedReplacement } from './paste/paste-replacement';
+export { cloneDocument, cloneNode } from './clone';

package/dist/tree-operations/list/empty-check.d.ts

@@ -0,0 +1,7 @@
+import type { NodeView } from '../../core/node-views';
+/**
+ * A list item is "user-empty" when every leaf descendant's raw is blank. Deliberately
+ * stronger than testing the first child: a shallow check drops trailing content whenever
+ * the first paragraph happens to be empty.
+ */
+export declare function isItemUserEmpty(item: NodeView): boolean;

package/dist/tree-operations/list/empty-check.js

@@ -0,0 +1,19 @@
+/**
+ * A list item is "user-empty" when every leaf descendant's raw is blank. Deliberately
+ * stronger than testing the first child: a shallow check drops trailing content whenever
+ * the first paragraph happens to be empty.
+ */
+export function isItemUserEmpty(item) {
+    if (!item.children || item.children.length === 0)
+        return true;
+    for (const child of item.children) {
+        if (child.children && child.children.length > 0) {
+            if (!isItemUserEmpty(child))
+                return false;
+        }
+        else if ((child.raw ?? '').trim() !== '') {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/tree-operations/list/exit-replacement.d.ts

@@ -0,0 +1,13 @@
+import type { CstNode } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
+/**
+ * The parent-level replacement when a list item exits its list, laid out as
+ * `[firstHalfList?, exitParagraph, ...liftedBlocks, secondHalfList?]`. Matching-type
+ * nested items rejoin the surviving halves; everything else lifts as a top-level block.
+ * `paragraphIndex` is the exit paragraph's slot, the caller's focus target. Input is not
+ * mutated.
+ */
+export declare function buildExitReplacement(list: NodeView, itemIndex: number): {
+    blocks: CstNode[];
+    paragraphIndex: number;
+};

package/dist/tree-operations/list/exit-replacement.js

@@ -0,0 +1,49 @@
+import { metadataOf } from '../../core/nodes';
+import { trailingLineEnding } from '../../core/lines';
+import { cloneNode } from '../clone';
+import { emptyParagraph } from '../node-ops';
+import { assembleListHalf } from './list-builders';
+import { partitionItemChildren } from './item-partition';
+import { orderedBaseOf } from './ordered-markers';
+/**
+ * The parent-level replacement when a list item exits its list, laid out as
+ * `[firstHalfList?, exitParagraph, ...liftedBlocks, secondHalfList?]`. Matching-type
+ * nested items rejoin the surviving halves; everything else lifts as a top-level block.
+ * `paragraphIndex` is the exit paragraph's slot, the caller's focus target. Input is not
+ * mutated.
+ */
+export function buildExitReplacement(list, itemIndex) {
+    const items = list.children ?? [];
+    const exitedItem = items[itemIndex];
+    const parentOrdered = metadataOf(list, 'list')?.ordered ?? false;
+    // Child 0 is the exiting paragraph, which the fresh one below replaces.
+    const { promotedItems, liftedBlocks } = partitionItemChildren((exitedItem?.children ?? []).slice(1), parentOrdered);
+    const before = items.slice(0, itemIndex).map(cloneNode);
+    const after = items.slice(itemIndex + 1).map(cloneNode);
+    // wasFirstItem has no `before` half, so promotions slide into `after`.
+    const wasFirstItem = itemIndex === 0;
+    const firstHalfItems = wasFirstItem ? [] : [...before, ...promotedItems];
+    const secondHalfItems = wasFirstItem ? [...promotedItems, ...after] : after;
+    // Every byte this op mints is a line ending, so it takes the list's (G4.20).
+    const lineEnding = trailingLineEnding(list.raw);
+    const exitParagraph = emptyParagraph('', lineEnding);
+    // Preserve the original list's starting number across the split.
+    const base = orderedBaseOf(items[0]);
+    const blocks = [];
+    if (firstHalfItems.length > 0) {
+        blocks.push(assembleListHalf(list, firstHalfItems, base));
+        // The exit paragraph follows the surviving list; without a blank line the
+        // parser lazy-continues a typed line into the list's last item on reload.
+        exitParagraph.leadingTrivia = lineEnding;
+    }
+    const paragraphIndex = blocks.length;
+    blocks.push(exitParagraph);
+    for (const lifted of liftedBlocks)
+        blocks.push(lifted);
+    if (secondHalfItems.length > 0) {
+        // Continue the sequence across the gap: the exited slot doesn't burn a number.
+        const secondHalfStart = base + firstHalfItems.length;
+        blocks.push(assembleListHalf(list, secondHalfItems, secondHalfStart));
+    }
+    return { blocks, paragraphIndex };
+}

package/dist/tree-operations/list/item-partition.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The promote/lift partition U1 and the empty-item exit share: a nested list whose `ordered`
+ * matches the parent gives its items to the parent level, everything else lifts out as a
+ * sibling block. Output is fully owned; the input is not mutated.
+ */
+import type { CstNode } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
+export interface ItemPartition {
+    promotedItems: CstNode[];
+    liftedBlocks: CstNode[];
+}
+/** Split a dissolving item's `children` into what rejoins the parent list and what lifts. */
+export declare function partitionItemChildren(children: readonly NodeView[], parentOrdered: boolean): ItemPartition;

package/dist/tree-operations/list/item-partition.js

@@ -0,0 +1,33 @@
+/**
+ * The promote/lift partition U1 and the empty-item exit share: a nested list whose `ordered`
+ * matches the parent gives its items to the parent level, everything else lifts out as a
+ * sibling block. Output is fully owned; the input is not mutated.
+ */
+import { metadataOf } from '../../core/nodes';
+import { cloneNode } from '../clone';
+/** Split a dissolving item's `children` into what rejoins the parent list and what lifts. */
+export function partitionItemChildren(children, parentOrdered) {
+    const promotedItems = [];
+    const liftedBlocks = [];
+    for (const child of children) {
+        if (promotesToParentLevel(child, parentOrdered)) {
+            for (const item of child.children)
+                promotedItems.push(adopt(item));
+            continue;
+        }
+        liftedBlocks.push(adopt(child));
+    }
+    return { promotedItems, liftedBlocks };
+}
+// A sublist with no items has nothing to give, and its bytes would vanish with it, so it lifts.
+function promotesToParentLevel(child, parentOrdered) {
+    if (child.kind !== 'list' || !child.children?.length)
+        return false;
+    return (metadataOf(child, 'list')?.ordered ?? false) === parentOrdered;
+}
+/** Both dispositions start a fresh line at their new level. */
+function adopt(node) {
+    const owned = cloneNode(node);
+    owned.leadingTrivia = '';
+    return owned;
+}

package/dist/tree-operations/list/list-builders.d.ts

@@ -0,0 +1,44 @@
+/** Constructors for list and listItem CST nodes. */
+import type { CstNode, ListItemMetadata } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
+/**
+ * A list node carrying `items`, mirroring `template`'s metadata and affixes and
+ * renumbering ordered markers from `startNumber`. Items are mutated in place.
+ */
+export declare function assembleListHalf(template: NodeView, items: CstNode[], startNumber: number): CstNode;
+/**
+ * A listItem mirroring `template`'s metadata/affixes. `children` are placed verbatim —
+ * clone before passing if they are still referenced from the source tree.
+ */
+export declare function buildListItemWithContent(template: NodeView, children: CstNode[]): CstNode;
+/**
+ * A listItem from explicit metadata with empty affixes, for sites deriving a fresh marker
+ * rather than mirroring a source item. `children` are placed verbatim.
+ */
+export declare function buildListItem(metadata: ListItemMetadata, children: CstNode[]): CstNode;
+/**
+ * A bare list shell with empty raw. Unlike `assembleListHalf` it neither renumbers nor
+ * rebuilds raw; a live-tree caller owns that and must route it through `sharing` so the
+ * moved items are unshared before being written (`unshare.ts`).
+ */
+export declare function buildListShell(ordered: boolean, children: CstNode[]): CstNode;
+/**
+ * Slice a leaf's raw at `offset` for a paste-style split, re-parsing each half. One
+ * leading whitespace is trimmed from the trailing slice, which would otherwise produce
+ * double-space markers after a word-boundary split. Null on an empty side. `raw` overrides
+ * the leaf's own bytes, which a paste that ran a delete half first supplies.
+ */
+export declare function splitLeafForPaste(leaf: CstNode, offset: number, raw?: string): {
+    leadingNode: CstNode | null;
+    trailingNode: CstNode | null;
+    lineEnding: '\n' | '\r\n';
+};
+/**
+ * The leading and trailing items replacing `item` when a paste splits it at
+ * `(innerIndex, offset)`. Either side is null when the caret sits flush against a
+ * boundary. `targetRaw` overrides the target leaf's bytes, as in `splitLeafForPaste`.
+ */
+export declare function buildSplitItems(item: CstNode, innerIndex: number, offset: number, targetRaw?: string): {
+    leadingItem: CstNode | null;
+    trailingItem: CstNode | null;
+};

package/dist/tree-operations/list/list-builders.js

@@ -0,0 +1,129 @@
+/** Constructors for list and listItem CST nodes. */
+import { snapToScalarBoundary, trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
+import { rebuildListItemRaw, rebuildListRaw } from '../../schema/container-rebuilders';
+import { cloneMetadata, cloneNode } from '../clone';
+import { parseFirstBlock } from '../parse-block';
+import { renumberOrderedListFrom } from './ordered-markers';
+import { assignIds } from '../../block-id';
+// ── List / item construction ─────────────────────────────────────────────────
+/**
+ * A list node carrying `items`, mirroring `template`'s metadata and affixes and
+ * renumbering ordered markers from `startNumber`. Items are mutated in place.
+ */
+export function assembleListHalf(template, items, startNumber) {
+    const half = {
+        kind: 'list',
+        leadingTrivia: '',
+        raw: '',
+        metadata: template.metadata
+            ? cloneMetadata(template.metadata)
+            : { ordered: false },
+        children: items,
+        childIds: assignIds(items),
+        innerPrefix: template.innerPrefix ?? '',
+        innerSuffix: template.innerSuffix ?? ''
+    };
+    if (items[0])
+        items[0].leadingTrivia = '';
+    for (const item of items)
+        rebuildListItemRaw(item);
+    renumberOrderedListFrom(half, startNumber);
+    rebuildListRaw(half);
+    return half;
+}
+/**
+ * A listItem mirroring `template`'s metadata/affixes. `children` are placed verbatim —
+ * clone before passing if they are still referenced from the source tree.
+ */
+export function buildListItemWithContent(template, children) {
+    const metadata = template.metadata
+        ? cloneMetadata(template.metadata)
+        : { marker: '- ', taskItem: false, taskChecked: false, taskMarker: null };
+    return mintListItem(metadata, template.innerPrefix ?? '', template.innerSuffix ?? '', children);
+}
+/**
+ * A listItem from explicit metadata with empty affixes, for sites deriving a fresh marker
+ * rather than mirroring a source item. `children` are placed verbatim.
+ */
+export function buildListItem(metadata, children) {
+    return mintListItem(metadata, '', '', children);
+}
+// Affixes are set before the rebuild, which derives the item's raw from them.
+function mintListItem(metadata, innerPrefix, innerSuffix, children) {
+    const item = {
+        kind: 'listItem',
+        leadingTrivia: '',
+        raw: '',
+        metadata,
+        innerPrefix,
+        children,
+        childIds: assignIds(children),
+        innerSuffix
+    };
+    if (children[0])
+        children[0].leadingTrivia = '';
+    rebuildListItemRaw(item);
+    return item;
+}
+/**
+ * A bare list shell with empty raw. Unlike `assembleListHalf` it neither renumbers nor
+ * rebuilds raw; a live-tree caller owns that and must route it through `sharing` so the
+ * moved items are unshared before being written (`unshare.ts`).
+ */
+export function buildListShell(ordered, children) {
+    const metadata = { ordered };
+    return {
+        kind: 'list',
+        leadingTrivia: '',
+        raw: '',
+        metadata,
+        children,
+        childIds: assignIds(children)
+    };
+}
+// ── Paste split ──────────────────────────────────────────────────────────────
+/**
+ * Slice a leaf's raw at `offset` for a paste-style split, re-parsing each half. One
+ * leading whitespace is trimmed from the trailing slice, which would otherwise produce
+ * double-space markers after a word-boundary split. Null on an empty side. `raw` overrides
+ * the leaf's own bytes, which a paste that ran a delete half first supplies.
+ */
+export function splitLeafForPaste(leaf, offset, raw = leaf.raw) {
+    const lineEnding = trailingLineEnding(raw);
+    const display = trimTrailingLineEnding(raw);
+    // Off any scalar interior first: the halves become separate items, so a pair cut here is
+    // unrecoverable bytes rather than a recoverable edit.
+    const cut = snapToScalarBoundary(display, offset);
+    const leadingText = display.slice(0, cut);
+    const trailingText = display.slice(cut).replace(/^[ \t]/, '');
+    const leadingNode = leadingText.length > 0 ? parseFirstBlock(leadingText + lineEnding) : null;
+    const trailingNode = trailingText.length > 0 ? parseFirstBlock(trailingText + lineEnding) : null;
+    return { leadingNode, trailingNode, lineEnding };
+}
+/**
+ * The leading and trailing items replacing `item` when a paste splits it at
+ * `(innerIndex, offset)`. Either side is null when the caret sits flush against a
+ * boundary. `targetRaw` overrides the target leaf's bytes, as in `splitLeafForPaste`.
+ */
+export function buildSplitItems(item, innerIndex, offset, targetRaw) {
+    if (!item.children)
+        return { leadingItem: null, trailingItem: null };
+    const targetLeaf = item.children[innerIndex];
+    if (!targetLeaf)
+        return { leadingItem: null, trailingItem: null };
+    const { leadingNode, trailingNode } = splitLeafForPaste(targetLeaf, offset, targetRaw ?? targetLeaf.raw);
+    const leadingChildren = item.children.slice(0, innerIndex).map(cloneNode);
+    if (leadingNode)
+        leadingChildren.push(leadingNode);
+    const trailingChildren = [];
+    if (trailingNode)
+        trailingChildren.push(trailingNode);
+    for (const c of item.children.slice(innerIndex + 1))
+        trailingChildren.push(cloneNode(c));
+    if (trailingChildren[0])
+        trailingChildren[0].leadingTrivia = '';
+    return {
+        leadingItem: leadingChildren.length > 0 ? buildListItemWithContent(item, leadingChildren) : null,
+        trailingItem: trailingChildren.length > 0 ? buildListItemWithContent(item, trailingChildren) : null
+    };
+}

package/dist/tree-operations/list/ordered-markers.d.ts

@@ -0,0 +1,36 @@
+/** Ordered-list marker bookkeeping: reads, renumbering, and matching item style to a list. */
+import type { CstNode } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
+import type { SharingState } from '../sharing';
+/** Read an item's marker as an integer base, defaulting to 1 for non-numeric markers. */
+export declare function orderedBaseOf(item: NodeView | undefined): number;
+/** The punctuation suffix (`. ` or `) `) from a list's first item; defaults to `. `. */
+export declare function readOrderedSuffix(list: NodeView): string;
+/** Increment an ordered marker's numeric prefix, preserving its suffix. */
+export declare function bumpOrderedMarker(marker: string): string;
+/**
+ * Renumber an ordered list's items in place from `fromIndex`, preserving marker suffixes.
+ * `fromIndex = 0` resets the sequence to 1; `renumberOrderedListFrom` owns non-1 bases.
+ * Every renumbered item's metadata and raw is WRITTEN, so a live-tree caller must pass
+ * `sharing`; construction-time callers on fresh nodes may omit it.
+ */
+export declare function renumberOrderedList(list: CstNode, fromIndex?: number, sharing?: SharingState): void;
+/**
+ * Renumber an ordered list from an arbitrary `base`: seed item 0's marker with `base`
+ * (suffix-preserving), then continue the sequence from item 1. No-op on unordered or
+ * childless lists.
+ */
+export declare function renumberOrderedListFrom(list: CstNode, base: number, sharing?: SharingState): void;
+/**
+ * Rewrite `item`'s marker style to match `parentList`, templating the suffix from a
+ * sibling so the destination list's choices are preserved. Numbers stay the caller's
+ * renumber pass's job: only the glyph and punctuation suffix reconcile here.
+ */
+export declare function normalizeItemMarkerToList(item: CstNode, parentList: CstNode): void;
+/**
+ * Rewrite pasted items' markers to the enclosing list's style: an unordered list templates
+ * the bullet glyph, an ordered list continues the sequence from `firstIndex`. Runs BEFORE
+ * any splice: `$state` wraps entries lazily, so a marker written to a newly-spliced item
+ * bypasses reactivity.
+ */
+export declare function templatePastedItemMarkers(items: CstNode[], outer: CstNode, firstIndex: number): void;