@agentshouse/mdruntime 0.1.0-cb9c79aee537a → 0.1.0-cc5745cd9af96

package/dist/chat/pieces.js

@@ -36,6 +36,11 @@ const PUNCTUATION = /[\p{P}\p{S}]/u;
 const ESCAPABLE = /[!-/:-@[-`{-~]/;
 const TAG_START = /[A-Za-z!?/]/;
 const LINE_ENDING = /\r\n?|\n/g;
+const QUOTE_MARKER = /^ {0,3}> ?/;
+const MARKER = /^(?:[-+*]|\d{1,9}[.)])/;
+const TASK = /^\[[ \txX]\]/;
+const NOTE = /^\[\^(?:[^\\\]]|\\.){1,999}\]:/;
+const SPACES = /^[ \t]*$/;
 const START = {
     fence: null,
     list: null,
@@ -288,11 +293,12 @@ export function longOf(text) {
         anchors,
         candidates,
         pieces: [],
-        next: { start: 0, path: [], join: '', carry: '' },
+        next: { start: 0, path: [], join: '', carry: '', levels: [] },
         urls: new Map(),
         spans: new Map(),
         discoveries: new Map(),
         regions: new Map(),
+        spreads: new Map(),
     };
 }
 function offsetOf(node) {
@@ -328,6 +334,7 @@ function windowOf(long, from, end, prefix) {
         lead,
         prefix,
         carry: from.carry,
+        levels: from.levels,
         nodes,
         defined: definedIn(nodes, from.start - lead),
     };
@@ -344,16 +351,15 @@ function spanned(long, anchor, stop) {
 function discovered(long, anchor, stop) {
     let discovery = long.discoveries.get(anchor);
     if (discovery === undefined) {
-        discovery = { found: [], next: { start: anchor, path: [], join: '', carry: '' } };
+        discovery = { found: [], next: { start: anchor, path: [], join: '', carry: '', levels: [] } };
         long.discoveries.set(anchor, discovery);
     }
     while (discovery.next !== null && discovery.next.start < stop) {
         const from = discovery.next;
-        const { window, cut } = cutWindow(long, from, 'discover', (end) => windowOf(long, from, end, ''));
+        const { pane, cut } = cutWindow(long, from, 'discover', (end) => windowOf(long, from, end, ''));
         const end = cut?.at ?? long.text.length;
-        discovery.found.push(...window.defined.filter((one) => one.at < end));
-        discovery.next =
-            cut === null ? null : { start: cut.at, path: cut.path, join: cut.join, carry: cut.carry };
+        discovery.found.push(...pane.defined.filter((one) => one.at < end));
+        discovery.next = cut === null ? null : nextOf(cut);
     }
     return discovery.found;
 }
@@ -420,10 +426,10 @@ function renderWindow(long, from, end) {
         long.urls.set(key, url);
         known.push(key);
     }
-    const window = windowOf(long, from, end, prefixOf(known));
+    const pane = windowOf(long, from, end, prefixOf(known));
     const later = [];
     for (const key of deferred) {
-        const native = window.defined.find((one) => one.key === key);
+        const native = pane.defined.find((one) => one.key === key);
         if (native !== undefined) {
             long.urls.set(key, native.url);
             continue;
@@ -434,7 +440,7 @@ function renderWindow(long, from, end) {
         long.urls.set(key, url);
         later.push(key);
     }
-    return later.length === 0 ? window : windowOf(long, from, end, prefixOf([...known, ...later]));
+    return later.length === 0 ? pane : windowOf(long, from, end, prefixOf([...known, ...later]));
 }
 function windowEnd(long, start, size) {
     const at = start + size;
@@ -443,19 +449,209 @@ function windowEnd(long, start, size) {
     const end = lineEnd(long.starts, long.text, lineOf(long, at));
     return end - at <= VIEW_CHARS ? Math.min(end + 1, long.text.length) : at;
 }
-function regionOf(long, line, depth) {
-    const stop = (depth > 0 ? long.quoteBreaks : long.breaks)[line];
-    const markers = markersOf(depth);
-    const name = `${depth}:${stop}`;
-    const held = long.regions.get(name);
+function nextOf(cut) {
+    return { start: cut.at, path: cut.path, join: cut.join, carry: cut.carry, levels: cut.levels };
+}
+function quotesOf(levels) {
+    return levels.filter((level) => level.kind === 'quote').length;
+}
+function itemed(levels) {
+    return levels.some((level) => level.kind !== 'quote');
+}
+function stepsOf(levels) {
+    return levels.flatMap((level) => level.kind === 'quote'
+        ? ['blockquote']
+        : level.kind === 'item'
+            ? ['list', 'item']
+            : ['footnote']);
+}
+function carryOf(levels) {
+    return levels.map((level) => level.carry).join('');
+}
+function columnOn(long, index, levels) {
+    const raw = lineText(long.starts, long.text, index);
+    let at = 0;
+    for (const level of levels) {
+        if (level.line === index) {
+            at = level.column;
+            if (at < 0)
+                return -1;
+        }
+        else if (level.kind === 'quote') {
+            const marker = QUOTE_MARKER.exec(raw.slice(at));
+            if (marker === null)
+                return -1;
+            at += marker[0].length;
+        }
+        else {
+            for (let column = 0; column < level.size; column += 1) {
+                if (raw[at + column] !== ' ')
+                    return -1;
+            }
+            at += level.size;
+        }
+    }
+    return at;
+}
+function withinOf(raw, levels) {
+    let rest = raw;
+    for (const [index, level] of levels.entries()) {
+        if (level.kind === 'quote') {
+            const marker = QUOTE_MARKER.exec(rest);
+            if (marker === null)
+                return SPACES.test(rest) ? 'gone' : 'line';
+            rest = rest.slice(marker[0].length);
+            continue;
+        }
+        if (SPACES.test(rest))
+            return quotesOf(levels.slice(index)) > 0 ? 'gone' : 'blank';
+        if (!rest.startsWith(' '.repeat(level.size)))
+            return 'line';
+        rest = rest.slice(level.size);
+    }
+    return SPACES.test(rest) ? 'blank' : 'line';
+}
+function plain(facts) {
+    return (!opens(facts) &&
+        !TAG.test(facts.content) &&
+        !DELIMITER_ROW.test(facts.content) &&
+        !UNDERLINE.test(facts.content));
+}
+function spreadScan(long, line, column, size, parents) {
+    const { text, starts } = long;
+    const lines = starts.length - 1;
+    const quotes = quotesOf(parents);
+    const breaks = quotes > 0 ? long.quoteBreaks : long.breaks;
+    const kind = (index) => withinOf(lineText(starts, text, index), parents);
+    let blank = breaks[line + 1];
+    while (blank < lines && kind(blank) === 'line')
+        blank = breaks[blank + 1];
+    if (blank >= lines || kind(blank) === 'gone')
+        return false;
+    let next = blank + 1;
+    while (next < lines && kind(next) === 'blank')
+        next += 1;
+    if (next >= lines || kind(next) === 'gone')
+        return false;
+    const at = columnOn(long, next, parents);
+    if (at < 0)
+        return false;
+    const lead = /^[ \t]*/.exec(lineText(starts, text, next).slice(at))[0];
+    if (lead.includes('\t'))
+        return null;
+    if (lead.length < size)
+        return false;
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${quotes}}`);
+    if (!plain(lineFacts(lineText(starts, text, line).slice(column))))
+        return null;
+    for (let index = line + 1; index < blank; index += 1) {
+        const raw = lineText(starts, text, index);
+        const held = columnOn(long, index, parents);
+        const rest = held < 0 ? raw.replace(leads, '') : raw.slice(held);
+        const indent = /^[ \t]*/.exec(rest)[0];
+        if (indent.includes('\t'))
+            return null;
+        const inner = indent.length >= size ? lineFacts(rest.slice(size)) : lineFacts(rest);
+        if (indent.length >= size && inner.indent >= 4)
+            return null;
+        if (!plain(inner))
+            return null;
+    }
+    return true;
+}
+function spreadOf(long, line, column, size, parents) {
+    const key = long.starts[line] + column;
+    const held = long.spreads.get(key);
     if (held !== undefined)
         return held;
+    const spread = spreadScan(long, line, column, size, parents);
+    long.spreads.set(key, spread);
+    return spread;
+}
+function itemLevel(long, pane, item, outer) {
+    const { text, starts } = long;
+    const marker = offsetOf(item) + pane.start - pane.lead;
+    const line = lineOf(long, marker);
+    const start = starts[line];
+    const base = columnOn(long, line, outer);
+    if (base < 0 || marker < start + base || !/^ *$/.test(text.slice(start + base, marker))) {
+        return null;
+    }
+    const sign = MARKER.exec(text.slice(marker, marker + 11))?.[0];
+    if (sign === undefined)
+        return null;
+    let after = marker + sign.length;
+    while (text[after] === ' ')
+        after += 1;
+    const spaces = after - marker - sign.length;
+    if (spaces < 1 || spaces > 4 || after >= lineEnd(starts, text, line))
+        return null;
+    if (/[\t\r\n]/.test(text[after]))
+        return null;
+    const column = after - start;
+    const size = column - base;
+    const spread = item.spread === true
+        ? true
+        : spreadOf(long, line, column, size, outer);
+    if (spread === null)
+        return null;
+    long.spreads.set(start + column, spread);
+    const carry = `${' '.repeat(marker - start - base)}${sign}${' '.repeat(spaces)}`;
+    return { kind: 'item', line, column, size, carry, spread };
+}
+function noteLevel(long, pane, note, outer) {
+    const { text, starts } = long;
+    const marker = offsetOf(note) + pane.start - pane.lead;
+    const line = lineOf(long, marker);
+    const start = starts[line];
+    const base = columnOn(long, line, outer);
+    if (base < 0 || marker < start + base || !/^ *$/.test(text.slice(start + base, marker))) {
+        return null;
+    }
+    const label = NOTE.exec(text.slice(marker, marker + 1_004))?.[0];
+    if (label === undefined)
+        return null;
+    let after = marker + label.length;
+    while (text[after] === ' ')
+        after += 1;
+    if (text[after] === '\t')
+        return null;
+    const column = after - start;
+    return { kind: 'note', line, column, size: 4, carry: `${label} `, spread: false };
+}
+function quoteLevel(long, pane, quote) {
+    const { text, starts } = long;
+    const marker = offsetOf(quote) + pane.start - pane.lead;
+    const line = lineOf(long, marker);
+    const known = text[marker] === '>' && text[marker + 1] !== '\t';
+    const after = text[marker + 1] === ' ' ? marker + 2 : marker + 1;
+    return {
+        kind: 'quote',
+        line,
+        column: known ? after - starts[line] : -1,
+        size: 0,
+        carry: '> ',
+        spread: false,
+    };
+}
+function regionOf(long, line, levels) {
+    const quotes = quotesOf(levels);
+    const lined = !itemed(levels);
+    const stop = (quotes > 0 ? long.quoteBreaks : long.breaks)[line];
+    const markers = markersOf(quotes);
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${quotes}}`);
+    const name = `${levels.map((level) => (level.kind === 'quote' ? '>' : level.size)).join(' ')}:${stop}`;
+    const held = long.regions.get(name);
+    if (held !== undefined && held.from <= line + 1)
+        return held;
     const { text, starts } = long;
-    let setext = false;
-    for (let index = line + 1; index < stop && !setext; index += 1) {
+    const looks = [];
+    for (let index = line + 1; index < stop; index += 1) {
         const raw = lineText(starts, text, index);
-        const facts = lineFacts(raw.replace(markers, ''));
-        setext = facts.indent <= 3 && UNDERLINE.test(facts.content);
+        const column = lined ? (markers.exec(raw)?.[0].length ?? -1) : columnOn(long, index, levels);
+        const facts = lineFacts(column < 0 ? raw.replace(lined ? markers : leads, '') : raw.slice(column));
+        if (facts.indent <= 3 && UNDERLINE.test(facts.content))
+            looks.push(index);
     }
     const from = starts[line];
     const to = Math.min(starts[stop], text.length);
@@ -470,10 +666,22 @@ function regionOf(long, line, depth) {
         runs.set(end - at, at);
         at = text.indexOf('`', end);
     }
