@xincli/opentui-core 0.4.6 → 0.4.7

package/src/edit-buffer.test.ts

@@ -1,1852 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach } from "bun:test"
-import { EditBuffer } from "./edit-buffer.js"
-import { resolveRenderLib } from "./zig.js"
-import { ManualClock } from "./testing/manual-clock.js"
-
-async function flushNativeEvents(): Promise<void> {
-  // EditBuffer forwards native events via queueMicrotask, so a manual 0ms tick
-  // gives the tests a deterministic async boundary without sleeping.
-  const clock = new ManualClock()
-  const wait = new Promise<void>((resolve) => {
-    clock.setTimeout(resolve, 0)
-  })
-  clock.advance(0)
-  await wait
-}
-
-describe("EditBuffer", () => {
-  let buffer: EditBuffer
-
-  beforeEach(() => {
-    buffer = EditBuffer.create("wcwidth")
-  })
-
-  afterEach(() => {
-    buffer.destroy()
-  })
-
-  describe("setText and getText", () => {
-    it("should set and retrieve text content", () => {
-      buffer.setText("Hello World")
-      expect(buffer.getText()).toBe("Hello World")
-    })
-
-    it("should handle empty text", () => {
-      buffer.setText("")
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should handle text with newlines", () => {
-      const text = "Line 1\nLine 2\nLine 3"
-      buffer.setText(text)
-      expect(buffer.getText()).toBe(text)
-    })
-
-    it("should handle Unicode characters", () => {
-      const text = "Hello 世界 🌟"
-      buffer.setText(text)
-      expect(buffer.getText()).toBe(text)
-    })
-
-    it("should return null bytes for zero-length getText output buffer", () => {
-      buffer.setText("Hello World")
-
-      const textBytes = (buffer as any).lib.editBufferGetText(buffer.ptr, 0)
-
-      expect(textBytes).toBeNull()
-    })
-  })
-
-  describe("cursor position", () => {
-    it("should start cursor at beginning after setText", () => {
-      buffer.setText("Hello World")
-      const cursor = buffer.getCursorPosition()
-
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should track cursor position after movements", () => {
-      buffer.setText("Hello World")
-
-      buffer.moveCursorRight()
-      let cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(1)
-
-      buffer.moveCursorRight()
-      cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(2)
-    })
-
-    it("should handle multi-line cursor positions", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.moveCursorDown()
-      let cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(1)
-
-      buffer.moveCursorDown()
-      cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(2)
-    })
-  })
-
-  describe("cursor movement", () => {
-    it("should move cursor left and right", () => {
-      buffer.setText("ABCDE")
-
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      expect(buffer.getCursorPosition().col).toBe(5)
-
-      buffer.moveCursorLeft()
-      expect(buffer.getCursorPosition().col).toBe(4)
-
-      buffer.moveCursorLeft()
-      expect(buffer.getCursorPosition().col).toBe(3)
-    })
-
-    it("should move cursor up and down", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.moveCursorDown()
-      expect(buffer.getCursorPosition().row).toBe(1)
-
-      buffer.moveCursorDown()
-      expect(buffer.getCursorPosition().row).toBe(2)
-
-      buffer.moveCursorUp()
-      expect(buffer.getCursorPosition().row).toBe(1)
-    })
-
-    it("should move to line start and end", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursorToLineCol(0, 11) // Move to end
-      expect(buffer.getCursorPosition().col).toBe(11)
-
-      const cursor = buffer.getCursorPosition()
-      buffer.setCursor(cursor.row, 0)
-      expect(buffer.getCursorPosition().col).toBe(0)
-    })
-
-    it("should goto specific line", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.gotoLine(1)
-      expect(buffer.getCursorPosition().row).toBe(1)
-
-      buffer.gotoLine(2)
-      expect(buffer.getCursorPosition().row).toBe(2)
-    })
-
-    it("should handle Unicode grapheme movement correctly", () => {
-      buffer.setText("A🌟B")
-
-      expect(buffer.getCursorPosition().col).toBe(0)
-
-      buffer.moveCursorRight() // Move to emoji
-      expect(buffer.getCursorPosition().col).toBe(1)
-
-      buffer.moveCursorRight() // Move past emoji (2 cells wide)
-      expect(buffer.getCursorPosition().col).toBe(3)
-
-      buffer.moveCursorRight() // Move to B
-      expect(buffer.getCursorPosition().col).toBe(4)
-    })
-  })
-
-  describe("text insertion", () => {
-    it("should insert single character", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursorToLineCol(0, 11) // Move to end
-      buffer.insertChar("!")
-
-      expect(buffer.getText()).toBe("Hello World!")
-    })
-
-    it("should insert text at cursor", () => {
-      buffer.setText("Hello")
-
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" World")
-
-      expect(buffer.getText()).toBe("Hello World")
-    })
-
-    it("should insert text in middle", () => {
-      buffer.setText("HelloWorld")
-
-      buffer.setCursorToLineCol(0, 5)
-      buffer.insertText(" ")
-
-      expect(buffer.getText()).toBe("Hello World")
-    })
-
-    it("should handle continuous typing (edit session)", () => {
-      buffer.setText("")
-
-      buffer.insertText("Hello")
-      buffer.insertText(" ")
-      buffer.insertText("World")
-
-      expect(buffer.getText()).toBe("Hello World")
-    })
-
-    it("should insert Unicode characters", () => {
-      buffer.setText("Hello")
-
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" 世界 🌟")
-
-      expect(buffer.getText()).toBe("Hello 世界 🌟")
-    })
-
-    it("should handle newline insertion", () => {
-      buffer.setText("HelloWorld")
-
-      buffer.setCursorToLineCol(0, 5)
-      buffer.newLine()
-
-      expect(buffer.getText()).toBe("Hello\nWorld")
-    })
-  })
-
-  describe("text deletion", () => {
-    it("should delete character at cursor", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursorToLineCol(0, 6)
-      buffer.deleteChar()
-
-      expect(buffer.getText()).toBe("Hello orld")
-    })
-
-    it("should delete character backward", () => {
-      buffer.setText("")
-
-      buffer.insertText("test")
-      buffer.deleteCharBackward()
-
-      expect(buffer.getText()).toBe("tes")
-    })
-
-    it("should delete range within a single line", () => {
-      buffer.setText("Hello World")
-
-      buffer.deleteRange(0, 0, 0, 5)
-
-      expect(buffer.getText()).toBe(" World")
-    })
-
-    it("should delete range across multiple lines", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.deleteRange(0, 5, 2, 5)
-
-      expect(buffer.getText()).toBe("Line 3")
-    })
-
-    it("should handle deleteRange with start equal to end (no-op)", () => {
-      buffer.setText("Hello World")
-
-      buffer.deleteRange(0, 5, 0, 5)
-
-      expect(buffer.getText()).toBe("Hello World")
-    })
-
-    it("should handle deleteRange with reversed start and end", () => {
-      buffer.setText("Hello World")
-
-      buffer.deleteRange(0, 10, 0, 5)
-
-      expect(buffer.getText()).toBe("Hellod")
-    })
-
-    it("should delete from middle of one line to middle of another", () => {
-      buffer.setText("AAAA\nBBBB\nCCCC")
-
-      buffer.deleteRange(0, 2, 2, 2)
-
-      expect(buffer.getText()).toBe("AACC")
-    })
-
-    it("should delete entire content with deleteRange", () => {
-      buffer.setText("Hello World")
-
-      buffer.deleteRange(0, 0, 0, 11)
-
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should handle deleteRange with Unicode characters", () => {
-      buffer.setText("Hello 世界 🌟")
-
-      buffer.deleteRange(0, 6, 0, 10)
-
-      expect(buffer.getText()).toBe("Hello  🌟")
-    })
-
-    it("should delete entire line", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.gotoLine(1) // Go to Line 2
-      buffer.deleteLine()
-
-      expect(buffer.getText()).toBe("Line 1\nLine 3")
-    })
-
-    // TODO: Re-implement deleteToLineEnd as scripted method
-    it.skip("should delete to line end", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursorToLineCol(0, 6)
-      // buffer.deleteToLineEnd()
-
-      expect(buffer.getText()).toBe("Hello ")
-    })
-
-    it("should handle backspace in active edit session", () => {
-      buffer.setText("")
-
-      buffer.insertText("test")
-      buffer.deleteCharBackward()
-      buffer.deleteCharBackward()
-
-      expect(buffer.getText()).toBe("te")
-    })
-  })
-
-  describe("complex editing scenarios", () => {
-    it("should handle multiple edit operations in sequence", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursorToLineCol(0, 11) // Move to end
-      buffer.insertText("!")
-
-      buffer.setCursorToLineCol(0, 0) // Move to start
-      buffer.insertText(">> ")
-
-      buffer.setCursorToLineCol(0, 99) // Move to end of line
-      buffer.newLine()
-      buffer.insertText("New line")
-
-      expect(buffer.getText()).toBe(">> Hello World!\nNew line")
-    })
-
-    it("should handle insert, delete, and cursor movement", () => {
-      buffer.setText("AAAA\nBBBB\nCCCC")
-
-      buffer.gotoLine(1)
-      buffer.setCursorToLineCol(1, 4) // Move to end of line 1
-      buffer.insertText("X")
-
-      const text1 = buffer.getText()
-      expect(text1).toBe("AAAA\nBBBBX\nCCCC")
-
-      // After insert, cursor is at end, deleteCharBackward will delete X
-      buffer.deleteCharBackward()
-
-      expect(buffer.getText()).toBe("AAAA\nBBBB\nCCCC")
-    })
-
-    it("should handle line operations", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.gotoLine(1) // Go to Line 2
-      buffer.deleteLine()
-
-      // After deleting Line 2, we should have Line 1 and Line 3
-      const result = buffer.getText()
-      expect(result === "Line 1\nLine 3" || result === "Line 1\nLine 3\n").toBe(true)
-    })
-  })
-
-  describe("history metadata", () => {
-    it("should return null bytes for zero-length undo and redo output buffers", () => {
-      buffer.setText("Hello")
-      buffer.insertText(" World")
-
-      const lib = (buffer as any).lib
-      const undoBytes = lib.editBufferUndo(buffer.ptr, 0)
-      const redoBytes = lib.editBufferRedo(buffer.ptr, 0)
-
-      expect(undoBytes).toBeNull()
-      expect(redoBytes).toBeNull()
-    })
-  })
-
-  describe("range getters", () => {
-    it("should return null bytes for zero-length range output buffers", () => {
-      buffer.setText("Hello\nWorld")
-
-      const lib = (buffer as any).lib
-
-      expect(lib.editBufferGetTextRange(buffer.ptr, 0, 5, 0)).toBeNull()
-      expect(lib.editBufferGetTextRangeByCoords(buffer.ptr, 0, 0, 1, 5, 0)).toBeNull()
-    })
-  })
-
-  describe("setCursor methods", () => {
-    it("should set cursor by line and byte offset", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursor(0, 6)
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(6)
-    })
-
-    it("should set cursor by line and column", () => {
-      buffer.setText("Hello World")
-
-      buffer.setCursorToLineCol(0, 5)
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(5)
-    })
-
-    it("should handle multi-line setCursorToLineCol", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.setCursorToLineCol(1, 3)
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(1)
-      expect(cursor.col).toBe(3)
-    })
-  })
-
-  describe("word boundary navigation", () => {
-    it("should get next word boundary", () => {
-      buffer.setText("hello world foo")
-      buffer.setCursorToLineCol(0, 0)
-
-      const nextBoundary = buffer.getNextWordBoundary()
-      expect(nextBoundary.col).toBeGreaterThan(0)
-    })
-
-    it("should get previous word boundary", () => {
-      buffer.setText("hello world foo")
-      buffer.setCursorToLineCol(0, 15)
-
-      const prevBoundary = buffer.getPrevWordBoundary()
-      expect(prevBoundary.col).toBeLessThan(15)
-    })
-
-    it("should handle word boundary at start", () => {
-      buffer.setText("hello world")
-      buffer.setCursorToLineCol(0, 0)
-
-      const prevBoundary = buffer.getPrevWordBoundary()
-      expect(prevBoundary.row).toBe(0)
-      expect(prevBoundary.col).toBe(0)
-    })
-
-    it("should handle word boundary at end", () => {
-      buffer.setText("hello world")
-      buffer.setCursorToLineCol(0, 11)
-
-      const nextBoundary = buffer.getNextWordBoundary()
-      expect(nextBoundary.col).toBe(11)
-    })
-
-    it("should navigate across lines", () => {
-      buffer.setText("hello\nworld")
-      buffer.setCursorToLineCol(0, 5)
-
-      const nextBoundary = buffer.getNextWordBoundary()
-      expect(nextBoundary.row).toBeGreaterThanOrEqual(0)
-    })
-
-    it("should handle punctuation boundaries", () => {
-      buffer.setText("hello-world test")
-      buffer.setCursorToLineCol(0, 0)
-
-      const next1 = buffer.getNextWordBoundary()
-      expect(next1.col).toBeGreaterThan(0)
-    })
-
-    it("should handle word boundaries after CJK graphemes", () => {
-      // "你" = 2 cols, " " = 1 col, "好" = 2 cols
-      buffer.setText("你 好")
-      buffer.setCursorToLineCol(0, 0)
-
-      const nextBoundary = buffer.getNextWordBoundary()
-      expect(nextBoundary.col).toBe(3)
-
-      buffer.setCursorToLineCol(0, 5)
-      const prevBoundary = buffer.getPrevWordBoundary()
-      expect(prevBoundary.col).toBe(3)
-    })
-
-    it("should handle word boundaries after emoji", () => {
-      // "🌟" = 2 cols, " " = 1 col, "ok" = 2 cols
-      buffer.setText("🌟 ok")
-      buffer.setCursorToLineCol(0, 0)
-
-      const nextBoundary = buffer.getNextWordBoundary()
-      expect(nextBoundary.col).toBe(3)
-
-      buffer.setCursorToLineCol(0, 5)
-      const prevBoundary = buffer.getPrevWordBoundary()
-      expect(prevBoundary.col).toBe(3)
-    })
-
-    it("should handle word boundaries around tabs", () => {
-      // tab = 2 cols
-      buffer.setText("Hello\tWorld")
-      buffer.setCursorToLineCol(0, 0)
-
-      const nextBoundary = buffer.getNextWordBoundary()
-      expect(nextBoundary.col).toBe(7)
-
-      buffer.setCursorToLineCol(0, 12)
-      const prevBoundary = buffer.getPrevWordBoundary()
-      expect(prevBoundary.col).toBe(7)
-    })
-  })
-
-  describe("native coordinate conversion methods", () => {
-    it("should convert offset to position", () => {
-      buffer.setText("Hello\nWorld")
-
-      const pos0 = buffer.offsetToPosition(0)
-      expect(pos0).toEqual({ row: 0, col: 0 })
-
-      const pos5 = buffer.offsetToPosition(5)
-      expect(pos5).toEqual({ row: 0, col: 5 })
-
-      const pos6 = buffer.offsetToPosition(6)
-      expect(pos6).toEqual({ row: 1, col: 0 })
-
-      const pos11 = buffer.offsetToPosition(11)
-      expect(pos11).toEqual({ row: 1, col: 5 })
-    })
-
-    it("should convert position to offset", () => {
-      buffer.setText("Hello\nWorld")
-
-      expect(buffer.positionToOffset(0, 0)).toBe(0)
-      expect(buffer.positionToOffset(0, 5)).toBe(5)
-      expect(buffer.positionToOffset(1, 0)).toBe(6)
-      expect(buffer.positionToOffset(1, 5)).toBe(11)
-    })
-
-    it("should get line start offset", () => {
-      buffer.setText("Line1\nLine2\nLine3")
-
-      expect(buffer.getLineStartOffset(0)).toBe(0)
-      expect(buffer.getLineStartOffset(1)).toBe(6)
-      expect(buffer.getLineStartOffset(2)).toBe(12)
-    })
-
-    it("should handle multiline text with varying lengths", () => {
-      buffer.setText("AAA\nBB\nCCCC")
-
-      expect(buffer.offsetToPosition(0)).toEqual({ row: 0, col: 0 })
-      expect(buffer.offsetToPosition(3)).toEqual({ row: 0, col: 3 })
-      expect(buffer.offsetToPosition(4)).toEqual({ row: 1, col: 0 })
-      expect(buffer.offsetToPosition(6)).toEqual({ row: 1, col: 2 })
-      expect(buffer.offsetToPosition(7)).toEqual({ row: 2, col: 0 })
-
-      expect(buffer.positionToOffset(0, 0)).toBe(0)
-      expect(buffer.positionToOffset(1, 0)).toBe(4)
-      expect(buffer.positionToOffset(2, 0)).toBe(7)
-    })
-
-    it("should return null for invalid offset", () => {
-      buffer.setText("Hello")
-      const result = buffer.offsetToPosition(1000)
-      expect(result).toBeNull()
-    })
-
-    it("should handle empty text", () => {
-      buffer.setText("")
-
-      const pos = buffer.offsetToPosition(0)
-      expect(pos).toEqual({ row: 0, col: 0 })
-
-      expect(buffer.positionToOffset(0, 0)).toBe(0)
-      expect(buffer.getLineStartOffset(0)).toBe(0)
-    })
-  })
-
-  describe("getEOL navigation", () => {
-    it("should get end of line from start", () => {
-      buffer.setText("Hello World")
-      buffer.setCursorToLineCol(0, 0)
-
-      const eol = buffer.getEOL()
-      expect(eol.row).toBe(0)
-      expect(eol.col).toBe(11)
-    })
-
-    it("should get end of line from middle", () => {
-      buffer.setText("Hello World")
-      buffer.setCursorToLineCol(0, 5)
-
-      const eol = buffer.getEOL()
-      expect(eol.row).toBe(0)
-      expect(eol.col).toBe(11)
-    })
-
-    it("should stay at end of line when already there", () => {
-      buffer.setText("Hello")
-      buffer.setCursorToLineCol(0, 5)
-
-      const eol = buffer.getEOL()
-      expect(eol.row).toBe(0)
-      expect(eol.col).toBe(5)
-    })
-
-    it("should handle multi-line text", () => {
-      buffer.setText("Hello\nWorld\nTest")
-      buffer.setCursorToLineCol(1, 0)
-
-      const eol = buffer.getEOL()
-      expect(eol.row).toBe(1)
-      expect(eol.col).toBe(5)
-    })
-
-    it("should handle empty lines", () => {
-      buffer.setText("Hello\n\nWorld")
-      buffer.setCursorToLineCol(1, 0)
-
-      const eol = buffer.getEOL()
-      expect(eol.row).toBe(1)
-      expect(eol.col).toBe(0)
-    })
-
-    it("should work on different lines", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-
-      buffer.setCursorToLineCol(0, 0)
-      const eol0 = buffer.getEOL()
-      expect(eol0.row).toBe(0)
-      expect(eol0.col).toBe(6)
-
-      buffer.setCursorToLineCol(1, 0)
-      const eol1 = buffer.getEOL()
-      expect(eol1.row).toBe(1)
-      expect(eol1.col).toBe(6)
-
-      buffer.setCursorToLineCol(2, 0)
-      const eol2 = buffer.getEOL()
-      expect(eol2.row).toBe(2)
-      expect(eol2.col).toBe(6)
-    })
-  })
-
-  describe("error handling", () => {
-    it("should throw error when using destroyed buffer", () => {
-      buffer.setText("Test")
-      buffer.destroy()
-
-      expect(() => buffer.getText()).toThrow("EditBuffer is destroyed")
-      expect(() => buffer.insertText("x")).toThrow("EditBuffer is destroyed")
-      expect(() => buffer.moveCursorLeft()).toThrow("EditBuffer is destroyed")
-    })
-  })
-
-  describe("line boundary operations", () => {
-    it("should merge lines when backspacing at BOL", () => {
-      buffer.setText("Line 1\nLine 2")
-      buffer.setCursorToLineCol(1, 0) // Start of line 2
-      buffer.deleteCharBackward()
-      expect(buffer.getText()).toBe("Line 1Line 2")
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(6)
-    })
-
-    it("should merge lines when deleting at EOL", () => {
-      buffer.setText("Line 1\nLine 2")
-      buffer.setCursorToLineCol(0, 6) // End of line 1
-      buffer.deleteChar()
-      expect(buffer.getText()).toBe("Line 1Line 2")
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(6)
-    })
-
-    it("should handle newline insertion at BOL", () => {
-      buffer.setText("Hello")
-      buffer.setCursorToLineCol(0, 0)
-      buffer.newLine()
-      expect(buffer.getText()).toBe("\nHello")
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(1)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should handle newline insertion at EOL", () => {
-      buffer.setText("Hello")
-      buffer.setCursorToLineCol(0, 5)
-      buffer.newLine()
-      expect(buffer.getText()).toBe("Hello\n")
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(1)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should handle CRLF in text", () => {
-      // CRLF is detected as a line break during setText
-      buffer.setText("Line 1\r\nLine 2")
-      // Both CR and LF are detected, so we get the text back
-      const text = buffer.getText()
-      // Verify we have two lines
-      buffer.setCursorToLineCol(1, 0)
-      buffer.deleteCharBackward()
-      expect(buffer.getText()).toBe("Line 1Line 2")
-    })
-
-    it("should handle multiple consecutive newlines", () => {
-      buffer.setText("A\n\n\nB")
-      buffer.setCursorToLineCol(1, 0) // Empty line
-      buffer.deleteCharBackward()
-      expect(buffer.getText()).toBe("A\n\nB")
-    })
-  })
-
-  describe("wide character handling", () => {
-    it("should handle tabs correctly in edits", () => {
-      buffer.setText("A\tB")
-      // Tab has a display width of 2 columns (by default, rounded to multiple of 2)
-      // So "A\tB" has positions: A at col 0-1, tab at col 1-2, B at col 2
-      // To insert after A, we use column 1
-      buffer.setCursorToLineCol(0, 1) // After A, at the tab position
-      // But since setCursorToLineCol might snap to grapheme boundaries,
-      // let's just verify the text remains intact when inserting at byte level
-      buffer.insertText("X")
-      // The insert should happen at the cursor position
-      const text = buffer.getText()
-      // Either AX\tB or A\tXB depending on how cursor snaps
-      expect(text.includes("A") && text.includes("B") && text.includes("\t") && text.includes("X")).toBe(true)
-    })
-
-    it("should handle CJK characters correctly", () => {
-      buffer.setText("世界")
-      buffer.setCursorToLineCol(0, 2) // After first character (2 columns wide)
-      buffer.insertText("X")
-      expect(buffer.getText()).toBe("世X界")
-    })
-
-    it("should handle emoji correctly", () => {
-      buffer.setText("🌟")
-      buffer.setCursorToLineCol(0, 0)
-      buffer.moveCursorRight()
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(2) // Emoji is 2 columns wide
-    })
-
-    it("should handle mixed width text correctly", () => {
-      buffer.setText("A世🌟B")
-      buffer.setCursorToLineCol(0, 1) // After A
-      buffer.moveCursorRight()
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(3) // A(1) + 世(2)
-    })
-  })
-
-  describe("multi-line insertion", () => {
-    it("should insert multi-line text correctly", () => {
-      buffer.setText("Start")
-      buffer.setCursorToLineCol(0, 5)
-      buffer.insertText("\nMiddle\nEnd")
-      expect(buffer.getText()).toBe("Start\nMiddle\nEnd")
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(2)
-      expect(cursor.col).toBe(3)
-    })
-
-    it("should insert multi-line text in middle", () => {
-      buffer.setText("StartEnd")
-      buffer.setCursorToLineCol(0, 5)
-      buffer.insertText("\nMiddle\n")
-      expect(buffer.getText()).toBe("Start\nMiddle\nEnd")
-    })
-
-    it("should handle inserting text with various line endings", () => {
-      buffer.setText("")
-      buffer.insertText("Line 1\nLine 2\rLine 3\r\nLine 4")
-      const text = buffer.getText()
-      // Line breaks are preserved in the buffer
-      // Just verify we have 4 lines
-      const lines = text.split(/\r?\n|\r/)
-      expect(lines.length).toBe(4)
-      expect(lines[0]).toBe("Line 1")
-      expect(lines[3]).toBe("Line 4")
-    })
-  })
-})
-
-describe("EditBuffer Placeholder", () => {
-  let buffer: EditBuffer
-
-  beforeEach(() => {
-    buffer = EditBuffer.create("wcwidth")
-  })
-
-  afterEach(() => {
-    buffer.destroy()
-  })
-})
-
-describe("EditBuffer Events", () => {
-  describe("events", () => {
-    it("should emit cursor-changed event when cursor moves", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello World")
-      testBuffer.moveCursorRight()
-
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(1) // setText + moveCursorRight
-      testBuffer.destroy()
-    })
-
-    it("should emit cursor-changed event on setCursor", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello World")
-      testBuffer.setCursorToLineCol(0, 5)
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(1) // setText + setCursor
-      testBuffer.destroy()
-    })
-
-    it("should emit cursor-changed event on text insertion", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello")
-      testBuffer.insertText(" World")
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(1) // setText + insertText
-      testBuffer.destroy()
-    })
-
-    it("should emit cursor-changed event on deletion", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello World")
-      const beforeDelete = eventCount
-      testBuffer.setCursorToLineCol(0, 5)
-      testBuffer.deleteChar()
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(beforeDelete + 1) // setCursor + deleteChar
-      testBuffer.destroy()
-    })
-
-    it("should emit cursor-changed event on undo/redo", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Test")
-      testBuffer.insertText(" Hello")
-
-      if (testBuffer.canUndo()) {
-        const beforeUndo = eventCount
-        testBuffer.undo()
-        await flushNativeEvents()
-        expect(eventCount).toBeGreaterThan(beforeUndo)
-      }
-
-      if (testBuffer.canRedo()) {
-        const beforeRedo = eventCount
-        testBuffer.redo()
-        await flushNativeEvents()
-        expect(eventCount).toBeGreaterThan(beforeRedo)
-      }
-
-      testBuffer.destroy()
-    })
-
-    it("should handle multiple event listeners", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let count1 = 0
-      let count2 = 0
-
-      testBuffer.on("cursor-changed", () => {
-        count1++
-      })
-      testBuffer.on("cursor-changed", () => {
-        count2++
-      })
-
-      testBuffer.setText("Hello")
-      testBuffer.moveCursorRight()
-      await flushNativeEvents()
-
-      expect(count1).toBeGreaterThan(1)
-      expect(count2).toBeGreaterThan(1)
-      expect(count1).toBe(count2)
-
-      testBuffer.destroy()
-    })
-
-    it("should support removing event listeners", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-      testBuffer.setText("Hello")
-
-      let eventCount = 0
-      const listener = () => {
-        eventCount++
-      }
-
-      testBuffer.on("cursor-changed", listener)
-      testBuffer.moveCursorRight()
-      await flushNativeEvents()
-
-      const firstCount = eventCount
-
-      testBuffer.off("cursor-changed", listener)
-      testBuffer.moveCursorRight()
-      await flushNativeEvents()
-
-      // Count should not have increased after removing listener
-      expect(eventCount).toBe(firstCount)
-
-      testBuffer.destroy()
-    })
-
-    it("should isolate events between different buffer instances", async () => {
-      const testBuffer1 = EditBuffer.create("wcwidth")
-      const testBuffer2 = EditBuffer.create("wcwidth")
-
-      let count1 = 0
-      let count2 = 0
-
-      testBuffer1.on("cursor-changed", () => {
-        count1++
-      })
-      testBuffer2.on("cursor-changed", () => {
-        count2++
-      })
-
-      testBuffer1.setText("Buffer 1")
-      await flushNativeEvents()
-      const count1AfterSetText = count1
-      testBuffer1.moveCursorRight()
-      await flushNativeEvents()
-
-      expect(count1).toBeGreaterThan(count1AfterSetText)
-      expect(count2).toBe(0)
-
-      testBuffer2.setText("Buffer 2")
-      await flushNativeEvents()
-      const count2AfterSetText = count2
-      testBuffer2.moveCursorRight()
-      await flushNativeEvents()
-
-      expect(count1).toBe(count1AfterSetText + 1)
-      expect(count2).toBeGreaterThan(count2AfterSetText)
-
-      testBuffer1.destroy()
-      testBuffer2.destroy()
-    })
-
-    it("should not emit events after destroy", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello")
-      testBuffer.moveCursorRight()
-      await flushNativeEvents()
-
-      const countBeforeDestroy = eventCount
-
-      testBuffer.destroy()
-
-      // Trying to move cursor on destroyed buffer should throw
-      // So we can't test event emission, but we can verify the instance is removed from registry
-      expect(countBeforeDestroy).toBeGreaterThan(1) // setText + moveCursorRight
-    })
-  })
-
-  describe("content-changed events", () => {
-    it("should emit content-changed event on setText", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello World")
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(0)
-      testBuffer.destroy()
-    })
-
-    it("should emit content-changed event on insertText", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello")
-      await flushNativeEvents()
-      const countAfterSetText = eventCount
-
-      testBuffer.insertText(" World")
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(countAfterSetText)
-      testBuffer.destroy()
-    })
-
-    it("should emit content-changed event on deleteChar", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello World")
-      await flushNativeEvents()
-      const countAfterSetText = eventCount
-
-      testBuffer.setCursorToLineCol(0, 5)
-      testBuffer.deleteChar()
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(countAfterSetText)
-      testBuffer.destroy()
-    })
-
-    it("should emit content-changed event on deleteCharBackward", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello")
-      await flushNativeEvents()
-      const countAfterSetText = eventCount
-
-      testBuffer.setCursorToLineCol(0, 5)
-      testBuffer.deleteCharBackward()
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(countAfterSetText)
-      testBuffer.destroy()
-    })
-
-    it("should emit content-changed event on deleteLine", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Line 1\nLine 2\nLine 3")
-      await flushNativeEvents()
-      const countAfterSetText = eventCount
-
-      testBuffer.gotoLine(1)
-      testBuffer.deleteLine()
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(countAfterSetText)
-      testBuffer.destroy()
-    })
-
-    it("should emit content-changed event on newLine", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello")
-      await flushNativeEvents()
-      const countAfterSetText = eventCount
-
-      testBuffer.setCursorToLineCol(0, 5)
-      testBuffer.newLine()
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(countAfterSetText)
-      testBuffer.destroy()
-    })
-
-    it("should handle multiple content-changed listeners", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let count1 = 0
-      let count2 = 0
-
-      testBuffer.on("content-changed", () => {
-        count1++
-      })
-      testBuffer.on("content-changed", () => {
-        count2++
-      })
-
-      testBuffer.setText("Hello")
-      await flushNativeEvents()
-
-      expect(count1).toBeGreaterThan(0)
-      expect(count2).toBeGreaterThan(0)
-      expect(count1).toBe(count2)
-
-      testBuffer.destroy()
-    })
-
-    it("should support removing content-changed listeners", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-      testBuffer.setText("Hello")
-      await flushNativeEvents()
-
-      let eventCount = 0
-      const listener = () => {
-        eventCount++
-      }
-
-      testBuffer.on("content-changed", listener)
-      testBuffer.insertText(" World")
-      await flushNativeEvents()
-
-      const firstCount = eventCount
-
-      testBuffer.off("content-changed", listener)
-      testBuffer.insertText("!")
-      await flushNativeEvents()
-
-      // Count should not have increased after removing listener
-      expect(eventCount).toBe(firstCount)
-
-      testBuffer.destroy()
-    })
-
-    it("should deliver native event payload bytes through the event callback bridge", async () => {
-      const lib = resolveRenderLib()
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      const payload = await new Promise<ArrayBuffer>((resolve) => {
-        lib.onceNativeEvent("eb_content-changed", (data) => resolve(data))
-        testBuffer.setText("event payload")
-      })
-
-      const id = new DataView(payload).getUint16(0, true)
-
-      expect(payload.byteLength).toBe(2)
-      expect(id).toBe(testBuffer.id)
-
-      testBuffer.destroy()
-    })
-
-    it("should isolate content-changed events between different buffer instances", async () => {
-      const testBuffer1 = EditBuffer.create("wcwidth")
-      const testBuffer2 = EditBuffer.create("wcwidth")
-
-      let count1 = 0
-      let count2 = 0
-
-      testBuffer1.on("content-changed", () => {
-        count1++
-      })
-      testBuffer2.on("content-changed", () => {
-        count2++
-      })
-
-      testBuffer1.setText("Buffer 1")
-      await flushNativeEvents()
-      const count1AfterSetText = count1
-
-      testBuffer1.insertText(" updated")
-      await flushNativeEvents()
-
-      expect(count1).toBeGreaterThan(count1AfterSetText)
-      expect(count2).toBe(0)
-
-      testBuffer2.setText("Buffer 2")
-      await flushNativeEvents()
-      const count2AfterSetText = count2
-
-      testBuffer2.insertText(" updated")
-      await flushNativeEvents()
-
-      expect(count1).toBe(count1AfterSetText + 1)
-      expect(count2).toBeGreaterThan(count2AfterSetText)
-
-      testBuffer1.destroy()
-      testBuffer2.destroy()
-    })
-
-    it("should not emit content-changed after destroy", async () => {
-      const testBuffer = EditBuffer.create("wcwidth")
-
-      let eventCount = 0
-      testBuffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      testBuffer.setText("Hello")
-      await flushNativeEvents()
-
-      const countBeforeDestroy = eventCount
-
-      testBuffer.destroy()
-
-      // Trying to modify destroyed buffer should throw
-      expect(countBeforeDestroy).toBeGreaterThan(0)
-    })
-  })
-})
-
-describe("EditBuffer History Management", () => {
-  let buffer: EditBuffer
-
-  beforeEach(() => {
-    buffer = EditBuffer.create("wcwidth")
-  })
-
-  afterEach(() => {
-    buffer.destroy()
-  })
-
-  describe("replaceText with history", () => {
-    it("should create undo history when using replaceText", () => {
-      buffer.replaceText("Initial text")
-      expect(buffer.canUndo()).toBe(true)
-    })
-
-    it("should allow undo after replaceText", () => {
-      buffer.replaceText("First text")
-      expect(buffer.getText()).toBe("First text")
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should allow redo after undo of replaceText", () => {
-      buffer.replaceText("First text")
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-
-      buffer.redo()
-      expect(buffer.getText()).toBe("First text")
-    })
-
-    it("should restore cursor position after undo and redo for mid-line edits", () => {
-      buffer.setText("hello world")
-      buffer.setCursorToLineCol(0, 8)
-
-      buffer.insertText("X")
-      expect(buffer.getText()).toBe("hello woXrld")
-      expect(buffer.getCursorPosition().row).toBe(0)
-      expect(buffer.getCursorPosition().col).toBe(9)
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("hello world")
-      expect(buffer.getCursorPosition().row).toBe(0)
-      expect(buffer.getCursorPosition().col).toBe(8)
-
-      buffer.redo()
-      expect(buffer.getText()).toBe("hello woXrld")
-      expect(buffer.getCursorPosition().row).toBe(0)
-      expect(buffer.getCursorPosition().col).toBe(9)
-    })
-
-    it("should maintain history across multiple replaceText calls", () => {
-      buffer.replaceText("Text 1")
-      buffer.replaceText("Text 2")
-      buffer.replaceText("Text 3")
-
-      expect(buffer.getText()).toBe("Text 3")
-      expect(buffer.canUndo()).toBe(true)
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("Text 2")
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("Text 1")
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-    })
-  })
-
-  describe("replaceTextOwned with history", () => {
-    it("should create undo history when using replaceTextOwned", () => {
-      buffer.replaceTextOwned("Initial text")
-      expect(buffer.canUndo()).toBe(true)
-    })
-
-    it("should allow undo after replaceTextOwned", () => {
-      buffer.replaceTextOwned("First text")
-      expect(buffer.getText()).toBe("First text")
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should allow redo after undo of replaceTextOwned", () => {
-      buffer.replaceTextOwned("First text")
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-
-      buffer.redo()
-      expect(buffer.getText()).toBe("First text")
-    })
-
-    it("should work correctly with Unicode text", () => {
-      buffer.replaceTextOwned("Hello 世界 🌟")
-      expect(buffer.getText()).toBe("Hello 世界 🌟")
-      expect(buffer.canUndo()).toBe(true)
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-    })
-  })
-
-  describe("setTextOwned without history", () => {
-    it("should not create undo history when using setTextOwned", () => {
-      buffer.setTextOwned("Initial text")
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should work correctly with Unicode text", () => {
-      buffer.setTextOwned("Hello 世界 🌟")
-      expect(buffer.getText()).toBe("Hello 世界 🌟")
-      expect(buffer.canUndo()).toBe(false)
-    })
-  })
-
-  describe("setText without history", () => {
-    it("should not create undo history when using setText", () => {
-      buffer.setText("Initial text")
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should set text content correctly", () => {
-      buffer.setText("Test content")
-      expect(buffer.getText()).toBe("Test content")
-    })
-
-    it("should clear existing history", () => {
-      buffer.replaceText("First text")
-      expect(buffer.canUndo()).toBe(true)
-
-      buffer.setText("Second text")
-      expect(buffer.getText()).toBe("Second text")
-      // setText clears all history
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should work with multi-line text", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-      expect(buffer.getText()).toBe("Line 1\nLine 2\nLine 3")
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should work with Unicode text", () => {
-      buffer.setText("Unicode 世界 🌟")
-      expect(buffer.getText()).toBe("Unicode 世界 🌟")
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should work with empty text", () => {
-      buffer.replaceText("Some text")
-      buffer.setText("")
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should reuse single memory slot on repeated calls", () => {
-      // This tests the memory efficiency - each call should replace the previous
-      buffer.setText("Text 1")
-      expect(buffer.getText()).toBe("Text 1")
-
-      buffer.setText("Text 2")
-      expect(buffer.getText()).toBe("Text 2")
-
-      buffer.setText("Text 3")
-      expect(buffer.getText()).toBe("Text 3")
-
-      // Should not have created any history
-      expect(buffer.canUndo()).toBe(false)
-    })
-  })
-
-  describe("mixed operations", () => {
-    it("should handle replaceText followed by insertText with full undo", () => {
-      buffer.replaceText("Hello")
-      // replaceText places cursor at (0,0), so move to end
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" World")
-      expect(buffer.getText()).toBe("Hello World")
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("Hello")
-
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should handle replaceText followed by insertText", () => {
-      buffer.replaceText("Hello")
-      // replaceText places cursor at (0,0)
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" World")
-      expect(buffer.getText()).toBe("Hello World")
-
-      // Can undo the insertText
-      buffer.undo()
-      expect(buffer.getText()).toBe("Hello")
-
-      // Can undo replaceText since it preserved history
-      buffer.undo()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should handle setText followed by insertText", () => {
-      buffer.setText("Hello")
-      // setText places cursor at (0,0)
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" World")
-      expect(buffer.getText()).toBe("Hello World")
-
-      // Can undo the insertText
-      buffer.undo()
-      expect(buffer.getText()).toBe("Hello")
-
-      // Cannot undo setText since it cleared history
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should handle replaceText and setText together", () => {
-      buffer.replaceText("Text 1")
-      buffer.setText("Text 2")
-      expect(buffer.getText()).toBe("Text 2")
-
-      // Cannot undo because setText cleared history
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should allow clearing history after replaceText", () => {
-      buffer.replaceText("Text 1")
-      buffer.replaceText("Text 2")
-      expect(buffer.canUndo()).toBe(true)
-
-      buffer.clearHistory()
-      expect(buffer.canUndo()).toBe(false)
-      expect(buffer.getText()).toBe("Text 2")
-    })
-  })
-
-  describe("events with different methods", () => {
-    it("should emit content-changed for setText", async () => {
-      let eventCount = 0
-      buffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      buffer.setText("Hello")
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(0)
-    })
-
-    it("should emit content-changed for replaceText", async () => {
-      let eventCount = 0
-      buffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      buffer.replaceText("Hello")
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(0)
-    })
-
-    it("should emit content-changed for setTextOwned", async () => {
-      let eventCount = 0
-      buffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      buffer.setTextOwned("Hello")
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(0)
-    })
-  })
-})
-
-describe("EditBuffer Clear Method", () => {
-  let buffer: EditBuffer
-
-  beforeEach(() => {
-    buffer = EditBuffer.create("wcwidth")
-  })
-
-  afterEach(() => {
-    buffer.destroy()
-  })
-
-  describe("basic clear functionality", () => {
-    it("should clear text content", () => {
-      buffer.setText("Hello World")
-      expect(buffer.getText()).toBe("Hello World")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should reset cursor to 0,0", () => {
-      buffer.setText("Hello World")
-      buffer.setCursorToLineCol(0, 5)
-      expect(buffer.getCursorPosition().col).toBe(5)
-
-      buffer.clear()
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-      expect(cursor.offset).toBe(0)
-    })
-
-    it("should clear multi-line text", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-      expect(buffer.getText()).toBe("Line 1\nLine 2\nLine 3")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should clear Unicode text", () => {
-      buffer.setText("Hello 世界 🌟")
-      expect(buffer.getText()).toBe("Hello 世界 🌟")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should handle clearing already empty buffer", () => {
-      buffer.setText("")
-      expect(buffer.getText()).toBe("")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should handle clearing after multiple edits", () => {
-      buffer.setText("Hello")
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" World")
-      buffer.insertText("!")
-      expect(buffer.getText()).toBe("Hello World!")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-  })
-
-  describe("clear with cursor positions", () => {
-    it("should reset cursor from end of text", () => {
-      buffer.setText("Hello World")
-      buffer.setCursorToLineCol(0, 11) // End of text
-
-      buffer.clear()
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should reset cursor from middle of multi-line text", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-      buffer.setCursorToLineCol(1, 3) // Middle of line 2
-
-      buffer.clear()
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should reset cursor from last line", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-      buffer.gotoLine(2) // Last line
-
-      buffer.clear()
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-  })
-
-  describe("clear without placeholder", () => {
-    it("should handle clear without placeholder", () => {
-      buffer.setText("Hello World")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-  })
-
-  describe("clear with events", () => {
-    it("should emit content-changed event on clear", async () => {
-      let eventCount = 0
-      buffer.on("content-changed", () => {
-        eventCount++
-      })
-
-      buffer.setText("Hello World")
-      await flushNativeEvents()
-      const countAfterSetText = eventCount
-
-      buffer.clear()
-      await flushNativeEvents()
-
-      expect(eventCount).toBeGreaterThan(countAfterSetText)
-    })
-
-    it("should emit cursor-changed event on clear", async () => {
-      let eventCount = 0
-      buffer.on("cursor-changed", () => {
-        eventCount++
-      })
-
-      buffer.setText("Hello World")
-      buffer.setCursorToLineCol(0, 5)
-      await flushNativeEvents()
-      const countBeforeClear = eventCount
-
-      buffer.clear()
-      await flushNativeEvents()
-
-      // Should emit cursor-changed when resetting cursor to 0,0
-      expect(eventCount).toBeGreaterThan(countBeforeClear)
-    })
-
-    it("should emit both events on clear", async () => {
-      let contentChangedCount = 0
-      let cursorChangedCount = 0
-
-      buffer.on("content-changed", () => {
-        contentChangedCount++
-      })
-      buffer.on("cursor-changed", () => {
-        cursorChangedCount++
-      })
-
-      buffer.setText("Hello World")
-      buffer.setCursorToLineCol(0, 5)
-      await flushNativeEvents()
-
-      const contentCountBefore = contentChangedCount
-      const cursorCountBefore = cursorChangedCount
-
-      buffer.clear()
-      await flushNativeEvents()
-
-      expect(contentChangedCount).toBeGreaterThan(contentCountBefore)
-      expect(cursorChangedCount).toBeGreaterThan(cursorCountBefore)
-    })
-  })
-
-  describe("clear and subsequent operations", () => {
-    it("should allow inserting text after clear", () => {
-      buffer.setText("Hello")
-      buffer.clear()
-
-      buffer.insertText("World")
-      expect(buffer.getText()).toBe("World")
-    })
-
-    it("should allow setText after clear", () => {
-      buffer.setText("Hello")
-      buffer.clear()
-
-      buffer.setText("New Text")
-      expect(buffer.getText()).toBe("New Text")
-    })
-
-    it("should maintain correct cursor after clear and insert", () => {
-      buffer.setText("Hello World")
-      buffer.clear()
-
-      buffer.insertText("Test")
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(4)
-    })
-
-    it("should allow multiple clear operations", () => {
-      buffer.setText("Text 1")
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-
-      buffer.setText("Text 2")
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-
-      buffer.setText("Text 3")
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-  })
-
-  describe("clear with complex scenarios", () => {
-    it("should clear after edit session", () => {
-      buffer.setText("Hello")
-      buffer.setCursorToLineCol(0, 5) // Move to end
-      buffer.insertText(" World")
-      buffer.insertText("!")
-      buffer.setCursorToLineCol(0, 0) // Move to start
-      buffer.insertText(">> ")
-
-      expect(buffer.getText()).toBe(">> Hello World!")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-
-    it("should clear after line operations", () => {
-      buffer.setText("Line 1\nLine 2\nLine 3")
-      buffer.gotoLine(1)
-      buffer.deleteLine()
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should clear after range deletion", () => {
-      buffer.setText("Hello World Test")
-      buffer.deleteRange(0, 6, 0, 11)
-      expect(buffer.getText()).toBe("Hello  Test")
-
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-    })
-
-    it("should handle clear with wide characters", () => {
-      buffer.setText("A世🌟B")
-      buffer.clear()
-      expect(buffer.getText()).toBe("")
-
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.row).toBe(0)
-      expect(cursor.col).toBe(0)
-    })
-  })
-
-  describe("error handling", () => {
-    it("should throw error when clearing destroyed buffer", () => {
-      buffer.setText("Test")
-      buffer.destroy()
-
-      expect(() => buffer.clear()).toThrow("EditBuffer is destroyed")
-    })
-  })
-
-  describe("Regression Tests", () => {
-    it("should handle moving left in a long line (potential BoundedArray overflow)", () => {
-      const longText = "a".repeat(500)
-      buffer.setText(longText)
-
-      buffer.setCursorToLineCol(0, 500)
-      buffer.moveCursorLeft()
-
-      const cursor = buffer.getCursorPosition()
-      expect(cursor.col).toBe(499)
-    })
-  })
-})
-
-describe("EditBuffer Memory Registry Limits", () => {
-  let buffer: EditBuffer
-
-  beforeEach(() => {
-    buffer = EditBuffer.create("wcwidth")
-  })
-
-  afterEach(() => {
-    buffer.destroy()
-  })
-
-  describe("Memory buffer management", () => {
-    it("should handle many setText calls without exceeding limit", () => {
-      for (let i = 0; i < 300; i++) {
-        buffer.setText(`Text ${i}`)
-      }
-
-      expect(buffer.getText()).toBe("Text 299")
-    })
-
-    it("should handle 1000 setText calls without memory registry errors", () => {
-      for (let i = 0; i < 1000; i++) {
-        buffer.setText(`Text ${i}`)
-      }
-
-      expect(buffer.getText()).toBe("Text 999")
-      expect(buffer.canUndo()).toBe(false)
-    })
-
-    it("should handle limited replaceText calls before hitting buffer limit", () => {
-      for (let i = 0; i < 200; i++) {
-        buffer.replaceText(`Text ${i}`)
-      }
-
-      expect(buffer.getText()).toBe("Text 199")
-    })
-
-    it("should handle mixed replaceText and setText calls", () => {
-      for (let i = 0; i < 100; i++) {
-        buffer.replaceText(`With history ${i}`)
-      }
-
-      for (let i = 0; i < 300; i++) {
-        buffer.setText(`Without history ${i}`)
-      }
-
-      expect(buffer.getText()).toBe("Without history 299")
-    })
-  })
-})