@elench/testkit 0.1.113 → 0.1.115

package/node_modules/ink/build/ink.js

@@ -9,11 +9,11 @@ import patchConsole from 'patch-console';
 import { LegacyRoot, ConcurrentRoot } from 'react-reconciler/constants.js';
 import Yoga from 'yoga-layout';
 import wrapAnsi from 'wrap-ansi';
-import { getWindowSize } from './utils.js';
+import terminalSize from 'terminal-size';
+import { isDev } from './utils.js';
 import reconciler from './reconciler.js';
 import render from './renderer.js';
 import * as dom from './dom.js';
-import { hideCursorEscape, showCursorEscape } from './cursor-helpers.js';
 import logUpdate from './log-update.js';
 import { bsu, esu, shouldSynchronize } from './write-synchronized.js';
 import instances from './instances.js';
@@ -21,10 +21,6 @@ import App from './components/App.js';
 import { accessibilityContext as AccessibilityContext } from './components/AccessibilityContext.js';
 import { resolveFlags, } from './kitty-keyboard.js';
 const noop = () => { };
-const textEncoder = new TextEncoder();
-const yieldImmediate = async () => new Promise(resolve => {
-    setImmediate(resolve);
-});
 const kittyQueryEscapeByte = 0x1b;
 const kittyQueryOpenBracketByte = 0x5b;
 const kittyQueryQuestionMarkByte = 0x3f;
@@ -80,51 +76,10 @@ const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
     }
     return keptBytes;
 };
-const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting, }) => {
-    if (!isTty) {
-        return false;
-    }
-    const hadPreviousFrame = previousOutputHeight > 0;
-    const wasFullscreen = previousOutputHeight >= viewportRows;
-    const wasOverflowing = previousOutputHeight > viewportRows;
-    const isOverflowing = nextOutputHeight > viewportRows;
-    const isLeavingFullscreen = wasFullscreen && nextOutputHeight < viewportRows;
-    const shouldClearOnUnmount = isUnmounting && wasFullscreen;
-    return (
-    // Overflowing frames still need full clear fallback.
-    wasOverflowing ||
-        (isOverflowing && hadPreviousFrame) ||
-        // Clear when shrinking from fullscreen to non-fullscreen output.
-        isLeavingFullscreen ||
-        // Preserve legacy unmount behavior for fullscreen frames: final teardown
-        // render should clear once to avoid leaving a scrolled viewport state.
-        shouldClearOnUnmount);
-};
 const isErrorInput = (value) => {
     return (value instanceof Error ||
         Object.prototype.toString.call(value) === '[object Error]');
 };
