@fairyhunter13/opentui-core 0.1.88 → 0.1.90

package/src/renderables/__tests__/Textarea.rendering.test.ts

@@ -0,0 +1,1864 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test"
+import { createTestRenderer, type TestRenderer, type MockInput } from "../../testing/test-renderer.js"
+import { createTextareaRenderable } from "./renderable-test-utils.js"
+import { RGBA } from "../../lib/RGBA.js"
+import { SyntaxStyle } from "../../syntax-style.js"
+import { OptimizedBuffer } from "../../buffer.js"
+import { fg, t } from "../../lib/index.js"
+import { BoxRenderable, TextareaRenderable, TextRenderable } from "../index.js"
+
+let currentRenderer: TestRenderer
+let renderOnce: () => Promise<void>
+let currentMockInput: MockInput
+let captureFrame: () => string
+let resize: (width: number, height: number) => void
+
+describe("Textarea - Rendering Tests", () => {
+  beforeEach(async () => {
+    ;({
+      renderer: currentRenderer,
+      renderOnce,
+      captureCharFrame: captureFrame,
+      mockInput: currentMockInput,
+      resize,
+    } = await createTestRenderer({
+      width: 80,
+      height: 24,
+    }))
+  })
+
+  afterEach(() => {
+    currentRenderer.destroy()
+  })
+
+  describe("Wrapping", () => {
+    it("should move cursor down through all wrapped visual lines at column 0", async () => {
+      // Create a long line that will wrap into multiple visual lines
+      const longText =
+        "This is a very long line that will definitely wrap into multiple visual lines when the viewport is small"
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: longText,
+        width: 20, // Small viewport to force wrapping
+        height: 10,
+        wrapMode: "word",
+      })
+
+      editor.focus()
+
+      // Set cursor at the beginning (0, 0) - logical position
+      editor.editBuffer.setCursor(0, 0)
+      await renderOnce()
+
+      // Get initial visual cursor position - should be at visual 0, 0
+      let visualCursor = editor.editorView.getVisualCursor()
+      expect(visualCursor.visualRow).toBe(0)
+      expect(visualCursor.visualCol).toBe(0)
+
+      // Verify we have multiple wrapped lines (should be 7 for this text)
+      const vlineCount = editor.editorView.getVirtualLineCount()
+      expect(vlineCount).toBeGreaterThan(1)
+
+      // Move down through each wrapped line - cursor should stay at column 0
+      for (let i = 1; i < vlineCount; i++) {
+        currentMockInput.pressArrow("down")
+        await renderOnce()
+
+        visualCursor = editor.editorView.getVisualCursor()
+
+        // Cursor should have moved down to the next visual line
+        expect(visualCursor.visualRow).toBe(i)
+
+        // Cursor should be at column 0 (beginning of each wrapped line)
+        expect(visualCursor.visualCol).toBe(0)
+      }
+
+      // After moving through all wrapped lines, we should be at the last wrapped line
+      expect(visualCursor.visualRow).toBe(vlineCount - 1)
+      expect(visualCursor.visualCol).toBe(0)
+    })
+
+    it("should move cursor up through all wrapped visual lines at column 0", async () => {
+      // Create a long line that will wrap into multiple visual lines
+      const longText =
+        "This is a very long line that will definitely wrap into multiple visual lines when the viewport is small"
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: longText,
+        width: 20, // Small viewport to force wrapping
+        height: 10,
+        wrapMode: "word",
+      })
+
+      editor.focus()
+
+      // Verify we have multiple wrapped lines
+      const vlineCount = editor.editorView.getVirtualLineCount()
+      expect(vlineCount).toBeGreaterThan(1)
+
+      // Start at the END of the line (which will be on the last wrapped visual line)
+      const eol = editor.editBuffer.getEOL()
+      editor.editBuffer.setCursor(eol.row, eol.col)
+      await renderOnce()
+
+      // Move to the beginning of the last wrapped line (column 0 of last visual line)
+      let visualCursor = editor.editorView.getVisualCursor()
+      const lastVisualRow = visualCursor.visualRow
+
+      // Set cursor to column 0 of the last wrapped visual line by finding its logical column
+      // Last visual line starts at a specific logical column - we need to find it
+      const lastVlineStartCol = editor.logicalCursor.col - visualCursor.visualCol
+      editor.editBuffer.setCursor(0, lastVlineStartCol)
+      await renderOnce()
+
+      visualCursor = editor.editorView.getVisualCursor()
+      expect(visualCursor.visualRow).toBe(lastVisualRow)
+      expect(visualCursor.visualCol).toBe(0)
+
+      // Now move UP through each wrapped line - cursor should stay at column 0
+      for (let i = lastVisualRow - 1; i >= 0; i--) {
+        currentMockInput.pressArrow("up")
+        await renderOnce()
+
+        visualCursor = editor.editorView.getVisualCursor()
+
+        // Cursor should have moved up to the previous visual line
+        expect(visualCursor.visualRow).toBe(i)
+
+        // Cursor should be at column 0 (beginning of each wrapped line)
+        expect(visualCursor.visualCol).toBe(0)
+      }
+
+      // After moving through all wrapped lines, we should be at the first wrapped line
+      expect(visualCursor.visualRow).toBe(0)
+      expect(visualCursor.visualCol).toBe(0)
+    })
+
+    it("should handle wrap mode property", async () => {
+      const longText = "A".repeat(100)
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: longText,
+        width: 20,
+        height: 10,
+        wrapMode: "word",
+      })
+
+      expect(editor.wrapMode).toBe("word")
+      const wrappedCount = editor.editorView.getVirtualLineCount()
+      expect(wrappedCount).toBeGreaterThan(1)
+
+      editor.wrapMode = "none"
+      expect(editor.wrapMode).toBe("none")
+      const unwrappedCount = editor.editorView.getVirtualLineCount()
+      expect(unwrappedCount).toBe(1)
+    })
+
+    it("should handle wrapMode changes", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello wonderful world",
+        width: 12,
+        height: 10,
+        wrapMode: "char",
+      })
+
+      expect(editor.wrapMode).toBe("char")
+
+      editor.wrapMode = "word"
+      expect(editor.wrapMode).toBe("word")
+    })
+
+    it("should render with tab indicator correctly", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1\tTabbed\nLine 2\t\tDouble tab",
+        tabIndicator: "→",
+        tabIndicatorColor: RGBA.fromValues(0.5, 0.5, 0.5, 1),
+        width: 40,
+        height: 10,
+      })
+
+      await renderOnce()
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+  })
+
+  describe("Height and Width Measurement", () => {
+    it("should grow height for multiline text without wrapping", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1\nLine 2\nLine 3\nLine 4\nLine 5",
+        wrapMode: "none",
+        width: 40,
+      })
+
+      await renderOnce()
+
+      expect(editor.height).toBe(5)
+      expect(editor.width).toBeGreaterThanOrEqual(6)
+    })
+
+    it("should grow height for wrapped text when wrapping enabled", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "This is a very long line that will definitely wrap to multiple lines",
+        wrapMode: "word",
+        width: 15,
+      })
+
+      await renderOnce()
+
+      expect(editor.height).toBeGreaterThan(1)
+      expect(editor.width).toBeLessThanOrEqual(15)
+    })
+
+    it("should measure full width when wrapping is disabled and not constrained by parent", async () => {
+      const longLine = "This is a very long line that would wrap but wrapping is disabled"
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: longLine,
+        wrapMode: "none",
+        position: "absolute",
+      })
+
+      await renderOnce()
+
+      expect(editor.height).toBe(1)
+      expect(editor.width).toBe(longLine.length)
+    })
+
+    it("should shrink height when deleting lines via value setter", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1\nLine 2\nLine 3\nLine 4\nLine 5",
+        width: 40,
+        wrapMode: "none",
+      })
+
+      editor.focus()
+      await renderOnce()
+      expect(editor.height).toBe(5)
+
+      // Remove lines by setting new value
+      editor.setText("Line 1\nLine 2")
+      await renderOnce()
+
+      expect(editor.height).toBe(2)
+      expect(editor.plainText).toBe("Line 1\nLine 2")
+    })
+
+    it("should update height when content changes from single to multiline", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Single line",
+        wrapMode: "none",
+      })
+
+      await renderOnce()
+      expect(editor.height).toBe(1)
+
+      editor.setText("Line 1\nLine 2\nLine 3")
+      await renderOnce()
+
+      expect(editor.height).toBe(3)
+    })
+
+    it("should grow height when pressing Enter to add newlines", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Single line",
+        width: 40,
+        wrapMode: "none",
+      })
+
+      // Add a second textarea below to verify layout reflow
+      const { textarea: belowEditor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Below",
+        width: 40,
+      })
+
+      await renderOnce()
+      expect(editor.height).toBe(1)
+      const initialHeight = editor.height
+      const initialBelowY = belowEditor.y
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+
+      // Press Enter 3 times to add 3 newlines
+      currentMockInput.pressEnter()
+      expect(editor.plainText).toBe("Single line\n")
+      await renderOnce() // Wait for layout recalculation
+
+      currentMockInput.pressEnter()
+      expect(editor.plainText).toBe("Single line\n\n")
+      await renderOnce() // Wait for layout recalculation
+
+      currentMockInput.pressEnter()
+      expect(editor.plainText).toBe("Single line\n\n\n")
+      await renderOnce() // Wait for layout recalculation
+
+      // The editor should have grown
+      expect(editor.height).toBeGreaterThan(initialHeight)
+      expect(editor.height).toBe(4) // 1 original line + 3 new lines
+      expect(editor.plainText).toBe("Single line\n\n\n")
+
+      // The element below should have moved down
+      expect(belowEditor.y).toBeGreaterThan(initialBelowY)
+      expect(belowEditor.y).toBe(4) // After the 4-line editor
+    })
+  })
+
+  describe("Unicode Support", () => {
+    it("should handle emoji insertion", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+      editor.insertText(" 🌟")
+
+      expect(editor.plainText).toBe("Hello 🌟")
+    })
+
+    it("should handle CJK characters", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+      editor.insertText(" 世界")
+
+      expect(editor.plainText).toBe("Hello 世界")
+    })
+
+    it("should handle emoji cursor movement", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "A🌟B",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      expect(editor.logicalCursor.col).toBe(0)
+
+      currentMockInput.pressArrow("right") // Move past A
+      expect(editor.logicalCursor.col).toBe(1)
+
+      currentMockInput.pressArrow("right") // Move past emoji (2 cells)
+      expect(editor.logicalCursor.col).toBe(3)
+
+      currentMockInput.pressArrow("right") // Move past B
+      expect(editor.logicalCursor.col).toBe(4)
+    })
+  })
+
+  describe("Content Property", () => {
+    it("should update content programmatically", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Initial",
+        width: 40,
+        height: 10,
+      })
+
+      editor.setText("Updated")
+      expect(editor.plainText).toBe("Updated")
+      expect(editor.plainText).toBe("Updated")
+    })
+
+    it("should reset cursor when content changes", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        width: 40,
+        height: 10,
+      })
+
+      editor.gotoLine(9999) // Move to end
+      expect(editor.logicalCursor.col).toBe(11)
+
+      editor.setText("New")
+      // Cursor should reset to start
+      expect(editor.logicalCursor.row).toBe(0)
+      expect(editor.logicalCursor.col).toBe(0)
+    })
+
+    it("should clear text with clear() method", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        width: 40,
+        height: 10,
+      })
+
+      expect(editor.plainText).toBe("Hello World")
+
+      editor.clear()
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should clear highlights with clear() method", async () => {
+      const style = SyntaxStyle.create()
+      const styleId = style.registerStyle("highlight", {
+        fg: RGBA.fromValues(1, 0, 0, 1),
+      })
+
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        width: 40,
+        height: 10,
+        syntaxStyle: style,
+      })
+
+      editor.addHighlightByCharRange({
+        start: 0,
+        end: 5,
+        styleId: styleId,
+        priority: 0,
+      })
+
+      const highlightsBefore = editor.getLineHighlights(0)
+      expect(highlightsBefore.length).toBeGreaterThan(0)
+
+      editor.clear()
+
+      expect(editor.plainText).toBe("")
+      const highlightsAfter = editor.getLineHighlights(0)
+      expect(highlightsAfter.length).toBe(0)
+    })
+
+    it("should clear both text and highlights together", async () => {
+      const style = SyntaxStyle.create()
+      const styleId = style.registerStyle("highlight", {
+        fg: RGBA.fromValues(1, 0, 0, 1),
+      })
+
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1\nLine 2\nLine 3",
+        width: 40,
+        height: 10,
+        syntaxStyle: style,
+      })
+
+      editor.addHighlight(0, { start: 0, end: 6, styleId: styleId, priority: 0 })
+      editor.addHighlight(1, { start: 0, end: 6, styleId: styleId, priority: 0 })
+
+      expect(editor.plainText).toBe("Line 1\nLine 2\nLine 3")
+      expect(editor.getLineHighlights(0).length).toBe(1)
+      expect(editor.getLineHighlights(1).length).toBe(1)
+
+      editor.clear()
+
+      expect(editor.plainText).toBe("")
+      expect(editor.getLineHighlights(0).length).toBe(0)
+      expect(editor.getLineHighlights(1).length).toBe(0)
+    })
+
+    it("should allow typing after clear()", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      expect(editor.plainText).toBe("Hello World")
+
+      currentMockInput.pressKey("!")
+      expect(editor.plainText).toBe("!Hello World")
+
+      editor.clear()
+      expect(editor.plainText).toBe("")
+
+      currentMockInput.pressKey("N")
+      currentMockInput.pressKey("e")
+      currentMockInput.pressKey("w")
+      expect(editor.plainText).toBe("New")
+
+      currentMockInput.pressKey(" ")
+      currentMockInput.pressKey("T")
+      currentMockInput.pressKey("e")
+      currentMockInput.pressKey("x")
+      currentMockInput.pressKey("t")
+      expect(editor.plainText).toBe("New Text")
+    })
+  })
+
+  describe("Rendering After Edits", () => {
+    it("should render correctly after insert text", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Test",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.insertText("x")
+
+      const buffer = OptimizedBuffer.create(80, 24, "wcwidth")
+      buffer.drawEditorView(editor.editorView, 0, 0)
+
+      expect(editor.plainText).toBe("xTest")
+      expect(editor.logicalCursor.col).toBe(1)
+
+      buffer.destroy()
+    })
+
+    it("should render correctly after rapid edits", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      const buffer = OptimizedBuffer.create(80, 24, "wcwidth")
+
+      for (let i = 0; i < 5; i++) {
+        editor.insertText("a")
+        buffer.drawEditorView(editor.editorView, 0, 0)
+      }
+
+      expect(editor.plainText).toBe("aaaaa")
+      expect(editor.logicalCursor.col).toBe(5)
+
+      buffer.destroy()
+    })
+
+    it("should render correctly after newline", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999)
+
+      const buffer = OptimizedBuffer.create(80, 24, "wcwidth")
+
+      editor.newLine()
+      buffer.drawEditorView(editor.editorView, 0, 0)
+
+      expect(editor.plainText).toBe("Hello\n")
+      expect(editor.logicalCursor.row).toBe(1)
+      expect(editor.logicalCursor.col).toBe(0)
+
+      buffer.destroy()
+    })
+
+    it("should render correctly after backspace", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999)
+
+      const buffer = OptimizedBuffer.create(80, 24, "wcwidth")
+
+      editor.deleteCharBackward()
+      buffer.drawEditorView(editor.editorView, 0, 0)
+
+      expect(editor.plainText).toBe("Hell")
+      expect(editor.logicalCursor.col).toBe(4)
+
+      buffer.destroy()
+    })
+
+    it("should render correctly with draw-edit-draw pattern", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Test",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      const buffer = OptimizedBuffer.create(80, 24, "wcwidth")
+
+      buffer.drawEditorView(editor.editorView, 0, 0)
+      editor.insertText("x")
+      buffer.drawEditorView(editor.editorView, 0, 0)
+
+      expect(editor.plainText).toBe("xTest")
+      expect(editor.logicalCursor.col).toBe(1)
+
+      buffer.destroy()
+    })
+
+    it("should render correctly after multiple text buffer modifications", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line1\nLine2\nLine3",
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      const buffer = OptimizedBuffer.create(80, 24, "wcwidth")
+
+      buffer.drawEditorView(editor.editorView, 0, 0)
+
+      editor.insertText("X")
+      buffer.drawEditorView(editor.editorView, 0, 0)
+      expect(editor.plainText).toBe("XLine1\nLine2\nLine3")
+
+      editor.newLine()
+      buffer.drawEditorView(editor.editorView, 0, 0)
+      expect(editor.plainText).toBe("X\nLine1\nLine2\nLine3")
+
+      editor.deleteCharBackward()
+      buffer.drawEditorView(editor.editorView, 0, 0)
+      expect(editor.plainText).toBe("XLine1\nLine2\nLine3")
+
+      buffer.destroy()
+    })
+  })
+
+  describe("Viewport Scrolling", () => {
+    it("should scroll viewport down when cursor moves below visible area", async () => {
+      // Create editor with small viewport
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 0\nLine 1\nLine 2\nLine 3\nLine 4\nLine 5\nLine 6\nLine 7\nLine 8\nLine 9",
+        width: 40,
+        height: 5, // Only 5 lines visible
+      })
+
+      editor.focus()
+
+      // Initial viewport should show lines 0-4
+      let viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBe(0)
+      expect(viewport.height).toBe(5)
+
+      // Move cursor to line 7 (beyond viewport)
+      editor.gotoLine(7)
+
+      // Viewport should have scrolled to keep cursor visible
+      viewport = editor.editorView.getViewport()
+      // With scroll margin of 0.2 (20% = 1 line), viewport should scroll to show line 7
+      // Expected: offsetY should be at least 3 (to show lines 3-7)
+      expect(viewport.offsetY).toBeGreaterThanOrEqual(3)
+    })
+
+    it("should scroll viewport up when cursor moves above visible area", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 0\nLine 1\nLine 2\nLine 3\nLine 4\nLine 5\nLine 6\nLine 7\nLine 8\nLine 9",
+        width: 40,
+        height: 5,
+      })
+
+      editor.focus()
+
+      // Start at line 8
+      editor.gotoLine(8)
+
+      let viewport = editor.editorView.getViewport()
+      // Viewport should have automatically scrolled to show line 8
+      expect(viewport.offsetY).toBeGreaterThan(0)
+
+      // Now move to line 1 (above viewport)
+      editor.gotoLine(1)
+
+      viewport = editor.editorView.getViewport()
+      // Viewport should have scrolled up to show line 1
+      expect(viewport.offsetY).toBeLessThanOrEqual(1)
+    })
+
+    it("should scroll viewport when using arrow keys to move beyond visible area", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 20 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 40,
+        height: 5,
+      })
+
+      editor.focus()
+
+      let viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBe(0)
+
+      // Press down arrow 6 times to move beyond initial viewport
+      for (let i = 0; i < 6; i++) {
+        currentMockInput.pressArrow("down")
+      }
+
+      viewport = editor.editorView.getViewport()
+      // Should have scrolled
+      expect(viewport.offsetY).toBeGreaterThan(0)
+    })
+
+    it("should maintain scroll margin when moving cursor", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 20 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 40,
+        height: 10,
+        scrollMargin: 0.2, // 20% = 2 lines margin
+      })
+
+      editor.focus()
+
+      // Move to line 8 (near bottom of initial viewport)
+      editor.gotoLine(8)
+
+      let viewport = editor.editorView.getViewport()
+
+      // With 2-line margin, cursor at line 8 should trigger scroll
+      // so that line 8 is at most at position 8 in viewport
+      expect(viewport.offsetY).toBeGreaterThanOrEqual(0)
+    })
+
+    it("should handle viewport scrolling with text wrapping", async () => {
+      const longLine = "word ".repeat(50) // Creates line that will wrap
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 10 }, (_, i) => (i === 5 ? longLine : `Line ${i}`)).join("\n"),
+        width: 20,
+        height: 5,
+        wrapMode: "word",
+      })
+
+      editor.focus()
+
+      // Move to the long line
+      editor.gotoLine(5)
+
+      const vlineCount = editor.editorView.getTotalVirtualLineCount()
+      expect(vlineCount).toBeGreaterThan(10) // Should be more due to wrapping
+
+      // Move to end of long line
+      const cursor = editor.logicalCursor
+      editor.editBuffer.setCursorToLineCol(cursor.row, 9999) // Move to end of line
+
+      let viewport = editor.editorView.getViewport()
+
+      // Viewport should have scrolled to show cursor
+      // This is complex with wrapping - we need virtual line scrolling
+    })
+
+    it("should verify viewport follows cursor to line 10", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 20 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 40,
+        height: 8,
+      })
+
+      editor.focus()
+
+      // Move to line 10
+      editor.gotoLine(10)
+
+      const viewport = editor.editorView.getViewport()
+
+      // Viewport should have scrolled to show line 10
+      // With height=8 and scroll margin, line 10 should be visible
+      expect(viewport.offsetY).toBeGreaterThan(0)
+      expect(viewport.offsetY).toBeLessThanOrEqual(10)
+
+      // Line 10 should be within the viewport range
+      const viewportEnd = viewport.offsetY + viewport.height
+      expect(10).toBeGreaterThanOrEqual(viewport.offsetY)
+      expect(10).toBeLessThan(viewportEnd)
+    })
+
+    it("should track viewport offset as cursor moves through document", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 15 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 30,
+        height: 5,
+      })
+
+      editor.focus()
+
+      const viewportOffsets: number[] = []
+
+      // Track viewport offset at different cursor positions
+      for (const line of [0, 2, 4, 6, 8, 10, 12]) {
+        editor.gotoLine(line)
+        const viewport = editor.editorView.getViewport()
+        viewportOffsets.push(viewport.offsetY)
+      }
+
+      // Viewport should generally increase as cursor moves down
+      // (with possible plateaus when cursor is already visible)
+      const lastOffset = viewportOffsets[viewportOffsets.length - 1]
+      const firstOffset = viewportOffsets[0]
+      expect(lastOffset).toBeGreaterThan(firstOffset)
+
+      // At line 0, viewport should be at 0
+      expect(viewportOffsets[0]).toBe(0)
+
+      // At line 12, viewport should have scrolled
+      expect(viewportOffsets[viewportOffsets.length - 1]).toBeGreaterThan(5)
+    })
+
+    it("should scroll viewport when cursor moves with Page Up/Page Down", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 30 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 40,
+        height: 10,
+      })
+
+      editor.focus()
+
+      let viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBe(0)
+
+      // Move down 15 lines (more than viewport height)
+      for (let i = 0; i < 15; i++) {
+        editor.moveCursorDown()
+      }
+
+      viewport = editor.editorView.getViewport()
+
+      // Should have scrolled
+      expect(viewport.offsetY).toBeGreaterThan(0)
+      expect(editor.logicalCursor.row).toBe(15)
+    })
+
+    it("should scroll viewport down when pressing Enter repeatedly", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Start",
+        width: 40,
+        height: 5,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+
+      let viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBe(0)
+      expect(editor.logicalCursor.row).toBe(0)
+
+      // Press Enter 8 times to create 8 new lines
+      for (let i = 0; i < 8; i++) {
+        currentMockInput.pressEnter()
+      }
+
+      // After 8 Enters, we should have 9 lines total (0-8)
+      expect(editor.logicalCursor.row).toBe(8)
+
+      // Viewport should have scrolled to keep cursor visible
+      viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBeGreaterThan(0)
+
+      // Cursor should be visible in viewport
+      const cursorLine = editor.logicalCursor.row
+      expect(cursorLine).toBeGreaterThanOrEqual(viewport.offsetY)
+      expect(cursorLine).toBeLessThan(viewport.offsetY + viewport.height)
+    })
+
+    it("should scroll viewport up when pressing Backspace to delete characters and move up", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 15 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 40,
+        height: 5,
+      })
+
+      editor.focus()
+
+      // Start at line 10, move to end so we have characters to delete
+      editor.gotoLine(10)
+      let cursor = editor.logicalCursor
+      editor.editBuffer.setCursorToLineCol(cursor.row, 9999) // Move to end of line
+
+      let viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBeGreaterThan(0)
+      const initialOffset = viewport.offsetY
+
+      // Delete all text and move cursor up to line 0
+      // Press Ctrl+A to go to start, then move to line 2, then backspace repeatedly
+      editor.gotoLine(0) // Move to start
+      editor.gotoLine(2)
+      cursor = editor.logicalCursor
+      editor.editBuffer.setCursorToLineCol(cursor.row, 9999) // Move to end of line
+
+      // Now we're at line 2, and viewport should have scrolled up
+      viewport = editor.editorView.getViewport()
+
+      // Viewport should have scrolled up from initial position
+      expect(viewport.offsetY).toBeLessThan(initialOffset)
+      expect(editor.logicalCursor.row).toBe(2)
+    })
+
+    it("should scroll viewport when typing at end creates wrapped lines beyond viewport", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Start",
+        width: 20,
+        height: 5,
+        wrapMode: "word",
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+
+      let viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBe(0)
+
+      // Type enough to create multiple wrapped lines
+      const longText = " word".repeat(50)
+      for (const char of longText) {
+        currentMockInput.pressKey(char)
+      }
+
+      viewport = editor.editorView.getViewport()
+      const vlineCount = editor.editorView.getTotalVirtualLineCount()
+
+      // Should have created multiple virtual lines
+      expect(vlineCount).toBeGreaterThan(5)
+
+      // Viewport should have scrolled to keep cursor visible
+      // (This test may fail if virtual line scrolling isn't implemented yet)
+      expect(viewport.offsetY).toBeGreaterThanOrEqual(0)
+    })
+
+    it("should scroll viewport when using Enter to add lines, then Backspace to remove them", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 0\nLine 1\nLine 2",
+        width: 40,
+        height: 5,
+      })
+
+      editor.focus()
+      editor.gotoLine(9999) // Move to end
+
+      let viewport = editor.editorView.getViewport()
+      const initialOffset = viewport.offsetY
+
+      // Add 6 new lines
+      for (let i = 0; i < 6; i++) {
+        currentMockInput.pressEnter()
+        currentMockInput.pressKey("X")
+      }
+
+      // Should have scrolled down
+      viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBeGreaterThan(initialOffset)
+      const maxOffset = viewport.offsetY
+
+      // Now delete those lines by backspacing
+      for (let i = 0; i < 12; i++) {
+        // 12 backspaces to delete 6 "X\n" pairs
+        currentMockInput.pressBackspace()
+      }
+
+      // Should have scrolled back up
+      viewport = editor.editorView.getViewport()
+      expect(viewport.offsetY).toBeLessThan(maxOffset)
+    })
+
+    it("should show last line at bottom of viewport with no gap", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: Array.from({ length: 10 }, (_, i) => `Line ${i}`).join("\n"),
+        width: 40,
+        height: 5,
+      })
+
+      editor.focus()
+
+      // Move to last line (line 9)
+      editor.gotoLine(9)
+
+      let viewport = editor.editorView.getViewport()
+
+      // With 10 lines (0-9) and viewport height 5, max offset is 10 - 5 = 5
+      // Viewport should be at offset 5, showing lines 5-9 with line 9 at the bottom
+      expect(viewport.offsetY).toBe(5)
+
+      // Verify cursor line is visible
+      expect(9).toBeGreaterThanOrEqual(viewport.offsetY)
+      expect(9).toBeLessThan(viewport.offsetY + viewport.height)
+
+      // No gap - last visible line should be the last line of content
+      const lastVisibleLine = viewport.offsetY + viewport.height - 1
+      expect(lastVisibleLine).toBe(9)
+    })
+
+    it("should not scroll past end when document is smaller than viewport", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 0\nLine 1\nLine 2",
+        width: 40,
+        height: 10, // Viewport bigger than content
+      })
+
+      editor.focus()
+
+      // Move to last line
+      editor.gotoLine(2)
+
+      let viewport = editor.editorView.getViewport()
+
+      // Should NOT scroll at all - content fits in viewport
+      expect(viewport.offsetY).toBe(0)
+    })
+  })
+
+  describe("Placeholder Support", () => {
+    it("should display placeholder when empty", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Enter text here...",
+      })
+
+      // plainText should return empty (placeholder is display-only)
+      expect(editor.plainText).toBe("")
+      expect(editor.placeholder).toBe("Enter text here...")
+    })
+
+    it("should hide placeholder when text is inserted", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Type something...",
+      })
+
+      editor.focus()
+      expect(editor.plainText).toBe("")
+
+      currentMockInput.pressKey("H")
+      currentMockInput.pressKey("i")
+
+      expect(editor.plainText).toBe("Hi")
+    })
+
+    it("should reactivate placeholder when all text is deleted", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Test",
+        width: 40,
+        height: 10,
+        placeholder: "Empty buffer...",
+      })
+
+      editor.focus()
+      expect(editor.plainText).toBe("Test")
+
+      // Move to end, then delete all text
+      editor.gotoLine(9999)
+      for (let i = 0; i < 4; i++) {
+        currentMockInput.pressBackspace()
+      }
+
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should update placeholder text dynamically", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "First placeholder",
+      })
+
+      expect(editor.placeholder).toBe("First placeholder")
+      expect(editor.plainText).toBe("")
+
+      editor.placeholder = "Second placeholder"
+      expect(editor.placeholder).toBe("Second placeholder")
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should update placeholder with styled text dynamically", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Colored placeholder",
+      })
+
+      expect(editor.plainText).toBe("")
+
+      // Update placeholder with styled text
+      editor.placeholder = t`${fg("#FF0000")("Red placeholder")}`
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should work with value property setter", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Empty state",
+      })
+
+      expect(editor.plainText).toBe("")
+
+      editor.setText("New content")
+      expect(editor.plainText).toBe("New content")
+
+      editor.setText("")
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should handle placeholder with focus changes", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Click to edit",
+      })
+
+      // Placeholder should show regardless of focus
+      expect(editor.plainText).toBe("")
+
+      editor.focus()
+      expect(editor.plainText).toBe("")
+
+      editor.blur()
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should handle typing after placeholder is shown", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Start typing...",
+      })
+
+      editor.focus()
+      expect(editor.plainText).toBe("")
+
+      currentMockInput.pressKey("H")
+      currentMockInput.pressKey("e")
+      currentMockInput.pressKey("l")
+      currentMockInput.pressKey("l")
+      currentMockInput.pressKey("o")
+
+      expect(editor.plainText).toBe("Hello")
+    })
+
+    it("should show placeholder after deleting all typed text", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Type here",
+      })
+
+      editor.focus()
+
+      // Type "Test"
+      currentMockInput.pressKey("T")
+      currentMockInput.pressKey("e")
+      currentMockInput.pressKey("s")
+      currentMockInput.pressKey("t")
+      expect(editor.plainText).toBe("Test")
+
+      // Backspace all
+      for (let i = 0; i < 4; i++) {
+        currentMockInput.pressBackspace()
+      }
+
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should handle placeholder with newlines", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Line 1\nLine 2",
+      })
+
+      expect(editor.plainText).toBe("")
+
+      editor.insertText("Content")
+      expect(editor.plainText).toBe("Content")
+    })
+
+    it("should handle null placeholder (no placeholder)", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: null,
+      })
+
+      expect(editor.placeholder).toBe(null)
+      expect(editor.plainText).toBe("")
+
+      editor.insertText("Content")
+      expect(editor.plainText).toBe("Content")
+    })
+
+    it("should clear placeholder when set to null", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Initial placeholder",
+      })
+
+      expect(editor.placeholder).toBe("Initial placeholder")
+      expect(editor.plainText).toBe("")
+
+      editor.placeholder = null
+      expect(editor.placeholder).toBe(null)
+      expect(editor.plainText).toBe("")
+    })
+
+    it("should reset placeholder when set to undefined", async () => {
+      const { textarea: editor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "",
+        width: 40,
+        height: 10,
+        placeholder: "Initial placeholder",
+      })
+
+      expect(editor.placeholder).toBe("Initial placeholder")
+
+      expect(() => {
+        editor.placeholder = undefined
+      }).not.toThrow()
+
+      expect(editor.placeholder).toBe(null)
+      expect(editor.plainText).toBe("")
+    })
+  })
+
+  describe("Textarea Content Snapshots", () => {
+    it("should render basic text content correctly", async () => {
+      await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello World",
+        left: 5,
+        top: 3,
+        width: 20,
+        height: 5,
+      })
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+
+    it("should render multiline text content correctly", async () => {
+      await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line 1: Hello\nLine 2: World\nLine 3: Testing\nLine 4: Multiline",
+        left: 1,
+        top: 1,
+        width: 30,
+        height: 10,
+      })
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+
+    it("should render text with character wrapping correctly", async () => {
+      await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "This is a very long text that should wrap to multiple lines when wrap is enabled",
+        wrapMode: "char",
+        width: 15,
+        left: 0,
+        top: 0,
+      })
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+
+    it("should render text with word wrapping and punctuation", async () => {
+      await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Hello,World.Test-Example/Path with various punctuation marks!",
+        wrapMode: "word",
+        width: 12,
+        left: 0,
+        top: 0,
+      })
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+
+    it("should render placeholder when creating textarea with placeholder directly", async () => {
+      await createTextareaRenderable(currentRenderer, renderOnce, {
+        placeholder: "Enter text here...",
+        left: 1,
+        top: 1,
+        width: 30,
+        height: 5,
+      })
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+
+    it("should render placeholder when set programmatically after creation", async () => {
+      const { textarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        left: 1,
+        top: 1,
+        width: 30,
+        height: 5,
+      })
+
+      textarea.placeholder = "Type something..."
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+    })
+
+    it("should resize correctly when typing return as first input with placeholder", async () => {
+      resize(40, 10)
+
+      const container = new BoxRenderable(currentRenderer, {
+        border: true,
+        left: 1,
+        top: 1,
+      })
+      currentRenderer.root.add(container)
+
+      const textarea = new TextareaRenderable(currentRenderer, {
+        placeholder: "Enter your message...",
+        width: 30,
+        minHeight: 1,
+        maxHeight: 3,
+      })
+      container.add(textarea)
+
+      textarea.focus()
+      await renderOnce()
+
+      const frameBeforeEnter = captureFrame()
+      expect(textarea.height).toBe(1)
+
+      currentMockInput.pressEnter()
+      await renderOnce()
+      await renderOnce()
+
+      const frameAfterEnter = captureFrame()
+      expect(frameAfterEnter).toMatchSnapshot()
+      expect(textarea.height).toBe(2)
+      expect(textarea.plainText).toBe("\n")
+    })
+  })
+
+  describe("Layout Reflow on Size Change", () => {
+    it("should reflow subsequent elements when textarea grows and shrinks", async () => {
+      const { textarea: firstEditor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Short",
+        width: 20,
+        wrapMode: "word",
+      })
+
+      const { textarea: secondEditor } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "I am below the first textarea",
+        width: 30,
+      })
+
+      await renderOnce()
+
+      // Initially, first editor is 1 line high
+      expect(firstEditor.height).toBe(1)
+      const initialSecondY = secondEditor.y
+      expect(initialSecondY).toBe(1) // Right after first editor
+
+      // Expand first editor with wrapped content
+      firstEditor.setText("This is a very long line that will wrap to multiple lines and push the second textarea down")
+      await renderOnce()
+
+      // First editor should now be taller
+      expect(firstEditor.height).toBeGreaterThan(1)
+      // Second editor should have moved down
+      expect(secondEditor.y).toBeGreaterThan(initialSecondY)
+      const expandedSecondY = secondEditor.y
+
+      // Shrink first editor back
+      firstEditor.setText("Short again")
+      await renderOnce()
+
+      // First editor should be 1 line again
+      expect(firstEditor.height).toBe(1)
+      // Second editor should have moved back up
+      expect(secondEditor.y).toBeLessThan(expandedSecondY)
+      expect(secondEditor.y).toBe(initialSecondY)
+    })
+  })
+
+  describe("Width/Height Setter Layout Tests", () => {
+    it("should not shrink box when width is set via setter", async () => {
+      resize(40, 10)
+
+      const container = new BoxRenderable(currentRenderer, { border: true, width: 30 })
+      currentRenderer.root.add(container)
+
+      const row = new BoxRenderable(currentRenderer, { flexDirection: "row", width: "100%" })
+      container.add(row)
+
+      const indicator = new BoxRenderable(currentRenderer, { backgroundColor: "#f00" })
+      row.add(indicator)
+
+      const indicatorText = new TextRenderable(currentRenderer, { content: ">" })
+      indicator.add(indicatorText)
+
+      const content = new BoxRenderable(currentRenderer, { backgroundColor: "#0f0", flexGrow: 1 })
+      row.add(content)
+
+      const contentText = new TextRenderable(currentRenderer, { content: "Content that takes up space" })
+      content.add(contentText)
+
+      await renderOnce()
+
+      const initialIndicatorWidth = indicator.width
+
+      indicator.width = 5
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(indicator.width).toBe(5)
+      expect(content.width).toBeGreaterThan(0)
+      expect(content.width).toBeLessThan(30)
+    })
+
+    it("should not shrink box when height is set via setter in column layout with textarea", async () => {
+      resize(30, 15)
+
+      const outerBox = new BoxRenderable(currentRenderer, { border: true, width: 25, height: 10 })
+      currentRenderer.root.add(outerBox)
+
+      const column = new BoxRenderable(currentRenderer, { flexDirection: "column", height: "100%" })
+      outerBox.add(column)
+
+      const header = new BoxRenderable(currentRenderer, { backgroundColor: "#f00" })
+      column.add(header)
+
+      const headerText = new TextRenderable(currentRenderer, { content: "Header" })
+      header.add(headerText)
+
+      const mainContent = new BoxRenderable(currentRenderer, { backgroundColor: "#0f0", flexGrow: 1 })
+      column.add(mainContent)
+
+      const { textarea: mainTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line1\nLine2\nLine3\nLine4\nLine5\nLine6\nLine7\nLine8",
+      })
+      mainContent.add(mainTextarea)
+
+      const footer = new BoxRenderable(currentRenderer, { height: 2, backgroundColor: "#00f" })
+      column.add(footer)
+
+      const footerText = new TextRenderable(currentRenderer, { content: "Footer" })
+      footer.add(footerText)
+
+      await renderOnce()
+
+      header.height = 3
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(header.height).toBe(3)
+      expect(mainContent.height).toBeGreaterThan(0)
+      expect(footer.height).toBe(2)
+    })
+
+    it("should not shrink box when minWidth is set via setter", async () => {
+      resize(40, 10)
+
+      const container = new BoxRenderable(currentRenderer, { border: true, width: 30 })
+      currentRenderer.root.add(container)
+
+      const row = new BoxRenderable(currentRenderer, { flexDirection: "row", width: "100%" })
+      container.add(row)
+
+      const indicator = new BoxRenderable(currentRenderer, { backgroundColor: "#f00", flexShrink: 1 })
+      row.add(indicator)
+
+      const indicatorText = new TextRenderable(currentRenderer, { content: ">" })
+      indicator.add(indicatorText)
+
+      const content = new BoxRenderable(currentRenderer, { backgroundColor: "#0f0", flexGrow: 1 })
+      row.add(content)
+
+      const contentText = new TextRenderable(currentRenderer, { content: "Content that takes up space" })
+      content.add(contentText)
+
+      await renderOnce()
+
+      indicator.minWidth = 5
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+      expect(indicator.width).toBeGreaterThanOrEqual(5)
+      expect(content.width).toBeGreaterThan(0)
+    })
+
+    it("should not shrink box when minHeight is set via setter in column layout with textarea", async () => {
+      resize(30, 15)
+
+      const outerBox = new BoxRenderable(currentRenderer, { border: true, width: 25, height: 10 })
+      currentRenderer.root.add(outerBox)
+
+      const column = new BoxRenderable(currentRenderer, { flexDirection: "column", height: "100%" })
+      outerBox.add(column)
+
+      const header = new BoxRenderable(currentRenderer, { backgroundColor: "#f00", flexShrink: 1 })
+      column.add(header)
+
+      const headerText = new TextRenderable(currentRenderer, { content: "Header" })
+      header.add(headerText)
+
+      const mainContent = new BoxRenderable(currentRenderer, { backgroundColor: "#0f0", flexGrow: 1 })
+      column.add(mainContent)
+
+      const { textarea: mainTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Line1\nLine2\nLine3\nLine4\nLine5\nLine6\nLine7\nLine8",
+      })
+      mainContent.add(mainTextarea)
+
+      const footer = new BoxRenderable(currentRenderer, { height: 2, backgroundColor: "#00f" })
+      column.add(footer)
+
+      const footerText = new TextRenderable(currentRenderer, { content: "Footer" })
+      footer.add(footerText)
+
+      await renderOnce()
+
+      header.minHeight = 3
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(header.height).toBeGreaterThanOrEqual(3)
+      expect(mainContent.height).toBeGreaterThan(0)
+      expect(footer.height).toBe(2)
+    })
+
+    it("should not shrink box when width is set from undefined via setter", async () => {
+      resize(40, 10)
+
+      const container = new BoxRenderable(currentRenderer, { border: true, width: 30 })
+      currentRenderer.root.add(container)
+
+      const row = new BoxRenderable(currentRenderer, { flexDirection: "row", width: "100%" })
+      container.add(row)
+
+      const indicator = new BoxRenderable(currentRenderer, { backgroundColor: "#f00", flexShrink: 1 })
+      row.add(indicator)
+
+      const indicatorText = new TextRenderable(currentRenderer, { content: ">" })
+      indicator.add(indicatorText)
+
+      const content = new BoxRenderable(currentRenderer, { backgroundColor: "#0f0", flexGrow: 1 })
+      row.add(content)
+
+      const contentText = new TextRenderable(currentRenderer, { content: "Content that takes up space" })
+      content.add(contentText)
+
+      await renderOnce()
+
+      indicator.width = 5
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(indicator.width).toBe(5)
+      expect(content.width).toBeGreaterThan(0)
+    })
+
+    it("should verify dimensions are actually respected under extreme pressure", async () => {
+      resize(30, 10)
+
+      const container = new BoxRenderable(currentRenderer, { border: true, width: 20 })
+      currentRenderer.root.add(container)
+
+      const row = new BoxRenderable(currentRenderer, { flexDirection: "row", width: "100%" })
+      container.add(row)
+
+      const box1 = new BoxRenderable(currentRenderer, { backgroundColor: "#f00", flexShrink: 1 })
+      row.add(box1)
+      const text1 = new TextRenderable(currentRenderer, { content: "AAA" })
+      box1.add(text1)
+
+      const box2 = new BoxRenderable(currentRenderer, { backgroundColor: "#0f0", flexShrink: 1 })
+      row.add(box2)
+      const text2 = new TextRenderable(currentRenderer, { content: "BBB" })
+      box2.add(text2)
+
+      const box3 = new BoxRenderable(currentRenderer, { backgroundColor: "#00f", flexGrow: 1 })
+      row.add(box3)
+      const text3 = new TextRenderable(currentRenderer, { content: "CCC" })
+      box3.add(text3)
+
+      await renderOnce()
+
+      box1.width = 7
+      box2.minWidth = 5
+      await renderOnce()
+
+      expect(box1.width).toBe(7)
+      expect(box2.width).toBeGreaterThanOrEqual(5)
+      expect(box3.width).toBeGreaterThan(0)
+
+      const total = box1.width + box2.width + box3.width
+      expect(total).toBeLessThanOrEqual(18)
+    })
+  })
+
+  describe("Absolute Positioned Box with Textarea", () => {
+    it("should render textarea in absolute positioned box with padding and borders correctly", async () => {
+      resize(80, 20)
+
+      const notificationBox = new BoxRenderable(currentRenderer, {
+        position: "absolute",
+        justifyContent: "center",
+        alignItems: "flex-start",
+        top: 2,
+        right: 2,
+        maxWidth: Math.min(60, 80 - 6),
+        paddingLeft: 2,
+        paddingRight: 2,
+        paddingTop: 1,
+        paddingBottom: 1,
+        backgroundColor: "#1e293b",
+        borderColor: "#3b82f6",
+        border: ["left", "right"],
+      })
+
+      currentRenderer.root.add(notificationBox)
+
+      const outerWrapperBox = new BoxRenderable(currentRenderer, {
+        flexDirection: "row",
+        paddingBottom: 1,
+        paddingTop: 1,
+        paddingLeft: 2,
+        paddingRight: 2,
+        gap: 2,
+      })
+      notificationBox.add(outerWrapperBox)
+
+      const innerContentBox = new BoxRenderable(currentRenderer, {
+        flexGrow: 1,
+        gap: 1,
+      })
+      outerWrapperBox.add(innerContentBox)
+
+      const titleText = new TextRenderable(currentRenderer, {
+        content: "Important Notification",
+        attributes: 1,
+        marginBottom: 1,
+        fg: "#f8fafc",
+      })
+      innerContentBox.add(titleText)
+
+      const { textarea: messageTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue:
+          "This is a longer message that should wrap properly within the absolutely positioned box with appropriate width constraints and padding applied.",
+        textColor: "#e2e8f0",
+        wrapMode: "word",
+        width: "100%",
+      })
+      innerContentBox.add(messageTextarea)
+
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(notificationBox.x).toBeGreaterThan(0)
+      expect(notificationBox.y).toBe(2)
+      expect(notificationBox.width).toBeGreaterThan(25)
+
+      expect(outerWrapperBox.width).toBeGreaterThan(15)
+      expect(innerContentBox.width).toBeGreaterThan(15)
+
+      expect(titleText.width).toBeGreaterThan(15)
+      expect(titleText.plainText).toBe("Important Notification")
+      expect(titleText.height).toBe(1)
+
+      expect(messageTextarea.width).toBeGreaterThan(15)
+      expect(messageTextarea.height).toBeGreaterThanOrEqual(1)
+      expect(messageTextarea.plainText).toBe(
+        "This is a longer message that should wrap properly within the absolutely positioned box with appropriate width constraints and padding applied.",
+      )
+    })
+
+    it("should render textarea fully visible in absolute positioned box at various positions", async () => {
+      resize(100, 25)
+
+      const topRightBox = new BoxRenderable(currentRenderer, {
+        position: "absolute",
+        top: 1,
+        right: 1,
+        maxWidth: 40,
+        paddingLeft: 1,
+        paddingRight: 1,
+        paddingTop: 0,
+        paddingBottom: 0,
+        backgroundColor: "#fef2f2",
+        borderColor: "#ef4444",
+        border: true,
+      })
+      currentRenderer.root.add(topRightBox)
+
+      const { textarea: topRightTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Error: File not found in the specified directory path",
+        textColor: "#991b1b",
+        wrapMode: "word",
+        width: "100%",
+      })
+      topRightBox.add(topRightTextarea)
+
+      const bottomLeftBox = new BoxRenderable(currentRenderer, {
+        position: "absolute",
+        bottom: 1,
+        left: 1,
+        maxWidth: 35,
+        paddingLeft: 1,
+        paddingRight: 1,
+        backgroundColor: "#f0fdf4",
+        borderColor: "#22c55e",
+        border: ["top", "bottom"],
+      })
+      currentRenderer.root.add(bottomLeftBox)
+
+      const { textarea: bottomLeftTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "Success: Operation completed successfully!",
+        textColor: "#166534",
+        wrapMode: "word",
+        width: "100%",
+      })
+      bottomLeftBox.add(bottomLeftTextarea)
+
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(topRightBox.y).toBe(1)
+      expect(topRightBox.x).toBeGreaterThan(50)
+      expect(topRightBox.width).toBeGreaterThan(30)
+      expect(topRightBox.width).toBeLessThanOrEqual(40)
+
+      expect(topRightTextarea.plainText).toBe("Error: File not found in the specified directory path")
+      expect(topRightTextarea.width).toBeGreaterThan(25)
+      expect(topRightTextarea.width).toBeLessThanOrEqual(38)
+      expect(topRightTextarea.height).toBeGreaterThan(1)
+
+      expect(bottomLeftBox.x).toBe(1)
+      expect(bottomLeftBox.y).toBeGreaterThan(15)
+      expect(bottomLeftBox.width).toBeGreaterThan(25)
+      expect(bottomLeftBox.width).toBeLessThanOrEqual(35)
+
+      expect(bottomLeftTextarea.plainText).toBe("Success: Operation completed successfully!")
+      expect(bottomLeftTextarea.width).toBeGreaterThan(25)
+      expect(bottomLeftTextarea.width).toBeLessThanOrEqual(33)
+      expect(bottomLeftTextarea.height).toBeGreaterThan(1)
+    })
+
+    it("should handle width:100% textarea in absolute positioned box with constrained maxWidth", async () => {
+      resize(70, 15)
+
+      const constrainedBox = new BoxRenderable(currentRenderer, {
+        position: "absolute",
+        top: 5,
+        left: 10,
+        maxWidth: 50,
+        paddingLeft: 3,
+        paddingRight: 3,
+        paddingTop: 2,
+        paddingBottom: 2,
+        backgroundColor: "#1e1e2e",
+      })
+      currentRenderer.root.add(constrainedBox)
+
+      const { textarea: longTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue:
+          "This is an extremely long piece of text that needs to wrap multiple times within the constrained width of the absolutely positioned container box with significant padding on all sides.",
+        textColor: "#cdd6f4",
+        wrapMode: "word",
+        width: "100%",
+      })
+      constrainedBox.add(longTextarea)
+
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(constrainedBox.width).toBeLessThanOrEqual(50)
+      expect(constrainedBox.width).toBeGreaterThan(40)
+      expect(constrainedBox.x).toBe(10)
+      expect(constrainedBox.y).toBe(5)
+
+      expect(longTextarea.width).toBeGreaterThan(35)
+      expect(longTextarea.width).toBeLessThanOrEqual(44)
+      expect(longTextarea.height).toBeGreaterThanOrEqual(5)
+      expect(longTextarea.plainText).toBe(
+        "This is an extremely long piece of text that needs to wrap multiple times within the constrained width of the absolutely positioned container box with significant padding on all sides.",
+      )
+    })
+
+    it("should render multiple textarea elements in absolute positioned box with proper spacing", async () => {
+      resize(90, 20)
+
+      const infoBox = new BoxRenderable(currentRenderer, {
+        position: "absolute",
+        justifyContent: "flex-start",
+        alignItems: "flex-start",
+        top: 3,
+        right: 5,
+        maxWidth: 45,
+        paddingLeft: 2,
+        paddingRight: 2,
+        paddingTop: 1,
+        paddingBottom: 1,
+        backgroundColor: "#eff6ff",
+        borderColor: "#3b82f6",
+        border: true,
+      })
+      currentRenderer.root.add(infoBox)
+
+      const headerText = new TextRenderable(currentRenderer, {
+        content: "System Update",
+        attributes: 1,
+        fg: "#1e40af",
+      })
+      infoBox.add(headerText)
+
+      const { textarea: bodyTextarea } = await createTextareaRenderable(currentRenderer, renderOnce, {
+        initialValue: "A new version is available with bug fixes and performance improvements.",
+        textColor: "#1e3a8a",
+        wrapMode: "word",
+        width: "100%",
+        marginTop: 1,
+      })
+      infoBox.add(bodyTextarea)
+
+      const footerText = new TextRenderable(currentRenderer, {
+        content: "Click to install",
+        fg: "#60a5fa",
+        marginTop: 1,
+      })
+      infoBox.add(footerText)
+
+      await renderOnce()
+
+      const frame = captureFrame()
+      expect(frame).toMatchSnapshot()
+
+      expect(headerText.plainText).toBe("System Update")
+      expect(bodyTextarea.plainText).toBe("A new version is available with bug fixes and performance improvements.")
+      expect(footerText.plainText).toBe("Click to install")
+
+      expect(infoBox.width).toBeGreaterThan(35)
+      expect(infoBox.width).toBeLessThanOrEqual(45)
+
+      expect(headerText.width).toBeGreaterThan(10)
+      expect(headerText.height).toBe(1)
+
+      expect(bodyTextarea.width).toBeGreaterThan(30)
+      expect(bodyTextarea.height).toBeGreaterThanOrEqual(2)
+
+      expect(footerText.width).toBeGreaterThan(10)
+      expect(footerText.height).toBe(1)
+
+      expect(bodyTextarea.y).toBeGreaterThan(headerText.y)
+      expect(footerText.y).toBeGreaterThan(bodyTextarea.y)
+    })
+  })
+})