tickmarkr 1.83.0 → 1.85.0

package/dist/tui/cockpit/layout.js

@@ -1,3 +1,4 @@
+import { PANEL_CHROME_ROWS, READABLE_PANEL_COLUMNS } from "./components.js";
 import { cellWidth } from "./width.js";
 export const COCKPIT_ROW_FLOOR = 14;
 export const COCKPIT_COLUMN_FLOOR = 40;
@@ -57,6 +58,30 @@ export const FRAME_WIDTH_FLOOR = COCKPIT_COLUMN_FLOOR;
 export const FRAME_HEIGHT_FLOOR = COCKPIT_ROW_FLOOR;
 export const SIDEBAR_COLUMN_FLOOR = 64;
 export const RAIL_COLUMNS = 15;
+/**
+ * The narrowest rail that still reads: the selection marker, one space and the
+ * longest view name, whole — the name measured in display cells by the width
+ * authority, never String length, so a name that ever gains a wide glyph moves
+ * the floor with it. A drag never takes the rail below it — below the floor
+ * the element stands at the floor, surrendered whole per the contract, never
+ * collapsed.
+ */
+export const RAIL_READABLE_FLOOR_COLUMNS = Math.max(...FRAME_VIEWS.map((view) => cellWidth(view))) + 2;
+/**
+ * The rail width the plan draws for a session resize override, clamped at both
+ * panels' readable floors: the rail never narrows past its own floor, and
+ * never widens past what leaves the body its readable floor
+ * (`READABLE_PANEL_COLUMNS`). The clamp is the plan's — the override is a
+ * request, the floors are the contract, and an element is surrendered whole or
+ * not at all, never collapsed by a drag. No override is the contract's
+ * constant rail.
+ */
+export function planRailColumns(columns, override) {
+    if (override === undefined || !Number.isFinite(override))
+        return RAIL_COLUMNS;
+    const ceiling = Math.max(RAIL_READABLE_FLOOR_COLUMNS, Math.floor(columns) - READABLE_PANEL_COLUMNS);
+    return Math.min(ceiling, Math.max(RAIL_READABLE_FLOOR_COLUMNS, Math.floor(override)));
+}
 export const STANDARD_TAIL_HEIGHT = 16;
 export const FULL_TAIL_HEIGHT = 24;
 export const TAIL_STANDARD_ROWS = 1;
@@ -93,6 +118,23 @@ export const FRAME_SURRENDER_FIT = {
     caption: ({ captionCells, columns }) => captionCells >= 1 && captionCells <= columns - HEADER_FIXED_CELLS,
     tail: ({ tailRows }) => tailRows > 0,
 };
+/**
+ * Border plus horizontal padding the drawn panel charges around its body —
+ * half of it on each side. The plan owns this because the plan owns the item
+ * rows: the paint draws its list into the region planned below, and nothing
+ * downstream subtracts chrome of its own to find it again.
+ */
+export const RUN_PANEL_HORIZONTAL_CHROME = 4;
+/**
+ * Row bands drawn INSIDE another band rather than beside it, mapped to the band
+ * that hosts them. A nested band refines its host's rows, so the band walk skips
+ * it when tiling the height and asserts containment instead. It is no less a
+ * member of `rowSpans` for that: the oracle pins its span against the planned
+ * region, and demands the paint register a node at exactly that rectangle —
+ * which is precisely what a parallel field beside the plan could never be held
+ * to.
+ */
+export const FRAME_NESTED_ROW_BANDS = { items: "body" };
 /* ------------------------------------------------------------------ */
 /* The sidebar band's composition: the menu at the rail's top, the     */
 /* vitals anchored to the rail's bottom, and at least one blank row    */
@@ -113,17 +155,28 @@ export const SIDEBAR_VITALS_COMPACT_ELEMENT_ROWS = 1;
  * one gap row is the vitals budget, spent on the full two-row block when it
  * fits whole, else on the one-row elements, surrendered from the top of the
  * block with the meter surrendered last. An element draws whole or not at all.
+ * `railRow` is the frame row the rail band starts at, so the view rows the plan
+ * reports are frame rows a reported cell is compared against directly. It is
+ * required for that reason: a default here would answer rail-relative rows in a
+ * field documented as frame rows — the same defaulted-measurement defect the key
+ * delivery carried, and this one would land in the rows a rail hit resolves
+ * through.
  */