-const getWritableStreamState = (stdout) => {
-    const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true);
-    const hasWritableState = stdout._writableState !== undefined || stdout.writableLength !== undefined;
-    return {
-        canWriteToStdout,
-        hasWritableState,
-    };
-};
-const settleThrottle = (throttled, canWriteToStdout) => {
-    if (!throttled ||
-        typeof throttled.flush !== 'function') {
-        return;
-    }
-    const throttledValue = throttled;
-    if (canWriteToStdout) {
-        throttledValue.flush();
-    }
-    else if (typeof throttledValue.cancel === 'function') {
-        throttledValue.cancel();
-    }
-};
 export default class Ink {
     /**
     Whether this instance is using concurrent rendering mode.
@@ -135,9 +90,6 @@ export default class Ink {
     cursorPosition;
     throttledLog;
     isScreenReaderEnabled;
-    interactive;
-    renderThrottleMs;
-    alternateScreen;
     // Ignore last render after unmounting a tree to prevent empty output before exit
     isUnmounted;
     isUnmounting;
@@ -159,7 +111,6 @@ export default class Ink {
     hasPendingThrottledRender = false;
     kittyProtocolEnabled = false;
     cancelKittyDetection;
-    nextRenderCommit;
     constructor(options) {
         autoBind(this);
         this.options = options;
@@ -168,18 +119,9 @@ export default class Ink {
         this.isScreenReaderEnabled =
             options.isScreenReaderEnabled ??
                 process.env['INK_SCREEN_READER'] === 'true';
-        // CI detection takes precedence: even a TTY stdout in CI defaults to non-interactive.
-        // Using Boolean(isTTY) (rather than an 'in' guard) correctly handles piped streams
-        // where the property is absent (e.g. `node app.js | cat`).
-        this.interactive = this.resolveInteractiveOption(options.interactive);
-        this.alternateScreen = false;
         const unthrottled = options.debug || this.isScreenReaderEnabled;
         const maxFps = options.maxFps ?? 30;
-        // Treat non-positive maxFps as an internal fallback case, not a supported
-        // "disable throttling" mode. Keep animation scheduling on a normal cadence
-        // so future changes don't accidentally reintroduce zero-delay loops.
         const renderThrottleMs = maxFps > 0 ? Math.max(1, Math.ceil(1000 / maxFps)) : 0;
-        this.renderThrottleMs = unthrottled ? 0 : renderThrottleMs;
         if (unthrottled) {
             this.rootNode.onRender = this.onRender;
             this.throttledOnRender = undefined;
@@ -204,7 +146,7 @@ export default class Ink {
             ? this.log
             : throttle((output) => {
                 const shouldWrite = this.log.willRender(output);
-                const sync = this.shouldSync();
+                const sync = shouldSynchronize(this.options.stdout);
                 if (sync && shouldWrite) {
                     this.options.stdout.write(bsu);
                 }
@@ -225,7 +167,7 @@ export default class Ink {
         this.lastOutput = '';
         this.lastOutputToRender = '';
         this.lastOutputHeight = 0;
-        this.lastTerminalWidth = getWindowSize(this.options.stdout).columns;
+        this.lastTerminalWidth = this.getTerminalWidth();
         // This variable is used only in debug mode to store full static output
         // so that it's rerendered every time, not just new static parts, like in non-debug mode
         this.fullStaticOutput = '';
@@ -235,31 +177,32 @@ export default class Ink {
         this.container = reconciler.createContainer(this.rootNode, rootTag, null, false, null, 'id', () => { }, () => { }, () => { }, () => { });
         // Unmount when process exits
         this.unsubscribeExit = signalExit(this.unmount, { alwaysLast: false });
-        this.setAlternateScreen(Boolean(options.alternateScreen));
-        if (process.env['DEV'] === 'true') {
+        if (isDev()) {
             // @ts-expect-error outdated types
             reconciler.injectIntoDevTools();
         }
         if (options.patchConsole) {
             this.patchConsole();
         }
-        if (this.interactive) {
+        if (!isInCi) {
             options.stdout.on('resize', this.resized);
             this.unsubscribeResize = () => {
                 options.stdout.off('resize', this.resized);
             };
         }
         this.initKittyKeyboard();
-        this.exitPromise = new Promise((resolve, reject) => {
-            this.resolveExitPromise = resolve;
-            this.rejectExitPromise = reject;
-        });
-        // Prevent global unhandled-rejection crashes when app code exits with an
-        // error but consumers never call waitUntilExit().
-        void this.exitPromise.catch(noop);
     }
+    getTerminalWidth = () => {
+        // The 'columns' property can be undefined or 0 when not using a TTY.
+        // Use terminal-size as a fallback for piped processes, then default to 80.
+        if (this.options.stdout.columns) {
+            return this.options.stdout.columns;
+        }
+        const size = terminalSize();
+        return size?.columns ?? 80;
+    };
     resized = () => {
-        const currentWidth = getWindowSize(this.options.stdout).columns;
+        const currentWidth = this.getTerminalWidth();
         if (currentWidth < this.lastTerminalWidth) {
             // We clear the screen when decreasing terminal width to prevent duplicate overlapping re-renders.
             this.log.clear();
@@ -289,16 +232,13 @@ export default class Ink {
         this.log.setCursorPosition(position);
     };
     restoreLastOutput = () => {
-        if (!this.interactive) {
-            return;
-        }
         // Clear() resets log-update's cursor state, so replay the latest cursor intent
         // before restoring output after external stdout/stderr writes.
         this.log.setCursorPosition(this.cursorPosition);
         this.log(this.lastOutputToRender || this.lastOutput + '\n');
     };
     calculateLayout = () => {
-        const terminalWidth = getWindowSize(this.options.stdout).columns;
+        const terminalWidth = this.getTerminalWidth();
         this.rootNode.yogaNode.setWidth(terminalWidth);
         this.rootNode.yogaNode.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
     };
@@ -307,10 +247,6 @@ export default class Ink {
         if (this.isUnmounted) {
             return;
         }
-        if (this.nextRenderCommit) {
-            this.nextRenderCommit.resolve();
-            this.nextRenderCommit = undefined;
-        }
         const startTime = performance.now();
         const { output, outputHeight, staticOutput } = render(this.rootNode, this.isScreenReaderEnabled);
         this.options.onRender?.({ renderTime: performance.now() - startTime });
@@ -320,13 +256,10 @@ export default class Ink {
             if (hasStaticOutput) {
                 this.fullStaticOutput += staticOutput;
             }
-            this.lastOutput = output;
-            this.lastOutputToRender = output;
-            this.lastOutputHeight = outputHeight;
             this.options.stdout.write(this.fullStaticOutput + output);
             return;
         }
-        if (!this.interactive) {
+        if (isInCi) {
             if (hasStaticOutput) {
                 this.options.stdout.write(staticOutput);
             }
@@ -336,7 +269,7 @@ export default class Ink {
             return;
         }
         if (this.isScreenReaderEnabled) {
-            const sync = this.shouldSync();
+            const sync = shouldSynchronize(this.options.stdout);
             if (sync) {
                 this.options.stdout.write(bsu);
             }
@@ -355,7 +288,7 @@ export default class Ink {
                 }
                 return;
             }
-            const terminalWidth = getWindowSize(this.options.stdout).columns;
+            const terminalWidth = this.getTerminalWidth();
             const wrappedOutput = wrapAnsi(output, terminalWidth, {
                 trim: false,
                 hard: true,
@@ -382,11 +315,49 @@ export default class Ink {
         if (hasStaticOutput) {
             this.fullStaticOutput += staticOutput;
         }
-        this.renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : '');
+        // Detect fullscreen: output fills or exceeds terminal height.
+        // Only apply when writing to a real TTY — piped output always gets trailing newlines.
+        const isFullscreen = this.options.stdout.isTTY && outputHeight >= this.options.stdout.rows;
+        const outputToRender = isFullscreen ? output : output + '\n';
+        if (this.lastOutputHeight >= this.options.stdout.rows) {
+            const sync = shouldSynchronize(this.options.stdout);
+            if (sync) {
+                this.options.stdout.write(bsu);
+            }
+            this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + output);
+            this.lastOutput = output;
+            this.lastOutputToRender = outputToRender;
+            this.lastOutputHeight = outputHeight;
+            this.log.sync(outputToRender);
+            if (sync) {
+                this.options.stdout.write(esu);
+            }
+            return;
+        }
+        // To ensure static output is cleanly rendered before main output, clear main output first
+        if (hasStaticOutput) {
+            const sync = shouldSynchronize(this.options.stdout);
+            if (sync) {
+                this.options.stdout.write(bsu);
+            }
+            this.log.clear();
+            this.options.stdout.write(staticOutput);
+            this.log(outputToRender);
+            if (sync) {
+                this.options.stdout.write(esu);
+            }
+        }
+        else if (output !== this.lastOutput || this.log.isCursorDirty()) {
+            // ThrottledLog manages its own bsu/esu at actual write time
+            this.throttledLog(outputToRender);
+        }
+        this.lastOutput = output;
+        this.lastOutputToRender = outputToRender;
+        this.lastOutputHeight = outputHeight;
     };
     render(node) {
         const tree = (React.createElement(AccessibilityContext.Provider, { value: { isScreenReaderEnabled: this.isScreenReaderEnabled } },
-            React.createElement(App, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, exitOnCtrlC: this.options.exitOnCtrlC, interactive: this.interactive, renderThrottleMs: this.renderThrottleMs, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, setCursorPosition: this.setCursorPosition, onExit: this.handleAppExit, onWaitUntilRenderFlush: this.waitUntilRenderFlush }, node)));
+            React.createElement(App, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, exitOnCtrlC: this.options.exitOnCtrlC, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, setCursorPosition: this.setCursorPosition, onExit: this.handleAppExit }, node)));
         if (this.options.concurrent) {
             // Concurrent mode: use updateContainer (async scheduling)
             reconciler.updateContainer(tree, this.container, null, noop);
@@ -405,11 +376,11 @@ export default class Ink {
             this.options.stdout.write(data + this.fullStaticOutput + this.lastOutput);
             return;
         }
-        if (!this.interactive) {
+        if (isInCi) {
             this.options.stdout.write(data);
             return;
         }
-        const sync = this.shouldSync();
+        const sync = shouldSynchronize(this.options.stdout);
         if (sync) {
             this.options.stdout.write(bsu);
         }
@@ -429,11 +400,11 @@ export default class Ink {
             this.options.stdout.write(this.fullStaticOutput + this.lastOutput);
             return;
         }
-        if (!this.interactive) {
+        if (isInCi) {
             this.options.stderr.write(data);
             return;
         }
-        const sync = this.shouldSync();
+        const sync = shouldSynchronize(this.options.stdout);
         if (sync) {
             this.options.stdout.write(bsu);
         }
@@ -444,7 +415,7 @@ export default class Ink {
             this.options.stdout.write(esu);
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-restricted-types
+    // eslint-disable-next-line @typescript-eslint/ban-types
     unmount(error) {
         if (this.isUnmounted || this.isUnmounting) {
             return;
@@ -455,10 +426,21 @@ export default class Ink {
             this.beforeExitHandler = undefined;
         }
         const stdout = this.options.stdout;
-        const { canWriteToStdout, hasWritableState } = getWritableStreamState(stdout);
+        const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true);
+        const settleThrottle = (throttled) => {
+            if (typeof throttled.flush !== 'function') {
+                return;
+            }
+            if (canWriteToStdout) {
+                throttled.flush();
+            }
+            else if (typeof throttled.cancel === 'function') {
+                throttled.cancel();
+            }
+        };
         // Clear any pending throttled render timer on unmount. When stdout is writable,
         // flush so the final frame is emitted; otherwise cancel to avoid delayed callbacks.
-        settleThrottle(this.throttledOnRender, canWriteToStdout);
+        settleThrottle(this.throttledOnRender ?? {});
         if (canWriteToStdout) {
             // If throttling is enabled and there is already a pending render, flushing above
             // is sufficient. Also avoid calling onRender() again when static output already
@@ -474,95 +456,84 @@ export default class Ink {
         // that could re-enter exit() via synchronous write callbacks.
         this.isUnmounted = true;
         this.unsubscribeExit();
-        // Flush any pending throttled log writes if possible, otherwise cancel to
-        // prevent delayed callbacks from writing to a closed stream.
-        settleThrottle(this.throttledLog, canWriteToStdout);
         if (typeof this.restoreConsole === 'function') {
-            // Once unmount starts, Ink stops trying to manage teardown-time
-            // console output. Restoring the native console before React cleanup keeps
-            // unmount behavior simple and avoids special-case handling for custom
-            // streams, fullscreen frames, and alternate-screen teardown.
             this.restoreConsole();
         }
-        const finishUnmount = () => {
-            if (typeof this.unsubscribeResize === 'function') {
-                this.unsubscribeResize();
-            }
-            // Cancel any in-progress auto-detection before checking protocol state
-            if (this.cancelKittyDetection) {
-                this.cancelKittyDetection();
-            }
-            if (canWriteToStdout) {
-                if (this.kittyProtocolEnabled) {
-                    this.writeBestEffort(this.options.stdout, '\u001B[<u');
-                }
-                // Alternate-screen content is disposable by design. We intentionally
-                // leave it active until React cleanup finishes, then restore the
-                // primary buffer without replaying prior frames, hook writes, or
-                // diagnostics onto it. Trying to preserve teardown output across the
-                // buffer switch adds fragile lifecycle-specific behavior, so Ink keeps
-                // alternate-screen teardown intentionally simple and best-effort.
-                if (this.alternateScreen) {
-                    this.writeBestEffort(this.options.stdout, ansiEscapes.exitAlternativeScreen);
-                    this.writeBestEffort(this.options.stdout, showCursorEscape);
-                    this.alternateScreen = false;
-                }
-                if (!this.interactive) {
-                    // Non-interactive environments don't handle erasing ansi escapes well.
-                    // In debug mode, each render already writes to stdout, so only a trailing
-                    // newline is needed. In non-debug mode, write the last frame now (it was
-                    // deferred during rendering).
-                    this.options.stdout.write(this.options.debug ? '\n' : this.lastOutput + '\n');
-                }
-                else if (!this.options.debug) {
-                    this.log.done();
-                }
-            }
-            this.kittyProtocolEnabled = false;
-            instances.delete(this.options.stdout);
-            // Ensure all queued writes have been processed before resolving the
-            // exit promise. For real writable streams, queue an empty write as a
-            // barrier — its callback fires only after all prior writes complete.
-            // For non-stream objects (e.g. test spies), resolve on next tick.
-            //
-            // When called from signal-exit during process shutdown (error is a
-            // number or null rather than undefined/Error), resolve synchronously
-            // because the event loop is draining and async callbacks won't fire.
-            const { exitResult } = this;
-            const resolveOrReject = () => {
-                if (isErrorInput(error)) {
-                    this.rejectExitPromise(error);
+        if (typeof this.unsubscribeResize === 'function') {
+            this.unsubscribeResize();
+        }
+        // Cancel any in-progress auto-detection before checking protocol state
+        if (this.cancelKittyDetection) {
+            this.cancelKittyDetection();
+        }
+        // Flush any pending throttled log writes if possible, otherwise cancel to
+        // prevent delayed callbacks from writing to a closed stream.
+        const throttledLog = this.throttledLog;
+        settleThrottle(throttledLog);
+        if (canWriteToStdout) {
+            if (this.kittyProtocolEnabled) {
+                try {
+                    this.options.stdout.write('\u001B[<u');
                 }
-                else {
-                    this.resolveExitPromise(exitResult);
+                catch {
+                    // Best-effort: stdout may already be destroyed during shutdown
                 }
-            };
-            const isProcessExiting = error !== undefined && !isErrorInput(error);
-            if (isProcessExiting) {
-                resolveOrReject();
             }
-            else if (canWriteToStdout && hasWritableState) {
-                this.options.stdout.write('', resolveOrReject);
+            // CIs don't handle erasing ansi escapes well, so it's better to
+            // only render last frame of non-static output
+            if (isInCi) {
+                this.options.stdout.write(this.lastOutput + '\n');
             }
-            else {
-                setImmediate(resolveOrReject);
+            else if (!this.options.debug) {
+                this.log.done();
             }
-        };
-        const concurrentReconciler = reconciler;
+        }
+        this.kittyProtocolEnabled = false;
         if (this.options.concurrent) {
-            reconciler.updateContainerSync(null, this.container, null, noop);
-            reconciler.flushSyncWork();
-            concurrentReconciler.flushPassiveEffects?.();
-            finishUnmount();
+            // Concurrent mode: use updateContainer (async scheduling)
+            reconciler.updateContainer(null, this.container, null, noop);
         }
         else {
             // Legacy mode: use updateContainerSync + flushSyncWork (sync)
             reconciler.updateContainerSync(null, this.container, null, noop);
             reconciler.flushSyncWork();
-            finishUnmount();
+        }
+        instances.delete(this.options.stdout);
+        // Ensure all queued writes have been processed before resolving the
+        // exit promise. For real writable streams, queue an empty write as a
+        // barrier — its callback fires only after all prior writes complete.
+        // For non-stream objects (e.g. test spies), resolve on next tick.
+        //
+        // When called from signal-exit during process shutdown (error is a
+        // number or null rather than undefined/Error), resolve synchronously
+        // because the event loop is draining and async callbacks won't fire.
+        const { exitResult } = this;
+        const resolveOrReject = () => {
+            if (isErrorInput(error)) {
+                this.rejectExitPromise(error);
+            }
+            else {
+                this.resolveExitPromise(exitResult);
+            }
+        };
+        const isProcessExiting = error !== undefined && !isErrorInput(error);
+        const hasWritableState = stdout._writableState !== undefined ||
+            stdout.writableLength !== undefined;
+        if (isProcessExiting) {
+            resolveOrReject();
+        }
+        else if (canWriteToStdout && hasWritableState) {
+            this.options.stdout.write('', resolveOrReject);
+        }
+        else {
+            setImmediate(resolveOrReject);
         }
     }
     async waitUntilExit() {
+        this.exitPromise ||= new Promise((resolve, reject) => {
+            this.resolveExitPromise = resolve;
+            this.rejectExitPromise = reject;
+        });
         if (!this.beforeExitHandler) {
             this.beforeExitHandler = () => {
                 this.unmount();
@@ -571,46 +542,8 @@ export default class Ink {
         }
         return this.exitPromise;
     }
-    async waitUntilRenderFlush() {
-        if (this.isUnmounted || this.isUnmounting) {
-            await this.awaitExit();
-            return;
-        }
-        // Yield to the macrotask queue so that React's scheduler has a chance to
-        // fire passive effects and process any work they enqueued.
-        await yieldImmediate();
-        if (this.isUnmounted || this.isUnmounting) {
-            await this.awaitExit();
-            return;
-        }
-        // In concurrent mode, React's scheduler may still be mid-render after
-        // the yield. Wait for the next render commit instead of polling.
-        if (this.isConcurrent && this.hasPendingConcurrentWork()) {
-            await Promise.race([this.awaitNextRender(), this.awaitExit()]);
-            if (this.isUnmounted || this.isUnmounting) {
-                this.nextRenderCommit = undefined;
-                await this.awaitExit();
-                return;
-            }
-        }
-        reconciler.flushSyncWork();
-        const stdout = this.options.stdout;
-        const { canWriteToStdout, hasWritableState } = getWritableStreamState(stdout);
-        // Flush pending throttled render/log timers so their output is included in this wait.
-        settleThrottle(this.throttledOnRender, canWriteToStdout);
-        settleThrottle(this.throttledLog, canWriteToStdout);
-        if (canWriteToStdout && hasWritableState) {
-            await new Promise(resolve => {
-                this.options.stdout.write('', () => {
-                    resolve();
-                });
-            });
-            return;
-        }
-        await yieldImmediate();
-    }
     clear() {
-        if (this.interactive && !this.options.debug) {
+        if (!isInCi && !this.options.debug) {
             this.log.clear();
             // Sync lastOutput so that unmount's final onRender
             // sees it as unchanged and log-update skips it
@@ -633,106 +566,6 @@ export default class Ink {
             }
         });
     }
-    setAlternateScreen(enabled) {
-        this.alternateScreen = this.resolveAlternateScreenOption(enabled, this.interactive);
-        if (this.alternateScreen) {
-            this.writeBestEffort(this.options.stdout, ansiEscapes.enterAlternativeScreen);
-            this.writeBestEffort(this.options.stdout, hideCursorEscape);
-        }
-    }
-    resolveInteractiveOption(interactive) {
-        return interactive ?? (!isInCi && Boolean(this.options.stdout.isTTY));
-    }
-    resolveAlternateScreenOption(alternateScreen, interactive) {
-        return (Boolean(alternateScreen) &&
-            interactive &&
-            Boolean(this.options.stdout.isTTY));
-    }
-    shouldSync() {
-        return shouldSynchronize(this.options.stdout, this.interactive);
-    }
-    // Best-effort write: streams may already be destroyed during shutdown.
-    writeBestEffort(stream, data) {
-        try {
-            stream.write(data);
-        }
-        catch { }
-    }
-    // Waits for the exit promise to settle, suppressing any rejection.
-    // Errors are surfaced via waitUntilExit() instead.
-    async awaitExit() {
-        try {
-            await this.exitPromise;
-        }
-        catch { }
-    }
-    hasPendingConcurrentWork() {
-        const concurrentContainer = this.container;
-        return ((concurrentContainer.pendingLanes ?? 0) !== 0 &&
-            concurrentContainer.callbackNode !== undefined &&
-            concurrentContainer.callbackNode !== null);
-    }
-    async awaitNextRender() {
-        if (!this.nextRenderCommit) {
-            let resolveRender;
-            const promise = new Promise(resolve => {
-                resolveRender = resolve;
-            });
-            this.nextRenderCommit = { promise, resolve: resolveRender };
-        }
-        return this.nextRenderCommit.promise;
-    }
-    renderInteractiveFrame(output, outputHeight, staticOutput) {
-        const hasStaticOutput = staticOutput !== '';
-        const isTty = this.options.stdout.isTTY;
-        // Detect fullscreen: output fills or exceeds terminal height.
-        // Only apply when writing to a real TTY — piped output always gets trailing newlines.
-        const viewportRows = isTty ? getWindowSize(this.options.stdout).rows : 24;
-        const isFullscreen = isTty && outputHeight >= viewportRows;
-        const outputToRender = isFullscreen ? output : output + '\n';
-        const shouldClearTerminal = shouldClearTerminalForFrame({
-            isTty,
-            viewportRows,
-            previousOutputHeight: this.lastOutputHeight,
-            nextOutputHeight: outputHeight,
-            isUnmounting: this.isUnmounting,
-        });
-        if (shouldClearTerminal) {
-            const sync = this.shouldSync();
-            if (sync) {
-                this.options.stdout.write(bsu);
-            }
-            this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + output);
-            this.lastOutput = output;
-            this.lastOutputToRender = outputToRender;
-            this.lastOutputHeight = outputHeight;
-            this.log.sync(outputToRender);
-            if (sync) {
-                this.options.stdout.write(esu);
-            }
-            return;
-        }
-        // To ensure static output is cleanly rendered before main output, clear main output first
-        if (hasStaticOutput) {
-            const sync = this.shouldSync();
-            if (sync) {
-                this.options.stdout.write(bsu);
-            }
-            this.log.clear();
-            this.options.stdout.write(staticOutput);
-            this.log(outputToRender);
-            if (sync) {
-                this.options.stdout.write(esu);
-            }
-        }
-        else if (output !== this.lastOutput || this.log.isCursorDirty()) {
-            // ThrottledLog manages its own bsu/esu at actual write time
-            this.throttledLog(outputToRender);
-        }
-        this.lastOutput = output;
-        this.lastOutputToRender = outputToRender;
-        this.lastOutputHeight = outputHeight;
-    }
     initKittyKeyboard() {
         // Protocol is opt-in: if kittyKeyboard is not specified, do nothing
         if (!this.options.kittyKeyboard) {
@@ -740,29 +573,26 @@ export default class Ink {
         }
         const opts = this.options.kittyKeyboard;
         const mode = opts.mode ?? 'auto';
-        if (mode === 'disabled') {
+        if (mode === 'disabled' ||
+            !this.options.stdin.isTTY ||
+            !this.options.stdout.isTTY) {
             return;
         }
         const flags = opts.flags ?? ['disambiguateEscapeCodes'];
-        // 'enabled' force-enables the protocol as long as both streams are TTYs,
-        // regardless of the interactive setting (e.g. even in CI).
         if (mode === 'enabled') {
-            if (this.options.stdin.isTTY && this.options.stdout.isTTY) {
-                this.enableKittyProtocol(flags);
-            }
+            this.enableKittyProtocol(flags);
             return;
         }
-        // Auto mode: require interactive + TTY
-        if (!this.interactive ||
-            !this.options.stdin.isTTY ||
-            !this.options.stdout.isTTY) {
-            return;
+        // Auto mode: use heuristic precheck, then confirm with protocol query
+        const term = process.env['TERM'] ?? '';
+        const termProgram = process.env['TERM_PROGRAM'] ?? '';
+        const isKnownSupportingTerminal = 'KITTY_WINDOW_ID' in process.env ||
+            term === 'xterm-kitty' ||
+            termProgram === 'WezTerm' ||
+            termProgram === 'ghostty';
+        if (!isInCi && isKnownSupportingTerminal) {
+            this.confirmKittySupport(flags);
         }
-        // Auto mode: query the terminal for kitty keyboard protocol support.
-        // The CSI ? u query is safe to send to any terminal — unsupporting
-        // terminals simply won't respond, and the 200ms timeout handles that.
-        // This avoids maintaining a hardcoded whitelist of terminal names.
-        this.confirmKittySupport(flags);
     }
     confirmKittySupport(flags) {
         const { stdin, stdout } = this.options;
@@ -777,11 +607,11 @@ export default class Ink {
             const remaining = stripKittyQueryResponsesAndTrailingPartial(responseBuffer);
             responseBuffer = [];
             if (remaining.length > 0) {
-                stdin.unshift(Uint8Array.from(remaining));
+                stdin.unshift(Buffer.from(remaining));
             }
         };
         const onData = (data) => {
-            const chunk = typeof data === 'string' ? textEncoder.encode(data) : data;
+            const chunk = typeof data === 'string' ? Buffer.from(data) : data;
             for (const byte of chunk) {
                 responseBuffer.push(byte);
             }