team 0.1.2 → 0.2.0

package/dist/watch/screen-core.js

@@ -43,75 +43,375 @@ export function statusRowOf(data, lines) {
     const at = statusIndex(composer, lines, composer.mode === 'status-then-one', () => false);
     return at === 'stop' || at < 0 ? null : (lines[at] ?? null);
 }
+/**
+ * The fold-shaped frame a window shows, or null: the marker row and the count it names (any
+ * integer, zero included), the tail rows below it, the box's two rules around both, and a footer
+ * under the bottom one. The top rule's width is the width the text wrapped at. The shape alone;
+ * whether the fold holds the typed text is the caller's to verify.
+ */
+function foldFrame(data, lines) {
+    const composer = data.composer;
+    if (composer.mode !== 'two-rules-footer-below' || !composer.fold)
+        return null;
+    let marker = -1;
+    let found = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const hit = composer.fold.exec(lines[i] ?? '');
+        if (hit) {
+            marker = i;
+            found = hit;
+            break;
+        }
+    }
+    if (marker < 0 || !found)
+        return null;
+    // The frame, as the capture draws it (folded-rules.txt): the box's opening rule at the pane's
+    // first column — the profile's rule pattern is anchored to it — sits directly above the
+    // marker, and the box's closing rule is the window's last rule row, drawn at the opening
+    // rule's own width. A rule-looking row between the marker and the closing rule is a tail row
+    // then, content that cannot match the typed text's own rows; a rule row where the capture
+    // draws none — directly above the opening rule, or at a width the opening rule does not have
+    // — leaves the read unable to tell the frame from content, and it fails closed.
+    let top = -1;
+    for (let i = marker - 1; i >= 0; i--) {
+        if (composer.rule.test(lines[i] ?? '')) {
+            top = i;
+            break;
+        }
+    }
+    if (top < 0)
+        return null;
+    if (top > 0 && composer.rule.test(lines[top - 1] ?? ''))
+        return null;
+    for (let i = top + 1; i < marker; i++) {
+        if ((lines[i] ?? '').trim())
+            return null;
+    }
+    let bottom = -1;
+    for (let i = lines.length - 1; i > marker; i--) {
+        if (composer.rule.test(lines[i] ?? '')) {
+            bottom = i;
+            break;
+        }
+    }
+    if (bottom < 0)
+        return null;
+    const width = (lines[top] ?? '').trim().length;
+    if ((lines[bottom] ?? '').trim().length !== width)
+        return null;
+    const rows = lines.slice(marker + 1, bottom).filter((line) => line.trim());
+    if (rows.length === 0)
+        return null;
+    if (!lines.slice(bottom + 1).some((line) => composer.footers.some((pattern) => pattern.test(line))))
+        return null;
+    const count = Number(found[1]);
+    if (!Number.isInteger(count))
+        return null;
+    return { count, rows, width };
+}
+/**
+ * The fold a `two-rules-footer-below` composer's window shows, or null. A marker whose count is
+ * zero names no hidden rows to compare against, so it is no fold; it is still a marker, and
+ * `foldMarked` catches it.
+ */
+export function foldOf(data, lines) {
+    const frame = foldFrame(data, lines);
+    if (frame === null || frame.count < 1)
+        return null;
+    return frame;
+}
+/**
+ * Whether the window shows a fold marker at all, whatever count it names: a marker claiming zero
+ * hidden rows (or a count a fold could not have) is still a box that is not showing the whole
+ * text, and it must never be taken for an ordinary unsent box and submitted unverified.
+ */
+export function foldMarked(data, lines) {
+    return foldFrame(data, lines) !== null;
+}
 /** `lines` is already the window: the last 20 lines, each keeping any ANSI styling. Matching
  *  runs on each line's plain form, trimmed at the end; the styled form is kept for the one
  *  question styling can answer, whether the composer's input line is all dim. */
 function plainLines(lines) {
     return lines.map((line) => stripSgr(line).trimEnd());
 }
