@vincemakes/kiso-tui 0.20.2 → 0.20.4

package/dist/compositor.js

@@ -47,7 +47,7 @@ import { MENU_ITEMS, displayWidth } from "./editor.js";
 import { leadWidth } from "./width.js"; // W23: the ONE width authority (the editor, #inputRow, and editCol share it)
 // KC3.5: the panel-slot reads come from the DISPATCHERS — one source
 // for four reads, so an ask can never render half as an approval.
-import { panelAffordanceOf, panelFrameOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
+import { panelFrameOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
 import { MOUSE_OFF } from "./editor.js";
 import { atPanelRows, bandHeader } from "./at-picker.js";
 // TUI2-R2 ②: the session picker's rows — the band's third occupant.
@@ -292,6 +292,20 @@ export class Body {
     #needsReset = false;
     #resizeTimer = null;
     #lastH = 0;
+    /** DC-34 — did THIS FRAME refold the committed cells?
+     *
+     *  It must be reset where the question is asked, not only where it
+     *  is answered. Armed once and consumed later, it latched: the
+     *  session's FIRST frame ran a vacuous refold over zero committed
+     *  cells and set it, and nothing cleared it until the first resize —
+     *  so every session's first widen still ran the adopt it was
+     *  supposed to skip, and swallowed the live band's worth of
+     *  committed rows. Three paragraphs, in the measurement that found
+     *  it. */
+    #refolded = false;
+    /** DC-34 — the previous frame's width; the reach-back guard is for a
+     *  WIDTH change, which re-indexes the model, not a height change. */
+    #lastW = 0;
     // KC1 §6: the composer's recorded extent — the row count the last
     // frame drew (exit's clear walks it) and the row its CHA parked the
     // cursor on (the steady frame's relative anchor). N = 1 reproduces
@@ -1806,8 +1820,25 @@ export class Body {
      *  now). */
     #statusSource() {
         const panel = this.#panelState?.() ?? null;
+        // DC-38: the panel's STATUS replaces the CLI's painting status —
+        // that half of W21 stands. The HINT does not come with it, because
+        // the panel block already ends in its own affordance row and has
+        // since TUI2-R1.5 ("the affordance — the phase's key hint, ONE
+        // row"). Both sites read `panelAffordance`, neither knew about the
+        // other, and an approval at W≥100 printed the same 48-cell sentence
+        // twice, six rows apart.
+        //
+        // The block's copy is the one to keep, on two grounds. It sits next
+        // to the options it names. And it never disappears: the status row
+        // drops its hint when the left text plus the hint will not fit, so
+        // the duplicate was width-dependent — one copy on an ask (long left
+        // text), two on an approval (`⏸ run paused`, twelve cells) — which
+        // is why every fixed-width gate was blind to it. Each flavour's
+        // block carries its own row (approval-panel.ts pushes it for the
+        // approval and the pick, ask-panel.ts for the ask), so nothing is
+        // lost anywhere.
         if (panel !== null)
-            return { status: panelStatusOf(panel), hint: panelAffordanceOf(panel) };
+            return { status: panelStatusOf(panel), hint: undefined };
         // W22: while turns wait in the queue, the right hint shows the
         // count — the chips below carry the lines themselves.
         const queued = this.#queueState?.().length ?? 0;
@@ -2443,15 +2474,86 @@ export class Body {
         // the NEW width, so the cached folds are stale. Re-fold the
         // committed cells so the every-row draw below re-paints them at the
         // current geometry — the frame's model and the screen agree.
+        // DC-34 — A WIDEN DOES NOT REFOLD WHAT IS ALREADY COMMITTED.
+        //
+        // Every count here is physical ROWS at the fold width in force
+        // when it was computed. Refolding the committed cells at a new W
+        // changes what every index MEANS while `#scrolledOff` is carried
+        // across untranslated — and no translation exists, because the
+        // row the scroll stopped at does not occur in the new fold. On a
+        // widen the stale count then points at text the terminal already
+        // holds, and the frame paints it a second time.
+        //
+        // A committed row is ink (ADR-0046): the rows still on screen are
+        // the same thing as the rows in the scrollback minus a scroll
+        // that has not happened, and no terminal reflows either. Leaving
+        // them folded as they were printed keeps every index valid.
+        //
+        // NARROWING still refolds — an old wide row does not FIT, and
+        // `#checked` would throw invariant ①. The comparison is against
+        // the CACHE's fold width, not the last render's: after 60 → 100
+        // (no refold, the cache is still 60) a narrowing to 80 must NOT
+        // refold, because 80 columns hold a 60-column row.
+        this.#refolded = false;
         if (this.#fullRedraw) {
-            this.#lineCache = this.#lineCache.map(() => null);
+            // DC-34 — THE REFOLD IS SCOPED BY THE FRONTIER.
+            //
+            // `#scrolledOff` is the record of what reached the terminal:
+            // rows [0, #scrolledOff) are in its scrollback, immutable, and
+            // no path of ours may contradict them. A cell with any row
+            // down there keeps the fold it was COMMITTED at, forever — in
+            // either direction. A cell entirely above the frontier has
+            // never left the screen, so re-folding it is free.
+            //
+            // Two scalar predicates were tried before this and both
+            // failed, in different ways: the last-refold width crashed on
+            // 60 → 100 → 80 (a cell committed at 100 emitted into an
+            // 80-column screen), and the cache's widest fold fires a FULL
+            // refold at the first narrowing, which re-wraps rows the
+            // scrollback already holds — the original defect, alive in
+            // the other direction. The frontier is not an approximation
+            // of them; it is the question they were both approximating.
+            // A cell is refolded when EITHER is true:
+            //   - it is entirely above the frontier (never left the
+            //     screen, so re-wrapping it contradicts nothing), or
+            //   - it does not FIT: some cached row is wider than W.
+            //
+            // The second is not a compromise of the first, it is the
+            // answer to a question the first cannot reach. A cell can
+            // STRADDLE the frontier — its head in the scrollback, its
+            // tail still on screen — and the tail must be painted at the
+            // current width. Holding its commit fold there emitted a
+            // 100-column row into an 80-column screen and invariant ①
+            // threw (60 → 100 → 80, measured). Fitting wins: a crash is
+            // worse than a seam, and the seam a narrowing leaves is
+            // rider 2's, stated rather than hidden.
+            let row = 0;
+            const refold = new Array(this.#committed).fill(false);
+            for (let i = 0; i < this.#committed; i += 1) {
+                const lines = this.#lineCache[i];
+                if (lines === null || lines === undefined) {
+                    refold[i] = true;
+                    continue;
+                }
+                const above = row >= this.#scrolledOff;
+                const fits = lines.every((l) => visibleWidth(l) <= W);
+                refold[i] = above || !fits;
+                const prev = i > 0 ? this.#lineCache[i - 1] : null;
+                row += this.#space(i, prev ?? null, lines).length;
+            }
+            for (let i = 0; i < this.#committed; i += 1) {
+                if (refold[i])
+                    this.#lineCache[i] = cellComponent(this.#cells[i]).render(W, ctx);
+            }
+            // #committedLines is re-derived over the WHOLE cache, because
+            // the frozen prefix still occupies its own rows.
             this.#committedLines = 0;
             for (let i = 0; i < this.#committed; i += 1) {
-                const cell = this.#cells[i];
-                const lines = cellComponent(cell).render(W, ctx);
-                this.#lineCache[i] = lines; // the cell's OWN rows — the cache stays raw
-                this.#committedLines += this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines).length;
+                const lines = this.#lineCache[i] ?? cellComponent(this.#cells[i]).render(W, ctx);
+                this.#lineCache[i] = lines;
+                this.#committedLines += this.#space(i, i > 0 ? (this.#lineCache[i - 1] ?? []) : null, lines).length;
             }
+            this.#refolded = refold.some(Boolean);
         }
         // 1. the natural commits — the leading DONE cells freeze: their
         //    lines leave the live region, the scrolls + the committed
@@ -2617,24 +2719,37 @@ export class Body {
             // the steady state for the session's whole life. It repairs a
             // killed predecessor straight into the same state. The visible
             // cursor comes back exactly once, in editor.exit().
-            out.push("\x1b[r\x1b[?69l\x1b[?7h\x1b[?25l");
-            // REL-0152-D20 — the mechanism is understood and the obvious fix
-            // is NOT taken here. See the finding.
+            // DC-40 — H line feeds BEFORE the reset, from wherever the shell
+            // left the cursor. The first frame is the full-redraw path and
+            // addresses rows 1..H absolutely; at launch those rows are the
+            // shell's (its prompt, the launch command, the tail of whatever
+            // ran before), and the frame painted over them — gone, not in
+            // the scrollback (REL-0152-D20 established the mechanism; 37/60
+            // shell lines survived on Apple Terminal, every line ON SCREEN
+            // lost). From cursor row r, H feeds move H−r rows and then
+            // scroll exactly r: the shell's rows 1..r enter the scrollback
+            // as CONTENT (at most one blank row — the cursor's own line),
+            // the screen is blank, and the model's assumption "row 0 is the
+            // terminal's row 1" is true by construction. The count does not
+            // depend on r, so nothing is asked of the terminal.
             //
-            // The first frame addresses rows 1..H absolutely and draws over
-            // whatever the terminal was showing. Scrolling a screenful away
-            // first would fix that, and it was built and measured: it pushes
-            // up to H BLANK rows into the scrollback, and TUI2-R2pre's
-            // blank-share gate went from 14/43 to 29/43 — past the "a
-            // healthy session's scrollback is mostly content" invariant that
-            // gate exists to hold. Trading a symptom with a five-second
-            // user-side setting for a broken invariant is a worse deal.
+            // THE ORDER IS THE FIX. `ESC[r` (DECSTBM) HOMES THE CURSOR to
+            // row 1 — VT100 semantics, honoured by Apple Terminal, xterm,
+            // xterm.js and tmux alike. Feeds emitted AFTER the reset start
+            // from row 1, move H−1 rows and scroll ONE: measured on Apple
+            // Terminal, 1/20 shell lines survived with an otherwise
+            // byte-identical frame. Feeds BEFORE the reset: 20/20. The house
+            // emulators did not model the homing and passed the wrong order;
+            // VtScrollback does now, and the DC-40 gate is red on it.
             //
-            // The correct version scrolls only as far as the terminal's
-            // content actually reaches, which needs a cursor-position query
-            // at boot — its own round, with its own risk (this file already
-            // declined a boot-time round-trip once, for racing the editor
-            // for stdin).
+            // The reset still precedes the FRAME (REL-0152-D19: a frame
+            // drawn into an inherited sub-region is the defect); only the
+            // feeds run under whatever region the shell left. A region a
+            // killed foreign program left set makes the feeds scroll that
+            // region alone and the frame paint over the rows outside it —
+            // which is what every frame did before this fix, never worse.
+            out.push("\n".repeat(H));
+            out.push("\x1b[r\x1b[?69l\x1b[?7h\x1b[?25l");
         }
         out.push("\x1b[?7l");
         // REL-0161: ?25l is the STEADY state now, not a frame bracket —
@@ -3577,7 +3692,25 @@ export class Body {
             // discarded because a reflow invalidates every row of it: the
             // next diff repaints the whole screen, which is exactly what a
             // resize needs.
-            this.#scrolledOff = Math.max(this.#scrolledOff, Math.max(0, Math.min(skip, all.length)));
+            // DC-34 — NO HIGH-WATER MARK ON A RESIZE.
+            //
+            // This was `max(#scrolledOff, …)`, which held a stale count
+            // whenever a widen made the fresh one smaller; `leaving` then
+            // stayed <= 0 and the text that marched past in the meantime
+            // never entered the scrollback at all — the hole, the other
+            // half of the same off-by-a-refold.
+            //
+            // The other implementation in this space reached the same
+            // conclusion independently and says so in its own source: a
+            // historical high-water mark "caused self-reinforcing
+            // inflation that pushed content into scrollback on terminal
+            // widen". Dropping it alone brings the DUPLICATE back — it is
+            // the pair with the no-refold rule above, not a substitute
+            // for it.
+            // PROBE 3: a widen leaves it ALONE; a narrow keeps REL-0152-R1.
+            if (this.#refolded)
+                this.#scrolledOff = Math.max(this.#scrolledOff, Math.max(0, Math.min(skip, all.length)));
+            this.#refolded = false;
             this.#screen = new Array(H).fill(NOT_PAINTED);
             this.#resizeFrame = false;
         }
@@ -3597,7 +3730,26 @@ export class Body {
         // OLDEST on screen — they are still in the model and come back on
         // the close.
         const contentRows = Math.max(0, H - CHROME_ROWS - inputExtra - queueRows.length - menuRows.length);
-        const march = all.slice(skip);
+        // DC-34 — THE MARCH NEVER REACHES BELOW THE FRONTIER.
+        //
+        // Rows [0, #scrolledOff) are in the terminal's scrollback and are
+        // immutable; painting one puts the same prose on screen twice,
+        // which is the owner's report. `skip` can drop below it whenever
+        // the model shrinks under a fixed screen — a widen refolding the
+        // cells above the frontier, or the live band collapsing — and
+        // nothing stopped it (rider 3's ungated reach-back).
+        //
+        // Clamping costs a gap under short content for one frame, which
+        // the next commit fills. Reaching back costs a duplicate that
+        // stands in the transcript forever.
+        // ...but only when the WIDTH moved. A height change re-indexes
+        // nothing — the folds are untouched, every row means what it
+        // meant — so reaching back there is the pre-existing behaviour a
+        // gate already covers (the A8 windowing case: grow the screen and
+        // the banner returns). The duplication measured in this round is
+        // width-driven, and so is the guard.
+        const march = all.slice(this.#lastW !== 0 && this.#lastW !== W ? Math.max(skip, this.#scrolledOff) : skip);
+        this.#lastW = W;
         for (const line of march.length > contentRows ? march.slice(march.length - contentRows) : march) {
             desired[r - 1] = this.#checked(line, W);
             r += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.20.2",
+	"version": "0.20.4",
 	"description": "kiso tui — the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.20.2"
+		"@vincemakes/kiso-tui-cells": "0.20.4"
 	}
 }