@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/tree-operations/leaf-range.js

@@ -0,0 +1,67 @@
+/**
+ * Replacing a range of one leaf, and joining two leaves, the way in-leaf edits and merges
+ * write them: cut back to the painted text, off any surrogate pair, and in live mode with the
+ * delimiter runs the join strands dropped, typed text included (`docs/design/live-mode.md` § 4.5).
+ */
+import { ownTrailingLineEnding, snapToScalarBoundary, trimTrailingLineEnding } from '../core/lines';
+import { getLiveJoinSeamCleaner } from '../schema/inline-construct-policy';
+import { normalizeOwnRaw } from './node-primitives';
+import { cutBeforeSuffix, joinKeepingSuffix } from './structural-suffix';
+/** `[start, end)` of `node` replaced by `typed`, the join cleaned against where `store` keeps it. */
+export function replaceRangeInLeaf(node, range, typed, store) {
+    // Only a drawn range can reach bytes the user never saw; a caret insert goes where the caret is.
+    const painted = range.start !== range.end && store.reading.hidesDelimitersAtCaret()
+        ? { start: cutBeforeSuffix(node, range.start), end: cutBeforeSuffix(node, range.end) }
+        : range;
+    const start = snapToScalarBoundary(node.raw, painted.start);
+    // An inverted range replaces nothing: the text goes in at its start.
+    const end = Math.max(start, snapToScalarBoundary(node.raw, painted.end));
+    if (start < end) {
+        const join = cleanJoin({ node, offset: start }, { node, offset: end }, typed, store, same);
+        if (join.cleaned) {
+            const { raw, seam } = withTyped(join.joined, typed);
+            return { raw, caret: seam + typed.length, range: { start, end }, matchesBrowserEdit: false };
+        }
+    }
+    const display = trimTrailingLineEnding(node.raw);
+    return {
+        raw: display.slice(0, start) + typed + display.slice(end) + ownTrailingLineEnding(node.raw),
+        caret: start + typed.length,
+        range: { start, end },
+        matchesBrowserEdit: start === range.start && end === range.end
+    };
+}
+/** The bytes `head` up to its offset and `tail` from its offset make with `typed` between them,
+ *  `seam` where `typed` starts. `tail`'s bytes take its kind's write rule, in `lineEnding`. */
+export function joinLeaves(head, tail, typed, store, lineEnding) {
+    const writeTail = (bytes) => normalizeOwnRaw(tail.node, bytes, lineEnding);
+    return withTyped(cleanJoin(head, tail, typed, store, writeTail).joined, typed);
+}
+/** `join.mergedRaw` minus the delimiter runs the join left unpaired, where the reading hides
+ *  delimiters. */
+export function cleanJoinedRaw(join) {
+    const literal = { raw: join.mergedRaw, seam: join.seam };
+    if (!join.store.reading.hidesDelimitersAtCaret())
+        return literal;
+    return getLiveJoinSeamCleaner()?.(join) ?? literal;
+}
+// ── The join ─────────────────────────────────────────────────────────────────
+function cleanJoin(head, tail, typed, store, writeTail) {
+    const merged = joinKeepingSuffix(head.node, head.offset, tail.node, tail.offset, writeTail);
+    const joined = cleanJoinedRaw({
+        mergedRaw: merged.raw,
+        seam: merged.start,
+        start: { node: head.node, offset: merged.start },
+        end: { node: tail.node, offset: merged.end },
+        typed,
+        store
+    });
+    return { joined, cleaned: joined.raw !== merged.raw };
+}
+/** The tail of a range inside one leaf: that leaf's write rule runs once, when the bytes are
+ *  installed. */
+const same = (bytes) => bytes;
+const withTyped = (join, typed) => ({
+    raw: join.raw.slice(0, join.seam) + typed + join.raw.slice(join.seam),
+    seam: join.seam
+});

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

@@ -1,7 +1,6 @@
 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.
+ * A list item is empty to the user when every leaf's raw is blank; checking only the first child
+ * would drop trailing content under an empty first paragraph.
  */
 export declare function isItemUserEmpty(item: NodeView): boolean;

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

