wyreframe 0.1.0 → 0.1.1

package/src/parser/__tests__/GridScanner_integration.test.res

@@ -1,816 +0,0 @@
-/**
- * Grid Scanner Integration Tests
- *
- * Requirements: REQ-25 (Testability - Unit Test Coverage)
- *
- * These integration tests verify the Grid Scanner module's ability to:
- * - Parse simple boxes
- * - Handle nested boxes
- * - Detect dividers
- * - Normalize uneven lines
- * - Recognize special characters
- *
- * Test Framework: Vitest with rescript-vitest
- * Language: ReScript
- * Date: 2025-12-22
- */
-
-open Vitest
-
-// Helper for passing tests
-let pass = ()
-
-// Note: These tests are written against the Grid module interface
-// defined in the design specification.
-
-/**
- * GS-01: Simple Box Creation and Scanning
- *
- * Tests basic grid creation from a simple rectangular box,
- * verifying dimensions, character indexing, and directional scanning.
- */
-describe("GS-01: Simple Box Creation and Scanning", t => {
-  let simpleBox = [
-    "+----------+",
-    "|          |",
-    "|  Content |",
-    "|          |",
-    "+----------+",
-  ]
-
-  test("creates grid with correct dimensions", t => {
-    let grid = Grid.fromLines(simpleBox)
-
-    // "+----------+" has 12 characters (1 + 10 dashes + 1)
-    t->expect(grid.width)->Expect.toBe(12)
-    t->expect(grid.height)->Expect.toBe(5)
-  })
-
-  test("indexes all corner characters correctly", t => {
-    let grid = Grid.fromLines(simpleBox)
-
-    t->expect(Array.length(grid.cornerIndex))->Expect.toBe(4)
-
-    // Verify corner positions - corners at column 11 (0-indexed) for 12-char width
-    let corners = grid.cornerIndex
-    t->expect(Array.get(corners, 0))->Expect.toEqual(Some({Types.Position.row: 0, col: 0})) // Top-left
-    t->expect(Array.get(corners, 1))->Expect.toEqual(Some({Types.Position.row: 0, col: 11})) // Top-right
-    t->expect(Array.get(corners, 2))->Expect.toEqual(Some({Types.Position.row: 4, col: 0})) // Bottom-left
-    t->expect(Array.get(corners, 3))->Expect.toEqual(Some({Types.Position.row: 4, col: 11})) // Bottom-right
-  })
-
-  test("indexes horizontal line characters", t => {
-    let grid = Grid.fromLines(simpleBox)
-
-    // Top border: 10 dashes + bottom border: 10 dashes = 20 total
-    t->expect(Array.length(grid.hLineIndex))->Expect.toBe(20)
-  })
-
-  test("indexes vertical line characters", t => {
-    let grid = Grid.fromLines(simpleBox)
-
-    // 2 vertical lines per row × 3 middle rows = 6 total
-    t->expect(Array.length(grid.vLineIndex))->Expect.toBe(6)
-  })
-
-  test("correctly accesses characters at specific positions", t => {
-    let grid = Grid.fromLines(simpleBox)
-
-    // Top-left corner
-    switch Grid.get(grid, Types.Position.make(0, 0)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Corner at (0, 0)
-    }
-
-    // Top border horizontal line
-    switch Grid.get(grid, Types.Position.make(0, 1)) {
-    | Some(HLine) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected HLine at (0, 1)
-    }
-
-    // Left border vertical line
-    switch Grid.get(grid, Types.Position.make(1, 0)) {
-    | Some(VLine) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected VLine at (1, 0)
-    }
-
-    // Space character inside box
-    switch Grid.get(grid, Types.Position.make(1, 1)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Space at (1, 1)
-    }
-
-    // Regular text character
-    switch Grid.get(grid, Types.Position.make(2, 3)) {
-    | Some(Char("C")) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Char('C') at (2, 3)
-    }
-  })
-
-  test("scans right from top-left corner correctly", t => {
-    let grid = Grid.fromLines(simpleBox)
-    let start = Types.Position.make(0, 0)
-
-    let results = Grid.scanRight(grid, start, cell => {
-      switch cell {
-      | Corner | HLine => true
-      | _ => false
-      }
-    })
-
-    // Should scan entire top border: + and 10 dashes and +
-    t->expect(Array.length(results))->Expect.toBe(12)
-  })
-
-  test("scans down from top-left corner correctly", t => {
-    let grid = Grid.fromLines(simpleBox)
-    let start = Types.Position.make(0, 0)
-
-    let results = Grid.scanDown(grid, start, cell => {
-      switch cell {
-      | Corner | VLine => true
-      | _ => false
-      }
-    })
-
-    // Should scan entire left border: + and 3 pipes and +
-    t->expect(Array.length(results))->Expect.toBe(5)
-  })
-
-  test("finds all corners using findAll", t => {
-    let grid = Grid.fromLines(simpleBox)
-    let corners = Grid.findAll(grid, Corner)
-
-    t->expect(Array.length(corners))->Expect.toBe(4)
-  })
-})
-
-/**
- * GS-02: Nested Boxes with Hierarchy
- *
- * Tests grid scanner's ability to handle nested box structures
- * while preserving spatial relationships and alignment.
- */
-describe("GS-02: Nested Boxes with Hierarchy", t => {
-  let nestedBoxes = [
-    "+--Outer--------------+",
-    "|                     |",
-    "|  +--Inner-------+  |",
-    "|  |              |  |",
-    "|  |   [ Button ] |  |",
-    "|  |              |  |",
-    "|  +--------------+  |",
-    "|                     |",
-    "+---------------------+",
-  ]
-
-  test("creates grid with normalized dimensions", t => {
-    let grid = Grid.fromLines(nestedBoxes)
-
-    // "+--Outer--------------+" has 23 characters
-    t->expect(grid.width)->Expect.toBe(23)
-    t->expect(grid.height)->Expect.toBe(9)
-  })
-
-  test("indexes corners from both outer and inner boxes", t => {
-    let grid = Grid.fromLines(nestedBoxes)
-
-    // 4 outer corners + 4 inner corners = 8 total
-    t->expect(Array.length(grid.cornerIndex))->Expect.toBe(8)
-  })
-
-  test("preserves spatial relationships between boxes", t => {
-    let grid = Grid.fromLines(nestedBoxes)
-
-    // Verify outer box top-left corner
-    switch Grid.get(grid, Types.Position.make(0, 0)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected outer box corner at (0, 0)
-    }
-
-    // Verify inner box top-left corner
-    switch Grid.get(grid, Types.Position.make(2, 3)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected inner box corner at (2, 3)
-    }
-
-    // Verify spacing between boxes (should be spaces)
-    switch Grid.get(grid, Types.Position.make(1, 3)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected space between boxes at (1, 3)
-    }
-  })
-
-  test("handles button text inside nested box", t => {
-    let grid = Grid.fromLines(nestedBoxes)
-
-    // Button text starts at row 4, column 7 (0-indexed)
-    // Row 4: "|  |   [ Button ] |  |"
-    switch Grid.get(grid, Types.Position.make(4, 7)) {
-    | Some(Char("[")) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected '[' character at button position
-    }
-  })
-
-  test("finds corners within specific bounds", t => {
-    let grid = Grid.fromLines(nestedBoxes)
-
-    // Define bounds for inner box area
-    let innerBounds = Types.Bounds.make(~top=2, ~left=3, ~bottom=6, ~right=18)
-    let cornersInRange = Grid.findInRange(grid, Corner, innerBounds)
-
-    // Should find 4 corners of inner box
-    t->expect(Array.length(cornersInRange))->Expect.toBe(4)
-  })
-
-  test("scans across nested structure correctly", t => {
-    let grid = Grid.fromLines(nestedBoxes)
-
-    // Scan right from row 4 (inner box content row)
-    let start = Types.Position.make(4, 0)
-    let results = Grid.scanRight(grid, start, _ => true)
-
-    // Should scan entire width (23 characters)
-    t->expect(Array.length(results))->Expect.toBe(23)
-  })
-})
-
-/**
- * GS-03: Divider Detection and Indexing
- *
- * Tests grid scanner's ability to identify and index divider
- * characters ('=') used as section separators within boxes.
- */
-describe("GS-03: Divider Detection and Indexing", t => {
-  let boxWithDividers = [
-    "+--Section Box--+",
-    "|               |",
-    "| Header        |",
-    "|               |",
-    "+===============+",
-    "| Body Content  |",
-    "|               |",
-    "+===============+",
-    "| Footer        |",
-    "|               |",
-    "+---------------+",
-  ]
-
-  test("indexes all divider characters", t => {
-    let grid = Grid.fromLines(boxWithDividers)
-
-    // Two divider rows with 15 '=' each = 30 total
-    t->expect(Array.length(grid.dividerIndex))->Expect.toBe(30)
-  })
-
-  test("divider positions are correct", t => {
-    let grid = Grid.fromLines(boxWithDividers)
-
-    // First divider should be at row 4
-    let firstDivider = Array.getUnsafe(grid.dividerIndex, 0)
-    t->expect(firstDivider.row)->Expect.toBe(4)
-
-    // Second divider should be at row 7
-    let dividers = Grid.findAll(grid, Divider)
-    let row7Dividers = dividers->Array.filter(pos => pos.row == 7)
-    t->expect(Array.length(row7Dividers))->Expect.toBe(15)
-  })
-
-  test("distinguishes dividers from horizontal lines", t => {
-    let grid = Grid.fromLines(boxWithDividers)
-
-    // Row 4 should have dividers
-    switch Grid.get(grid, Types.Position.make(4, 1)) {
-    | Some(Divider) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Divider at row 4
-    }
-
-    // Row 10 (bottom) should have horizontal lines
-    switch Grid.get(grid, Types.Position.make(10, 1)) {
-    | Some(HLine) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected HLine at row 10
-    }
-  })
-
-  test("findAll returns all divider positions", t => {
-    let grid = Grid.fromLines(boxWithDividers)
-    let dividers = Grid.findAll(grid, Divider)
-
-    t->expect(Array.length(dividers))->Expect.toBe(30)
-  })
-
-  test("scans across divider line correctly", t => {
-    let grid = Grid.fromLines(boxWithDividers)
-    let start = Types.Position.make(4, 0)
-
-    let results = Grid.scanRight(grid, start, cell => {
-      switch cell {
-      | Corner | Divider => true
-      | _ => false
-      }
-    })
-
-    // Should scan: + and 15 '=' and +
-    t->expect(Array.length(results))->Expect.toBe(17)
-  })
-
-  test("dividers maintain consistent width with box", t => {
-    let grid = Grid.fromLines(boxWithDividers)
-
-    // Get dividers from row 4
-    let row4Dividers = grid.dividerIndex->Array.filter(pos => pos.row == 4)
-
-    // Should span from column 1 to 15 (width - 2 for corners)
-    let minCol = row4Dividers->Array.reduce(999, (min, pos) =>
-      Math.Int.min(min, pos.col)
-    )
-    let maxCol = row4Dividers->Array.reduce(0, (max, pos) =>
-      Math.Int.max(max, pos.col)
-    )
-
-    t->expect(minCol)->Expect.toBe(1)
-    t->expect(maxCol)->Expect.toBe(15)
-  })
-})
-
-/**
- * GS-04: Uneven Line Normalization
- *
- * Tests grid scanner's ability to normalize lines of varying
- * lengths by padding with spaces.
- */
-describe("GS-04: Uneven Line Normalization", t => {
-  let unevenLines = [
-    "+-+",
-    "|    |",
-    "+------+",
-    "|  X",
-    "+--------+",
-  ]
-
-  test("sets grid width to maximum line length", t => {
-    let grid = Grid.fromLines(unevenLines)
-
-    t->expect(grid.width)->Expect.toBe(10)
-  })
-
-  test("pads shorter lines with spaces", t => {
-    let grid = Grid.fromLines(unevenLines)
-
-    // First line "+-+" should be padded to width 10
-    // Check position beyond original line
-    switch Grid.get(grid, Types.Position.make(0, 5)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Space padding at (0, 5)
-    }
-
-    switch Grid.get(grid, Types.Position.make(0, 9)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Space padding at (0, 9)
-    }
-  })
-
-  test("preserves original content of each line", t => {
-    let grid = Grid.fromLines(unevenLines)
-
-    // First line starts with "+-+"
-    switch Grid.get(grid, Types.Position.make(0, 0)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Corner at (0, 0)
-    }
-
-    switch Grid.get(grid, Types.Position.make(0, 1)) {
-    | Some(HLine) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected HLine at (0, 1)
-    }
-
-    switch Grid.get(grid, Types.Position.make(0, 2)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Corner at (0, 2)
-    }
-  })
-
-  test("handles line with trailing content", t => {
-    let grid = Grid.fromLines(unevenLines)
-
-    // Line 3: "|  X" (4 chars, padded to 10)
-    switch Grid.get(grid, Types.Position.make(3, 3)) {
-    | Some(Char("X")) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Char('X') at (3, 3)
-    }
-
-    // Check padding after 'X'
-    switch Grid.get(grid, Types.Position.make(3, 4)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Space padding at (3, 4)
-    }
-  })
-
-  test("all lines accessible as full-width arrays", t => {
-    let grid = Grid.fromLines(unevenLines)
-
-    // Get each line and verify width
-    for row in 0 to 4 {
-      switch Grid.getLine(grid, row) {
-      | Some(line) => t->expect(Array.length(line))->Expect.toBe(10)
-      | None => t->expect(true)->Expect.toBe(false) // fail: Expected line at row
-      }
-    }
-  })
-
-  test("getRange works correctly with padding", t => {
-    let grid = Grid.fromLines(unevenLines)
-
-    // Get range from first line beyond original content
-    switch Grid.getRange(grid, 0, ~startCol=3, ~endCol=9) {
-    | Some(range) => {
-        t->expect(Array.length(range))->Expect.toBe(7)
-        // All should be spaces
-        let allSpaces = range->Array.every(cell => {
-          switch cell {
-          | Space => true
-          | _ => false
-          }
-        })
-        t->expect(allSpaces)->Expect.toBe(true)
-      }
-    | None => t->expect(true)->Expect.toBe(false) // fail: Expected range
-    }
-  })
-})
-
-/**
- * GS-05: Special Character Recognition
- *
- * Tests grid scanner's ability to correctly identify and
- * categorize all special characters used in wireframes.
- */
-describe("GS-05: Special Character Recognition", t => {
-  let specialChars = [
-    "+------|",
-    "|      |",
-    "+======+",
-  ]
-
-  test("recognizes Corner characters", t => {
-    let grid = Grid.fromLines(specialChars)
-
-    // Row 0: "+------|" has corner at 0 only (ends with |, not +)
-    // Row 2: "+======+" has corners at 0 and 7
-    // Total: 3 corners
-    t->expect(Array.length(grid.cornerIndex))->Expect.toBe(3)
-
-    // Verify corner character type
-    switch Grid.get(grid, Types.Position.make(0, 0)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Corner type
-    }
-  })
-
-  test("recognizes HLine characters", t => {
-    let grid = Grid.fromLines(specialChars)
-
-    // Top line has 4 dashes
-    let hLines = Grid.findAll(grid, HLine)
-    t->expect(Array.length(hLines))->Expect.Int.toBeGreaterThan(0)
-
-    switch Grid.get(grid, Types.Position.make(0, 1)) {
-    | Some(HLine) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected HLine type
-    }
-  })
-
-  test("recognizes VLine characters", t => {
-    let grid = Grid.fromLines(specialChars)
-
-    let vLines = Grid.findAll(grid, VLine)
-    t->expect(Array.length(vLines))->Expect.Int.toBeGreaterThan(0)
-
-    switch Grid.get(grid, Types.Position.make(1, 0)) {
-    | Some(VLine) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected VLine type
-    }
-  })
-
-  test("recognizes Divider characters", t => {
-    let grid = Grid.fromLines(specialChars)
-
-    t->expect(Array.length(grid.dividerIndex))->Expect.toBe(6)
-
-    switch Grid.get(grid, Types.Position.make(2, 1)) {
-    | Some(Divider) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Divider type
-    }
-  })
-
-  test("recognizes Space characters", t => {
-    let grid = Grid.fromLines(specialChars)
-
-    // Spaces inside the box
-    switch Grid.get(grid, Types.Position.make(1, 1)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Space type
-    }
-  })
-
-  test("recognizes regular text as Char", t => {
-    let textGrid = Grid.fromLines(["Hello"])
-
-    switch Grid.get(textGrid, Types.Position.make(0, 0)) {
-    | Some(Char("H")) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Char('H') type
-    }
-
-    switch Grid.get(textGrid, Types.Position.make(0, 1)) {
-    | Some(Char("e")) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Char('e') type
-    }
-  })
-
-  test("all special character indices are mutually exclusive", t => {
-    let grid = Grid.fromLines(specialChars)
-
-    // No position should appear in multiple indices
-    let allPositions = Array.concat(
-      Array.concat(
-        Array.concat(grid.cornerIndex, grid.hLineIndex),
-        grid.vLineIndex
-      ),
-      grid.dividerIndex
-    )
-
-    // Convert to set and check for uniqueness
-    let uniquePositions = Set.fromArray(
-      allPositions->Array.map(pos => Types.Position.toString(pos))
-    )
-
-    t->expect(Set.size(uniquePositions))->Expect.toBe(Array.length(allPositions))
-  })
-})
-
-/**
- * GS-06: Empty Input Handling
- *
- * Tests grid scanner's graceful handling of edge cases
- * including empty and minimal inputs.
- */
-describe("GS-06: Empty Input Handling", t => {
-  test("handles empty array", t => {
-    let grid = Grid.fromLines([])
-
-    t->expect(grid.width)->Expect.toBe(0)
-    t->expect(grid.height)->Expect.toBe(0)
-    t->expect(Array.length(grid.cornerIndex))->Expect.toBe(0)
-  })
-
-  test("handles array of empty strings", t => {
-    let grid = Grid.fromLines(["", "", ""])
-
-    t->expect(grid.width)->Expect.toBe(0)
-    t->expect(grid.height)->Expect.toBe(3)
-  })
-
-  test("handles single character", t => {
-    let grid = Grid.fromLines(["a"])
-
-    t->expect(grid.width)->Expect.toBe(1)
-    t->expect(grid.height)->Expect.toBe(1)
-
-    switch Grid.get(grid, Types.Position.make(0, 0)) {
-    | Some(Char("a")) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Char('a')
-    }
-  })
-
-  test("handles single line with single special char", t => {
-    let grid = Grid.fromLines(["+"])
-
-    t->expect(grid.width)->Expect.toBe(1)
-    t->expect(grid.height)->Expect.toBe(1)
-    t->expect(Array.length(grid.cornerIndex))->Expect.toBe(1)
-  })
-
-  test("get returns None for invalid positions on empty grid", t => {
-    let grid = Grid.fromLines([])
-
-    t->expect(Grid.get(grid, Types.Position.make(0, 0)))->Expect.toBe(None)
-    t->expect(Grid.get(grid, Types.Position.make(5, 5)))->Expect.toBe(None)
-  })
-
-  test("isValidPosition returns false for empty grid", t => {
-    let grid = Grid.fromLines([])
-
-    t->expect(Grid.isValidPosition(grid, Types.Position.make(0, 0)))->Expect.toBe(false)
-  })
-})
-
-/**
- * GS-07: Large Wireframe Performance
- *
- * Tests grid scanner performance with large inputs to verify
- * it meets the <10ms requirement for 1000-line grids.
- */
-describe("GS-07: Large Wireframe Performance", t => {
-  // Helper to generate large grid
-  let generateLargeGrid = (~lines: int): array<string> => {
-    let result = []
-    for i in 0 to lines - 1 {
-      if mod(i, 10) == 0 {
-        result->Array.push("+--------------------+")->ignore
-      } else if mod(i, 5) == 0 {
-        result->Array.push("+====================+")->ignore
-      } else {
-        result->Array.push("|    Content Line    |")->ignore
-      }
-    }
-    result
-  }
-
-  test("parses 1000-line grid in under 10ms", t => {
-    let largeInput = generateLargeGrid(~lines=1000)
-
-    let start = Date.now()
-    let grid = Grid.fromLines(largeInput)
-    let duration = Date.now() -. start
-
-    t->expect(duration)->Expect.Float.toBeLessThan(10.0)
-    t->expect(grid.height)->Expect.toBe(1000)
-  })
-
-  test("builds character indices for large grid", t => {
-    let largeInput = generateLargeGrid(~lines=1000)
-    let grid = Grid.fromLines(largeInput)
-
-    // Should have indexed all corners
-    t->expect(Array.length(grid.cornerIndex))->Expect.Int.toBeGreaterThan(0)
-
-    // Should have indexed dividers
-    t->expect(Array.length(grid.dividerIndex))->Expect.Int.toBeGreaterThan(0)
-  })
-
-  test("random access is performant on large grid", t => {
-    let largeInput = generateLargeGrid(~lines=1000)
-    let grid = Grid.fromLines(largeInput)
-
-    let start = Date.now()
-
-    // Perform 1000 random accesses
-    for _ in 0 to 999 {
-      let randomRow = Math.Int.random(0, 999)
-      let randomCol = Math.Int.random(0, 22)
-      let _ = Grid.get(grid, Types.Position.make(randomRow, randomCol))
-    }
-
-    let duration = Date.now() -. start
-
-    // 1000 accesses should be very fast (under 5ms with timing variance)
-    t->expect(duration)->Expect.Float.toBeLessThan(5.0)
-  })
-
-  test("findAll is efficient on large grid", t => {
-    let largeInput = generateLargeGrid(~lines=1000)
-    let grid = Grid.fromLines(largeInput)
-
-    let start = Date.now()
-    let corners = Grid.findAll(grid, Corner)
-    let duration = Date.now() -. start
-
-    t->expect(duration)->Expect.Float.toBeLessThan(5.0)
-    t->expect(Array.length(corners))->Expect.Int.toBeGreaterThan(0)
-  })
-})
-
-/**
- * GS-08: Complex Multi-Box Wireframe
- *
- * Integration test with realistic multi-box wireframe structure
- * simulating a dashboard layout.
- */
-describe("GS-08: Complex Multi-Box Wireframe", t => {
-  let complexWireframe = [
-    "@scene: dashboard",
-    "",
-    "+--Header-----------------------+",
-    "| Logo           [ Logout ]     |",
-    "+===============================+",
-    "",
-    "+--Sidebar--+  +--Main Content-----------+",
-    "|           |  |                          |",
-    "| [ Home ]  |  | +--Card 1----------+    |",
-    "|           |  | | Title            |    |",
-    "| [ Data ]  |  | | Content here...  |    |",
-    "|           |  | +------------------+    |",
-    "| [Reports] |  |                          |",
-    "|           |  | +--Card 2----------+    |",
-    "+-----------+  | | Title            |    |",
-    "               | | More content...  |    |",
-    "               | +------------------+    |",
-    "               |                          |",
-    "               +--------------------------+",
-  ]
-
-  test("parses entire complex structure", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    t->expect(grid.height)->Expect.toBe(19)
-    t->expect(grid.width)->Expect.Int.toBeGreaterThan(0)
-  })
-
-  test("indexes all box corners correctly", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Header: 4, Sidebar: 4, Main: 4, Card1: 4, Card2: 4 = 20 corners
-    t->expect(Array.length(grid.cornerIndex))->Expect.toBe(20)
-  })
-
-  test("indexes divider line in header", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Row 4 should have divider
-    let row4Dividers = grid.dividerIndex->Array.filter(pos => pos.row == 4)
-    t->expect(Array.length(row4Dividers))->Expect.Int.toBeGreaterThan(0)
-  })
-
-  test("preserves spacing between sidebar and main content", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Row 6: "+--Sidebar--+  +--Main Content-----------+"
-    // Position 12 is '+' (Sidebar end), positions 13-14 are spaces
-    switch Grid.get(grid, Types.Position.make(6, 13)) {
-    | Some(Space) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected space between boxes
-    }
-  })
-
-  test("handles multiple adjacent boxes on same row", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Row 6: "+--Sidebar--+  +--Main Content-----------+"
-    // Has 4 corners: positions 0, 11, 14, and end of line
-    let row6Corners = grid.cornerIndex->Array.filter(pos => pos.row == 6)
-    t->expect(Array.length(row6Corners))->Expect.toBe(4)
-  })
-
-  test("character access works across all regions", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Header region
-    switch Grid.get(grid, Types.Position.make(2, 0)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected corner in header
-    }
-
-    // Sidebar region
-    switch Grid.get(grid, Types.Position.make(6, 0)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected corner in sidebar
-    }
-
-    // Main content region
-    switch Grid.get(grid, Types.Position.make(6, 15)) {
-    | Some(Corner) => pass
-    | _ => t->expect(true)->Expect.toBe(false) // fail: Expected corner in main content
-    }
-  })
-
-  test("scans across complex row with multiple boxes", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Row 8 has content from both Sidebar and Main Content
-    let start = Types.Position.make(8, 0)
-    let results = Grid.scanRight(grid, start, _ => true)
-
-    // Should scan entire width
-    t->expect(Array.length(results))->Expect.toBe(grid.width)
-  })
-
-  test("finds corners in nested card region", t => {
-    let grid = Grid.fromLines(complexWireframe)
-
-    // Define bounds for Card 1 area
-    let card1Bounds = Types.Bounds.make(~top=8, ~left=17, ~bottom=11, ~right=37)
-    let cornersInCard = Grid.findInRange(grid, Corner, card1Bounds)
-
-    // Should find 4 corners of Card 1
-    t->expect(Array.length(cornersInCard))->Expect.toBe(4)
-  })
-})
-
-// Summary
-//
-// These integration tests cover:
-// - Simple box creation and scanning (GS-01)
-// - Nested boxes with hierarchy (GS-02)
-// - Divider detection and indexing (GS-03)
-// - Uneven line normalization (GS-04)
-// - Special character recognition (GS-05)
-// - Empty input handling (GS-06)
-// - Large wireframe performance (GS-07)
-// - Complex multi-box wireframe (GS-08)
-//
-// Total test cases: 60+
-// Coverage target: >=90% for Grid module
-//
-// Test execution:
-// - npm run test -- GridScanner_integration.test.mjs
-// - npm run test:coverage