@vincemakes/kiso-tui 0.24.4 → 0.25.0

package/dist/compositor.d.ts

@@ -227,31 +227,6 @@ export declare class Body {
      *  there is no pointer, so there is nothing a pointer could reach
      *  that a keyboard cannot. */
     viewerKey(cmd: "up" | "down" | "toggle" | "all" | "pageUp" | "pageDown" | "home" | "end"): void;
-    /**
-     * DC-35 — ctrl+o does not print the same expansion twice in a row.
-     *
-     * The ring walks newest-back and restarts its cycle once every entry
-     * has been opened (R4/C1, which is what makes the walk immune to the
-     * ring growing underneath it). With a ring of ONE the restart is
-     * immediate, so holding the key appended the identical block over
-     * and over — the owner got three copies of the same four rows, each
-     * closing with `ctrl+o opens the one before it`, a footer naming
-     * something that does not exist.
-     *
-     * The bar is the BOTTOM of the transcript, not "ever shown": once
-     * other content has arrived the expansion has scrolled up and
-     * re-opening it is the point of the key, so the guard clears itself
-     * the moment a cell is added.
-     */
-    expandNext(): {
-        kind: "toggled";
-    } | {
-        kind: "appended";
-        lines: string[];
-    } | {
-        kind: "none";
-        why?: "already-last";
-    };
     /** Docked = the chrome is live (a color TTY with a real size). */
     get active(): boolean;
     enter(): void;
@@ -313,6 +288,24 @@ export declare class Body {
      * repaint, once per session.
      */
     onGroundChange(): void;
+    /**
+     * DC-50 — ctrl+o flips ONE switch, and every settled card obeys it.
+     *
+     * The walk this replaces existed because ADR-0046 §3 forbade
+     * re-rendering a committed card, so the only way to show one's body
+     * was to APPEND a copy further down — with a ring to decide which
+     * card was next, `#opened` to keep the ring from repeating, and
+     * `#lastAppend` to stop a held key printing the same rows three times
+     * (DC-35). Amendment 1 removes the premise: the scrollback is ours to
+     * erase, so a card can simply be re-rendered where it stands.
+     *
+     * A RUNNING card is exempt. Its height is E2/DC-43's — it grows from
+     * its own content — and a global "show everything" has no business
+     * reaching into a card whose content is still arriving.
+     */
+    toggleExpanded(): void;
+    /** DC-50 — the switch itself, for the CLI's affordance text. */
+    expandedAll(): boolean;
     /** W18: the status row's right-aligned hint is part of the status
      *  state — the compacting row passes "esc to cancel" (the affordance
      *  must survive repaints). */

package/dist/compositor.js

@@ -52,7 +52,7 @@ 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.
 import { sessionPickerRows } from "./session-picker.js";
-import { CAP_PREVIEW, thinkingRow, expandedCard, Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, foldCountsObjects, foldTerms, focusToken, foldLine, gutterCut, cutLine, isExploreTool, moreRunningRow, pendingQueueRows, slotPad, slotTail, statusLine, visibleWidth, breathFrame, } from "./components.js";
+import { CAP_PREVIEW, thinkingRow, Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, foldCountsObjects, foldTerms, focusToken, foldLine, gutterCut, cutLine, isExploreTool, moreRunningRow, pendingQueueRows, slotPad, slotTail, statusLine, visibleWidth, breathFrame, } from "./components.js";
 import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, toolTarget } from "./render.js";
 import { displayVerb, keysSheetRows } from "./strings.js";
 // R5 — the transcript viewer's PURE projection. The compositor supplies
@@ -212,6 +212,30 @@ export class Body {
     /** 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;
+    /** R14 — the geometry the last SETTLE ran at. A winch back to the
+     *  same size is not a resize and must not erase the scrollback. */
+    /** R14 — the geometry the last frame PAINTED, and the snapshot of it
+     *  taken when a winch opens a settle window.
+     *
+     *  Three versions of this question were wrong before this one.
+     *  Seeding in `enter()` never ran under the unit pool (it bails on a
+     *  non-TTY), so a same-size winch erased the scrollback. Comparing
+     *  against the CURRENT frame's geometry let an ordinary frame render
+     *  at the new size between the winch and the settle and eat the
+     *  change, so a real resize silently stopped reprinting. Seeding once
+     *  on the first frame had the same hole whenever the first frame had
+     *  not run yet.
+     *
+     *  The question the settle actually asks is "is the terminal holding
+     *  a rendering made at a DIFFERENT geometry than the one we have
+     *  now" — so the comparison is against what was on screen when the
+     *  winch arrived, snapshotted then, once per storm. */
+    #paintedW = 0;
+    #paintedH = 0;
+    #winchFromW = 0;
+    #winchFromH = 0;
+    /** DC-50 — the ONE expansion switch ctrl+o flips. */
+    #expandedAll = false;
     // 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
@@ -237,18 +261,12 @@ export class Body {
     #mdBase = 0;
     #toolCells = new Map(); // callId → cell index (parallel tools)
     // W15: the collapsed (cut) tool cells — committed cells whose last
-    // rendered row carried the "ctrl+o" affordance; the expand key's
-    // cycling pointer walks this list from the newest back.
+    // rendered row carried the "ctrl+o" affordance.
+    //
+    // DC-50 / R14: the expand key no longer WALKS this. It is the
+    // VIEWER's index now (ctrl+r, `#viewerEntries`) — the two surfaces
+    // coexist and §9 says so. It is kept, not retired, for that reader.
     #collapsed = [];
-    /** R4 (C1) — the ring walk is by IDENTITY, not by a modular pointer.
-     *  `#collapsed` is unshifted on every commit that carries the key, so
-     *  a numeric pointer's target silently CHANGED whenever a new fold
-     *  landed mid-cycle: the ring was not stable under itself, and the
-     *  next press opened something other than what the last press
-     *  implied. This set records what the current cycle has already
-     *  opened; the walk takes the newest entry not in it, and empties it
-     *  when every entry has been seen. */
-    #opened = new Set();
     // W14: the turn records — one per userLine, the fold-hold's state
     // machine (ended / hasText / folded) plus the folded-turn line's
     // counts (accumulated at toolStart). The cells carry the record's
@@ -1167,112 +1185,32 @@ export class Body {
             cutLine(`${p.dim} ${viewerHint(this.#viewer, entries)}${p.reset}`, W),
         ];
     }
-    /** DC-35 — the last block this key appended, and the cell count when
-     *  it did. An expansion earns its rows by showing something the
-     *  transcript does not already END with. */
-    #lastAppend = null;
-    /**
-     * DC-35 — ctrl+o does not print the same expansion twice in a row.
-     *
-     * The ring walks newest-back and restarts its cycle once every entry
-     * has been opened (R4/C1, which is what makes the walk immune to the
-     * ring growing underneath it). With a ring of ONE the restart is
-     * immediate, so holding the key appended the identical block over
-     * and over — the owner got three copies of the same four rows, each
-     * closing with `ctrl+o opens the one before it`, a footer naming
-     * something that does not exist.
-     *
-     * The bar is the BOTTOM of the transcript, not "ever shown": once
-     * other content has arrived the expansion has scrolled up and
-     * re-opening it is the point of the key, so the guard clears itself
-     * the moment a cell is added.
+    /*
+     * RETIRED (DC-50 / R14, 2026-09-05) — `expandNext`, `#expandNextRaw`,
+     * `#lastAppend`, and the `#opened` bookkeeping that went with them.
+     *
+     * The whole apparatus served ONE constraint: ADR-0046 §3 forbade
+     * re-rendering a committed card, so the only way to show one's body
+     * was to APPEND a copy further down the transcript. That needed a ring
+     * to choose which card came next, a set to stop the ring repeating
+     * itself, and DC-35's guard to stop a HELD key printing the same four
+     * rows three times — a defect the owner met in the field, each copy
+     * closing with a footer that named something which did not exist.
+     *
+     * Amendment 1 removes the constraint. The terminal's scrollback is
+     * ours to erase, so a committed card is re-rendered where it stands:
+     * nothing to append, nothing to choose between, no repeat to guard.
+     * `toggleExpanded` is the whole of the feature now.
+     *
+     * `#collapsed` STAYS — the viewer (ctrl+r) reads it as its index of
+     * expandable cells, and §9 keeps the two surfaces side by side.
+     *
+     * `expandedCard` does NOT stay, and an earlier draft of this note said
+     * it did. An expanded card is drawn by the ORDINARY card renderer with
+     * `expanded` set — full body, `ctrl+o collapses` in place of the cut
+     * note — which `r14-global-expand` pins. `expandedCard` was the shape
+     * of the APPENDED block and has no caller once the append is gone.
      */
-    expandNext() {
-        const out = this.#expandNextRaw();
-        if (out.kind !== "appended")
-            return out;
-        const lines = out.lines.join("\n");
-        if (this.#lastAppend !== null && this.#lastAppend.lines === lines && this.#lastAppend.atCells === this.#cells.length) {
-            // NOT the same answer as "nothing is folded". The caller says
-            // which, because a reader who pressed the key deserves to know
-            // whether there is nothing to open or whether they are already
-            // looking at it.
-            return { kind: "none", why: "already-last" };
-        }
-        this.#lastAppend = { lines, atCells: this.#cells.length };
-        return out;
-    }
-    #expandNextRaw() {
-        for (let i = this.#cells.length - 1; i >= this.#committed; i -= 1) {
-            const cell = this.#cells[i];
-            if (cell.kind === "tool" && cell.state !== "pending") {
-                cell.expanded = !cell.expanded;
-                this.#mark();
-                return { kind: "toggled" };
-            }
-            // W20: the LIVE task block toggles in place too — the capped
-            // form flips to the full list (the "done-collapse expands
-            // under ctrl+o" claim). The SETTLED block is already full —
-            // no toggle, and its rows carry no affordance, so it never
-            // joins #collapsed (the committed /last append is moot).
-            if (cell.kind === "checklist" && !cell.done) {
-                cell.expanded = !cell.expanded;
-                this.#mark();
-                return { kind: "toggled" };
-            }
-        }
-        if (this.#collapsed.length === 0)
-            return { kind: "none" };
-        // R4 (C1) — the newest entry this cycle has not opened yet. When
-        // every entry has been seen the cycle restarts, so the walk is
-        // still "newest back" — it is simply immune to the ring growing
-        // underneath it.
-        if (this.#collapsed.every((i) => this.#opened.has(i)))
-            this.#opened.clear();
-        const idx = this.#collapsed.find((i) => !this.#opened.has(i)) ?? this.#collapsed[0];
-        this.#opened.add(idx);
-        const cell = this.#cells[idx];
-        // R3b — a folded SEGMENT expands to the work it stands for.
-        //
-        // The fold line collapses a run of thinking and tool cells into
-        // one row; without this the run would be unreachable, which is
-        // hiding a durable record behind a summary. The rows are APPENDED
-        // (ADR-0046 — history is never rewritten), exactly as every other
-        // expand in this method does, and they are the cells' OWN renders,
-        // so the expansion cannot drift from what was folded.
-        // R13 — expandNext's FOLD branch retired with the segment fold.
-        // A fold line collapsed a run of cells into one row, so the key had
-        // to be able to open the run; with every call standing as its own
-        // card there is nothing collapsed for it to open, and `#collapsed`
-        // now holds cards alone.
-        if (cell.kind !== "tool")
-            return { kind: "none" };
-        // R13 — and the ROLLUP branch retired with `rolled`.
-        let input = {};
-        try {
-            input = JSON.parse(cell.inputFull);
-        }
-        catch {
-            // the full JSON is always parseable (it was stringified at
-            // toolStart) — the empty fallback never fires
-        }
-        const turnsBack = this.#cells.slice(idx + 1).filter((c) => c.kind === "user").length;
-        const p = palette();
-        // 0.24.2 ③ — the expansion is a CARD, and `✦` is not its mark: that
-        // glyph is the turn recap's, and one symbol with two meanings is
-        // §4.1. The head row names the call, which is the tie to it that
-        // the mark's sentence used to be.
-        const verb = displayVerb(cell.name);
-        const elapsed = cell.startedAt !== null && cell.doneAt !== null ? ((cell.doneAt - cell.startedAt) / 1000).toFixed(1) : "?";
-        const n = cell.resultText === "" ? 0 : cell.resultText.split("\n").length;
-        return {
-            kind: "appended",
-            lines: expandedCard(verb, toolTarget(cell.name, input), `expanded · ${turnsBack} ${turnsBack === 1 ? "turn" : "turns"} back`, 
-            // TUI2-R2pre ④: the SECTION HEADERS say the act; the payloads
-            // below them (inputFull, resultText) are RAW and byte-identical.
-            [`--- ${verb} input ---`, cell.inputFull, `--- ${verb} output${cell.isError ? " (error)" : ""} ---`, cell.resultText], [cell.isError ? "failed" : "exit 0", `${n} line${n === 1 ? "" : "s"}`, `${elapsed}s`].filter((x) => x !== "").join(" · "), this.#opts.width()),
-        };
-    }
     // ---- the Dock façade (the CLI's chrome API — same shape as the old dock) ----
     /** Docked = the chrome is live (a color TTY with a real size). */
     get active() {
@@ -1506,6 +1444,14 @@ export class Body {
     onResize() {
         if (!this.#isActive())
             return;
+        // R14 — the FIRST winch of a storm snapshots what the terminal is
+        // currently holding. A drag fires many winches; the settle must
+        // compare its end against the storm's beginning, not against the
+        // previous winch.
+        if (!this.#resizePending) {
+            this.#winchFromW = this.#paintedW;
+            this.#winchFromH = this.#paintedH;
+        }
         this.#resizePending = true;
         if (this.#resizeTimer !== null)
             clearTimeout(this.#resizeTimer);
@@ -1533,20 +1479,128 @@ export class Body {
         this.#screen = [];
         this.onResize();
     }
-    /** The one repaint a drag earns, once its signals have stopped. */
+    /**
+     * R14 / route B — THE ONE REPAINT A DRAG EARNS IS A REPRINT.
+     *
+     * It used to be `ESC[from;1H ESC[0J` — erase from the recorded live
+     * top down, then redraw the live area, leaving the committed rows
+     * above to whatever the terminal's own reflow had made of them. That
+     * is the shape R10 measured on the owner's real terminal, and it
+     * lost: a grow dropped 16 rows of history (DC-39), a narrow
+     * duplicated four tokens, and the scrolled-off transcript never
+     * reflowed at all. All three are one fault — kiso doing window
+     * arithmetic over rows the terminal had already reflowed underneath
+     * it, with `#scrolledOff` carried across a fold change that makes
+     * every index mean something else.
+     *
+     * So it stops arguing. `2J H 3J` — erase screen, home, erase
+     * scrollback, in THAT order because on Apple Terminal a bare `2J`
+     * scrolls the screen into history and only the following `3J` makes
+     * the state clean — and then the whole committed transcript is
+     * reprinted at the new geometry through the path a fresh terminal
+     * already uses. The terminal ends holding exactly one rendering.
+     *
+     * The declared cost (ADR-0046 Amendment 1): everything the terminal
+     * held before kiso started is erased at the first resize. Measured
+     * on the reference implementation as 0/60 in every direction — this
+     * is the behaviour being adopted, not a regression. kiso's own
+     * record is untouched: the session log holds it, `--resume` replays
+     * it, and G4' asserts the 0/60 so the cost cannot drift silently.
+     *
+     * D-B2: EVERY settled resize reprints, height-only included. A
+     * SIGWINCH at the same geometry emits nothing at all.
+     */
     #settleResize() {
         if (!this.#resizePending || !this.#isActive())
             return;
         this.#resizePending = false;
         const H = this.#opts.height();
-        const liveRows = this.#lastLiveRows > 0 ? this.#lastLiveRows : 3;
-        const from = Math.max(1, (this.#lastH > 0 ? this.#lastH : H) - liveRows + 1);
-        this.#write(`\x1b[${Math.min(from, Math.max(1, H))};1H\x1b[0J`);
+        const W = this.#opts.width();
+        // D-B2's other half: a winch that did not change the geometry is
+        // not a resize. Emitting the erase for it would throw away the
+        // terminal's scrollback for nothing (the V6-1 idempotence case).
+        if (this.#winchFromW === W && this.#winchFromH === H)
+            return;
+        // §9.2 — the viewer is closed first. Nothing commits while it is
+        // up and a reprint is a commit storm; the user reopens it. One
+        // keypress, stated rather than hidden.
+        if (this.#viewer !== null) {
+            this.#viewer = null;
+            this.#viewerWasUp = true;
+        }
+        this.#reprint();
+    }
+    /**
+     * R14 — ERASE THE TERMINAL AND PRINT THE SESSION AGAIN.
+     *
+     * Two callers: a settled resize, and DC-50's ctrl+o. They are the
+     * same act — the rendering the terminal holds is wrong (wrong
+     * geometry, or wrong expansion state) and the model is the only
+     * authority on what it should be — so they share the path rather
+     * than growing two.
+     */
+    #reprint() {
+        const H = this.#opts.height();
+        this.#write("\x1b[2J\x1b[H\x1b[3J");
+        // The terminal now holds nothing, so every record of what it held
+        // is void. `#scrolledOff` is the frontier of what reached its
+        // scrollback: after the erase, that is zero — which is also what
+        // releases the committed cells to be refolded at the new width
+        // without contradicting anything, the thing DC-34's frontier rule
+        // existed to prevent.
+        this.#scrolledOff = 0;
+        for (let i = 0; i < this.#committed; i += 1)
+            this.#lineCache[i] = null;
+        this.#screen = new Array(Math.max(1, H)).fill(NOT_PAINTED);
+        this.#cursorRow = 1;
         this.#fullRedraw = true;
         this.#resizeFrame = true;
         this.#dirty = true;
         this.render();
     }
+    /**
+     * DC-50 — ctrl+o flips ONE switch, and every settled card obeys it.
+     *
+     * The walk this replaces existed because ADR-0046 §3 forbade
+     * re-rendering a committed card, so the only way to show one's body
+     * was to APPEND a copy further down — with a ring to decide which
+     * card was next, `#opened` to keep the ring from repeating, and
+     * `#lastAppend` to stop a held key printing the same rows three times
+     * (DC-35). Amendment 1 removes the premise: the scrollback is ours to
+     * erase, so a card can simply be re-rendered where it stands.
+     *
+     * A RUNNING card is exempt. Its height is E2/DC-43's — it grows from
+     * its own content — and a global "show everything" has no business
+     * reaching into a card whose content is still arriving.
+     */
+    toggleExpanded() {
+        this.#expandedAll = !this.#expandedAll;
+        for (const cell of this.#cells) {
+            // SETTLED CONTENT, not "done". A card parked for approval is
+            // `state: "approval"`, `done: false` — and its content is not
+            // still arriving: the diff is complete and the card is waiting
+            // for a human to read it and decide. The mechanism this
+            // replaces toggled it (any state but "pending"), and the
+            // dispatch comment said why: "the approval pause is exactly
+            // when the user reads a cut diff, and the key must answer then,
+            // never after the run." A `done`-only switch answers with
+            // nothing at the one moment the answer matters most.
+            //
+            // The exemption is for the card still GROWING — E2 and DC-43
+            // own its height, and a global "show everything" has no
+            // business reaching into content that is still arriving. That
+            // is the ruling's reason; `done` alone was its wording.
+            if (cell.kind !== "tool")
+                continue;
+            if (cell.done || cell.state === "approval")
+                cell.expanded = this.#expandedAll;
+        }
+        this.#reprint();
+    }
+    /** DC-50 — the switch itself, for the CLI's affordance text. */
+    expandedAll() {
+        return this.#expandedAll;
+    }
     /** W18: the status row's right-aligned hint is part of the status
      *  state — the compacting row passes "esc to cancel" (the affordance
      *  must survive repaints). */
@@ -1949,6 +2003,10 @@ export class Body {
         if (H < 4)
             return;
         this.#lastH = H;
+        // R14 — the geometry THIS frame painted. `onResize` snapshots it
+        // at the moment the winch arrives; see `#winchFromW`.
+        this.#paintedW = W;
+        this.#paintedH = H;
         const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: H };
         // V6-1 (the screen-state == frame-state rule): the resize's first
         // frame — the terminal's reflow re-wrapped the committed content at
@@ -2384,11 +2442,9 @@ export class Body {
         const hidesRows = cell.kind === "tool" && lines.some((l) => l.includes("ctrl+o"));
         if (isFoldHead || hidesRows) {
             this.#collapsed.unshift(i);
-            // R4a — a new fold resets the walk, so the FIRST press after any
-            // new work always opens the most recent one. That is the whole
-            // of the owner's "which one does it open": the answer is always
-            // "the last one", and repeats walk back from there.
-            this.#opened.clear();
+            // R4a's walk reset retired with the walk (DC-50): there is no
+            // "which one does it open" any more — one press opens all of
+            // them.
         }
         this.#lineCache[i] = lines;
         const placed = this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines);
@@ -2944,38 +3000,31 @@ export class Body {
         // sit with the live band empty and the chrome at its minimum — the
         // one-way part of a movement that otherwise goes both ways.
         if (this.#resizeFrame) {
-            // REL-0152-R1: a resize scrolls NOTHING of ours. Shrinking the
-            // window is the terminal's own scroll — it reflows the old
-            // content and pushes the overflow into its scrollback before we
-            // are called — so emitting our own LFs on top put the same rows
-            // in twice (TT-1B: twelve rows of a forty-line burst). The
-            // counter adopts the terminal's work, and the held screen is
-            // discarded because a reflow invalidates every row of it: the
-            // next diff repaints the whole screen, which is exactly what a
-            // resize needs.
-            // DC-34 — NO HIGH-WATER MARK ON A RESIZE.
+            // R14 / route B — THE RESIZE FRAME SCROLLS LIKE ANY OTHER.
             //
-            // 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.
+            // Everything this branch used to hold is retired with the
+            // window arithmetic it served. It adopted the terminal's own
+            // reflow-scroll into `#scrolledOff` (REL-0152-R1), then had to
+            // stop adopting it on a widen and keep adopting it on a narrow
+            // (DC-34), because the counter it was feeding meant a different
+            // thing at every fold width. There is no such counter to feed
+            // now: `#settleResize` erased the terminal and set
+            // `#scrolledOff` to zero, so the frontier is real and empty and
+            // the frame simply reprints from the top.
             //
-            // 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)));
+            // Falling through to `#emitScroll` is not a convenience — it is
+            // the whole point. The transcript above the last screenful has
+            // to reach the scrollback, chunked and staged from the model,
+            // exactly as a resumed session's replay does. Without it the
+            // reprint painted the last screenful onto a terminal whose
+            // history it had just erased, and everything above was simply
+            // GONE: `dc34-widen-seam` measured 36 tokens missing from the
+            // scrollback the first time this branch was left in place.
             this.#refolded = false;
             this.#screen = new Array(H).fill(NOT_PAINTED);
             this.#resizeFrame = false;
         }
-        else if (!overlay) {
+        if (!overlay) {
             // DC-46 — THE ROWS THAT LEAVE THE WINDOW SCROLL, and the target
             // is `skip` itself.
             //

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.24.4",
+	"version": "0.25.0",
 	"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.24.4"
+		"@vincemakes/kiso-tui-cells": "0.25.0"
 	}
 }