@gajae-code/tui 0.12.7 → 0.12.10

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [0.12.10] - 2026-08-03
+
+## [0.12.9] - 2026-08-03
+### Fixed
+
+- Corrected the off-screen transcript duplication fix released in 0.12.8, which could still render a Bash tool block twice and could stop appended rows reaching native scrollback. It keyed on whether the last committed row's bytes changed, which is neither necessary nor sufficient: a substituted status line changes that row without anything moving, and repeated or blank rows at the frontier hide a real insertion. The suffix commit now repaints the live viewport instead when two things hold together: the previously visible rows reappear almost intact at some uniform offset below their old index, and the rows that offset pulls into the top of the visible region are exactly the last rows already committed to scrollback — which is the damage itself, since those are the rows about to be emitted twice. Requiring both keeps an ordinary append committing even when repeated or blank rows make it look displaced. Rendered rows carry no identity, so no test on their bytes can prove which logical row moved; this is a policy for which failure to prefer when a frame is ambiguous, chosen to be never worse than the previous behavior and strictly better on every duplication case found.
+
+### Fixed
+
+- `Ctrl+J` now inserts a newline when multiplexers such as Herdr forward it through Kitty CSI-u or xterm `modifyOtherKeys`, matching the existing legacy line-feed behavior and displayed shortcut.
+- A terminal that disappears under a running session (tmux pane killed, SSH connection dropped, terminal window closed) no longer kills the agent process. The in-flight `stdin` read fails with `EIO`, and `process.stdin` had no `error` listener, so the event was rethrown as an uncaught exception; an `EIO` on `stdin` now retires the terminal the same way `stdout` errors already did. Only `EIO` is treated as a detach — any other `stdin` error (`EBADF`, `EPIPE`, an unexpected platform failure) keeps its default `EventEmitter` propagation and leaves the terminal usable, so the new listener cannot silently swallow unrelated stream failures.
+
+## [0.12.8] - 2026-08-02
+### Fixed
+
+- Fixed a tool block being rendered two or three times in the transcript (a pending `⏳` copy stranded above its own completed `✓` copy, with the rows between duplicated). When a block above the live viewport top grows in place — the bash tool's compact call render becoming a partial box and then a final box, with the editor/status chrome keeping it off-screen — the "commit only the changed visible suffix" path emitted rows by index even though the growth had shifted committed content down across the native-scrollback frontier, so rows already in scrollback were appended a second time under their new content. The suffix commit is now taken only when the last committed row is unchanged (a same-length off-screen substitution, such as a streaming status line); growth that shifts the committed boundary repaints the live viewport instead.
+- Temporary TUI restarts now retain their native-scrollback admission frontier when the following viewport repaint fails, preventing newly appended rows from being duplicated on retry.
+- Restored the `isProcessTerminal`/`shouldUseViewportRepaintForHost` gate on the width-change viewport-repaint intercept so plain terminals (non-multiplexer, non-process-terminal) use `fullRender` for width changes instead of an unconditional viewport repaint. The #3684 chain removed this gate, causing lossless Korean/CJK prose wrapping to break at narrow widths because the viewport repaint only painted the visible rows without committing the full transcript to scrollback (#1979).
+- Restored the `fullRender` fallback for the `firstChanged < viewportTop` branch on non-viewport-repaint hosts, so above-viewport mutations replay the full frame instead of silently viewport-repainting.
+- Propagated IME cursor write failure from `#writeRenderBufferAndReanchorImeCursor` so callers detect terminal detach when the deferred cursor write fails after the shared frame commits.
+
 ## [0.12.7] - 2026-07-31
 
 ## [0.12.6] - 2026-07-31
