@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

package/dist/src/test-utils/render.js

@@ -1,15 +1,16 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { render as inkRender } from 'ink-testing-library';
+import { render as inkRenderDirect, } from 'ink';
+import { EventEmitter } from 'node:events';
 import { Box } from 'ink';
+import { Terminal } from '@xterm/headless';
 import { vi } from 'vitest';
+import stripAnsi from 'strip-ansi';
 import { act, useState } from 'react';
-import os from 'node:os';
-import { LoadedSettings } from '../config/settings.js';
 import { KeypressProvider } from '../ui/contexts/KeypressContext.js';
 import { SettingsContext } from '../ui/contexts/SettingsContext.js';
 import { ShellFocusContext } from '../ui/contexts/ShellFocusContext.js';
@@ -24,54 +25,321 @@ import { StreamingState } from '../ui/types.js';
 import { ToolActionsProvider } from '../ui/contexts/ToolActionsContext.js';
 import { AskUserActionsProvider } from '../ui/contexts/AskUserActionsContext.js';
 import { TerminalProvider } from '../ui/contexts/TerminalContext.js';
+import { OverflowProvider, useOverflowActions, useOverflowState, } from '../ui/contexts/OverflowContext.js';
 import { makeFakeConfig } from '@google/gemini-cli-core';
+import {} from '@google/gemini-cli-core';
 import { FakePersistentState } from './persistentStateFake.js';
 import { AppContext } from '../ui/contexts/AppContext.js';
 import { createMockSettings } from './settings.js';
+import { SessionStatsProvider } from '../ui/contexts/SessionContext.js';
+import { themeManager, DEFAULT_THEME } from '../ui/themes/theme-manager.js';
+import { DefaultLight } from '../ui/themes/builtin/light/default-light.js';
+import { pickDefaultThemeName } from '../ui/themes/theme.js';
+import { generateSvgForTerminal } from './svg.js';
 export const persistentStateMock = new FakePersistentState();
+if (process.env['NODE_ENV'] === 'test') {
+    // We mock NODE_ENV to development during tests that use render.tsx
+    // so that animations (which check process.env.NODE_ENV !== 'test')
+    // are actually tested. We mutate process.env directly here because
+    // vi.stubEnv() is cleared by vi.unstubAllEnvs() in test-setup.ts
+    // after each test.
+    process.env['NODE_ENV'] = 'development';
+}
 vi.mock('../utils/persistentState.js', () => ({
-    persistentState: persistentStateMock,
+    get persistentState() {
+        return persistentStateMock;
+    },
 }));
 vi.mock('../ui/utils/terminalUtils.js', () => ({
     isLowColorDepth: vi.fn(() => false),
     getColorDepth: vi.fn(() => 24),
     isITerm2: vi.fn(() => false),
 }));