-export function planSidebar(railRows) {
+export function planSidebar(railRows, railRow) {
     const menuRows = railRows >= SIDEBAR_MENU_LABEL_ROWS
         ? 1 + FRAME_VIEWS.length
         : FRAME_VIEWS.length;
+    // The views occupy the menu block's last rows: whatever the block exceeds
+    // them by is the label row the plan funded above them.
+    const firstViewRow = railRow + (menuRows - FRAME_VIEWS.length);
+    const viewRows = Object.fromEntries(FRAME_VIEWS.map((view, index) => [view, firstViewRow + index]));
     const fullRows = SIDEBAR_VITALS_ORDER.length * SIDEBAR_VITALS_FULL_ELEMENT_ROWS;
     // The gap is funded before the vitals are: the budget is what remains after it.
     const budget = railRows - menuRows - 1;
     if (budget >= fullRows) {
         return {
             menuRows,
+            viewRows,
             gapRows: railRows - menuRows - fullRows,
             vitalsMode: "full",
             vitals: SIDEBAR_VITALS_ORDER,
@@ -132,11 +185,29 @@ export function planSidebar(railRows) {
     const kept = Math.max(0, Math.min(SIDEBAR_VITALS_ORDER.length, Math.floor(budget)));
     return {
         menuRows,
+        viewRows,
         gapRows: kept > 0 ? railRows - menuRows - kept : 0,
         vitalsMode: "compact",
         vitals: SIDEBAR_VITALS_ORDER.slice(SIDEBAR_VITALS_ORDER.length - kept),
     };
 }
+/**
+ * The item rows of a body band: the band less the chrome the drawn panel puts
+ * around its list — the border row and the title row above the first item, the
+ * border row below it, and a bordered padded column on each side. THE ONE
+ * PLACE that subtraction happens, and it happens in the plan: paint and hit
+ * resolution alike consume this region rather than deriving it again.
+ */
+function planItemRows(body) {
+    const heading = PANEL_CHROME_ROWS - 1; // border row, then the title row
+    return {
+        id: "items",
+        row: body.row + heading,
+        rows: Math.max(1, body.rows - PANEL_CHROME_ROWS),
+        column: body.column + RUN_PANEL_HORIZONTAL_CHROME / 2,
+        columns: Math.max(1, body.columns - RUN_PANEL_HORIZONTAL_CHROME),
+    };
+}
 function tailRowsFor(rows) {
     if (rows >= FULL_TAIL_HEIGHT)
         return TAIL_FULL_ROWS;
@@ -151,7 +222,9 @@ function tailRowsFor(rows) {
  * height exactly — header, rule, the view strip (40–63 columns), the body
  * band, a second rule, the journal tail surrendered whole by height tier,
  * status, keybar — and, at ≥64 columns, column bands that tile the width
- * exactly: the constant 15-column rail beside the body. The body is the sole
+ * exactly: the rail beside the body, at the constant 15 columns or at the
+ * session's dragged override clamped to both panels' readable floors
+ * (`planRailColumns`). The body is the sole
  * flexible element on both axes. The view and state decide what the flexible
  * bands draw (the Journal view is the full-height tail; SETUP turns the tail
  * into PENDING WRITES; an open detail owns the body) without moving any
@@ -165,7 +238,12 @@ function tailRowsFor(rows) {
  * of the block, the meter last, rather than closing the gap. rowSpans and
  * columnSpans are band maps: they deliberately exclude the nested caption,
  * and column bands are reported for the body band only, so each map's spans
- * sum to the full height and width respectively.
+ * sum to the full height and width respectively. The body band's item rows are
+ * a band of the plan in their own right — a region in `regions` and a span in
+ * `rowSpans`, nested inside the body band rather than tiling beside it — so the
+ * region the paint draws its list into and the region a pointer resolves a row
+ * through are the one thing the oracle pins, and neither subtracts the drawn
+ * panel's chrome for itself.
  */
 export function planFrame(size, view = "tasks", state = {}) {
     const columns = Math.floor(size.columns);
@@ -178,6 +256,9 @@ export function planFrame(size, view = "tasks", state = {}) {
     }
     const tab = state.tab ?? "watch";
     const band = columns >= SIDEBAR_COLUMN_FLOOR ? "sidebar" : "strip";
+    // The one panel the session can resize: the rail, at the operator's dragged
+    // override clamped to the readable floors, or the contract's constant rail.
+    const railColumns = planRailColumns(columns, state.railColumns);
     const stripRows = band === "strip" ? 1 : 0;
     const tailRows = tailRowsFor(rows);
     // Fixed chrome is five rows: header, rule, a second rule below the body
@@ -221,25 +302,21 @@ export function planFrame(size, view = "tasks", state = {}) {
             row: bodyRow,
             rows: bodyRows,
             column: 0,
-            columns: RAIL_COLUMNS,
-        });
-        regions.push({
-            id: "body",
-            row: bodyRow,
-            rows: bodyRows,
-            column: RAIL_COLUMNS,
-            columns: columns - RAIL_COLUMNS,
+            columns: railColumns,
         });
     }
-    else {
-        regions.push({
+    const bodyRegion = band === "sidebar"
+        ? {
             id: "body",
             row: bodyRow,
             rows: bodyRows,
-            column: 0,
-            columns,
-        });
-    }
+            column: railColumns,
+            columns: columns - railColumns,
+        }
+        : { id: "body", row: bodyRow, rows: bodyRows, column: 0, columns };
+    regions.push(bodyRegion);
+    const itemsRegion = planItemRows(bodyRegion);
+    regions.push(itemsRegion);
     if (captionFits) {
         regions.push({
             id: "caption",
@@ -253,13 +330,14 @@ export function planFrame(size, view = "tasks", state = {}) {
     if (stripRows > 0)
         rowSpans.strip = stripRows;
     rowSpans.body = bodyRows;
+    rowSpans.items = itemsRegion.rows;
     rowSpans.rule2 = 1;
     if (tailRows > 0)
         rowSpans.tail = tailRows;
     rowSpans.status = 1;
     rowSpans.keybar = 1;
     const columnSpans = band === "sidebar"
-        ? { rail: RAIL_COLUMNS, body: columns - RAIL_COLUMNS }
+        ? { rail: railColumns, body: columns - railColumns }
         : { body: columns };
     return {
         kind: "frame",
@@ -275,7 +353,7 @@ export function planFrame(size, view = "tasks", state = {}) {
         rowSpans,
         columnSpans,
         flexible: { row: "body", column: "body" },
-        sidebar: band === "sidebar" ? planSidebar(bodyRows) : null,
+        sidebar: band === "sidebar" ? planSidebar(bodyRows, bodyRow) : null,
         surrendered,
     };
 }

package/dist/tui/cockpit/live.d.ts

@@ -1,5 +1,6 @@
 import type { CockpitGraph, RunCockpitData, RunCockpitSource } from "./derive.js";
 import { type RunInteractionState, type RunKeyEvent } from "./keys.js";
+import { type PointerReport, type PointerSurface } from "./pointer.js";
 /**
  * THE engagement selection rule — stated once, here, so it can change in one
  * place without touching the renderer or the command: an explicit engagement
@@ -46,6 +47,17 @@ export declare function reconcileLiveRunInteraction(interaction: RunInteractionS
  * one place rows enter the dispatcher, so no key can reach a journal row.
  */
 export declare function liveRunViewRowIds(interaction: RunInteractionState, data: RunCockpitData): readonly string[];
+/**
+ * The suite's own planning of the surface a frame at this data, state and
+ * measured size commits — the same composition the renderer publishes through
+ * its commit seam, so a hit is tested against the frame production actually
+ * painted. The live input path never calls this: it resolves through the
+ * committed frame, and what nothing has painted yet has no geometry.
+ */
+export declare function liveRunPointerSurface(data: RunCockpitData, interaction: RunInteractionState, size: {
+    readonly columns: number;
+    readonly rows: number;
+}): PointerSurface | undefined;
 export type LiveCockpitSurface = {
     readonly data: RunCockpitData;
     readonly interaction: RunInteractionState;
@@ -62,7 +74,8 @@ export type LiveCockpitSurface = {
 export type LiveCockpitDelivery = {
     readonly snapshot: () => LiveCockpitSurface;
     readonly refresh: () => boolean;
-    readonly key: (event: RunKeyEvent, columns?: number) => boolean;
+    readonly key: (event: RunKeyEvent) => boolean;
+    readonly pointer: (report: PointerReport) => boolean;
     readonly batch: <Result>(deliver: () => Result) => Result;
 };
 export declare function runLiveCockpit({ input, output, cwd, runId, binaryVersion, refreshMs, now, debug, onDelivery, }: {

package/dist/tui/cockpit/live.js

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { render, useApp, useInput } from "ink";
-import { createElement, useEffect, useRef, useSyncExternalStore } from "react";
+import { createElement, useCallback, useEffect, useRef, useSyncExternalStore } from "react";
 import { graphPath, loadGraph, stateDirName } from "../../graph/graph.js";
 import { Journal, parseRunId } from "../../run/journal.js";
 import { deriveRunCockpitData } from "./derive.js";
-import { deriveRunViewRows, runKeyColumns, RunCockpitFrame } from "./run-cockpit.js";
+import { deriveRunViewRows, drawnRunViewRowIds, planRunCockpitFrame, runKeyColumns, RunCockpitFrame, } from "./run-cockpit.js";
 import { dispatchRunSurfaceKey, openingRunSurfaceState, reconcileRunInteraction, RUN_INPUT_BINDINGS, selectableRunViewRowIds, } from "./keys.js";
+import { applyPointerReport, borrowPointerTracking, createPointerReportReader, } from "./pointer.js";
 // ponytail: fixed 2s re-derive cadence, matching `status --watch`; promote to a
 // config knob only if an operator asks.
 const REFRESH_MS = 2_000;
@@ -110,7 +111,44 @@ export function liveRunViewRowIds(interaction, data) {
     deriveRunViewRows(data, interaction.activeView, interaction.filterQuery)
         .map((row) => row.id));
 }
-function createLiveCockpitDelivery({ cwd, runId, binaryVersion, now, }) {
+/**
+ * The pointer surface a committed frame carries: the plan the paint drew and
+ * the rows drawn into its body, both read off the renderer's own output. This
+ * is the only composition the live input path resolves through — it holds no
+ * planner and no geometry of its own, so a hit can never land on bands or
+ * rows the operator has not seen.
+ */
+function committedRunPointerSurface(planned, data) {
+    if (planned.plan.kind !== "frame" || planned.content === undefined) {
+        return undefined;
+    }
+    return {
+        interaction: planned.interaction,
+        // The plan is the whole geometry the pointer receives: the item rows it
+        // resolves a hit through are the plan's own `items` band, the same region
+        // the paint draws its list into, so there is no second reading of where the
+        // list starts.
+        plan: planned.plan,
+        drawnRowIds: drawnRunViewRowIds(data, planned.interaction, planned.content.items.rows),
+        rowIds: liveRunViewRowIds(planned.interaction, data),
+    };
+}
+/**
+ * The suite's own planning of the surface a frame at this data, state and
+ * measured size commits — the same composition the renderer publishes through
+ * its commit seam, so a hit is tested against the frame production actually
+ * painted. The live input path never calls this: it resolves through the
+ * committed frame, and what nothing has painted yet has no geometry.
+ */
+export function liveRunPointerSurface(data, interaction, size) {
+    return committedRunPointerSurface(planRunCockpitFrame({
+        data,
+        columns: size.columns,
+        rows: size.rows,
+        interaction,
+    }), data);
+}
+function createLiveCockpitDelivery({ cwd, runId, binaryVersion, now, size, }) {
     // Both sources are read every refresh: a recompile between refreshes changes
     // which tasks exist, and the surface must draw the graph the repository has
     // now rather than the one it had when the cockpit opened.
@@ -124,6 +162,15 @@ function createLiveCockpitDelivery({ cwd, runId, binaryVersion, now, }) {
     const listeners = new Set();
     let batchDepth = 0;
     let pendingDraw = false;
+    /**
+     * The frame on the screen, published by the renderer each time it commits
+     * one. Pointer reports resolve through this and only this: the input path
+     * plans nothing and caches no geometry, so a refresh, resize or key that
+     * nothing has painted yet cannot move a hit — the target set is the bands
+     * and rows the operator is actually looking at, until the paint replaces
+     * them.
+     */
+    let committedPointerSurface;
     const publish = () => {
         if (batchDepth > 0) {
             pendingDraw = true;
@@ -154,6 +201,9 @@ function createLiveCockpitDelivery({ cwd, runId, binaryVersion, now, }) {
             finally {
                 batchDepth -= 1;
                 if (batchDepth === 0 && pendingDraw) {
+                    // The batch ends and the surface is drawn again; the renderer's
+                    // commit of that draw publishes the frame the next report resolves
+                    // through.
                     pendingDraw = false;
                     publish();
                 }
@@ -178,10 +228,12 @@ function createLiveCockpitDelivery({ cwd, runId, binaryVersion, now, }) {
         // can be in. The prompt is a scope inside that registry rather than an
         // owner in front of it, so a global key — Tab above all — reaches its
         // handler with a prompt open exactly as it does without one.
-        key: (event, columns = Number.MAX_SAFE_INTEGER) => transition((current) => {
+        key: (event) => transition((current) => {
             const next = dispatchRunSurfaceKey(event, { interaction: current.interaction, stashed: current.stashed }, RUN_INPUT_BINDINGS, liveRunViewRowIds(current.interaction, current.data), 
-            // The dispatcher decides on rail visibility, and the plan owns that.
-            runKeyColumns(columns));
+            // The dispatcher decides on rail visibility from the width the surface
+            // is measured at. A default here routed every key as if the rail were
+            // drawn, at widths where the plan draws no rail at all.
+            runKeyColumns(size().columns));
             if (next === undefined)
                 return current;
             const interaction = reconcileLiveRunInteraction(next.interaction, current.data);
@@ -189,9 +241,40 @@ function createLiveCockpitDelivery({ cwd, runId, binaryVersion, now, }) {
                 ? current
                 : { ...current, interaction, stashed: next.stashed };
         }),
+        // A pointer report resolves through the committed frame — the plan and
+        // the drawn rows the paint has on the screen, and nothing the input path
+        // derives for itself. Adjacent reports — a double click above all —
+        // arrive in one batch, which defers the redraw: they all resolve through
+        // the ONE committed frame still on the screen, and only the state each
+        // transition is dispatched FROM moves. The first press's own new scroll
+        // window cannot slide the list under the second press, because that
+        // window does not exist until the paint draws it.
+        pointer: (report) => transition((current) => {
+            const drawn = committedPointerSurface;
+            if (drawn === undefined)
+                return current;
+            const next = applyPointerReport(report, {
+                ...drawn,
+                interaction: current.interaction,
+            });
+            if (next === undefined)
+                return current;
+            const interaction = reconcileLiveRunInteraction(next, current.data);
+            return interaction === current.interaction
+                ? current
+                : { ...current, interaction };
+        }),
+        commitPointerSurface: (surface) => {
+            committedPointerSurface = surface;
+        },
     };
     return delivery;
 }
+/** The measured size a snapshot states, in the whole cells a plan is made of. */
+function parseMeasuredSize(snapshot) {
+    const [columns, rows] = snapshot.split(":").map((part) => Math.max(0, Math.floor(Number(part))));
+    return { columns, rows };
+}
 function measureOutput(output) {
     const read = () => `${output.columns ?? 80}:${output.rows ?? 24}`;
     let size = read();
@@ -245,11 +328,83 @@ function measureOutput(output) {
         close: () => output.off("resize", resized),
     };
 }
+/**
+ * The stdin the surface's keyboard reads: the real stream with every pointer
+ * report taken out of it. Reports and keys arrive interleaved on one stream, and
+ * a reader beside Ink's would not be enough — Ink would still see the report
+ * bytes and read a whole one as an unnameable escape sequence, or half of one as
+ * the single character its chunk happens to end on, dispatching either into
+ * whatever scope is live. So the split sits in the pull Ink already does
+ * (`read()` under its `readable` listener): reports are handed to the pointer
+ * boundary, and only what was left is ever read as a keystroke. A chunk that was
+ * nothing but reports reads as no input at all rather than as empty input.
+ */
+function pointerFilteredInput(input, deliver) {
+    const reader = createPointerReportReader();
+    const tokens = [];
+    let pendingEscape;
+    const clearPendingEscape = () => {
+        if (pendingEscape === undefined)
+            return;
+        clearImmediate(pendingEscape);
+        pendingEscape = undefined;
+    };
+    const wake = () => {
+        input.emit("readable");
+    };
+    const schedulePendingEscape = () => {
+        clearPendingEscape();
+        // The same next-turn grace Ink gives an ambiguous ESC: a continuation that
+        // arrives first completes the report; otherwise ESC becomes keyboard input.
+        if (reader.pending() !== "\x1b")
+            return;
+        pendingEscape = setImmediate(() => {
+            pendingEscape = undefined;
+            tokens.push(...reader.flush().tokens);
+            wake();
+        });
+    };
+    const read = (...args) => {
+        while (true) {
+            const token = tokens.shift();
+            if (token?.type === "pointer") {
+                const reports = [token.report];
+                while (tokens[0]?.type === "pointer") {
+                    const adjacent = tokens.shift();
+                    if (adjacent?.type === "pointer")
+                        reports.push(adjacent.report);
+                }
+                deliver(reports);
+                continue;
+            }
+            if (token?.type === "keys")
+                return token.bytes;
+            const chunk = input.read(...args);
+            if (chunk === null || chunk === undefined)
+                return null;
+            clearPendingEscape();
+            const readout = reader(String(chunk));
+            tokens.push(...readout.tokens);
+            schedulePendingEscape();
+        }
+    };
+    const stdin = new Proxy(input, {
+        get(target, property) {
+            if (property === "read")
+                return read;
+            const value = Reflect.get(target, property);
+            return typeof value === "function" && !Object.hasOwn(target, property)
+                ? value.bind(target)
+                : value;
+        },
+    });
+    return { stdin, close: clearPendingEscape };
+}
 function LiveApp({ delivery, size, refreshMs, }) {
     const { exit } = useApp();
     const surface = useSyncExternalStore(delivery.subscribe, delivery.snapshot, delivery.snapshot);
     const measuredSize = useSyncExternalStore(size.subscribe, size.snapshot, size.snapshot);
-    const [columns, rows] = measuredSize.split(":").map((part) => Math.max(0, Math.floor(Number(part))));
+    const { columns, rows } = parseMeasuredSize(measuredSize);
     const drawnSize = useRef(measuredSize);
     useEffect(() => {
         if (drawnSize.current === measuredSize)
@@ -270,42 +425,81 @@ function LiveApp({ delivery, size, refreshMs, }) {
             exit();
             return;
         }
-        delivery.key({ input, key }, columns);
+        delivery.key({ input, key });
     });
+    // Every frame the renderer commits is published to the delivery, so a
+    // pointer report resolves against the plan and the drawn rows of the frame
+    // on the screen — the input path never plans one of its own.
+    const commitFrame = useCallback((planned, frameData) => {
+        delivery.commitPointerSurface(committedRunPointerSurface(planned, frameData));
+    }, [delivery]);
     return createElement(RunCockpitFrame, {
         data: surface.data,
         columns,
         rows,
         interaction: surface.interaction,
+        onCommittedFrame: commitFrame,
     });
 }
 export async function runLiveCockpit({ input, output, cwd, runId, binaryVersion, refreshMs = REFRESH_MS, now = Date.now, debug = false, onDelivery, }) {
-    const delivery = createLiveCockpitDelivery({
-        cwd,
-        runId,
-        binaryVersion,
-        now,
-    });
-    onDelivery?.(delivery);
     // Subscribe before Ink mounts so no stale-size repaint can overtake the
-    // surface's newly planned frame.
+    // surface's newly planned frame — and before the delivery exists, which
+    // routes every input against this measurement.
     const size = measureOutput(output);
-    const app = render(createElement(LiveApp, {
-        delivery,
-        size,
-        refreshMs,
-    }), {
-        stdin: input,
-        stdout: size.stdout,
-        debug,
-        exitOnCtrlC: false,
-        patchConsole: false,
-    });
+    let app;
+    let filteredInput;
+    let releasePointerTracking;
     try {
+        const delivery = createLiveCockpitDelivery({
+            cwd,
+            runId,
+            binaryVersion,
+            now,
+            size: () => parseMeasuredSize(size.snapshot()),
+        });
+        onDelivery?.(delivery);
+        // Pointer reports are their own input class: they are taken off the stream
+        // before the keyboard reads it and delivered to the pointer boundary, never
+        // handed to a key handler. A batch keeps adjacent reports to one redraw.
+        filteredInput = pointerFilteredInput(input, (reports) => {
+            delivery.batch(() => {
+                for (const report of reports)
+                    delivery.pointer(report);
+            });
+        });
+        // One loan owns the complete live lifecycle. Its signal repayments stand
+        // before the ask, then remain installed through mount, paint, input and
+        // unmount. Non-tty output borrows nothing and writes nothing.
+        releasePointerTracking = borrowPointerTracking(output);
+        app = render(createElement(LiveApp, {
+            delivery,
+            size,
+            refreshMs,
+        }), {
+            stdin: filteredInput.stdin,
+            stdout: size.stdout,
+            debug,
+            exitOnCtrlC: false,
+            patchConsole: false,
+        });
         await app.waitUntilExit();
     }
     finally {
-        size.close();
-        app.unmount();
+        try {
+            filteredInput?.close();
+        }
+        finally {
+            try {
+                app?.unmount();
+            }
+            finally {
+                try {
+                    releasePointerTracking?.();
+                }
+                finally {
+                    size.close();
+                }
+            }
+        }
     }
 }