+const SCREEN_KINDS = new Set([
+    'idle',
+    'working',
+    'unsent',
+    'permission',
+    'trust',
+    'question',
+    'unknown',
+]);
+function getProfileFn(profile, key) {
+    if (!profile || (typeof profile !== 'object' && typeof profile !== 'function'))
+        return undefined;
+    try {
+        const fn = profile[key];
+        if (fn === undefined || fn === null)
+            return undefined;
+        if (typeof fn !== 'function')
+            return 'fail';
+        return fn;
+    }
+    catch {
+        return 'fail';
+    }
+}
+function evalPredicate(predicate, lines) {
+    if (predicate === 'fail')
+        return 'fail';
+    if (typeof predicate !== 'function')
+        return 'fail';
+    try {
+        const res = predicate(lines);
+        if (res && (typeof res === 'object' || typeof res === 'function') && typeof res.catch === 'function') {
+            try {
+                res.catch(() => { });
+            }
+            catch { }
+            return 'fail';
+        }
+        if (res === true)
+            return 'match';
+        if (res === false)
+            return 'miss';
+        return 'fail';
+    }
+    catch {
+        return 'fail';
+    }
+}
+function callComposer(composer, lines) {
+    if (composer === 'fail')
+        return { kind: 'unknown' };
+    if (typeof composer !== 'function')
+        return { kind: 'unknown' };
+    try {
+        const reading = composer(lines);
+        if (reading && (typeof reading === 'object' || typeof reading === 'function') && typeof reading.catch === 'function') {
+            try {
+                reading.catch(() => { });
+            }
+            catch { }
+            return { kind: 'unknown' };
+        }
+        if (!reading || typeof reading !== 'object')
+            return { kind: 'unknown' };
+        let kind;
+        try {
+            kind = reading.kind;
+        }
+        catch {
+            return { kind: 'unknown' };
+        }
+        if (typeof kind !== 'string' || !SCREEN_KINDS.has(kind)) {
+            return { kind: 'unknown' };
+        }
+        return {
+            kind: kind,
+            from: 0,
+            input: -1,
+        };
+    }
+    catch {
+        return { kind: 'unknown' };
+    }
+}
 /** `lines` is already the window: the last 20 lines, each trimmed at the end. */
 export function classifyLines(data, lines, clock) {
-    const now = clock?.now ?? Date.now;
-    const budget = clock?.budgetMs ?? BUDGET_MS;
-    const start = now();
-    const tick = () => now() - start > budget;
-    const plain = plainLines(lines);
-    const order = [
-        ['unknown', data.unknown],
-        ['trust', data.trust],
-        ['permission', data.permission],
-        ['question', data.question],
-        ['working', data.working],
-    ];
-    for (const [kind, stage] of order) {
-        if (!stage)
-            continue;
-        for (const rule of stage.rules) {
-            const hit = ruleMatches(data, plain, rule, tick);
-            if (hit === 'stop')
+    try {
+        const now = clock?.now ?? Date.now;
+        const budget = clock?.budgetMs ?? BUDGET_MS;
+        const start = now();
+        const tick = () => now() - start > budget;
+        const plain = plainLines(lines);
+        // Rule (a): Every hatch predicate is monotone toward caution: hatch OR data, for working,
+        // every dialog (trust, permission, question) and unknown. The data stage of a profile always runs;
+        // a hatch predicate can only add a match. A hatch can only add caution, never remove it.
+        const cautionStages = [
+            ['unknown', data.unknown],
+            ['trust', data.trust],
+            ['permission', data.permission],
+            ['question', data.question],
+            ['working', data.working],
+        ];
+        for (const [kind, stage] of cautionStages) {
+            if (tick())
                 return { kind: 'unknown' };
-            if (hit)
-                return { kind };
+            const fn = getProfileFn(data.profile, kind);
+            if (fn !== undefined) {
+                const outcome = evalPredicate(fn, plain);
+                if (outcome === 'match')
+                    return { kind };
+                if (outcome === 'fail')
+                    return { kind: 'unknown' };
+            }
+            if (stage) {
+                for (const rule of stage.rules) {
+                    const hit = ruleMatches(data, plain, rule, tick);
+                    if (hit === 'stop')
+                        return { kind: 'unknown' };
+                    if (hit)
+                        return { kind };
+                }
+            }
         }
-    }
-    const composed = compose(data, plain, lines, tick);
-    if (composed.kind === 'stop' || composed.kind === 'unknown')
-        return { kind: 'unknown' };
-    if (composed.kind !== 'idle' && composed.kind !== 'unsent')
+        // Composer stage: comes from hatch OR from data (refused if both at load).
+        const composerFn = getProfileFn(data.profile, 'composer');
+        if (composerFn !== undefined) {
+            const composed = callComposer(composerFn, plain);
+            if (composed.kind === 'stop' || composed.kind === 'unknown')
+                return { kind: 'unknown' };
+            const marked = floorHits(plain, 0, -1, data.chrome, tick);
+            if (marked === 'stop' || marked)
+                return { kind: 'unknown' };
+            return { kind: composed.kind };
+        }
+        const composed = compose(data, plain, lines, tick);
+        if (composed.kind === 'stop' || composed.kind === 'unknown')
+            return { kind: 'unknown' };
+        if (composed.kind !== 'idle' && composed.kind !== 'unsent')
+            return { kind: composed.kind };
+        const marked = floorHits(plain, composed.from, composed.input, data.chrome, tick);
+        if (marked === 'stop' || marked)
+            return { kind: 'unknown' };
         return { kind: composed.kind };
-    const marked = floorHits(plain, composed.from, composed.input, data.chrome, tick);
-    if (marked === 'stop' || marked)
+    }
+    catch {
         return { kind: 'unknown' };
-    return { kind: composed.kind };
+    }
 }
 /**
- * The composer alone, for a turn that is still running. The unknown stage is
- * read first, as in the full classification, and the floor still applies.
+ * The composer alone, for a turn that is still running. The dialog stages and
+ * floor must not be overridden by composer readings returning idle or unsent.
  */
 export function composeLines(data, lines, clock) {
-    const now = clock?.now ?? Date.now;
-    const budget = clock?.budgetMs ?? BUDGET_MS;
-    const start = now();
-    const tick = () => now() - start > budget;
-    const plain = plainLines(lines);
-    if (data.unknown) {
-        for (const rule of data.unknown.rules) {
-            const hit = ruleMatches(data, plain, rule, tick);
-            if (hit === 'stop')
+    try {
+        const now = clock?.now ?? Date.now;
+        const budget = clock?.budgetMs ?? BUDGET_MS;
+        const start = now();
+        const tick = () => now() - start > budget;
+        const plain = plainLines(lines);
+        const composerFn = getProfileFn(data.profile, 'composer');
+        if (composerFn !== undefined) {
+            // Profile has a HATCH composer (no data composer).
+            // Check if any caution stage (data or hatch) matches:
+            const stages = [
+                ['unknown', data.unknown],
+                ['trust', data.trust],
+                ['permission', data.permission],
+                ['question', data.question],
+                ['working', data.working],
+            ];
+            for (const [kind, stage] of stages) {
+                if (tick())
+                    return { kind: 'unknown' };
+                const fn = getProfileFn(data.profile, kind);
+                if (fn !== undefined) {
+                    const outcome = evalPredicate(fn, plain);
+                    if (outcome === 'match' || outcome === 'fail')
+                        return { kind: 'unknown' };
+                }
+                if (stage) {
+                    for (const rule of stage.rules) {
+                        const hit = ruleMatches(data, plain, rule, tick);
+                        if (hit === 'stop')
+                            return { kind: 'unknown' };
+                        if (hit)
+                            return { kind: 'unknown' };
+                    }
+                }
+            }
+            const composed = callComposer(composerFn, plain);
+            if (composed.kind === 'stop' || composed.kind === 'unknown')
                 return { kind: 'unknown' };
-            if (hit)
+            const marked = floorHits(plain, 0, -1, data.chrome, tick);
+            if (marked === 'stop' || marked)
                 return { kind: 'unknown' };
+            return { kind: composed.kind };
         }
-    }
-    const composed = compose(data, plain, lines, tick);
-    if (composed.kind === 'stop' || composed.kind === 'unknown')
-        return { kind: 'unknown' };
-    if (composed.kind !== 'idle' && composed.kind !== 'unsent')
+        // Profile has a DATA composer.
+        // Check hatch dialog predicates:
+        const dialogKinds = ['unknown', 'trust', 'permission', 'question'];
+        for (const kind of dialogKinds) {
+            if (tick())
+                return { kind: 'unknown' };
+            const fn = getProfileFn(data.profile, kind);
+            if (fn !== undefined) {
+                const outcome = evalPredicate(fn, plain);
+                if (outcome === 'match' || outcome === 'fail')
+                    return { kind: 'unknown' };
+            }
+        }
+        // Also if hatch working returns 'fail', fail safe:
+        const workingFn = getProfileFn(data.profile, 'working');
+        if (workingFn !== undefined) {
+            const outcome = evalPredicate(workingFn, plain);
+            if (outcome === 'fail')
+                return { kind: 'unknown' };
+        }
+        if (data.unknown) {
+            for (const rule of data.unknown.rules) {
+                const hit = ruleMatches(data, plain, rule, tick);
+                if (hit === 'stop')
+                    return { kind: 'unknown' };
+                if (hit)
+                    return { kind: 'unknown' };
+            }
+        }
+        const composed = compose(data, plain, lines, tick);
+        if (composed.kind === 'stop' || composed.kind === 'unknown')
+            return { kind: 'unknown' };
+        if (composed.kind !== 'idle' && composed.kind !== 'unsent')
+            return { kind: composed.kind };
+        const marked = floorHits(plain, composed.from, composed.input, data.chrome, tick);
+        if (marked === 'stop' || marked)
+            return { kind: 'unknown' };
         return { kind: composed.kind };
-    const marked = floorHits(plain, composed.from, composed.input, data.chrome, tick);
-    if (marked === 'stop' || marked)
+    }
+    catch {
         return { kind: 'unknown' };
-    return { kind: composed.kind };
+    }
+}
+/**
+ * The input box a composer draws for its current text, or null when the composer does not read
+ * `unsent`: an idle box holds nothing, and every other shape is not the box. The rows are the
+ * ones the mode's own frame delimits — between the prompt row and the box's closing line; the
+ * `status-then-one` fallback (the captured completion frame) delimits nothing, so its box is
+ * its one input row, the popup rows below it being its filter's to exclude. The caller compares
+ * the box to the text it typed; nothing here decides that.
+ */
+export function composerBox(data, lines) {
+    if (!data.composer || data.profile?.composer)
+        return null;
+    const plain = plainLines(lines);
+    const hit = compose(data, plain, lines, () => false);
+    if (hit.kind === 'stop' || hit.kind === 'unknown')
+        return null;
+    if (hit.kind !== 'unsent')
+        return null;
+    const input = plain[hit.input] ?? '';
+    const found = data.composer.prompt.exec(input);
+    if (!found)
+        return null;
+    let rest = input.slice(found[0].length);
+    const suffix = 'stripSuffix' in data.composer ? data.composer.stripSuffix : undefined;
+    if (suffix)
+        rest = rest.replace(suffix, '');
+    const indent = found[0].length + rest.length - rest.trimStart().length;
+    const rows = hit.rows ?? [];
+    // The pane draws empty rows of its own under the text, inside the box's frame — the drop
+    // before the status line, or before the closing rule. The captures name them per profile
+    // (`frame_rows`), and only those are stripped: they are the box's frame, not its content.
+    // Every row after them stays, so a box that shows an empty row the typed text does not have
+    // is not the typed text, and the caller refuses it.
+    let frame = data.composer.frameRows;
+    while (frame > 0 && rows.length > 0 && rows[rows.length - 1] === '') {
+        rows.pop();
+        frame -= 1;
+    }
+    return { first: rest.trimStart(), indent, rows, wrap: 'wrap' in data.composer ? data.composer.wrap : undefined };
 }
 function ruleMatches(data, lines, rule, tick) {
     const where = rule.onFooter ? [footerLine(data, lines)] : lines;
@@ -233,59 +533,110 @@ function compose(data, plain, styled, tick) {
         return statusThenOne(plain, styled, composer, tick);
     return twoRules(plain, styled, composer, tick);
 }
+/** The rule a line carries, or null: the profile's rule pattern anchored to the line's own
+ *  first column, as the captures draw the box's rules. */
+function ruleRun(composer, line) {
+    const hit = composer.rule.exec(line);
+    return hit === null ? null : hit[0];
+}
 function boxToRule(lines, styled, composer, tick) {
-    let input = -1;
+    // The frame first, as the captures draw it (unsent-typed-ansi.txt): a rule is an unbroken run
+    // from the pane's first column — the profile's rule pattern is anchored to it — and the box's
+    // closing rule is the window's last rule row; nothing rule-shaped sits under the box's
+    // footers, and a rule-looking row the box holds is drawn at the content column: content,
+    // never the frame.
+    let close = -1;
     for (let i = lines.length - 1; i >= 0; i--) {
         if (tick())
             return { kind: 'stop' };
-        if (composer.prompt.test(lines[i] ?? '')) {
-            input = i;
+        if (ruleRun(composer, lines[i] ?? '') !== null) {
+            close = i;
             break;
         }
     }
-    if (input < 0)
+    if (close < 0)
         return { kind: 'unknown' };
-    // The frame is the box itself: a closing rule under this prompt. A rule anywhere
-    // above, or a rule with shell output under it, is not the box. A shell's last
-    // prompt never has that closing rule.
-    let close = -1;
-    for (let i = input + 1; i < lines.length; i++) {
+    // The capture draws only the box's own footers under the closing rule. A prompt-looking row
+    // there is a row the frame does not draw — leftover-box.txt shows a second, leftover prompt
+    // under the box's status — so this pane is not the one box the caller can compare against
+    // typed text, and the read fails closed.
+    for (let i = close + 1; i < lines.length; i++) {
         if (tick())
             return { kind: 'stop' };
-        if (composer.rule.test(lines[i] ?? '')) {
-            close = i;
-            break;
-        }
+        if (composer.prompt.test(lines[i] ?? ''))
+            return { kind: 'unknown' };
     }
-    if (close < 0)
-        return { kind: 'unknown' };
-    const above = input > 0 && composer.rule.test(lines[input - 1] ?? '');
-    let footer = false;
-    for (let j = close + 1; j < lines.length; j++) {
+    let open = -1;
+    for (let i = close - 1; i >= 0; i--) {
         if (tick())
             return { kind: 'stop' };
-        if (statusFooter(lines[j] ?? '')) {
-            footer = true;
+        if (ruleRun(composer, lines[i] ?? '') !== null) {
+            open = i;
             break;
         }
     }
-    // The opening rule on the line directly above, or the status footer when that
-    // rule has scrolled out of the window.
-    if (!above && !footer)
-        return { kind: 'unknown' };
-    const from = above ? input - 1 : input;
+    let input;
+    let from;
+    if (open >= 0) {
+        // The two rules of one box are drawn at one width (53 columns in unsent-typed-ansi.txt).
+        if (ruleRun(composer, lines[close] ?? '') !== ruleRun(composer, lines[open] ?? ''))
+            return { kind: 'unknown' };
+        // The input row is the box's first row under its opening frame, and it carries the prompt
+        // at the capture's own column. A row there that does not is not this box's input — the read
+        // fails closed rather than take some later row whose content begins with a prompt glyph,
+        // which would drop the rows above it from the box the caller compares.
+        input = open + 1;
+        if (input >= close || !composer.prompt.test(lines[input] ?? ''))
+            return { kind: 'unknown' };
+        from = open;
+    }
+    else {
+        // The opening rule has scrolled out of the window. The frame is then the ordered footers
+        // under the closing rule — every pattern matched in sequence, equal count, as the capture
+        // draws them — and the input row is the lowest row above the closing rule carrying the
+        // prompt at that column: content is drawn at the text's column, so a row at the prompt's
+        // own can only be the box's first. Any non-blank row above it is a row the frame does not
+        // explain, and the read fails closed.
+        let footer = false;
+        const rawFooters = [];
+        for (let j = close + 1; j < lines.length; j++) {
+            if (tick())
+                return { kind: 'stop' };
+            const raw = lines[j] ?? '';
+            if (raw.trim())
+                rawFooters.push(raw);
+        }
+        if (composer.footers.length > 0 && rawFooters.length === composer.footers.length) {
+            footer = composer.footers.every((pattern, idx) => pattern.test(rawFooters[idx] ?? ''));
+        }
+        if (!footer)
+            return { kind: 'unknown' };
+        input = -1;
+        for (let i = close - 1; i >= 0; i--) {
+            if (tick())
+                return { kind: 'stop' };
+            if (composer.prompt.test(lines[i] ?? '')) {
+                input = i;
+                break;
+            }
+        }
+        if (input < 0)
+            return { kind: 'unknown' };
+        for (let i = 0; i < input; i++) {
+            if (tick())
+                return { kind: 'stop' };
+            if ((lines[i] ?? '').trim())
+                return { kind: 'unknown' };
+        }
+        from = input;
+    }
+    const rows = lines.slice(input + 1, close);
     for (let i = input + 1; i < close; i++) {
         if ((lines[i] ?? '').trim())
-            return { kind: 'unsent', from, input };
+            return { kind: 'unsent', from, input, rows };
     }
     const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
-    return { kind: placeholder(typed, composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from, input };
-}
-// The composer footer, not a line of shell output under a stray rule. The model
-// row uses a middot; the permissions line is the other footer.
-function statusFooter(line) {
-    const text = line.trim();
-    return text.includes('·') || /bypass permissions/i.test(text);
+    return { kind: placeholder(typed, composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from, input, rows };
 }
 function statusLast(lines, styled, composer, tick, allowOneTrailing) {
     const status = statusIndex(composer, lines, allowOneTrailing, tick);
@@ -298,10 +649,11 @@ function statusLast(lines, styled, composer, tick, allowOneTrailing) {
         input--;
     if (input < 0)
         return { kind: 'unknown' };
+    const rows = lines.slice(input + 1, status);
     for (let i = input + 1; i < status; i++)
         if ((lines[i] ?? '').trim())
-            return { kind: 'unsent', from: input, input };
-    return { kind: placeholder(stripTyped(lines[input] ?? '', composer), composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from: input, input };
+            return { kind: 'unsent', from: input, input, rows };
+    return { kind: placeholder(stripTyped(lines[input] ?? '', composer), composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from: input, input, rows };
 }
 function statusThenOne(lines, styled, composer, tick) {
     const found = statusLast(lines, styled, composer, tick, true);
@@ -332,25 +684,37 @@ function statusThenOne(lines, styled, composer, tick) {
     return { kind: 'unknown' };
 }
 function twoRules(lines, styled, composer, tick) {
+    // The frame first: the box's bottom rule is the window's last rule row, and its top rule is
+    // the nearest rule row above it — the captures draw exactly two rules around the box, both
+    // unbroken runs from the pane's first column (unsent.txt draws them at rows 7 and 12). A
+    // rule-looking row the box holds is drawn at the content column and is content, never frame.
     let bottom = -1;
     let top = -1;
-    let input = -1;
     for (let i = lines.length - 1; i >= 0; i--) {
         if (tick())
             return { kind: 'stop' };
-        const line = lines[i] ?? '';
-        if (composer.rule.test(line)) {
+        if (composer.rule.test(lines[i] ?? '')) {
             if (bottom === -1)
                 bottom = i;
-            else if (top === -1 && input !== -1) {
+            else {
                 top = i;
                 break;
             }
         }
-        else if (bottom !== -1 && input === -1 && composer.prompt.test(line))
-            input = i;
     }
-    if (top < 0 || bottom < 0 || input <= top || input >= bottom)
+    if (top < 0 || bottom < 0)
+        return { kind: 'unknown' };
+    // The two rules of one box are drawn at one width (53 columns in unsent.txt, 54 in
+    // folded-rules.txt). A window whose rules differ is not that frame — the box the caller
+    // compares against typed text cannot be established — and the read fails closed.
+    if (ruleRun(composer, lines[bottom] ?? '') !== ruleRun(composer, lines[top] ?? ''))
+        return { kind: 'unknown' };
+    // The input row is the box's first row under its opening frame, and it carries the prompt at
+    // the capture's own column. A row there that does not — a folded box's marker row
+    // (folded-rules.txt) — is not this box's input, and the read fails closed rather than take
+    // some later row whose content begins with a prompt glyph.
+    const input = top + 1;
+    if (input >= bottom || !composer.prompt.test(lines[input] ?? ''))
         return { kind: 'unknown' };
     let footer = false;
     for (let i = bottom + 1; i < lines.length; i++) {
@@ -361,10 +725,11 @@ function twoRules(lines, styled, composer, tick) {
     }
     if (!footer)
         return { kind: 'unknown' };
-    if (lines.slice(input + 1, bottom).some((line) => line.trim()))
-        return { kind: 'unsent', from: top, input };
+    const rows = lines.slice(input + 1, bottom);
+    if (rows.some((line) => line.trim()))
+        return { kind: 'unsent', from: top, input, rows };
     const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
-    return { kind: placeholder(typed, composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from: top, input };
+    return { kind: placeholder(typed, composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from: top, input, rows };
 }
 function stripTyped(line, composer) {
     const stripped = composer.stripSuffix ? line.replace(composer.prompt, '').replace(composer.stripSuffix, '') : line.replace(composer.prompt, '');