@@ -9,6 +30,7 @@
 
 - Truncated text now shrinks horizontal padding when the viewport is narrower than the requested inset, keeping every rendered line within its width contract.
 - Select-list no-match rows now stay within the requested render width instead of wrapping into extra terminal lines after narrow resizes (#3600).
+- Preserve transcript rows when a resize/reflow is coalesced with appended output.
 
 ## [0.12.5] - 2026-07-30
 

package/dist/types/components/editor.d.ts

@@ -54,7 +54,7 @@ export declare class Editor implements Component, Focusable {
     disableSubmit: boolean;
     constructor(theme: EditorTheme);
     dispose(): void;
-    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    setAutocompleteProvider(provider: AutocompleteProvider | undefined): void;
     getAutocompleteProvider(): AutocompleteProvider | undefined;
     /** Whether the autocomplete dropdown is currently open. */
     isAutocompleteOpen(): boolean;

package/dist/types/terminal.d.ts

@@ -77,6 +77,8 @@ export declare function resolveTerminalColumns(stream?: TerminalSizeStream, envC
 export declare function resolveTerminalRows(stream?: TerminalSizeStream, envRows?: string | undefined): number;
 export declare function __stdoutErrorSubscriberCountForTests(): number;
 export declare function __stdoutErrorDispatcherInstalledForTests(): boolean;
+export declare function __stdinErrorSubscriberCountForTests(): number;
+export declare function __stdinErrorDispatcherInstalledForTests(): boolean;
 /**
  * Real terminal using process.stdin/stdout
  */

package/dist/types/tui.d.ts

@@ -279,11 +279,6 @@ export declare class TUI extends Container {
     getShowHardwareCursor(): boolean;
     setShowHardwareCursor(enabled: boolean): void;
     getClearOnShrink(): boolean;
-    /**
-     * Set whether to trigger full re-render when content shrinks.
-     * When true (default), empty rows are cleared when content shrinks.
-     * When false, empty rows remain (reduces redraws on slower terminals).
-     */
     setClearOnShrink(enabled: boolean): void;
     setFocus(component: Component | null): void;
     /** Returns the currently focused component without exposing mutable focus state. */
@@ -306,7 +301,7 @@ export declare class TUI extends Container {
     setViewportAnchorComponent(component: Component | null): void;
     /** Returns the direct component registered as the semantic viewport anchor source. */
     getViewportAnchorComponent(): Component | null;
-    /** Clear manual viewport ownership before replacing the transcript identity namespace. */
+    /** Clear manual viewport ownership and durable history before replacing the transcript identity. */
     resetViewportAnchorIntent(): void;
     /** Allow one semantic-neighbor reconciliation after a definitive same-transcript rebuild. */
     prepareViewportAnchorForTranscriptRebuild(): void;
@@ -345,24 +340,14 @@ export declare class TUI extends Container {
     /**
      * Viewport-repaint-aware resize render request.
      *
-     * A forced full redraw (`requestRender(true)`) resets `#previousWidth`/`#previousHeight`
-     * to -1, which makes `#doRender` treat the frame as a width change and fall into the
-     * `fullRender` path. In terminal multiplexers that path skips the scrollback-clearing
-     * `3J` escape (users navigate scrollback history), so replaying every transcript line
-     * piles it back on top of scrollback — the "top of screen scrolls down to the prompt at
-     * high speed" resize storm. Windows Terminal/ConPTY can also visibly jump to
-     * the transcript top during streaming redraws, so viewport-repaint sessions
-     * keep force off and let `#doRender` repaint only the live viewport. Set
-     * `PI_TUI_LEGACY_MULTIPLEXER_FULL_RENDER=1` to restore the legacy tmux redraw.
+     * A forced repaint resets `#previousWidth`/`#previousHeight` to -1, which makes
+     * `#doRender` treat the frame as a dimension change. Repaints stay anchored to
+     * the live viewport so native scrollback is never replayed or erased.
      *
      * Spurious resize events (SIGWINCH with unchanged dimensions — iTerm2 tab
      * switches and window focus changes, the self-sent SIGWINCH after resume)
-     * must not force either: on hosts still using the `fullRender` path (legacy
-     * multiplexer opt-in, non-process terminals) the forced redraw clears
-     * scrollback (`2J`/`H`/`3J`) and replays the whole transcript, which can
-     * park the native viewport at the transcript top. Only force when the grid
-     * size actually changed since the last committed frame; a plain diff render
-     * is a no-op otherwise.
+     * must not force either: only force when the grid size actually changed since
+     * the last committed frame.
      */
     requestResizeRender(): void;
     requestRender(force?: boolean, source?: string): void;
@@ -378,10 +363,9 @@ export declare class TUI extends Container {
     /** Retry queued terminal cleanup after terminal recovery or before shutdown. */
     flushTerminalCleanup(): void;
     /**
-     * Register an emitter whose escape payload is appended to every render
-     * write (inside its own synchronized-output block, cursor saved/restored).
-     * Used for absolute-positioned overlays such as pixel-image pets that live
-     * outside the line-based component model. Return null to emit nothing.
+     * Register an emitter whose payload is delivered after each shared render
+     * transaction. The emitter is an exempt physical overlay: its bytes are
+     * deliberately kept out of the shared transcript write.
      */
     setPostRenderEmitter(emitter: (() => string | null) | undefined): void;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/tui",
-	"version": "0.12.7",
+	"version": "0.12.10",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -36,8 +36,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/natives": "0.12.7",
-		"@gajae-code/utils": "0.12.7",
+		"@gajae-code/natives": "0.12.10",
+		"@gajae-code/utils": "0.12.10",
 		"lru-cache": "11.3.6",
 		"marked": "18.0.6"
 	},

package/src/components/editor.ts

@@ -522,8 +522,13 @@ export class Editor implements Component, Focusable {
 		this.#disposeTabWidthListener = undefined;
 	}
 
-	setAutocompleteProvider(provider: AutocompleteProvider): void {
+	setAutocompleteProvider(provider: AutocompleteProvider | undefined): void {
 		this.#autocompleteProvider = provider;
+		if (provider === undefined) {
+			this.#cancelAutocomplete();
+			this.onAutocompleteUpdate?.();
+		}
+		this.invalidate();
 	}
 
 	getAutocompleteProvider(): AutocompleteProvider | undefined {
@@ -1361,6 +1366,7 @@ export class Editor implements Component, Focusable {
 		}
 		// New line
 		else if (
+			matchesKey(data, "ctrl+j") || // Ctrl+J (Kitty/modifyOtherKeys)
 			(data.charCodeAt(0) === 10 && data.length > 1) || // Ctrl+Enter with modifiers
 			matchesKey(data, "ctrl+enter") || // Ctrl+Enter (Kitty/modifyOtherKeys, including lock bits/keypad Enter)
 			matchesKey(data, "ctrl+shift+enter") || // Ctrl+Shift+Enter (Kitty/modifyOtherKeys combined modifier)

package/src/terminal.ts

@@ -224,6 +224,46 @@ function unsubscribeFromStdoutErrors(subscriber: (err: Error) => void): void {
 	if (stdoutErrorSubscribers.size === 0) process.stdout.removeListener("error", dispatchStdoutError);
 }
 
+const STDIN_ERROR_HANDLER_GRACE_MS = 250;
+const stdinErrorSubscribers = new Set<(err: Error) => void>();
+export function __stdinErrorSubscriberCountForTests(): number {
+	return stdinErrorSubscribers.size;
+}
+export function __stdinErrorDispatcherInstalledForTests(): boolean {
+	return process.stdin.listeners("error").includes(dispatchStdinError);
+}
+/**
+ * A vanished controlling terminal fails the in-flight stdin read with EIO.
+ * That is the only stdin error this module owns; every other failure
+ * (EBADF, EPIPE, an unexpected platform error) keeps its default
+ * EventEmitter propagation so it stays observable instead of being
+ * downgraded to a silently retired terminal.
+ */
+function isTerminalDetachStdinError(err: Error): boolean {
+	return (err as NodeJS.ErrnoException).code === "EIO";
+}
+const dispatchStdinError = (err: Error): void => {
+	if (!isTerminalDetachStdinError(err)) {
+		// Our listener must not be the reason a non-EIO error stops propagating.
+		// When no other "error" listener exists, EventEmitter would have thrown;
+		// rethrowing from inside emit() reproduces that exact contract.
+		const hasOtherListener = process.stdin.listeners("error").some(listener => listener !== dispatchStdinError);
+		if (!hasOtherListener) throw err;
+		return;
+	}
+	for (const subscriber of stdinErrorSubscribers) subscriber(err);
+};
+
+function subscribeToStdinErrors(subscriber: (err: Error) => void): void {
+	if (stdinErrorSubscribers.size === 0) process.stdin.on("error", dispatchStdinError);
+	stdinErrorSubscribers.add(subscriber);
+}
+
+function unsubscribeFromStdinErrors(subscriber: (err: Error) => void): void {
+	stdinErrorSubscribers.delete(subscriber);
+	if (stdinErrorSubscribers.size === 0) process.stdin.removeListener("error", dispatchStdinError);
+}
+
 /**
  * Real terminal using process.stdin/stdout
  */
@@ -242,6 +282,8 @@ export class ProcessTerminal implements Terminal {
 	#windowsVTInputRestore?: () => void;
 	#stdoutErrorHandler?: (err: Error) => void;
 	#stdoutErrorHandlerCleanupTimer?: Timer;
+	#stdinErrorHandler?: (err: Error) => void;
+	#stdinErrorHandlerCleanupTimer?: Timer;
 	#appearanceCallbacks: Array<(appearance: TerminalAppearance) => void> = [];
 	#appearance: TerminalAppearance | undefined;
 	#osc11Pending = false;
@@ -330,6 +372,21 @@ export class ProcessTerminal implements Terminal {
 			};
 			subscribeToStdoutErrors(this.#stdoutErrorHandler);
 		}
+		// stdin carries the same hazard as stdout: when the controlling PTY
+		// disappears (tmux pane killed, SSH dropped, terminal closed) the next
+		// read fails with EIO. `process.stdin` is an EventEmitter, so an
+		// unobserved "error" event is rethrown as an uncaught exception that
+		// kills the whole agent process instead of just retiring the terminal.
+		if (this.#stdinErrorHandlerCleanupTimer) {
+			clearTimeout(this.#stdinErrorHandlerCleanupTimer);
+			this.#stdinErrorHandlerCleanupTimer = undefined;
+		}
+		if (!this.#stdinErrorHandler) {
+			this.#stdinErrorHandler = (err: Error) => {
+				this.#markUnavailable(err, "stdin-error");
+			};
+			subscribeToStdinErrors(this.#stdinErrorHandler);
+		}
 
 		// Refresh terminal dimensions - they may be stale after suspend/resume
 		// (SIGWINCH is lost while process is stopped). Unix only.
@@ -860,6 +917,7 @@ export class ProcessTerminal implements Terminal {
 			this.#resizeHandler = undefined;
 		}
 		this.#scheduleStdoutErrorHandlerCleanup();
+		this.#scheduleStdinErrorHandlerCleanup();
 
 		// Pause stdin to prevent any buffered input (e.g., Ctrl+D) from being
 		// re-interpreted after raw mode is disabled. This fixes a race condition
@@ -889,6 +947,22 @@ export class ProcessTerminal implements Terminal {
 		this.#stdoutErrorHandlerCleanupTimer.unref?.();
 	}
 
+	#scheduleStdinErrorHandlerCleanup(): void {
+		if (!this.#stdinErrorHandler) return;
+		if (this.#stdinErrorHandlerCleanupTimer) clearTimeout(this.#stdinErrorHandlerCleanupTimer);
+		// stdin.pause() below does not cancel a read already in flight, so a PTY
+		// that vanishes during teardown still delivers EIO after stop() returns.
+		// Keep the listener armed for the same grace window as stdout.
+		this.#stdinErrorHandlerCleanupTimer = setTimeout(() => {
+			if (this.#stdinErrorHandler) {
+				unsubscribeFromStdinErrors(this.#stdinErrorHandler);
+				this.#stdinErrorHandler = undefined;
+			}
+			this.#stdinErrorHandlerCleanupTimer = undefined;
+		}, STDIN_ERROR_HANDLER_GRACE_MS);
+		this.#stdinErrorHandlerCleanupTimer.unref?.();
+	}
+
 	write(data: string): void {
 		this.#safeWrite(data);
 		if (this.#writeLogPath) {