@@ -1,7 +1,7 @@
+import { isBlankText } from '../../core/lines';
 /**
- * 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.
+ * A list item is empty to the user when every leaf's raw is blank; checking only the first child
+ * would drop trailing content under an empty first paragraph.
  */
 export function isItemUserEmpty(item) {
     if (!item.children || item.children.length === 0)
@@ -11,7 +11,7 @@ export function isItemUserEmpty(item) {
             if (!isItemUserEmpty(child))
                 return false;
         }
-        else if ((child.raw ?? '').trim() !== '') {
+        else if (!isBlankText(child.raw ?? '')) {
             return false;
         }
     }

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

@@ -1,13 +1,11 @@
 import type { CstNode } from '../../core/nodes';
 import type { NodeView } from '../../core/node-views';
+import type { LineEnding } from '../../core/lines';
 /**
- * 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.
+ * The replacement when an item exits its list: the list's halves around a fresh exit paragraph at
+ * `paragraphIndex`, the item's same-type nested items rejoining the halves and the rest lifted.
  */
-export declare function buildExitReplacement(list: NodeView, itemIndex: number): {
+export declare function buildExitReplacement(list: NodeView, itemIndex: number, lineEnding: LineEnding): {
     blocks: CstNode[];
     paragraphIndex: number;
 };

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

@@ -1,18 +1,14 @@
 import { metadataOf } from '../../core/nodes';
-import { trailingLineEnding } from '../../core/lines';
 import { cloneNode } from '../clone';
 import { emptyParagraph } from '../node-primitives';
 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.
+ * The replacement when an item exits its list: the list's halves around a fresh exit paragraph at
+ * `paragraphIndex`, the item's same-type nested items rejoining the halves and the rest lifted.
  */
-export function buildExitReplacement(list, itemIndex) {
+export function buildExitReplacement(list, itemIndex, lineEnding) {
     const items = list.children ?? [];
     const exitedItem = items[itemIndex];
     const parentOrdered = metadataOf(list, 'list')?.ordered ?? false;
@@ -24,8 +20,7 @@ export function buildExitReplacement(list, itemIndex) {
     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);
+    // Every byte this op creates is a line ending, the document's.
     const exitParagraph = emptyParagraph('', lineEnding);
     // Preserve the original list's starting number across the split.
     const base = orderedBaseOf(items[0]);

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

@@ -1,6 +1,6 @@
 /**
- * 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
+ * The partition the first-item unwrap 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';

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

@@ -1,6 +1,6 @@
 /**
- * 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
+ * The partition the first-item unwrap 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';

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

@@ -1,14 +1,17 @@
 /** Constructors for list and listItem CST nodes. */
 import type { CstNode, ListItemMetadata } from '../../core/nodes';
 import type { NodeView } from '../../core/node-views';
+import { type LineEnding } from '../../core/lines';
+import { type FragmentReader } from './task-paragraph';
+import type { GrammarView } from '../../schema/block-openers';
 /**
  * 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.
+ * A listItem mirroring `template`'s metadata/affixes. `children` are placed verbatim, so
+ * clone them before passing if they are still referenced from the source tree.
  */
 export declare function buildListItemWithContent(template: NodeView, children: CstNode[]): CstNode;
 /**
@@ -17,28 +20,27 @@ export declare function buildListItemWithContent(template: NodeView, children: C
  */
 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`).
+ * A bare list shell that neither renumbers nor rebuilds raw; a live-tree caller does both through
+ * `sharing`, so the moved items are copied before being written.
  */
 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.
+ * Split a leaf's raw at `offset` for a paste, each half read as its landing slot reads it, the
+ * trailing half losing one leading space or tab so the new marker's space isn't doubled.
  */
-export declare function splitLeafForPaste(leaf: CstNode, offset: number, raw?: string): {
+export declare function splitLeafForPaste(leaf: CstNode, offset: number, ending: LineEnding, raw: string | undefined, read: {
+    leading: FragmentReader;
+    trailing: FragmentReader;
+}): {
     leadingNode: CstNode | null;
-    trailingNode: CstNode | null;
-    lineEnding: '\n' | '\r\n';
+    trailingNodes: CstNode[];
+    lineEnding: 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`.
+ * The items replacing `item` when a paste splits it at `(innerIndex, offset)`; either is null when
+ * the caret sits flush against a boundary.
  */
-export declare function buildSplitItems(item: CstNode, innerIndex: number, offset: number, targetRaw?: string): {
+export declare function buildSplitItems(item: CstNode, innerIndex: number, offset: number, ending: LineEnding, targetRaw: string | undefined, grammar: GrammarView): {
     leadingItem: CstNode | null;
     trailingItem: CstNode | null;
 };

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

@@ -1,10 +1,14 @@
 /** Constructors for list and listItem CST nodes. */
-import { snapToScalarBoundary, trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
+import { trailingLineEnding } from '../../core/lines';
 import { rebuildListItemRaw, rebuildListRaw } from '../../schema/container-rebuilders';
 import { cloneMetadata, cloneNode } from '../clone';
-import { parseFirstBlock } from '../parse-block';
+import { parseCutResidue, parseFirstBlock } from '../parse-block';
+import { cutKeepingStructure } from '../structural-suffix';
 import { renumberOrderedListFrom } from './ordered-markers';
 import { assignIds } from '../../block-id';
+import { readBlocks } from '../../core/parser';
+import { emptyParagraph } from '../node-primitives';
+import { fragmentReaderAt } from './task-paragraph';
 // ── List / item construction ─────────────────────────────────────────────────
 /**
  * A list node carrying `items`, mirroring `template`'s metadata and affixes and
@@ -32,8 +36,8 @@ export function assembleListHalf(template, items, startNumber) {
     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.
+ * A listItem mirroring `template`'s metadata/affixes. `children` are placed verbatim, so
+ * clone them before passing if they are still referenced from the source tree.
  */
 export function buildListItemWithContent(template, children) {
     const metadata = template.metadata
@@ -66,9 +70,8 @@ function mintListItem(metadata, innerPrefix, innerSuffix, children) {
     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`).
+ * A bare list shell that neither renumbers nor rebuilds raw; a live-tree caller does both through
+ * `sharing`, so the moved items are copied before being written.
  */
 export function buildListShell(ordered, children) {
     const metadata = { ordered };
@@ -83,47 +86,73 @@ export function buildListShell(ordered, 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.
+ * Split a leaf's raw at `offset` for a paste, each half read as its landing slot reads it, the
+ * trailing half losing one leading space or tab so the new marker's space isn't doubled.
  */
-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 };
+export function splitLeafForPaste(leaf, offset, ending, raw = leaf.raw, read) {
+    const lineEnding = trailingLineEnding(raw, ending);
+    const { head: leadingText, rest } = cutKeepingStructure({ ...leaf, raw }, offset);
+    const trailingText = rest.replace(/^[ \t]/, '');
+    const leadingNode = leadingText.length > 0 ? parseFirstBlock(leadingText + lineEnding, read.leading) : null;
+    // The line the cut ended is dropped: the trailing item's marker starts a line of its own.
+    const trailingNodes = parseCutResidue(trailingText, lineEnding, read.trailing).blocks;
+    return { leadingNode, trailingNodes, 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`.
+ * The items replacing `item` when a paste splits it at `(innerIndex, offset)`; either is null when
+ * the caret sits flush against a boundary.
  */
-export function buildSplitItems(item, innerIndex, offset, targetRaw) {
+export function buildSplitItems(item, innerIndex, offset, ending, targetRaw, grammar) {
     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);
+    // Both halves keep the item's marker, so the leading one stays at `innerIndex` under it and
+    // the trailing one opens its own copy of the item.
+    const { leadingNode, trailingNodes, lineEnding } = splitLeafForPaste(targetLeaf, offset, ending, targetRaw ?? targetLeaf.raw, {
+        leading: fragmentReaderAt(item, innerIndex, grammar),
+        trailing: fragmentReaderAt(item, 0, grammar)
+    });
     const leadingChildren = item.children.slice(0, innerIndex).map(cloneNode);
     if (leadingNode)
         leadingChildren.push(leadingNode);
     const trailingChildren = [];
-    if (trailingNode)
-        trailingChildren.push(trailingNode);
+    for (const node of trailingNodes)
+        trailingChildren.push(node);
     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
+        trailingItem: trailingChildren.length > 0
+            ? trailingItemFor(item, trailingChildren, lineEnding, grammar)
+            : null
     };
 }
+/**
+ * The item holding the text after a split, its first block on the marker line unless the reload
+ * reads that line otherwise (indented code reads as a wider marker), then below an empty marker.
+ */
+function trailingItemFor(template, children, lineEnding, grammar) {
+    const onMarkerLine = buildListItemWithContent(template, children);
+    if (readsBackAsBuilt(onMarkerLine, grammar))
+        return onMarkerLine;
+    const belowMarker = buildListItemWithContent(template, [
+        emptyParagraph('', lineEnding),
+        ...children
+    ]);
+    return readsBackAsBuilt(belowMarker, grammar) ? belowMarker : onMarkerLine;
+}
+/** Whether `item`'s bytes, read alone, give back one item holding the same blocks. */
+function readsBackAsBuilt(item, grammar) {
+    const blocks = readBlocks(item.raw, { grammar, scope: 'fragment' }).children;
+    const list = blocks.length === 1 && blocks[0].kind === 'list' ? blocks[0] : null;
+    const read = list?.children?.length === 1 ? list.children[0] : null;
+    const built = item.children ?? [];
+    return (read?.children?.length === built.length &&
+        read.children.every((child, i) => child.kind === built[i].kind &&
+            child.raw === built[i].raw &&
+            child.leadingTrivia === built[i].leadingTrivia));
+}

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

@@ -9,28 +9,19 @@ 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.
+ * Renumber an ordered list's items from `fromIndex`, keeping marker suffixes. Each item's metadata
+ * and raw is written, so a caller on the live tree must pass `sharing`.
  */
 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.
- */
+/** Renumber an ordered list starting at `base`, keeping marker suffixes. */
 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.
+ * Rewrite `item`'s marker glyph and suffix to match `parentList`'s first item; the number is left
+ * to the caller's renumber pass.
  */
 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.
+ * Rewrite pasted items' markers to the enclosing list's style before the splice, since `$state`
+ * wraps entries lazily and a marker written to an item already spliced would bypass reactivity.
  */
 export declare function templatePastedItemMarkers(items: CstNode[], outer: CstNode, firstIndex: number): void;

package/dist/tree-operations/list/ordered-markers.js

@@ -25,10 +25,8 @@ export function bumpOrderedMarker(marker) {
     return marker.replace(/^(\d+)/, (_, n) => String(Number(n) + 1));
 }
 /**
- * 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.
+ * Renumber an ordered list's items from `fromIndex`, keeping marker suffixes. Each item's metadata
+ * and raw is written, so a caller on the live tree must pass `sharing`.
  */
 export function renumberOrderedList(list, fromIndex = 0, sharing) {
     if (!list.children)
@@ -44,11 +42,7 @@ export function renumberOrderedList(list, fromIndex = 0, sharing) {
         rebuildListItemRaw(item);
     }
 }
-/**
- * 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.
- */
+/** Renumber an ordered list starting at `base`, keeping marker suffixes. */
 export function renumberOrderedListFrom(list, base, sharing) {
     if (!metadataOf(list, 'list')?.ordered)
         return;
@@ -62,9 +56,8 @@ export function renumberOrderedListFrom(list, base, sharing) {
 }
 // ── Style templating ─────────────────────────────────────────────────────────
 /**
- * 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.
+ * Rewrite `item`'s marker glyph and suffix to match `parentList`'s first item; the number is left
+ * to the caller's renumber pass.
  */
 export function normalizeItemMarkerToList(item, parentList) {
     const parentOrdered = metadataOf(parentList, 'list')?.ordered ?? false;
@@ -88,10 +81,8 @@ export function normalizeItemMarkerToList(item, parentList) {
     rebuildListItemRaw(item);
 }
 /**
- * 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.
+ * Rewrite pasted items' markers to the enclosing list's style before the splice, since `$state`
+ * wraps entries lazily and a marker written to an item already spliced would bypass reactivity.
  */
 export function templatePastedItemMarkers(items, outer, firstIndex) {
     if (outer.kind !== 'list')

package/dist/tree-operations/list/reconcile-task.d.ts

@@ -1,12 +1,21 @@
 /**
- * Reconcile listItem task metadata against its first paragraph's raw. The parser stores
- * the task marker on the item's metadata, but live typing only mutates `paragraph.raw` —
- * so without this, typing `[ ] ` serializes as a task the live CST still calls plain.
+ * Keeps a list item's task metadata in step with its first block. The parser keeps the task marker
+ * in the item's metadata, but a write changes only the block, so every write into an item's first
+ * slot goes through `writeKeepingTaskMarker`, which reconciles the marker with what stands there.
  */
 import type { CstNode } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
+import type { SharingState } from '../sharing';
+/** Runs `write` against the child at `slot`, then reconciles the owner's task marker with what
+ *  stands there now. Pass the owner as the tree holds it once any copy before the write is made. */
+export declare function writeKeepingTaskMarker<T>(owner: CstNode | undefined, children: readonly CstNode[], slot: number, sharing: SharingState | undefined, write: () => T): T;
 /**
- * Align the item's task fields with what a fresh parse of its first line would produce.
- * On demote the stripped marker bytes are restored into the paragraph raw, so the user's
- * content survives.
+ * Align the item's task fields with a fresh parse of its first line, putting a demoted marker's
+ * bytes back in the paragraph; the marker is dropped only if it stood before the replaced block.
  */
-export declare function reconcileTaskMetadata(listItem: CstNode): void;
+export declare function reconcileTaskMetadata(listItem: CstNode, writtenIndex: number, markerStoodBefore: boolean, sharing?: SharingState): void;
+/**
+ * How far back a caret in the first paragraph moves when writing `text` there takes a task marker
+ * off its front; read before the write, while the item still holds its current marker.
+ */
+export declare function taskMarkerCaretShift(listItem: NodeView, text: string): number;

package/dist/tree-operations/list/reconcile-task.js

@@ -1,47 +1,104 @@
 /**
- * Reconcile listItem task metadata against its first paragraph's raw. The parser stores
- * the task marker on the item's metadata, but live typing only mutates `paragraph.raw` —
- * so without this, typing `[ ] ` serializes as a task the live CST still calls plain.
+ * Keeps a list item's task metadata in step with its first block. The parser keeps the task marker
+ * in the item's metadata, but a write changes only the block, so every write into an item's first
+ * slot goes through `writeKeepingTaskMarker`, which reconciles the marker with what stands there.
  */
 import { metadataOf } from '../../core/nodes';
-const TASK_REGEX = /^\[( |x|X)\]\s+/;
+import { trimTrailingLineEnding } from '../../core/lines';
+import { matchTaskCheckbox } from '../../core/parsers/list';
+import { ensureUnsharedChild } from '../unshare';
+/** Runs `write` against the child at `slot`, then reconciles the owner's task marker with what
+ *  stands there now. Pass the owner as the tree holds it once any copy before the write is made. */
+export function writeKeepingTaskMarker(owner, children, slot, sharing, write) {
+    // Read before the write, which can put a block there no task marker may stand before.
+    const stood = children[slot] !== undefined && taskMarkerMayStandBefore(children[slot]);
+    const result = write();
+    if (owner)
+        reconcileTaskMetadata(owner, slot, stood, sharing);
+    return result;
+}
+/** Whether a task marker may stand in front of this block: only its own paragraph (GFM task lists). */
+function taskMarkerMayStandBefore(block) {
+    return block.kind === 'paragraph';
+}
 /**
- * Align the item's task fields with what a fresh parse of its first line would produce.
- * On demote the stripped marker bytes are restored into the paragraph raw, so the user's
- * content survives.
+ * Align the item's task fields with a fresh parse of its first line, putting a demoted marker's
+ * bytes back in the paragraph; the marker is dropped only if it stood before the replaced block.
  */
-export function reconcileTaskMetadata(listItem) {
-    if (listItem.kind !== 'listItem')
+export function reconcileTaskMetadata(listItem, writtenIndex, markerStoodBefore, sharing) {
+    if (listItem.kind !== 'listItem' || writtenIndex !== 0)
         return;
     const firstChild = listItem.children?.[0];
-    if (!firstChild || firstChild.kind !== 'paragraph')
+    if (!firstChild)
         return;
     const meta = metadataOf(listItem, 'listItem');
     if (!meta)
         return;
-    const firstLineEnd = firstChild.raw.indexOf('\n');
-    const firstLineRaw = firstLineEnd === -1 ? firstChild.raw : firstChild.raw.slice(0, firstLineEnd);
-    const restRaw = firstLineEnd === -1 ? '' : firstChild.raw.slice(firstLineEnd);
-    const effectiveFirstLine = (meta.taskMarker ?? '') + firstLineRaw;
-    const match = effectiveFirstLine.match(TASK_REGEX);
+    if (firstChild.kind !== 'paragraph') {
+        // A task marker stands before a paragraph (GFM § 5.3), so the write that puts a block there
+        // the marker cannot stand in front of gives the checkbox up with the paragraph it had.
+        if (!meta.taskItem || !markerStoodBefore)
+            return;
+        if (taskMarkerMayStandBefore(firstChild))
+            return;
+        meta.taskItem = false;
+        meta.taskMarker = null;
+        meta.taskChecked = false;
+        return;
+    }
+    const firstLineText = firstLineTextOf(firstChild.raw);
+    // The first line's ending stays with the rest of the paragraph.
+    const restRaw = firstChild.raw.slice(firstLineText.length);
+    const { match, kept } = splitTaskLine(meta, firstLineText);
     if (match) {
-        const newTaskMarker = match[0];
-        const newTaskChecked = match[1].toLowerCase() === 'x';
         const drift = meta.taskItem !== true ||
-            meta.taskMarker !== newTaskMarker ||
-            meta.taskChecked !== newTaskChecked;
+            meta.taskMarker !== match.rawMarker ||
+            meta.taskChecked !== match.checked;
         if (drift) {
             meta.taskItem = true;
-            meta.taskMarker = newTaskMarker;
-            meta.taskChecked = newTaskChecked;
-            firstChild.raw = effectiveFirstLine.slice(newTaskMarker.length) + restRaw;
+            meta.taskMarker = match.rawMarker;
+            meta.taskChecked = match.checked;
+            ownedFirstChild(listItem, sharing).raw = kept + restRaw;
         }
         return;
     }
     if (meta.taskItem === true || meta.taskMarker !== null) {
-        firstChild.raw = effectiveFirstLine + restRaw;
+        ownedFirstChild(listItem, sharing).raw = kept + restRaw;
         meta.taskItem = false;
         meta.taskMarker = null;
         meta.taskChecked = false;
     }
 }
+/**
+ * How far back a caret in the first paragraph moves when writing `text` there takes a task marker
+ * off its front; read before the write, while the item still holds its current marker.
+ */
+export function taskMarkerCaretShift(listItem, text) {
+    if (listItem.kind !== 'listItem')
+        return 0;
+    const meta = metadataOf(listItem, 'listItem');
+    if (!meta)
+        return 0;
+    const firstLineText = firstLineTextOf(text);
+    return splitTaskLine(meta, firstLineText).kept.length - firstLineText.length;
+}
+/** The checkbox the item's first line reads as once `firstLineText` stands after the item's
+ *  current marker, and the text its paragraph keeps: a demoted marker goes back into the text. */
+function splitTaskLine(meta, firstLineText) {
+    const line = (meta.taskMarker ?? '') + firstLineText;
+    const match = matchTaskCheckbox(line);
+    if (match)
+        return { match, kept: line.slice(match.rawMarker.length) };
+    const demoted = meta.taskItem === true || meta.taskMarker !== null;
+    return { match: null, kept: demoted ? line : firstLineText };
+}
+/** The first line of `raw` without its ending. */
+function firstLineTextOf(raw) {
+    const end = raw.indexOf('\n');
+    return trimTrailingLineEnding(end === -1 ? raw : raw.slice(0, end + 1));
+}
+/** The marker's bytes move between the item's metadata and its first child, so that child is
+ *  copied out of the undo snapshot before it is written (`unshare.ts` header). */
+function ownedFirstChild(listItem, sharing) {
+    return sharing ? ensureUnsharedChild(listItem, 0, sharing) : listItem.children[0];
+}