-    const region = { setext, last, runs };
+    const region = { from: line + 1, looks, last, runs };
     long.regions.set(name, region);
     return region;
 }
+function after(lines, line) {
+    let low = 0;
+    let high = lines.length;
+    while (low < high) {
+        const middle = (low + high) >> 1;
+        if (lines[middle] <= line)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return lines[low] ?? Infinity;
+}
 const CODE = 1;
 const LINKED = 2;
 const EMPHASIZED = 4;
@@ -513,12 +721,12 @@ function opener(text, from, to, paragraph) {
     const right = !space(before) && (!mark(before) || space(after) || mark(after));
     return left && (!right || mark(before));
 }
-function pendingAt(long, window, paragraph, start, region) {
+function pendingAt(long, pane, paragraph, start, region) {
     const { text } = long;
-    const shift = window.start - window.lead;
-    const flags = new Uint8Array(window.end - start);
+    const shift = pane.start - pane.lead;
+    const flags = new Uint8Array(pane.end - start);
     marked(paragraph, flags, shift, start, text);
-    for (let at = start; at < window.end; at += 1) {
+    for (let at = start; at < pane.end; at += 1) {
         if ((flags[at - start] & CODE) !== 0)
             continue;
         const one = text[at];
@@ -565,61 +773,102 @@ function inside(spans, at) {
 function markersOf(depth) {
     return new RegExp(`^(?: {0,3}> ?){${depth}}`);
 }
-function paragraphCuts(long, window, paragraph, depth, mode) {
+function spreadAlong(nodes, levels) {
+    let node = nodes.at(-1);
+    for (const level of levels) {
+        if (node === undefined || !('children' in node))
+            break;
+        if (level.kind !== 'item') {
+            node = node.children.at(-1);
+            continue;
+        }
+        const item = node.children.at(-1);
+        if (node.type !== 'list' || item?.type !== 'listItem')
+            break;
+        item.spread = level.spread;
+        node = item.children.at(-1);
+    }
+    return nodes;
+}
+function openable(long, line, cut, begun, frame) {
     const { text, starts } = long;
-    const markers = markersOf(depth);
-    const leads = new RegExp(`^(?: {0,3}> ?){0,${depth}}`);
-    const carry = '> '.repeat(depth);
-    const shift = window.start - window.lead;
-    const start = Math.max(offsetOf(paragraph) + shift, window.start);
+    if (!/^ *$/.test(text.slice(cut, begun)))
+        return false;
+    const content = lineText(starts, text, line).slice(cut - starts[line]);
+    const inner = frame.at(-1).kind;
+    if (inner !== 'quote' && cut !== begun)
+        return false;
+    if (inner === 'item' && TASK.test(content))
+        return false;
+    return frame.every((_, index) => {
+        const facts = lineFacts(`${carryOf(frame.slice(index))}${content}`);
+        return facts.indent > 3 || !THEMATIC.test(facts.content);
+    });
+}
+function paragraphCuts(long, pane, paragraph, levels, mode) {
+    const { text, starts } = long;
+    const quotes = quotesOf(levels);
+    const lined = !itemed(levels);
+    const markers = markersOf(quotes);
+    const leads = new RegExp(`^(?: {0,3}> ?){0,${quotes}}`);
+    const carry = carryOf(levels);
+    const shift = pane.start - pane.lead;
+    const start = Math.max(offsetOf(paragraph) + shift, pane.start);
     const first = lineOf(long, start);
-    const region = regionOf(long, first, depth);
-    if (region.setext)
+    const region = regionOf(long, first, levels);
+    if (after(region.looks, first) !== Infinity)
         return [];
-    const pending = mode === 'render' ? pendingAt(long, window, paragraph, start, region) : Infinity;
+    const pending = mode === 'render' ? pendingAt(long, pane, paragraph, start, region) : Infinity;
     const spans = mode === 'render'
         ? paragraph.children
             .filter((child) => child.type !== 'text')
             .map((child) => [offsetOf(child) + shift, endOf(child) + shift])
         : [];
-    const last = lineOf(long, window.end - 1);
+    const last = lineOf(long, pane.end - 1);
     const lines = starts.length - 1;
-    const path = [...Array(depth).fill('blockquote'), 'paragraph'];
-    const reparsed = (at) => () => windowOf(long, { start: window.start, path: [], join: '', carry: window.carry }, at, window.prefix).nodes;
+    const path = [...stepsOf(levels), 'paragraph'];
+    const reparsed = (at) => () => spreadAlong(windowOf(long, { start: pane.start, path: [], join: '', carry: pane.carry, levels: pane.levels }, at, pane.prefix).nodes, levels);
     const cuts = [];
     const settled = (at) => at > start && at < pending && !inside(spans, at);
-    const unbroken = (index) => {
-        if (index >= lines)
-            return true;
-        const next = lineText(starts, text, index);
-        return !DELIMITER_ROW.test(lineFacts(next.replace(markers, '')).content);
+    const restOf = (index) => {
+        const raw = lineText(starts, text, index);
+        const column = lined ? -1 : columnOn(long, index, levels);
+        return column < 0 ? raw.replace(lined ? markers : leads, '') : raw.slice(column);
     };
-    const contentOf = (index) => starts[index] + leads.exec(lineText(starts, text, index))[0].length;
+    const unbroken = (index) => index >= lines || !DELIMITER_ROW.test(lineFacts(restOf(index)).content);
+    const contentOf = (index) => {
+        const raw = lineText(starts, text, index);
+        const column = lined ? -1 : columnOn(long, index, levels);
+        return starts[index] + (column < 0 ? leads.exec(raw)[0].length : column);
+    };
+    const fresh = (at) => levels.at(-1)?.kind !== 'item' || !TASK.test(text.slice(at, at + 3));
     for (let index = first + 1; index <= last; index += 1) {
         const line = starts[index];
         if (line >= pending)
             break;
-        const whole = markers.test(lineText(starts, text, index));
+        const whole = lined && markers.test(lineText(starts, text, index));
         const content = contentOf(index);
         const at = whole ? line : content;
         const previous = lineText(starts, text, index - 1);
-        if (!restartable(text, content) || /[ \t\\]$/.test(previous))
+        if (!restartable(text, content) || !fresh(content) || /[ \t\\]$/.test(previous))
             continue;
         if (!settled(at) || !unbroken(index + 1))
             continue;
         const join = text.slice(starts[index - 1] + previous.length, line);
-        cuts.push({ at, path, join, carry: whole ? '' : carry, nodes: reparsed(at) });
+        cuts.push({ at, path, join, carry: whole ? '' : carry, levels, nodes: reparsed(at) });
     }
     if (cuts.length > 0)
         return cuts;
     for (let index = first; index <= last; index += 1) {
         const content = contentOf(index);
-        const end = Math.min(lineEnd(starts, text, index), window.end);
+        const end = Math.min(lineEnd(starts, text, index), pane.end);
         for (let at = Math.max(content + 1, start + 1); at < end; at += 1) {
             if (at >= pending)
                 return cuts;
             if (!/[ \t]/.test(text[at - 1]) || !restartable(text, at) || !settled(at))
                 continue;
+            if (!fresh(at))
+                continue;
             if (!unbroken(index + 1))
                 break;
             let from = at - 1;
@@ -627,21 +876,21 @@ function paragraphCuts(long, window, paragraph, depth, mode) {
                 from -= 1;
             if (from === content)
                 continue;
-            cuts.push({ at, path, join: text.slice(from, at), carry, nodes: reparsed(at) });
+            cuts.push({ at, path, join: text.slice(from, at), carry, levels, nodes: reparsed(at) });
         }
     }
     return cuts;
 }
-function cutsOf(long, window, mode) {
-    const { nodes } = window;
-    const shift = window.start - window.lead;
+function cutsOf(long, pane, mode) {
+    const { nodes } = pane;
+    const shift = pane.start - pane.lead;
     const at = (node) => lineStartOf(long, offsetOf(node) + shift);
     const cuts = [];
     for (let index = 1; index < nodes.length; index += 1) {
         const start = at(nodes[index]);
-        if (start > window.start) {
+        if (start > pane.start) {
             const taken = nodes.slice(0, index);
-            cuts.push({ at: start, path: [], join: '', carry: '', nodes: () => taken });
+            cuts.push({ at: start, path: [], join: '', carry: '', levels: [], nodes: () => taken });
         }
     }
     const last = nodes.at(-1);
@@ -649,46 +898,111 @@ function cutsOf(long, window, mode) {
         return cuts;
     const before = nodes.slice(0, -1);
     const chain = [];
-    const within = (parent, step, carry) => {
+    const levels = [];
+    const spreads = new Map();
+    const within = (parent, path, frame, header) => {
         const held = [...chain, parent];
-        const path = [...Array(chain.length).fill('blockquote'), step];
-        const marked = markersOf(path.filter((one) => one === 'blockquote').length);
+        const lined = !itemed(frame);
+        const marked = markersOf(quotesOf(frame));
         for (let index = 1; index < parent.children.length; index += 1) {
-            const start = at(parent.children[index]);
-            if (start <= window.start)
+            const begun = offsetOf(parent.children[index]) + shift;
+            const line = lineOf(long, begun);
+            let cut = long.starts[line];
+            if (lined) {
+                if (!marked.test(lineText(long.starts, long.text, line)))
+                    continue;
+            }
+            else {
+                const column = columnOn(long, line, frame);
+                if (column < 0)
+                    continue;
+                if (header === null) {
+                    cut += column;
+                    if (!openable(long, line, cut, begun, frame))
+                        continue;
+                }
+            }
+            if (cut <= pane.start)
                 continue;
-            if (!marked.test(lineText(long.starts, long.text, lineOf(long, start))))
-                continue;
-            const taken = [...before, truncated(held, index)];
-            cuts.push({ at: start, path, join: '', carry, nodes: () => taken });
+            const taken = [...before, truncated(held, index, spreads)];
+            const carry = header ?? (lined ? '' : carryOf(frame));
+            cuts.push({ at: cut, path, join: '', carry, levels: frame, nodes: () => taken });
         }
     };
+    const carried = (node) => offsetOf(node) < pane.lead;
     let node = last;
     while (node !== undefined) {
         if (node.type === 'paragraph') {
-            cuts.push(...paragraphCuts(long, window, node, chain.length, mode));
+            cuts.push(...paragraphCuts(long, pane, node, levels, mode));
         }
-        if (node.type === 'list')
-            within(node, 'list', '');
         if (node.type === 'table' && node.children.length > 1) {
-            const begun = offsetOf(node) + shift < window.start;
-            const carry = begun ? window.carry : long.text.slice(at(node), at(node.children[1]));
-            within(node, 'table', carry);
+            const begun = offsetOf(node) + shift;
+            const lined = !itemed(levels);
+            const header = begun < pane.start
+                ? pane.carry
+                : lined
+                    ? long.text.slice(at(node), at(node.children[1]))
+                    : long.text[begun] === ' '
+                        ? null
+                        : `${carryOf(levels)}${long.text.slice(begun, at(node.children[1]))}`;
+            if (header !== null)
+                within(node, [...stepsOf(levels), 'table'], levels, header);
+        }
+        if (node.type === 'list') {
+            within(node, [...stepsOf(levels), 'list'], levels, null);
+            const item = node.children.at(-1);
+            if (item === undefined)
+                break;
+            const level = carried(item)
+                ? pane.levels[levels.length]
+                : itemLevel(long, pane, item, levels);
+            if (level === undefined || level === null || level.kind !== 'item')
+                break;
+            chain.push(node);
+            levels.push(level);
+            spreads.set(item, level.spread);
+            within(item, stepsOf(levels), levels, null);
+            chain.push(item);
+            node = item.children.at(-1);
+            continue;
+        }
+        if (node.type === 'footnoteDefinition') {
+            const level = carried(node)
+                ? pane.levels[levels.length]
+                : noteLevel(long, pane, node, levels);
+            if (level === undefined || level === null || level.kind !== 'note')
+                break;
+            levels.push(level);
+            within(node, stepsOf(levels), levels, null);
+            chain.push(node);
+            node = node.children.at(-1);
+            continue;
         }
         if (node.type !== 'blockquote')
             break;
-        within(node, 'blockquote', '');
+        const level = carried(node) ? pane.levels[levels.length] : quoteLevel(long, pane, node);
+        if (level === undefined || level.kind !== 'quote')
+            break;
+        levels.push(level);
+        within(node, stepsOf(levels), levels, null);
         chain.push(node);
         node = node.children.at(-1);
     }
     return cuts;
 }
-function truncated(chain, index) {
+function truncated(chain, index, spreads) {
     const [outer, ...inner] = chain;
-    if (inner.length === 0)
-        return { ...outer, children: outer.children.slice(0, index) };
+    const spread = spreads.get(outer);
+    const kept = spread === undefined ? {} : { spread };
+    if (inner.length === 0) {
+        return { ...outer, ...kept, children: outer.children.slice(0, index) };
+    }
     const children = outer.children.slice(0, -1);
-    return { ...outer, children: [...children, truncated(inner, index)] };
+    return {
+        ...outer,
+        ...kept,
+        children: [...children, truncated(inner, index, spreads)],
+    };
 }
 function chosen(cuts, target) {
     let best = null;
@@ -704,12 +1018,12 @@ function chosen(cuts, target) {
     }
     return best;
 }
-function closingOf(long, window) {
-    const last = window.nodes.at(-1);
+function closingOf(long, pane) {
+    const last = pane.nodes.at(-1);
     if (last?.type !== 'code')
         return 0;
     const { text, starts } = long;
-    const line = lineOf(long, offsetOf(last) + window.start - window.lead);
+    const line = lineOf(long, offsetOf(last) + pane.start - pane.lead);
     const fence = fenceOf(lineFacts(lineText(starts, text, line)));
     if (fence === null)
         return 0;
@@ -725,30 +1039,29 @@ function cutWindow(long, from, mode, open) {
     const line = Math.min(lineOf(long, from.start) + WINDOW_LINES, long.starts.length - 1);
     let end = windowEnd(long, from.start, Math.min(WINDOW_CHARS, long.starts[line] - from.start));
     for (;;) {
-        const window = open(end);
+        const pane = open(end);
         if (end >= long.text.length)
-            return { window, cut: null };
-        const cut = chosen(cutsOf(long, window, mode), from.start + VIEW_CHARS);
+            return { pane, cut: null };
+        const cut = chosen(cutsOf(long, pane, mode), from.start + VIEW_CHARS);
         if (cut !== null)
-            return { window, cut };
+            return { pane, cut };
         const grown = windowEnd(long, from.start, 2 * (end - from.start));
         const whole = 2 * grown - from.start >= long.text.length;
-        end = Math.max(whole ? long.text.length : grown, closingOf(long, window));
+        end = Math.max(whole ? long.text.length : grown, closingOf(long, pane));
     }
 }
 export function pieceAt(long, index) {
     while (long.pieces.length <= index && long.next !== null) {
         const from = long.next;
-        const { window, cut } = cutWindow(long, from, 'render', (end) => renderWindow(long, from, end));
+        const { pane, cut } = cutWindow(long, from, 'render', (end) => renderWindow(long, from, end));
         const end = cut?.at ?? long.text.length;
-        for (const one of window.defined) {
+        for (const one of pane.defined) {
             if (one.at < end && !long.urls.has(one.key))
                 long.urls.set(one.key, one.url);
         }
-        const nodes = cut === null ? window.nodes : cut.nodes();
+        const nodes = cut === null ? pane.nodes : cut.nodes();
         long.pieces.push({ nodes, path: from.path, join: from.join });
-        long.next =
-            cut === null ? null : { start: cut.at, path: cut.path, join: cut.join, carry: cut.carry };
+        long.next = cut === null ? null : nextOf(cut);
     }
     return long.pieces[index] ?? null;
 }