-// Wrapper around ink-testing-library's render that ensures act() is called
-export const render = (tree, terminalWidth) => {
-    let renderResult = 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    undefined;
-    act(() => {
-        renderResult = inkRender(tree);
-    });
-    if (terminalWidth !== undefined && renderResult?.stdout) {
-        // Override the columns getter on the stdout instance provided by ink-testing-library
-        Object.defineProperty(renderResult.stdout, 'columns', {
-            get: () => terminalWidth,
-            configurable: true,
+function isInkRenderMetrics(metrics) {
+    const m = metrics;
+    return (typeof m === 'object' &&
+        m !== null &&
+        'output' in m &&
+        // eslint-disable-next-line no-restricted-syntax
+        typeof m['output'] === 'string');
+}
+class XtermStdout extends EventEmitter {
+    state;
+    pendingWrites = 0;
+    renderCount = 0;
+    queue;
+    isTTY = true;
+    getColorDepth() {
+        return 24;
+    }
+    lastRenderOutput = undefined;
+    lastRenderStaticContent = undefined;
+    constructor(state, queue) {
+        super();
+        this.state = state;
+        this.queue = queue;
+    }
+    get columns() {
+        return this.state.terminal.cols;
+    }
+    get rows() {
+        return this.state.terminal.rows;
+    }
+    get frames() {
+        return [];
+    }
+    write = (data) => {
+        this.pendingWrites++;
+        this.queue.promise = this.queue.promise.then(async () => {
+            await new Promise((resolve) => this.state.terminal.write(data, resolve));
+            this.pendingWrites--;
         });
-        // Trigger a rerender so Ink can pick up the new terminal width
-        act(() => {
-            renderResult.rerender(tree);
+    };
+    clear = () => {
+        this.state.terminal.reset();
+        this.lastRenderOutput = undefined;
+        this.lastRenderStaticContent = undefined;
+    };
+    dispose = () => {
+        this.state.terminal.dispose();
+    };
+    onRender = (staticContent, output) => {
+        this.renderCount++;
+        this.lastRenderStaticContent = staticContent;
+        this.lastRenderOutput = output;
+        this.emit('render');
+    };
+    normalizeFrame = (text) => text.replace(/\r\n/g, '\n');
+    generateSvg = () => generateSvgForTerminal(this.state.terminal);
+    lastFrameRaw = (options = {}) => {
+        const result = (this.lastRenderStaticContent ?? '') + (this.lastRenderOutput ?? '');
+        const normalized = this.normalizeFrame(result);
+        if (normalized === '' && !options.allowEmpty) {
+            throw new Error('lastFrameRaw() returned an empty string. If this is intentional, use lastFrameRaw({ allowEmpty: true }). ' +
+                'Otherwise, ensure you are calling await waitUntilReady() and that the component is rendering correctly.');
+        }
+        return normalized;
+    };
+    lastFrame = (options = {}) => {
+        const buffer = this.state.terminal.buffer.active;
+        const allLines = [];
+        for (let i = 0; i < buffer.length; i++) {
+            allLines.push(buffer.getLine(i)?.translateToString(true) ?? '');
+        }
+        const trimmed = [...allLines];
+        while (trimmed.length > 0 && trimmed[trimmed.length - 1] === '') {
+            trimmed.pop();
+        }
+        const result = trimmed.join('\n');
+        const normalized = this.normalizeFrame(result);
+        if (normalized === '' && !options.allowEmpty) {
+            throw new Error('lastFrame() returned an empty string. If this is intentional, use lastFrame({ allowEmpty: true }). ' +
+                'Otherwise, ensure you are calling await waitUntilReady() and that the component is rendering correctly.');
+        }
+        return normalized === '' ? normalized : normalized + '\n';
+    };
+    async waitUntilReady() {
+        const startRenderCount = this.renderCount;
+        if (!vi.isFakeTimers()) {
+            // Give Ink a chance to start its rendering loop
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        await act(async () => {
+            if (vi.isFakeTimers()) {
+                await vi.advanceTimersByTimeAsync(50);
+            }
+            else {
+                // Wait for at least one render to be called if we haven't rendered yet or since start of this call,
+                // but don't wait forever as some renders might be synchronous or skipped.
+                if (this.renderCount === startRenderCount) {
+                    const renderPromise = new Promise((resolve) => this.once('render', resolve));
+                    const timeoutPromise = new Promise((resolve) => setTimeout(resolve, 1000));
+                    await Promise.race([renderPromise, timeoutPromise]);
+                }
+            }
+        });
+        let attempts = 0;
+        const maxAttempts = 50;
+        let lastCurrent = '';
+        let lastExpected = '';
+        while (attempts < maxAttempts) {
+            // Ensure all pending writes to the terminal are processed.
+            await this.queue.promise;
+            const currentFrame = stripAnsi(this.lastFrame({ allowEmpty: true })).trim();
+            const expectedFrame = this.normalizeFrame(stripAnsi((this.lastRenderStaticContent ?? '') + (this.lastRenderOutput ?? ''))).trim();
+            lastCurrent = currentFrame;
+            lastExpected = expectedFrame;
+            const isMatch = () => {
+                if (expectedFrame === '...') {
+                    // '...' is our fallback when output isn't in metrics, meaning Ink rendered *something*
+                    // but we don't know what it is. If terminal has content, we consider it a match.
+                    // However, if the component rendered null, both would be empty, but our fallback
+                    // made expectedFrame '...'. In that case, we can't easily know if it's ready,
+                    // but we can assume if there are no pending writes, it's ready.
+                    return currentFrame !== '' || this.pendingWrites === 0;
+                }
+                // If Ink expects nothing (no new static content and no dynamic output),
+                // we consider it a match because the terminal buffer will just hold the historical static content.
+                if (expectedFrame === '') {
+                    return true;
+                }
+                if (this.lastRenderOutput === undefined) {
+                    return false;
+                }
+                // If the terminal is empty but Ink expects something, it's not a match.
+                if (currentFrame === '') {
+                    return false;
+                }
+                // Check if the current frame contains the expected content.
+                // We use includes because xterm might have some formatting or
+                // extra whitespace that Ink doesn't account for in its raw output metrics.
+                return currentFrame.includes(expectedFrame);
+            };
+            if (this.pendingWrites === 0 && isMatch()) {
+                return;
+            }
+            attempts++;
+            await act(async () => {
+                if (vi.isFakeTimers()) {
+                    await vi.advanceTimersByTimeAsync(10);
+                }
+                else {
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                }
+            });
+        }
+        throw new Error(`waitUntilReady() timed out after ${maxAttempts} attempts.\n` +
+            `Expected content (stripped ANSI):\n"${lastExpected}"\n` +
+            `Actual content (stripped ANSI):\n"${lastCurrent}"\n` +
+            `Pending writes: ${this.pendingWrites}\n` +
+            `Render count: ${this.renderCount}`);
+    }
+}
+class XtermStderr extends EventEmitter {
+    state;
+    pendingWrites = 0;
+    queue;
+    isTTY = true;
+    constructor(state, queue) {
+        super();
+        this.state = state;
+        this.queue = queue;
+    }
+    write = (data) => {
+        this.pendingWrites++;
+        this.queue.promise = this.queue.promise.then(async () => {
+            await new Promise((resolve) => this.state.terminal.write(data, resolve));
+            this.pendingWrites--;
         });
+    };
+    dispose = () => {
+        this.state.terminal.dispose();
+    };
+    lastFrame = () => '';
+}
+class XtermStdin extends EventEmitter {
+    isTTY = true;
+    data = null;
+    constructor(options = {}) {
+        super();
+        this.isTTY = options.isTTY ?? true;
     }
-    const originalUnmount = renderResult.unmount;
-    const originalRerender = renderResult.rerender;
+    write = (data) => {
+        this.data = data;
+        this.emit('readable');
+        this.emit('data', data);
+    };
+    setEncoding() { }
+    setRawMode() { }
+    resume() { }
+    pause() { }
+    ref() { }
+    unref() { }
+    read = () => {
+        const { data } = this;
+        this.data = null;
+        return data;
+    };
+}
+const instances = [];
+export const render = async (tree, terminalWidth) => {
+    const cols = terminalWidth ?? 100;
+    // We use 1000 rows to avoid windows with incorrect snapshots if a correct
+    // value was used (e.g. 40 rows). The alternatives to make things worse are
+    // windows unfortunately with odd duplicate content in the backbuffer
+    // which does not match actual behavior in xterm.js on windows.
+    const rows = 1000;
+    const terminal = new Terminal({
+        cols,
+        rows,
+        allowProposedApi: true,
+        convertEol: true,
+    });
+    const state = {
+        terminal,
+        cols,
+        rows,
+    };
+    const writeQueue = { promise: Promise.resolve() };
+    const stdout = new XtermStdout(state, writeQueue);
+    const stderr = new XtermStderr(state, writeQueue);
+    const stdin = new XtermStdin();
+    let instance;
+    stdout.clear();
+    act(() => {
+        instance = inkRenderDirect(tree, {
+            stdout: stdout,
+            stderr: stderr,
+            stdin: stdin,
+            debug: false,
+            exitOnCtrlC: false,
+            patchConsole: false,
+            onRender: (metrics) => {
+                const output = isInkRenderMetrics(metrics) ? metrics.output : '...';
+                const staticOutput = isInkRenderMetrics(metrics)
+                    ? (metrics.staticOutput ?? '')
+                    : '';
+                stdout.onRender(staticOutput, output);
+            },
+        });
+    });
+    instances.push(instance);
+    await stdout.waitUntilReady();
     return {
-        ...renderResult,
-        unmount: () => {
+        rerender: (newTree) => {
             act(() => {
-                originalUnmount();
+                stdout.clear();
+                instance.rerender(newTree);
             });
         },
-        rerender: (newTree) => {
+        unmount: () => {
             act(() => {
-                originalRerender(newTree);
+                instance.unmount();
             });
+            stdout.dispose();
+            stderr.dispose();
         },
+        cleanup: instance.cleanup,
+        stdout,
+        stderr,
+        stdin,
+        frames: stdout.frames,
+        lastFrame: stdout.lastFrame,
+        lastFrameRaw: stdout.lastFrameRaw,
+        generateSvg: stdout.generateSvg,
+        terminal: state.terminal,
+        waitUntilReady: () => stdout.waitUntilReady(),
     };
 };
+export const cleanup = () => {
+    for (const instance of instances) {
+        act(() => {
+            instance.unmount();
+        });
+        instance.cleanup();
+    }
+    instances.length = 0;
+};
 export const simulateClick = async (stdin, col, row, button = 0) => {
     // Terminal mouse events are 1-based, so convert if necessary.
     const mouseEventString = `\x1b[<${button};${col};${row}M`;
@@ -79,52 +347,42 @@ export const simulateClick = async (stdin, col, row, button = 0) => {
         stdin.write(mouseEventString);
     });
 };
-let mockConfigInternal;
-const getMockConfigInternal = () => {
-    if (!mockConfigInternal) {
-        mockConfigInternal = makeFakeConfig({
-            targetDir: os.tmpdir(),
-            enableEventDrivenScheduler: true,
-        });
-    }
-    return mockConfigInternal;
-};
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-const configProxy = new Proxy({}, {
-    get(_target, prop) {
-        if (prop === 'getTargetDir') {
-            return () => '/Users/test/project/foo/bar/and/some/more/directories/to/make/it/long';
-        }
-        if (prop === 'getUseBackgroundColor') {
-            return () => true;
-        }
-        const internal = getMockConfigInternal();
-        if (prop in internal) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-            return internal[prop];
-        }
-        throw new Error(`mockConfig does not have property ${String(prop)}`);
-    },
-});
-export const mockSettings = new LoadedSettings({ path: '', settings: {}, originalSettings: {} }, { path: '', settings: {}, originalSettings: {} }, { path: '', settings: {}, originalSettings: {} }, { path: '', settings: {}, originalSettings: {} }, true, []);
+export const mockSettings = createMockSettings();
 // A minimal mock UIState to satisfy the context provider.
 // Tests that need specific UIState values should provide their own.
 const baseMockUiState = {
+    history: [],
     renderMarkdown: true,
     streamingState: StreamingState.Idle,
-    terminalWidth: 120,
+    isConfigInitialized: true,
+    isAuthenticating: false,
+    terminalWidth: 100,
     terminalHeight: 40,
     currentModel: 'gemini-pro',
-    terminalBackgroundColor: undefined,
+    terminalBackgroundColor: 'black',
+    cleanUiDetailsVisible: false,
+    allowPlanMode: true,
     activePtyId: undefined,
-    backgroundShells: new Map(),
-    backgroundShellHeight: 0,
+    backgroundTasks: new Map(),
+    backgroundTaskHeight: 0,
     quota: {
         userTier: undefined,
         stats: undefined,
         proQuotaRequest: null,
         validationRequest: null,
     },
+    hintMode: false,
+    hintBuffer: '',
+    bannerData: {
+        defaultText: '',
+        warningText: '',
+    },
+    bannerVisible: false,
+    nightly: false,
+    updateInfo: null,
+    pendingHistoryItems: [],
+    mainControlsRef: () => { },
+    rootUiRef: { current: null },
 };
 export const mockAppState = {
     version: '1.2.3',
@@ -154,6 +412,7 @@ const mockUIActions = {
     vimHandleInput: vi.fn(),
     handleIdePromptComplete: vi.fn(),
     handleFolderTrustSelect: vi.fn(),
+    setIsPolicyUpdateDialogOpen: vi.fn(),
     setConstrainHeight: vi.fn(),
     onEscapePromptChange: vi.fn(),
     refreshStatic: vi.fn(),
@@ -161,40 +420,68 @@ const mockUIActions = {
     handleClearScreen: vi.fn(),
     handleProQuotaChoice: vi.fn(),
     handleValidationChoice: vi.fn(),
+    handleOverageMenuChoice: vi.fn(),
+    handleEmptyWalletChoice: vi.fn(),
     setQueueErrorMessage: vi.fn(),
+    addMessage: vi.fn(),
     popAllMessages: vi.fn(),
     handleApiKeySubmit: vi.fn(),
     handleApiKeyCancel: vi.fn(),
     setBannerVisible: vi.fn(),
     setShortcutsHelpVisible: vi.fn(),
+    setCleanUiDetailsVisible: vi.fn(),
+    toggleCleanUiDetailsVisible: vi.fn(),
+    revealCleanUiDetailsTemporarily: vi.fn(),
+    handleWarning: vi.fn(),
     setEmbeddedShellFocused: vi.fn(),
-    dismissBackgroundShell: vi.fn(),
-    setActiveBackgroundShellPid: vi.fn(),
-    setIsBackgroundShellListOpen: vi.fn(),
+    dismissBackgroundTask: vi.fn(),
+    setActiveBackgroundTaskPid: vi.fn(),
+    setIsBackgroundTaskListOpen: vi.fn(),
     setAuthContext: vi.fn(),
+    onHintInput: vi.fn(),
+    onHintBackspace: vi.fn(),
+    onHintClear: vi.fn(),
+    onHintSubmit: vi.fn(),
     handleRestart: vi.fn(),
     handleNewAgentsSelect: vi.fn(),
+    getPreferredEditor: vi.fn(),
+    clearAccountSuspension: vi.fn(),
+};
+import {} from '../ui/components/shared/text-buffer.js';
+import { InputContext } from '../ui/contexts/InputContext.js';
+let capturedOverflowState;
+let capturedOverflowActions;
+const ContextCapture = ({ children, }) => {
+    capturedOverflowState = useOverflowState();
+    capturedOverflowActions = useOverflowActions();
+    return _jsx(_Fragment, { children: children });
 };
-export const renderWithProviders = (component, { shellFocus = true, settings = mockSettings, uiState: providedUiState, width, mouseEventsEnabled = false, 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-config = configProxy, useAlternateBuffer = true, uiActions, persistentState, appState = mockAppState, } = {}) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+export const renderWithProviders = async (component, { shellFocus = true, settings = mockSettings, uiState: providedUiState, inputState: providedInputState, width, mouseEventsEnabled = false, config, uiActions, toolActions, persistentState, appState = mockAppState, } = {}) => {
     const baseState = new Proxy({ ...baseMockUiState, ...providedUiState }, {
         get(target, prop) {
             if (prop in target) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 return target[prop];
             }
             // For properties not in the base mock or provided state,
             // we'll check the original proxy to see if it's a defined but
             // unprovided property, and if not, throw.
             if (prop in baseMockUiState) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 return baseMockUiState[prop];
             }
             throw new Error(`mockUiState does not have property ${String(prop)}`);
         },
     });
+    const inputState = {
+        buffer: { text: '' },
+        userMessages: [],
+        shellModeActive: false,
+        showEscapePrompt: false,
+        copyModeEnabled: false,
+        inputWidth: 80,
+        suggestionsWidth: 40,
+        ...providedUiState,
+        ...providedInputState,
+    };
     if (persistentState?.get) {
         persistentStateMock.get.mockImplementation(persistentState.get);
     }
@@ -203,33 +490,43 @@ config = configProxy, useAlternateBuffer = true, uiActions, persistentState, app
     }
     persistentStateMock.mockClear();
     const terminalWidth = width ?? baseState.terminalWidth;
-    let finalSettings = settings;
-    if (useAlternateBuffer !== undefined) {
-        finalSettings = createMockSettings({
-            ...settings.merged,
-            ui: {
-                ...settings.merged.ui,
-                useAlternateBuffer,
-            },
+    if (!config) {
+        config = makeFakeConfig({
+            useAlternateBuffer: settings.merged.ui?.useAlternateBuffer,
+            showMemoryUsage: settings.merged.ui?.showMemoryUsage,
+            accessibility: settings.merged.ui?.accessibility,
         });
     }
-    const mainAreaWidth = terminalWidth;
+    const mainAreaWidth = providedUiState?.mainAreaWidth ?? terminalWidth;
     const finalUiState = {
         ...baseState,
         terminalWidth,
         mainAreaWidth,
     };
+    themeManager.setTerminalBackground(baseState.terminalBackgroundColor);
+    const themeName = pickDefaultThemeName(baseState.terminalBackgroundColor, themeManager.getAllThemes(), DEFAULT_THEME.name, DefaultLight.name);
+    themeManager.setActiveTheme(themeName);
     const finalUIActions = { ...mockUIActions, ...uiActions };
     const allToolCalls = (finalUiState.pendingHistoryItems || [])
         .filter((item) => item.type === 'tool_group')
         .flatMap((item) => item.tools);
-    const renderResult = render(_jsx(AppContext.Provider, { value: appState, children: _jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: finalSettings, children: _jsx(UIStateContext.Provider, { value: finalUiState, children: _jsx(VimModeProvider, { settings: finalSettings, children: _jsx(ShellFocusContext.Provider, { value: shellFocus, children: _jsx(StreamingContext.Provider, { value: finalUiState.streamingState, children: _jsx(UIActionsContext.Provider, { value: finalUIActions, children: _jsx(ToolActionsProvider, { config: config, toolCalls: allToolCalls, children: _jsx(AskUserActionsProvider, { request: null, onSubmit: vi.fn(), onCancel: vi.fn(), children: _jsx(KeypressProvider, { children: _jsx(MouseProvider, { mouseEventsEnabled: mouseEventsEnabled, children: _jsx(TerminalProvider, { children: _jsx(ScrollProvider, { children: _jsx(Box, { width: terminalWidth, flexShrink: 0, flexGrow: 0, flexDirection: "column", children: component }) }) }) }) }) }) }) }) }) }) }) }) }) }) }), terminalWidth);
-    return { ...renderResult, simulateClick };
+    capturedOverflowState = undefined;
+    capturedOverflowActions = undefined;
+    const wrapWithProviders = (comp) => (_jsx(AppContext.Provider, { value: appState, children: _jsx(ConfigContext.Provider, { value: config, children: _jsx(SettingsContext.Provider, { value: settings, children: _jsx(InputContext.Provider, { value: inputState, children: _jsx(UIStateContext.Provider, { value: finalUiState, children: _jsx(VimModeProvider, { children: _jsx(ShellFocusContext.Provider, { value: shellFocus, children: _jsx(SessionStatsProvider, { children: _jsx(StreamingContext.Provider, { value: finalUiState.streamingState, children: _jsx(UIActionsContext.Provider, { value: finalUIActions, children: _jsx(OverflowProvider, { children: _jsx(ToolActionsProvider, { config: config, toolCalls: allToolCalls, isExpanded: toolActions?.isExpanded ??
+                                                        vi.fn().mockReturnValue(false), toggleExpansion: toolActions?.toggleExpansion ?? vi.fn(), toggleAllExpansion: toolActions?.toggleAllExpansion ?? vi.fn(), children: _jsx(AskUserActionsProvider, { request: null, onSubmit: vi.fn(), onCancel: vi.fn(), children: _jsx(KeypressProvider, { children: _jsx(MouseProvider, { mouseEventsEnabled: mouseEventsEnabled, children: _jsx(TerminalProvider, { children: _jsx(ScrollProvider, { children: _jsx(ContextCapture, { children: _jsx(Box, { width: terminalWidth, flexShrink: 0, flexGrow: 0, flexDirection: "column", children: comp }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }));
+    const renderResult = await render(wrapWithProviders(component), terminalWidth);
+    return {
+        ...renderResult,
+        rerender: (newComponent) => {
+            renderResult.rerender(wrapWithProviders(newComponent));
+        },
+        capturedOverflowState,
+        capturedOverflowActions,
+        simulateClick: (col, row, button) => simulateClick(renderResult.stdin, col, row, button),
+    };
 };
-export function renderHook(renderCallback, options) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+export async function renderHook(renderCallback, options) {
     const result = { current: undefined };
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
     let currentProps = options?.initialProps;
     function TestComponent({ renderCallback, props, }) {
         result.current = renderCallback(props);
@@ -238,24 +535,24 @@ export function renderHook(renderCallback, options) {
     const Wrapper = options?.wrapper || (({ children }) => _jsx(_Fragment, { children: children }));
     let inkRerender = () => { };
     let unmount = () => { };
-    act(() => {
-        const renderResult = render(_jsx(Wrapper, { children: _jsx(TestComponent, { renderCallback: renderCallback, props: currentProps }) }));
-        inkRerender = renderResult.rerender;
-        unmount = renderResult.unmount;
-    });
+    let waitUntilReady = async () => { };
+    let generateSvg = () => '';
+    const renderResult = await render(_jsx(Wrapper, { children: _jsx(TestComponent, { renderCallback: renderCallback, props: currentProps }) }));
+    inkRerender = renderResult.rerender;
+    unmount = renderResult.unmount;
+    waitUntilReady = renderResult.waitUntilReady;
+    generateSvg = renderResult.generateSvg;
     function rerender(props) {
         if (arguments.length > 0) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             currentProps = props;
         }
         act(() => {
             inkRerender(_jsx(Wrapper, { children: _jsx(TestComponent, { renderCallback: renderCallback, props: currentProps }) }));
         });
     }
-    return { result, rerender, unmount };
+    return { result, rerender, unmount, waitUntilReady, generateSvg };
 }
-export function renderHookWithProviders(renderCallback, options = {}) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+export async function renderHookWithProviders(renderCallback, options = {}) {
     const result = { current: undefined };
     let setPropsFn;
     let forceUpdateFn;
@@ -269,13 +566,12 @@ export function renderHookWithProviders(renderCallback, options = {}) {
     }
     const Wrapper = options.wrapper || (({ children }) => _jsx(_Fragment, { children: children }));
     let renderResult;
-    act(() => {
-        renderResult = renderWithProviders(_jsx(Wrapper, { children: _jsx(TestComponent, { initialProps: options.initialProps }) }), options);
+    await act(async () => {
+        renderResult = await renderWithProviders(_jsx(Wrapper, { children: _jsx(TestComponent, { initialProps: options.initialProps }) }), options);
     });
     function rerender(newProps) {
         act(() => {
             if (arguments.length > 0 && setPropsFn) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 setPropsFn(newProps);
             }
             else if (forceUpdateFn) {
@@ -291,6 +587,8 @@ export function renderHookWithProviders(renderCallback, options = {}) {
                 renderResult.unmount();
             });
         },
+        waitUntilReady: () => renderResult.waitUntilReady(),
+        generateSvg: () => renderResult.generateSvg(),
     };
 }
 //# sourceMappingURL=render.js.map