@xincli/opentui-core 0.4.6 → 0.4.7

package/src/tests/renderer.console-startup.test.ts

@@ -1,2151 +0,0 @@
-import { afterEach, beforeEach, expect, spyOn, test } from "bun:test"
-
-import { ANSI } from "../ansi.js"
-import { capture } from "../console.js"
-import { clearEnvCache } from "../lib/env.js"
-import { createTestRenderer, type TestRenderer } from "../testing/test-renderer.js"
-import { ManualClock } from "../testing/manual-clock.js"
-import { TextRenderable, type ScrollbackRenderContext } from "../index.js"
-
-let renderer: TestRenderer | null = null
-let previousShowConsole: string | undefined
-let previousUseAlternateScreen: string | undefined
-let previousOverrideStdout: string | undefined
-let previousUseConsole: string | undefined
-
-function textScrollbackWrite(data: string) {
-  return (ctx: ScrollbackRenderContext) => {
-    const lines = data.replace(/\r/g, "").split("\n")
-    if (lines.length > 0 && lines[lines.length - 1] === "") {
-      lines.pop()
-    }
-
-    const normalizedLines = lines.length > 0 ? lines : [""]
-    const width = Math.max(
-      1,
-      Math.min(
-        ctx.width,
-        normalizedLines.reduce((max, line) => Math.max(max, line.length), 1),
-      ),
-    )
-    const height = Math.max(1, normalizedLines.length)
-    const root = new TextRenderable(ctx.renderContext, {
-      id: "scrollback-test-text",
-      position: "absolute",
-      left: 0,
-      top: 0,
-      width,
-      height,
-      content: normalizedLines.map((line) => line.slice(0, width)).join("\n"),
-    })
-
-    return {
-      root,
-      width,
-      height,
-    }
-  }
-}
-
-function requireSnapshotRoot(root: TextRenderable | null): TextRenderable {
-  if (root === null) {
-    throw new Error("expected scrollback snapshot root")
-  }
-
-  return root
-}
-
-function blockSplitStartupCursorSeed(target: TestRenderer): () => void {
-  ;(target as any).pendingSplitStartupCursorSeed = true
-  ;(target as any).splitStartupSeedTimeoutId = setTimeout(() => {}, 10)
-
-  return () => {
-    if ((target as any).splitStartupSeedTimeoutId !== null) {
-      clearTimeout((target as any).splitStartupSeedTimeoutId)
-      ;(target as any).splitStartupSeedTimeoutId = null
-    }
-
-    ;(target as any).pendingSplitStartupCursorSeed = false
-  }
-}
-
-beforeEach(() => {
-  previousShowConsole = process.env.SHOW_CONSOLE
-  previousUseAlternateScreen = process.env.OTUI_USE_ALTERNATE_SCREEN
-  previousOverrideStdout = process.env.OTUI_OVERRIDE_STDOUT
-  previousUseConsole = process.env.OTUI_USE_CONSOLE
-  delete process.env.SHOW_CONSOLE
-  delete process.env.OTUI_USE_ALTERNATE_SCREEN
-  delete process.env.OTUI_OVERRIDE_STDOUT
-  delete process.env.OTUI_USE_CONSOLE
-  clearEnvCache()
-})
-
-afterEach(() => {
-  renderer?.destroy()
-  renderer = null
-  capture.claimOutput()
-
-  if (previousShowConsole === undefined) {
-    delete process.env.SHOW_CONSOLE
-  } else {
-    process.env.SHOW_CONSOLE = previousShowConsole
-  }
-
-  if (previousUseAlternateScreen === undefined) {
-    delete process.env.OTUI_USE_ALTERNATE_SCREEN
-  } else {
-    process.env.OTUI_USE_ALTERNATE_SCREEN = previousUseAlternateScreen
-  }
-
-  if (previousOverrideStdout === undefined) {
-    delete process.env.OTUI_OVERRIDE_STDOUT
-  } else {
-    process.env.OTUI_OVERRIDE_STDOUT = previousOverrideStdout
-  }
-
-  if (previousUseConsole === undefined) {
-    delete process.env.OTUI_USE_CONSOLE
-  } else {
-    process.env.OTUI_USE_CONSOLE = previousUseConsole
-  }
-
-  clearEnvCache()
-})
-
-test("CliRenderer initializes its clock before SHOW_CONSOLE triggers a render", async () => {
-  process.env.SHOW_CONSOLE = "true"
-  clearEnvCache()
-
-  const result = await createTestRenderer({
-    clock: new ManualClock(),
-  })
-
-  renderer = result.renderer
-
-  expect(renderer).toBeDefined()
-})
-
-test("CliRenderer uses its shared clock for debounced resize", async () => {
-  const clock = new ManualClock()
-  const result = await createTestRenderer({
-    width: 40,
-    height: 20,
-    clock,
-  })
-
-  renderer = result.renderer
-  ;(renderer as any).handleResize(70, 30)
-
-  expect(renderer.width).toBe(40)
-  expect(renderer.height).toBe(20)
-
-  clock.advance(99)
-
-  expect(renderer.width).toBe(40)
-  expect(renderer.height).toBe(20)
-
-  clock.advance(1)
-
-  expect(renderer.width).toBe(70)
-  expect(renderer.height).toBe(30)
-})
-
-test("CliRenderer applies explicit screen and output modes", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  expect(renderer.screenMode).toBe("split-footer")
-  expect(renderer.footerHeight).toBe(6)
-  expect(renderer.externalOutputMode).toBe("capture-stdout")
-  expect(renderer.consoleMode).toBe("disabled")
-})
-
-test("CliRenderer consoleMode disabled restores the original console", async () => {
-  process.env.OTUI_USE_CONSOLE = "true"
-  clearEnvCache()
-
-  const originalConsole = global.console
-
-  const result = await createTestRenderer({
-    consoleMode: "console-overlay",
-  })
-
-  renderer = result.renderer
-
-  expect(global.console).not.toBe(originalConsole)
-
-  renderer.consoleMode = "disabled"
-
-  expect(global.console).toBe(originalConsole)
-})
-
-test("CliRenderer clamps split footer height to terminal height at startup", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 5,
-    screenMode: "split-footer",
-    footerHeight: 12,
-    externalOutputMode: "capture-stdout",
-  })
-
-  renderer = result.renderer
-
-  expect(renderer.footerHeight).toBe(12)
-  expect(renderer.height).toBe(5)
-  expect((renderer as any)._splitHeight).toBe(5)
-  expect((renderer as any).renderOffset).toBe(0)
-})
-
-test("CliRenderer rejects captured output outside split-footer mode", async () => {
-  await expect(
-    createTestRenderer({
-      screenMode: "main-screen",
-      externalOutputMode: "capture-stdout",
-    }),
-  ).rejects.toThrow('externalOutputMode "capture-stdout" requires screenMode "split-footer"')
-})
-
-test("CliRenderer writeToScrollback throws when screen mode is not split-footer", async () => {
-  const result = await createTestRenderer({
-    screenMode: "main-screen",
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  expect(() => renderer!.writeToScrollback(textScrollbackWrite("ignored\n"))).toThrow(
-    'writeToScrollback requires screenMode "split-footer" and externalOutputMode "capture-stdout"',
-  )
-})
-
-test("CliRenderer writeToScrollback throws when external output mode is passthrough", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  expect(() => renderer!.writeToScrollback(textScrollbackWrite("ignored\n"))).toThrow(
-    'writeToScrollback requires screenMode "split-footer" and externalOutputMode "capture-stdout"',
-  )
-})
-
-test("CliRenderer writeToScrollback enqueues snapshot commits to native", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const lib = (renderer as any).lib
-  const snapshotCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  let decodedOutput = ""
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    const snapshotBuffer = args[1]
-    decodedOutput = new TextDecoder().decode(snapshotBuffer.getRealCharBytes(true))
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  renderer.writeToScrollback(textScrollbackWrite("api-line-1\napi-line-2\n"))
-
-  expect((renderer as any).externalOutputQueue.size).toBe(1)
-
-  await result.renderOnce()
-
-  expect(snapshotCommitSpy).toHaveBeenCalledTimes(1)
-  expect(decodedOutput).toContain("api-line-1")
-  expect(decodedOutput).toContain("api-line-2")
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  snapshotCommitSpy.mockRestore()
-})
-
-test("CliRenderer writeToScrollback passes width and widthMethod to the scrollback writer", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  let receivedContext: ScrollbackRenderContext | null = null
-
-  renderer.writeToScrollback((ctx) => {
-    receivedContext = ctx
-
-    const root = new TextRenderable(ctx.renderContext, {
-      id: "scrollback-context-test",
-      position: "absolute",
-      left: 0,
-      top: 0,
-      width: 3,
-      height: 1,
-      content: "ctx",
-    })
-
-    return {
-      root,
-      width: 3,
-      height: 1,
-    }
-  })
-
-  expect(receivedContext).not.toBeNull()
-
-  if (receivedContext === null) {
-    throw new Error("expected writeToScrollback to provide context")
-  }
-
-  const writeContext = receivedContext as ScrollbackRenderContext
-  expect(writeContext.width).toBe(result.renderer.width)
-  expect(writeContext.widthMethod).toBe(result.renderer.widthMethod)
-})
-
-test("CliRenderer writeToScrollback runs snapshot teardown after enqueueing", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  let teardownCalls = 0
-  let snapshotRoot: TextRenderable | null = null
-
-  renderer.writeToScrollback((ctx) => {
-    const root = new TextRenderable(ctx.renderContext, {
-      id: "scrollback-teardown-success",
-      position: "absolute",
-      left: 0,
-      top: 0,
-      width: 4,
-      height: 1,
-      content: "done",
-    })
-    snapshotRoot = root
-
-    return {
-      root,
-      width: 4,
-      height: 1,
-      teardown: () => {
-        teardownCalls += 1
-      },
-    }
-  })
-
-  expect(teardownCalls).toBe(1)
-  expect(requireSnapshotRoot(snapshotRoot).isDestroyed).toBe(true)
-  expect((renderer as any).externalOutputQueue.size).toBe(1)
-})
-
-test("CliRenderer writeToScrollback runs snapshot teardown when snapshot validation fails", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  let teardownCalls = 0
-  let snapshotRoot: TextRenderable | null = null
-
-  expect(() => {
-    renderer!.writeToScrollback((ctx) => {
-      const root = new TextRenderable(ctx.renderContext, {
-        id: "scrollback-teardown-failure",
-        position: "absolute",
-        left: 0,
-        top: 0,
-        width: 4,
-        height: 1,
-        content: "fail",
-      })
-      snapshotRoot = root
-
-      return {
-        root,
-        width: Number.NaN,
-        height: 1,
-        teardown: () => {
-          teardownCalls += 1
-        },
-      }
-    })
-  }).toThrow("writeToScrollback produced a non-finite width")
-
-  expect(teardownCalls).toBe(1)
-  expect(requireSnapshotRoot(snapshotRoot).isDestroyed).toBe(true)
-})
-
-test("CliRenderer preserves append order when writeToScrollback and stdout capture are interleaved", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    const snapshotBuffer = args[1]
-    const content = new TextDecoder().decode(snapshotBuffer.getRealCharBytes(true)).trim()
-    const startOnNewLine = args[3]
-    order.push(`${startOnNewLine ? "api" : "stdout"}:${content}`)
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  renderer.writeToScrollback(textScrollbackWrite("api-1\n"))
-  ;(renderer as any).stdout.write("stdout-1\n")
-  renderer.writeToScrollback(textScrollbackWrite("api-2\n"))
-
-  await result.renderOnce()
-
-  expect(order).toHaveLength(3)
-  expect(order[0]).toContain("api:api-1")
-  expect(order[1]).toContain("stdout:stdout-1")
-  expect(order[2]).toContain("api:api-2")
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-})
-
-test("CliRenderer writeToScrollback bypasses global console capture singleton", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  capture.claimOutput()
-
-  renderer.writeToScrollback(textScrollbackWrite("api-only\n"))
-  await result.renderOnce()
-
-  expect(capture.size).toBe(0)
-  expect(capture.claimOutput()).toBe("")
-})
-
-test("CliRenderer flushes captured output before switching to passthrough in split-footer", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const lib = (renderer as any).lib
-  const splitCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  let committedOutput = ""
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    committedOutput = new TextDecoder().decode(args[1].getRealCharBytes(true))
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  ;(renderer as any).stdout.write("pending output\n")
-
-  expect((renderer as any).externalOutputQueue.size).toBe(1)
-
-  renderer.externalOutputMode = "passthrough"
-
-  expect(splitCommitSpy).toHaveBeenCalledTimes(1)
-  expect(committedOutput).toContain("pending output")
-  expect((renderer as any).externalOutputQueue.size).toBe(0)
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  splitCommitSpy.mockRestore()
-})
-
-test("CliRenderer drains all pending split commits before switching to passthrough", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const lib = (renderer as any).lib
-  const splitCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-
-  for (let i = 0; i < 10; i += 1) {
-    ;(renderer as any).stdout.write(`pending-${i}\n`)
-  }
-
-  expect((renderer as any).externalOutputQueue.size).toBe(10)
-
-  renderer.externalOutputMode = "passthrough"
-
-  expect(splitCommitSpy).toHaveBeenCalledTimes(10)
-  expect((renderer as any).externalOutputQueue.size).toBe(0)
-
-  splitCommitSpy.mockRestore()
-})
-
-test("CliRenderer keeps stdout captured until a deferred passthrough switch drains", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const unblockStartupSeed = blockSplitStartupCursorSeed(renderer)
-
-  const committedOutput: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    committedOutput.push(new TextDecoder().decode(args[1].getRealCharBytes(true)))
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  try {
-    ;(renderer as any).stdout.write("older\n")
-    renderer.externalOutputMode = "passthrough"
-
-    expect((renderer as any).externalOutputMode).toBe("capture-stdout")
-
-    ;(renderer as any).stdout.write("newer\n")
-
-    expect((renderer as any).externalOutputQueue.size).toBe(2)
-
-    unblockStartupSeed()
-    await result.renderOnce()
-
-    expect(committedOutput[0]).toContain("older")
-    expect(committedOutput[1]).toContain("newer")
-    expect((renderer as any).externalOutputQueue.size).toBe(0)
-    expect(renderer.externalOutputMode).toBe("passthrough")
-  } finally {
-    unblockStartupSeed()
-    lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  }
-})
-
-test("CliRenderer drains deferred passthrough output before leaving split-footer", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const unblockStartupSeed = blockSplitStartupCursorSeed(renderer)
-
-  const lib = (renderer as any).lib
-  const splitCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-
-  try {
-    ;(renderer as any).stdout.write("before-leave\n")
-    renderer.externalOutputMode = "passthrough"
-
-    expect((renderer as any).externalOutputMode).toBe("capture-stdout")
-
-    renderer.screenMode = "main-screen"
-
-    expect(splitCommitSpy).toHaveBeenCalledTimes(1)
-    expect((renderer as any).externalOutputQueue.size).toBe(0)
-    expect(renderer.externalOutputMode).toBe("passthrough")
-    expect(renderer.screenMode).toBe("main-screen")
-  } finally {
-    unblockStartupSeed()
-    splitCommitSpy.mockRestore()
-  }
-})
-
-test("CliRenderer leaving split-footer aborts an in-flight startup CPR reply", async () => {
-  const clock = new ManualClock()
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-    clock,
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  ;(renderer as any).pendingSplitStartupCursorSeed = true
-  ;(renderer as any).splitStartupSeedTimeoutId = clock.setTimeout(() => {}, 120)
-  ;(renderer as any).capabilityTimeoutId = clock.setTimeout(() => {}, 5000)
-  ;(renderer as any).updateStdinParserProtocolContext({ startupCursorCprActive: true })
-
-  const keypresses: string[] = []
-  renderer.keyInput.on("keypress", (event) => {
-    keypresses.push(event.name)
-  })
-
-  try {
-    renderer.stdin.emit("data", Buffer.from("\x1b["))
-
-    ;(renderer as any).stdout.write("before-leave\n")
-    renderer.externalOutputMode = "passthrough"
-
-    expect((renderer as any).externalOutputMode).toBe("capture-stdout")
-
-    renderer.screenMode = "main-screen"
-
-    expect((renderer as any).pendingSplitStartupCursorSeed).toBe(false)
-    expect((renderer as any).splitStartupSeedTimeoutId).toBeNull()
-    expect((renderer as any).stdinParser.protocolContext.startupCursorCprActive).toBe(false)
-
-    renderer.stdin.emit("data", Buffer.from("24;80R"))
-    clock.advance(20)
-
-    expect(keypresses).toEqual([])
-  } finally {
-    if ((renderer as any).capabilityTimeoutId !== null) {
-      clock.clearTimeout((renderer as any).capabilityTimeoutId)
-      ;(renderer as any).capabilityTimeoutId = null
-    }
-
-    if ((renderer as any).splitStartupSeedTimeoutId !== null) {
-      clock.clearTimeout((renderer as any).splitStartupSeedTimeoutId)
-      ;(renderer as any).splitStartupSeedTimeoutId = null
-    }
-  }
-})
-
-test("CliRenderer preserves split render offset when switching to passthrough", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any).stdout.write("seed\n")
-  await result.renderOnce()
-
-  const before = (renderer as any).renderOffset
-  const pinned = (renderer as any)._terminalHeight - (renderer as any)._splitHeight
-
-  renderer.externalOutputMode = "passthrough"
-
-  expect(before).toBeGreaterThan(0)
-  expect(before).toBeLessThanOrEqual(pinned)
-  expect((renderer as any).renderOffset).toBe(before)
-})
-
-test("CliRenderer does not force split repaint when switching to passthrough with no pending output", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const lib = (renderer as any).lib
-  const repaintSpy = spyOn(lib, "repaintSplitFooter")
-
-  expect((renderer as any).externalOutputQueue.size).toBe(0)
-
-  renderer.externalOutputMode = "passthrough"
-
-  expect(repaintSpy).toHaveBeenCalledTimes(0)
-  repaintSpy.mockRestore()
-})
-
-test("CliRenderer flushes pending split output before resize applies new geometry", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  ;(renderer as any).stdout.write("before-resize\n")
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalResizeRenderer = lib.resizeRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.resizeRenderer = (...args: any[]) => {
-    order.push("resize")
-    return originalResizeRenderer(...args)
-  }
-
-  ;(renderer as any).processResize(60, 16)
-
-  expect(order.indexOf("split-commit")).toBeGreaterThanOrEqual(0)
-  expect(order.indexOf("resize")).toBeGreaterThanOrEqual(0)
-  expect(order.indexOf("split-commit")).toBeLessThan(order.indexOf("resize"))
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  lib.resizeRenderer = originalResizeRenderer
-})
-
-test("CliRenderer flushes pending writeToScrollback output before resize applies new geometry", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  renderer.writeToScrollback(textScrollbackWrite("before-resize\n"))
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalResizeRenderer = lib.resizeRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.resizeRenderer = (...args: any[]) => {
-    order.push("resize")
-    return originalResizeRenderer(...args)
-  }
-
-  ;(renderer as any).processResize(60, 16)
-
-  expect(order.indexOf("split-commit")).toBeGreaterThanOrEqual(0)
-  expect(order.indexOf("resize")).toBeGreaterThanOrEqual(0)
-  expect(order.indexOf("split-commit")).toBeLessThan(order.indexOf("resize"))
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  lib.resizeRenderer = originalResizeRenderer
-})
-
-test("CliRenderer resetSplitFooterForReplay clears published scrollback and starts fresh", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  renderer.writeToScrollback(textScrollbackWrite("before-replay\n"))
-
-  const lib = (renderer as any).lib
-  const resetSpy = spyOn(lib, "resetSplitScrollback")
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-
-  renderer.resetSplitFooterForReplay({ clearSavedLines: true })
-
-  expect(resetSpy).toHaveBeenCalledWith((renderer as any).rendererPtr, 0, 6)
-  expect(writeOutSpy).toHaveBeenCalledWith("\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H")
-  expect((renderer as any).splitTailColumn).toBe(0)
-  expect((renderer as any).pendingSplitFooterTransition).toBeNull()
-
-  resetSpy.mockRestore()
-  writeOutSpy.mockRestore()
-})
-
-test("CliRenderer resetSplitFooterForReplay rejects suspended terminal ownership", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  renderer.suspend()
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-
-  expect(() => renderer!.resetSplitFooterForReplay({ clearSavedLines: true })).toThrow(
-    "resetSplitFooterForReplay requires an active terminal",
-  )
-  expect(writeOutSpy).not.toHaveBeenCalled()
-
-  writeOutSpy.mockRestore()
-})
-
-test("CliRenderer reuses generic suspend/resume native helpers in split-footer mode", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const suspendGenericSpy = spyOn((renderer as any).lib, "suspendRenderer")
-  const resumeGenericSpy = spyOn((renderer as any).lib, "resumeRenderer")
-
-  renderer.suspend()
-  renderer.resume()
-
-  expect(suspendGenericSpy).toHaveBeenCalledTimes(1)
-  expect(resumeGenericSpy).toHaveBeenCalledTimes(1)
-
-  suspendGenericSpy.mockRestore()
-  resumeGenericSpy.mockRestore()
-})
-
-test("CliRenderer split-footer resume forces the next footer repaint", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  renderer.start()
-  renderer.suspend()
-
-  const repaintSpy = spyOn((renderer as any).lib, "repaintSplitFooter")
-  renderer.resume()
-  renderer.pause()
-
-  const lastCall = repaintSpy.mock.calls[repaintSpy.mock.calls.length - 1]
-  expect(lastCall?.[2]).toBe(true)
-  expect((renderer as any).forceFullRepaintRequested).toBe(false)
-
-  repaintSpy.mockRestore()
-})
-
-test("CliRenderer applies suspended screen mode changes on resume", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "main-screen",
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const lib = (renderer as any).lib
-  const originalSetupTerminal = lib.setupTerminal.bind(lib)
-  const originalResumeRenderer = lib.resumeRenderer.bind(lib)
-  const setupTerminalCalls: any[][] = []
-  let resumeRendererCalls = 0
-
-  lib.setupTerminal = (...args: any[]) => {
-    setupTerminalCalls.push(args)
-  }
-  lib.resumeRenderer = (...args: any[]) => {
-    resumeRendererCalls += 1
-    return originalResumeRenderer(...args)
-  }
-
-  try {
-    renderer.suspend()
-    const setupCallsAfterSuspend = setupTerminalCalls.length
-    renderer.screenMode = "alternate-screen"
-
-    expect(setupTerminalCalls.length).toBe(setupCallsAfterSuspend)
-
-    renderer.resume()
-
-    expect(setupTerminalCalls.length).toBe(setupCallsAfterSuspend + 1)
-    expect(setupTerminalCalls.at(-1)?.[1]).toBe(true)
-    expect(resumeRendererCalls).toBe(0)
-  } finally {
-    lib.setupTerminal = originalSetupTerminal
-    lib.resumeRenderer = originalResumeRenderer
-  }
-})
-
-test("CliRenderer resumes preserved split-footer reservation after suspended screen roundtrip", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const lib = (renderer as any).lib
-  const originalSetupTerminal = lib.setupTerminal.bind(lib)
-  const originalResumeRenderer = lib.resumeRenderer.bind(lib)
-  let setupTerminalCalls = 0
-  let resumeRendererCalls = 0
-
-  lib.setupTerminal = (...args: any[]) => {
-    setupTerminalCalls += 1
-    return originalSetupTerminal(...args)
-  }
-  lib.resumeRenderer = (...args: any[]) => {
-    resumeRendererCalls += 1
-    return originalResumeRenderer(...args)
-  }
-
-  try {
-    renderer.suspend()
-    renderer.screenMode = "alternate-screen"
-    renderer.screenMode = "split-footer"
-    renderer.resume()
-
-    expect(setupTerminalCalls).toBe(0)
-    expect(resumeRendererCalls).toBe(1)
-  } finally {
-    lib.setupTerminal = originalSetupTerminal
-    lib.resumeRenderer = originalResumeRenderer
-  }
-})
-
-test("CliRenderer does not flush captured split output during resize while suspended", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const splitCommitSpy = spyOn((renderer as any).lib, "commitSplitFooterSnapshot")
-
-  renderer.suspend()
-  ;(renderer as any).stdout.write("during-suspend\n")
-  ;(renderer as any).processResize(60, 16)
-
-  expect(splitCommitSpy).toHaveBeenCalledTimes(0)
-
-  splitCommitSpy.mockRestore()
-})
-
-test("CliRenderer recomputes queued split tail after a blocked resize", async () => {
-  const result = await createTestRenderer({
-    width: 10,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const unblockStartupSeed = blockSplitStartupCursorSeed(renderer)
-
-  try {
-    ;(renderer as any).stdout.write("123456789012345")
-    ;(renderer as any).processResize(20, 10)
-
-    let tailColumn = -1
-    renderer.writeToScrollback((ctx) => {
-      tailColumn = ctx.tailColumn
-      const root = new TextRenderable(ctx.renderContext, {
-        id: "tail-after-resize-probe",
-        content: "x",
-        width: 1,
-        height: 1,
-      })
-
-      return {
-        root,
-        width: 1,
-        height: 1,
-        startOnNewLine: false,
-        trailingNewline: false,
-      }
-    })
-
-    expect(tailColumn).toBe(15)
-  } finally {
-    unblockStartupSeed()
-  }
-})
-
-test("CliRenderer preserves captured split output when switching output mode while suspended", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const splitCommitSpy = spyOn((renderer as any).lib, "commitSplitFooterSnapshot")
-
-  renderer.suspend()
-  const commitCallsAfterSuspend = splitCommitSpy.mock.calls.length
-  ;(renderer as any).stdout.write("during-suspend\n")
-  renderer.externalOutputMode = "passthrough"
-
-  expect(splitCommitSpy.mock.calls.length).toBe(commitCallsAfterSuspend)
-  expect((renderer as any).externalOutputQueue.size).toBe(1)
-  expect((renderer as any).externalOutputMode).toBe("capture-stdout")
-
-  renderer.resume()
-
-  expect(splitCommitSpy.mock.calls.length).toBe(commitCallsAfterSuspend + 1)
-  expect((renderer as any).externalOutputQueue.size).toBe(0)
-  expect(renderer.externalOutputMode).toBe("passthrough")
-
-  splitCommitSpy.mockRestore()
-})
-
-test("CliRenderer preserves captured split output until startup cursor seed unblocks passthrough switch", async () => {
-  const clock = new ManualClock()
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-    clock,
-  })
-
-  renderer = result.renderer
-  const lib = (renderer as any).lib
-  const originalSetupTerminal = lib.setupTerminal.bind(lib)
-  lib.setupTerminal = () => {}
-
-  const splitCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-
-  try {
-    await renderer.setupTerminal()
-
-    ;(renderer as any).stdout.write("during-startup\n")
-    renderer.externalOutputMode = "passthrough"
-
-    expect(splitCommitSpy).toHaveBeenCalledTimes(0)
-    expect((renderer as any).externalOutputQueue.size).toBe(1)
-    expect((renderer as any).externalOutputMode).toBe("capture-stdout")
-
-    clock.advance(120)
-
-    expect(splitCommitSpy).toHaveBeenCalledTimes(1)
-    expect((renderer as any).externalOutputQueue.size).toBe(0)
-    expect(renderer.externalOutputMode).toBe("passthrough")
-  } finally {
-    lib.setupTerminal = originalSetupTerminal
-    splitCommitSpy.mockRestore()
-  }
-})
-
-test("CliRenderer flushes pending split output on suspend even when startup cursor seeding is pending", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const unblockStartupSeed = blockSplitStartupCursorSeed(renderer)
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalSuspendRenderer = lib.suspendRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.suspendRenderer = (...args: any[]) => {
-    order.push("suspend")
-    return originalSuspendRenderer(...args)
-  }
-
-  try {
-    ;(renderer as any).stdout.write("before-suspend\n")
-    renderer.suspend()
-
-    expect(order.indexOf("split-commit")).toBeGreaterThanOrEqual(0)
-    expect(order.indexOf("suspend")).toBeGreaterThanOrEqual(0)
-    expect(order.indexOf("split-commit")).toBeLessThan(order.indexOf("suspend"))
-    expect((renderer as any).externalOutputQueue.size).toBe(0)
-  } finally {
-    unblockStartupSeed()
-    lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-    lib.suspendRenderer = originalSuspendRenderer
-  }
-})
-
-test("CliRenderer flushes pending writeToScrollback output before suspend", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  renderer.writeToScrollback(textScrollbackWrite("before-suspend\n"))
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalSuspendRenderer = lib.suspendRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.suspendRenderer = (...args: any[]) => {
-    order.push("suspend")
-    return originalSuspendRenderer(...args)
-  }
-
-  renderer.suspend()
-
-  expect(order.indexOf("split-commit")).toBeGreaterThanOrEqual(0)
-  expect(order.indexOf("suspend")).toBeGreaterThanOrEqual(0)
-  expect(order.indexOf("split-commit")).toBeLessThan(order.indexOf("suspend"))
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  lib.suspendRenderer = originalSuspendRenderer
-})
-
-test("CliRenderer clears split footer surface when leaving split-footer mode", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const clearCalls: number[] = []
-  const lib = (renderer as any).lib
-  const originalSetRenderOffset = lib.setRenderOffset.bind(lib)
-
-  lib.setRenderOffset = (...args: any[]) => {
-    if (args[1] === 0) {
-      clearCalls.push(args[1])
-    }
-    return originalSetRenderOffset(...args)
-  }
-
-  renderer.screenMode = "main-screen"
-
-  expect(clearCalls.length).toBeGreaterThanOrEqual(1)
-
-  lib.setRenderOffset = originalSetRenderOffset
-})
-
-test("CliRenderer destroy flushes split output before clearing split footer surface", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  ;(renderer as any).stdout.write("before-destroy\n")
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalSetRenderOffset = lib.setRenderOffset.bind(lib)
-  const originalDestroyRenderer = lib.destroyRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.setRenderOffset = (...args: any[]) => {
-    if (args[1] === 0) {
-      order.push("clear")
-    }
-    return originalSetRenderOffset(...args)
-  }
-  lib.destroyRenderer = (...args: any[]) => {
-    order.push("destroy")
-    return originalDestroyRenderer(...args)
-  }
-
-  renderer.destroy()
-
-  expect(order).toEqual(["split-commit", "clear", "destroy"])
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  lib.setRenderOffset = originalSetRenderOffset
-  lib.destroyRenderer = originalDestroyRenderer
-})
-
-test("CliRenderer destroy flushes writeToScrollback output before clearing split footer surface", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  renderer.writeToScrollback(textScrollbackWrite("before-destroy\n"))
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalSetRenderOffset = lib.setRenderOffset.bind(lib)
-  const originalDestroyRenderer = lib.destroyRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.setRenderOffset = (...args: any[]) => {
-    if (args[1] === 0) {
-      order.push("clear")
-    }
-    return originalSetRenderOffset(...args)
-  }
-  lib.destroyRenderer = (...args: any[]) => {
-    order.push("destroy")
-    return originalDestroyRenderer(...args)
-  }
-
-  renderer.destroy()
-
-  expect(order).toEqual(["split-commit", "clear", "destroy"])
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  lib.setRenderOffset = originalSetRenderOffset
-  lib.destroyRenderer = originalDestroyRenderer
-})
-
-test("CliRenderer destroy does not clear split footer surface when clearOnShutdown is false", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-    clearOnShutdown: false,
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  ;(renderer as any).stdout.write("before-destroy\n")
-
-  const order: string[] = []
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const originalSetRenderOffset = lib.setRenderOffset.bind(lib)
-  const originalDestroyRenderer = lib.destroyRenderer.bind(lib)
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    order.push("split-commit")
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-  lib.setRenderOffset = (...args: any[]) => {
-    if (args[1] === 0) {
-      order.push("clear")
-    }
-    return originalSetRenderOffset(...args)
-  }
-  lib.destroyRenderer = (...args: any[]) => {
-    order.push("destroy")
-    return originalDestroyRenderer(...args)
-  }
-
-  renderer.destroy()
-
-  expect(order).toEqual(["split-commit", "destroy"])
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  lib.setRenderOffset = originalSetRenderOffset
-  lib.destroyRenderer = originalDestroyRenderer
-})
-
-test("CliRenderer split-footer passthrough ignores console capture writes", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const requestRenderSpy = spyOn(renderer, "requestRender")
-
-  capture.write("stdout", "from console capture\n")
-
-  expect(requestRenderSpy).toHaveBeenCalledTimes(0)
-  expect((renderer as any).externalOutputQueue.size).toBe(0)
-  requestRenderSpy.mockRestore()
-})
-
-test("CliRenderer split-footer captures direct console writes when console mode is disabled", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  ;(renderer as any).stdout.write("direct write\n")
-
-  const commits = (renderer as any).externalOutputQueue.claim()
-  expect(commits.length).toBe(1)
-  expect(commits[0]?.startOnNewLine).toBe(false)
-  expect(commits[0]?.trailingNewline).toBe(true)
-  expect(commits[0]?.rowColumns).toBe(12)
-  const rendered = new TextDecoder().decode(commits[0]?.snapshot.getRealCharBytes(true))
-  expect(rendered).toContain("direct write")
-  commits[0]?.snapshot.destroy()
-  expect(capture.size).toBe(0)
-})
-
-test("CliRenderer split-footer renderNative does not call TypeScript flush path", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const flushSpy = spyOn(renderer as any, "flushStdoutCache")
-
-  ;(renderer as any).stdout.write("pending output\n")
-  await result.renderOnce()
-
-  expect(flushSpy).toHaveBeenCalledTimes(0)
-  flushSpy.mockRestore()
-})
-
-test("CliRenderer split-footer renderNative repaints footer frame with no pending commits", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const splitCommitSpy = spyOn((renderer as any).lib, "repaintSplitFooter")
-
-  await result.renderOnce()
-
-  expect(splitCommitSpy).toHaveBeenCalledTimes(1)
-  expect(splitCommitSpy.mock.calls[0]?.[2]).toBe(false)
-
-  splitCommitSpy.mockRestore()
-})
-
-test("CliRenderer split-footer forwards forced repaint flag to final pending commit", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const lib = (renderer as any).lib
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const forceFlags: boolean[] = []
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    forceFlags.push(args[6] as boolean)
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  ;(renderer as any).stdout.write("line-1\nline-2\n")
-  ;(renderer as any).forceFullRepaintRequested = true
-
-  await result.renderOnce()
-
-  expect(forceFlags).toEqual([false, true])
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-})
-
-test("CliRenderer split-footer defers first native frame while startup cursor seed is pending", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const unblockStartupSeed = blockSplitStartupCursorSeed(renderer)
-
-  const repaintSpy = spyOn((renderer as any).lib, "repaintSplitFooter")
-  const commitSpy = spyOn((renderer as any).lib, "commitSplitFooterSnapshot")
-
-  try {
-    await result.renderOnce()
-
-    expect(repaintSpy).toHaveBeenCalledTimes(0)
-    expect(commitSpy).toHaveBeenCalledTimes(0)
-  } finally {
-    unblockStartupSeed()
-    repaintSpy.mockRestore()
-    commitSpy.mockRestore()
-  }
-})
-
-test("CliRenderer split-footer starts in settling phase and then pins as output grows", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  expect((renderer as any).renderOffset).toBe(1)
-
-  ;(renderer as any).stdout.write("a\n")
-  await result.renderOnce()
-  expect((renderer as any).renderOffset).toBe(2)
-
-  ;(renderer as any).stdout.write("b\n")
-  await result.renderOnce()
-  expect((renderer as any).renderOffset).toBe(3)
-
-  ;(renderer as any).stdout.write("c\n")
-  await result.renderOnce()
-  expect((renderer as any).renderOffset).toBe(4)
-
-  for (let i = 0; i < 8; i++) {
-    ;(renderer as any).stdout.write(`line-${i}\n`)
-    await result.renderOnce()
-  }
-
-  expect((renderer as any).renderOffset).toBe(6)
-})
-
-test("CliRenderer split-footer footerHeight changes defer settling cleanup to the next native frame", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-  const repaintSpy = spyOn((renderer as any).lib, "repaintSplitFooter")
-
-  renderer.footerHeight = 8
-  renderer.footerHeight = 3
-
-  expect((renderer as any).renderOffset).toBe(1)
-  expect(writeOutSpy).toHaveBeenCalledTimes(0)
-
-  await result.renderOnce()
-
-  expect(repaintSpy).toHaveBeenCalledTimes(1)
-  expect(repaintSpy.mock.calls[0]?.[2]).toBe(true)
-
-  writeOutSpy.mockRestore()
-  repaintSpy.mockRestore()
-})
-
-test("CliRenderer split-footer footerHeight changes coalesce while settling before the next frame", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const repaintSpy = spyOn((renderer as any).lib, "repaintSplitFooter")
-
-  renderer.footerHeight = 8
-  renderer.footerHeight = 3
-
-  await result.renderOnce()
-
-  expect(repaintSpy).toHaveBeenCalledTimes(1)
-  expect(repaintSpy.mock.calls[0]?.[1]).toBe(7)
-  expect(repaintSpy.mock.calls[0]?.[2]).toBe(true)
-
-  repaintSpy.mockRestore()
-})
-
-test("CliRenderer split-footer grow then shrink back before frame keeps grown top line", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  ;(renderer as any).stdout.write("a\n")
-  await result.renderOnce()
-  ;(renderer as any).stdout.write("b\n")
-  await result.renderOnce()
-
-  expect((renderer as any).renderOffset).toBe(3)
-
-  renderer.footerHeight = 8
-  renderer.footerHeight = 4
-
-  await result.renderOnce()
-
-  expect((renderer as any).renderOffset).toBe(2)
-})
-
-test("CliRenderer split-footer pinned footerHeight shrink defers clear-stale-row cleanup to the next native frame", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  for (let i = 0; i < 12; i += 1) {
-    ;(renderer as any).stdout.write(`line-${i}\n`)
-    await result.renderOnce()
-  }
-
-  expect((renderer as any).renderOffset).toBe(6)
-
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-  const repaintSpy = spyOn((renderer as any).lib, "repaintSplitFooter")
-
-  renderer.footerHeight = 3
-
-  expect((renderer as any).renderOffset).toBe(6)
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "clear-stale-rows",
-    sourceTopLine: 7,
-    sourceHeight: 4,
-    targetTopLine: 7,
-    targetHeight: 3,
-    scrollLines: 0,
-  })
-  expect(writeOutSpy).toHaveBeenCalledTimes(0)
-
-  await result.renderOnce()
-
-  expect((renderer as any).renderOffset).toBe(6)
-  expect(repaintSpy).toHaveBeenCalledTimes(1)
-  expect(repaintSpy.mock.calls[0]?.[1]).toBe(7)
-  expect(repaintSpy.mock.calls[0]?.[2]).toBe(true)
-
-  writeOutSpy.mockRestore()
-  repaintSpy.mockRestore()
-})
-
-test("CliRenderer split-footer reuses the reserved gap when reopening the footer before new output arrives", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  for (let i = 0; i < 12; i += 1) {
-    ;(renderer as any).stdout.write(`line-${i}\n`)
-    await result.renderOnce()
-  }
-
-  expect((renderer as any).renderOffset).toBe(6)
-
-  renderer.footerHeight = 8
-
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "viewport-scroll",
-    sourceTopLine: 7,
-    sourceHeight: 4,
-    targetTopLine: 3,
-    targetHeight: 8,
-    scrollLines: 4,
-  })
-
-  await result.renderOnce()
-
-  renderer.footerHeight = 4
-
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "clear-stale-rows",
-    sourceTopLine: 3,
-    sourceHeight: 8,
-    targetTopLine: 3,
-    targetHeight: 4,
-    scrollLines: 0,
-  })
-
-  await result.renderOnce()
-
-  expect((renderer as any).renderOffset).toBe(2)
-
-  renderer.footerHeight = 7
-
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "clear-stale-rows",
-    sourceTopLine: 3,
-    sourceHeight: 4,
-    targetTopLine: 3,
-    targetHeight: 7,
-    scrollLines: 0,
-  })
-})
-
-test("CliRenderer split-footer passthrough footerHeight shrink clears stale rows without reverse scrolling", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-
-  renderer.footerHeight = 3
-
-  expect(writeOutSpy).toHaveBeenCalledTimes(1)
-  expect(writeOutSpy.mock.calls[0]?.[0]).toBe(`${ANSI.moveCursor(7, 1)}\x1b[2K`)
-
-  writeOutSpy.mockRestore()
-})
-
-test("CliRenderer split-footer resize cleanup uses the visible footer surface while a deferred footer transition is pending", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-
-  renderer.footerHeight = 3
-
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "clear-stale-rows",
-    sourceTopLine: 2,
-    sourceHeight: 4,
-    targetTopLine: 2,
-    targetHeight: 3,
-    scrollLines: 0,
-  })
-
-  result.resize(20, 10)
-
-  expect(writeOutSpy).toHaveBeenCalledTimes(1)
-  expect(writeOutSpy.mock.calls[0]?.[0]).toBe(ANSI.moveCursorAndClear(2, 1))
-  expect((renderer as any).pendingSplitFooterTransition).toBeNull()
-
-  writeOutSpy.mockRestore()
-})
-
-test("CliRenderer split-footer resize cleanup uses the visible source top line across width and height resize while a deferred footer transition is pending", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-
-  renderer.footerHeight = 3
-
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "clear-stale-rows",
-    sourceTopLine: 2,
-    sourceHeight: 4,
-    targetTopLine: 2,
-    targetHeight: 3,
-    scrollLines: 0,
-  })
-
-  result.resize(20, 12)
-
-  expect(writeOutSpy).toHaveBeenCalledTimes(1)
-  expect(writeOutSpy.mock.calls[0]?.[0]).toBe(ANSI.moveCursorAndClear(2, 1))
-
-  writeOutSpy.mockRestore()
-})
-
-test("CliRenderer split-footer resize cleanup still clears the visible source surface when only height changes while a deferred footer transition is pending", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  const writeOutSpy = spyOn(renderer as any, "writeOut")
-
-  renderer.footerHeight = 3
-
-  result.resize(40, 12)
-
-  expect(writeOutSpy).toHaveBeenCalledTimes(1)
-  expect(writeOutSpy.mock.calls[0]?.[0]).toBe(ANSI.moveCursorAndClear(2, 1))
-
-  writeOutSpy.mockRestore()
-})
-
-test("CliRenderer split-footer footerHeight changes do not queue deferred transitions while startup cursor seeding blocks the first frame", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-  const unblockStartupSeed = blockSplitStartupCursorSeed(renderer)
-
-  const setPendingTransitionSpy = spyOn((renderer as any).lib, "setPendingSplitFooterTransition")
-
-  try {
-    renderer.footerHeight = 3
-
-    expect(setPendingTransitionSpy).toHaveBeenCalledTimes(0)
-    expect((renderer as any).pendingSplitFooterTransition).toBeNull()
-    expect((renderer as any).forceFullRepaintRequested).toBe(true)
-  } finally {
-    unblockStartupSeed()
-    setPendingTransitionSpy.mockRestore()
-  }
-})
-
-test("CliRenderer entering split capture seeds from current terminal cursor row", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 20,
-    screenMode: "main-screen",
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  renderer.footerHeight = 6
-  renderer.setCursorPosition(1, 4, true)
-
-  renderer.screenMode = "split-footer"
-  renderer.externalOutputMode = "capture-stdout"
-
-  expect((renderer as any).renderOffset).toBe(4)
-})
-
-test("CliRenderer entering split capture after a committed main-screen frame clears the old pinned footer surface", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  await result.renderOnce()
-
-  renderer.externalOutputMode = "passthrough"
-  renderer.screenMode = "main-screen"
-  await result.renderOnce()
-
-  renderer.screenMode = "split-footer"
-  renderer.externalOutputMode = "capture-stdout"
-
-  expect((renderer as any).pendingSplitFooterTransition).toEqual({
-    mode: "clear-stale-rows",
-    sourceTopLine: 7,
-    sourceHeight: 4,
-    targetTopLine: 2,
-    targetHeight: 4,
-    scrollLines: 0,
-  })
-  expect((renderer as any).forceFullRepaintRequested).toBe(true)
-})
-
-test("CliRenderer reseeds split startup offset from non-home CPR capability response", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 20,
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  expect((renderer as any).renderOffset).toBe(1)
-
-  const lib = (renderer as any).lib
-  const originalGetCursorState = lib.getCursorState.bind(lib)
-  ;(renderer as any).pendingSplitStartupCursorSeed = true
-  ;(renderer as any).capabilityTimeoutId = setTimeout(() => {}, 10)
-  ;(renderer as any).setPendingSplitFooterTransition({
-    mode: "clear-stale-rows",
-    sourceTopLine: 2,
-    sourceHeight: 6,
-    targetTopLine: 2,
-    targetHeight: 4,
-  })
-
-  try {
-    lib.getCursorState = () => ({
-      ...originalGetCursorState((renderer as any).rendererPtr),
-      y: 5,
-    })
-
-    const handled = (renderer as any).processCapabilitySequence("\x1b[5;1R", true)
-
-    expect(handled).toBe(false)
-    expect((renderer as any).renderOffset).toBe(5)
-    expect((renderer as any).pendingSplitStartupCursorSeed).toBe(false)
-    expect((renderer as any).pendingSplitFooterTransition).toBeNull()
-  } finally {
-    clearTimeout((renderer as any).capabilityTimeoutId)
-    ;(renderer as any).capabilityTimeoutId = null
-    lib.getCursorState = originalGetCursorState
-  }
-})
-
-test("CliRenderer does not consume standalone CPR replies during capability window", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 20,
-    screenMode: "main-screen",
-    externalOutputMode: "passthrough",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  ;(renderer as any).pendingSplitStartupCursorSeed = false
-  ;(renderer as any).capabilityTimeoutId = setTimeout(() => {}, 10)
-
-  const handled = (renderer as any).processCapabilitySequence("\x1b[7;11R", true)
-  expect(handled).toBe(false)
-
-  clearTimeout((renderer as any).capabilityTimeoutId)
-  ;(renderer as any).capabilityTimeoutId = null
-})
-
-test("CliRenderer preserves cursor seed rows when split starts with zero pinned offset", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 12,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  expect((renderer as any).renderOffset).toBe(0)
-
-  renderer.footerHeight = 4
-
-  expect((renderer as any).renderOffset).toBe(1)
-})
-
-test("CliRenderer split-footer commits only unpublished captured output chunks", async () => {
-  const result = await createTestRenderer({
-    width: 40,
-    height: 10,
-    screenMode: "split-footer",
-    footerHeight: 4,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const lib = (renderer as any).lib
-  const snapshotCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-  const fullRenderSpy = spyOn(lib, "repaintSplitFooter")
-
-  const committedPayloads: string[] = []
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    committedPayloads.push(new TextDecoder().decode(args[1].getRealCharBytes(true)).trim())
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  ;(renderer as any).stdout.write("first\n")
-  await result.renderOnce()
-
-  ;(renderer as any).stdout.write("second\n")
-  await result.renderOnce()
-
-  await result.renderOnce()
-
-  expect(snapshotCommitSpy).toHaveBeenCalledTimes(2)
-  expect(committedPayloads[0]).toContain("first")
-  expect(committedPayloads[1]).toContain("second")
-
-  expect(fullRenderSpy).toHaveBeenCalledTimes(1)
-  expect(fullRenderSpy.mock.calls[0]?.[2]).toBe(false)
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  snapshotCommitSpy.mockRestore()
-  fullRenderSpy.mockRestore()
-})
-
-test("CliRenderer split-footer routes captured output through snapshot native commit path", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-  const lib = (renderer as any).lib
-  const splitCommitSpy = spyOn(lib, "commitSplitFooterSnapshot")
-  const originalCommitSplitFooterSnapshot = lib.commitSplitFooterSnapshot.bind(lib)
-  const payloads: string[] = []
-
-  lib.commitSplitFooterSnapshot = (...args: any[]) => {
-    payloads.push(new TextDecoder().decode(args[1].getRealCharBytes(true)).trim())
-    return originalCommitSplitFooterSnapshot(...args)
-  }
-
-  ;(renderer as any).stdout.write("line-1\nline-2\n")
-  await result.renderOnce()
-
-  expect(splitCommitSpy).toHaveBeenCalledTimes(2)
-  expect(payloads[0]).toContain("line-1")
-  expect(payloads[1]).toContain("line-2")
-  expect((renderer as any).renderOffset).toBe(3)
-
-  lib.commitSplitFooterSnapshot = originalCommitSplitFooterSnapshot
-  splitCommitSpy.mockRestore()
-})
-
-test("CliRenderer split-footer native scrollback tracks wrapped tail state across commits", async () => {
-  const result = await createTestRenderer({
-    width: 4,
-    height: 6,
-    screenMode: "split-footer",
-    footerHeight: 2,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-  })
-
-  renderer = result.renderer
-
-  ;(renderer as any).stdout.write("abcd")
-  await result.renderOnce()
-
-  expect((renderer as any).renderOffset).toBe(1)
-
-  ;(renderer as any).stdout.write("e")
-  await result.renderOnce()
-
-  expect((renderer as any).renderOffset).toBe(2)
-})
-
-test("CliRenderer flushes captured output when leaving split-footer for alternate-screen", async () => {
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    footerHeight: 6,
-    externalOutputMode: "capture-stdout",
-    consoleMode: "disabled",
-    useThread: false,
-  })
-
-  renderer = result.renderer
-  ;(renderer as any)._terminalIsSetup = true
-
-  ;(renderer as any).stdout.write("pending output\n")
-  renderer.externalOutputMode = "passthrough"
-  renderer.screenMode = "alternate-screen"
-
-  expect((renderer as any).externalOutputQueue.size).toBe(0)
-})
-
-test("CliRenderer allows env to force main-screen mode", async () => {
-  process.env.OTUI_USE_ALTERNATE_SCREEN = "false"
-  clearEnvCache()
-
-  const result = await createTestRenderer({
-    screenMode: "alternate-screen",
-  })
-
-  renderer = result.renderer
-
-  expect(renderer.screenMode).toBe("main-screen")
-})
-
-test("CliRenderer allows env to force alternate-screen mode", async () => {
-  process.env.OTUI_USE_ALTERNATE_SCREEN = "true"
-  clearEnvCache()
-
-  const result = await createTestRenderer({
-    screenMode: "main-screen",
-  })
-
-  renderer = result.renderer
-
-  expect(renderer.screenMode).toBe("alternate-screen")
-})
-
-test("CliRenderer allows env to force passthrough stdout", async () => {
-  process.env.OTUI_OVERRIDE_STDOUT = "false"
-  clearEnvCache()
-
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    externalOutputMode: "capture-stdout",
-  })
-
-  renderer = result.renderer
-
-  expect(renderer.externalOutputMode).toBe("passthrough")
-})
-
-test("CliRenderer allows env to force captured stdout in split-footer", async () => {
-  process.env.OTUI_OVERRIDE_STDOUT = "true"
-  clearEnvCache()
-
-  const result = await createTestRenderer({
-    screenMode: "split-footer",
-    externalOutputMode: "passthrough",
-  })
-
-  renderer = result.renderer
-
-  expect(renderer.externalOutputMode).toBe("capture-stdout")
-})