wyreframe 0.1.0 → 0.1.5

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

@@ -1,1008 +0,0 @@
-/**
- * Integration Tests: WyreframeParser
- *
- * Tests login scene, multi-scene, nested boxes, interactions, errors, warnings
- * with realistic examples.
- * Requirements: REQ-25
- *
- * This test suite validates the complete WyreframeParser pipeline
- * (Grid Scanner → Shape Detector → Semantic Parser) with realistic wireframe examples.
- *
- * Test Framework: Vitest with rescript-vitest
- * Date: 2025-12-22
- */
-
-open Vitest
-
-// Helper for passing tests
-let pass = ()
-
-// =============================================================================
-// Recursive Element Search Helpers
-// =============================================================================
-
-/**
- * Recursively collect all elements including those nested inside Box children.
- * This is needed because named boxes contain their elements in Box.children,
- * not directly in scene.elements.
- */
-let rec collectAllElements = (elements: array<Types.element>): array<Types.element> => {
-  elements->Array.flatMap(el => {
-    switch el {
-    | Box({children}) => Array.concat([el], collectAllElements(children))
-    | other => [other]
-    }
-  })
-}
-
-/**
- * Find an element matching a predicate, searching recursively into Box children.
- */
-let findElement = (elements: array<Types.element>, predicate: Types.element => bool): option<Types.element> => {
-  let allElements = collectAllElements(elements)
-  Belt.Array.getBy(allElements, predicate)
-}
-
-/**
- * Check if any element matches a predicate, searching recursively.
- */
-let hasElement = (elements: array<Types.element>, predicate: Types.element => bool): bool => {
-  let allElements = collectAllElements(elements)
-  Belt.Array.some(allElements, predicate)
-}
-
-/**
- * Count elements matching a predicate, searching recursively.
- */
-let countElements = (elements: array<Types.element>, predicate: Types.element => bool): int => {
-  let allElements = collectAllElements(elements)
-  Belt.Array.reduce(allElements, 0, (count, el) => predicate(el) ? count + 1 : count)
-}
-
-// =============================================================================
-// E2E-01: Parse Simple Login Scene
-// =============================================================================
-
-describe("E2E-01: Parse Simple Login Scene", t => {
-  test("parses complete login scene with all element types", t => {
-    let loginWireframe = `
-@scene: login
-@title: Login Page
-@transition: fade
-
-+--Login----------------+
-|                       |
-|  * Welcome Back       |
-|                       |
-|  Email:               |
-|  #email               |
-|                       |
-|  Password:            |
-|  #password            |
-|                       |
-|  [x] Remember me      |
-|                       |
-|     [ Login ]         |
-|                       |
-|  "Forgot password?"   |
-|                       |
-+-----------------------+
-`
-
-    // Parse wireframe
-    let result = Parser.parse(loginWireframe)
-
-    // Verify successful parse
-    switch result {
-    | Ok(ast) => {
-        // Verify scene properties
-        t->expect(Belt.Array.length(ast.scenes))->Expect.toBe(1)
-
-        let scene = ast.scenes->Array.getUnsafe(0)
-        t->expect(scene.id)->Expect.toBe("login")
-        t->expect(scene.title)->Expect.toBe("Login Page")
-        t->expect(scene.transition)->Expect.toBe("fade")
-
-        // Verify emphasis text element (search recursively inside boxes)
-        let emphasisFound = hasElement(scene.elements, el => {
-          switch el {
-          | Text({content, emphasis: true}) => Js.String2.includes(content, "Welcome Back")
-          | _ => false
-          }
-        })
-        t->expect(emphasisFound)->Expect.toBe(true)
-
-        // Verify input elements (search recursively inside boxes)
-        let emailInput = findElement(scene.elements, el => {
-          switch el {
-          | Input({id: "email"}) => true
-          | _ => false
-          }
-        })
-        t->expect(emailInput)->Expect.not->Expect.toBe(None)
-
-        let passwordInput = findElement(scene.elements, el => {
-          switch el {
-          | Input({id: "password"}) => true
-          | _ => false
-          }
-        })
-        t->expect(passwordInput)->Expect.not->Expect.toBe(None)
-
-        // Verify checkbox element (search recursively inside boxes)
-        let checkbox = findElement(scene.elements, el => {
-          switch el {
-          | Checkbox({checked: true, label}) => Js.String2.includes(label, "Remember me")
-          | _ => false
-          }
-        })
-        t->expect(checkbox)->Expect.not->Expect.toBe(None)
-
-        // Verify button element (search recursively inside boxes)
-        let button = findElement(scene.elements, el => {
-          switch el {
-          | Button({text: "Login", align: Center}) => true
-          | _ => false
-          }
-        })
-        t->expect(button)->Expect.not->Expect.toBe(None)
-
-        // Verify link element (search recursively inside boxes)
-        let link = findElement(scene.elements, el => {
-          switch el {
-          | Link({text}) => Js.String2.includes(text, "Forgot password")
-          | _ => false
-          }
-        })
-        t->expect(link)->Expect.not->Expect.toBe(None)
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of login scene
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-02: Parse Multi-Scene Wireframe
-// =============================================================================
-
-describe("E2E-02: Parse Multi-Scene Wireframe", t => {
-  test("parses multiple scenes with correct transitions", t => {
-    let multiSceneWireframe = `
-@scene: home
-@title: Home Screen
-@transition: slide-right
-
-+--Home---------------+
-|                     |
-|  "Go to Settings"   |
-|                     |
-+---------------------+
-
----
-
-@scene: settings
-@title: Settings
-@transition: slide-left
-
-+--Settings----------+
-|                    |
-|  [x] Notifications |
-|  [ ] Dark Mode     |
-|                    |
-|  [ Save ]          |
-|                    |
-+--------------------+
-`
-
-    let result = Parser.parse(multiSceneWireframe)
-
-    switch result {
-    | Ok(ast) => {
-        // Verify scene count
-        t->expect(Belt.Array.length(ast.scenes))->Expect.toBe(2)
-
-        // Verify first scene
-        let homeScene = ast.scenes->Array.getUnsafe(0)
-        t->expect(homeScene.id)->Expect.toBe("home")
-        t->expect(homeScene.title)->Expect.toBe("Home Screen")
-        t->expect(homeScene.transition)->Expect.toBe("slide-right")
-
-        // Verify second scene
-        let settingsScene = ast.scenes->Array.getUnsafe(1)
-        t->expect(settingsScene.id)->Expect.toBe("settings")
-        t->expect(settingsScene.title)->Expect.toBe("Settings")
-        t->expect(settingsScene.transition)->Expect.toBe("slide-left")
-
-        // Verify settings scene contains checkboxes (search recursively)
-        let notificationsCheckbox = findElement(settingsScene.elements, el => {
-          switch el {
-          | Checkbox({checked: true, label}) => Js.String2.includes(label, "Notifications")
-          | _ => false
-          }
-        })
-        t->expect(notificationsCheckbox)->Expect.not->Expect.toBe(None)
-
-        let darkModeCheckbox = findElement(settingsScene.elements, el => {
-          switch el {
-          | Checkbox({checked: false, label}) => Js.String2.includes(label, "Dark Mode")
-          | _ => false
-          }
-        })
-        t->expect(darkModeCheckbox)->Expect.not->Expect.toBe(None)
-
-        // Verify button (search recursively)
-        let saveButton = findElement(settingsScene.elements, el => {
-          switch el {
-          | Button({text: "Save"}) => true
-          | _ => false
-          }
-        })
-        t->expect(saveButton)->Expect.not->Expect.toBe(None)
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of multi-scene wireframe
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-03: Parse Deeply Nested Boxes
-// =============================================================================
-
-describe("E2E-03: Parse Deeply Nested Boxes", t => {
-  test("parses 3-level nested boxes with correct hierarchy", t => {
-    let nestedWireframe = `
-@scene: nested-test
-
-+--Level1-(Outer)------------------+
-|                                  |
-| +--Level2-(Middle)-----------+   |
-| |                            |   |
-| | +--Level3-(Inner)------+   |   |
-| | |                      |   |   |
-| | |  [ Action Button ]   |   |   |
-| | |                      |   |   |
-| | +----------------------+   |   |
-| |                            |   |
-| +----------------------------+   |
-|                                  |
-+----------------------------------+
-`
-
-    let result = Parser.parse(nestedWireframe)
-
-    switch result {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Find root box
-        let rootBox = Belt.Array.getBy(scene.elements, el => {
-          switch el {
-          | Box({name: Some(boxName)}) => Js.String2.includes(boxName, "Level1")
-          | _ => false
-          }
-        })
-
-        t->expect(rootBox)->Expect.not->Expect.toBe(None)
-
-        // Verify nesting hierarchy
-        switch rootBox {
-        | Some(Box({children, name: Some(boxName)})) => {
-            t->expect(Js.String2.includes(boxName, "Outer"))->Expect.toBe(true)
-            t->expect(Belt.Array.length(children))->Expect.Int.toBeGreaterThan(0)
-
-            // Check for Level 2 box
-            let level2Box = Belt.Array.getBy(children, el => {
-              switch el {
-              | Box({name: Some(name)}) => Js.String2.includes(name, "Level2")
-              | _ => false
-              }
-            })
-            t->expect(level2Box)->Expect.not->Expect.toBe(None)
-
-            // Check for Level 3 box within Level 2
-            switch level2Box {
-            | Some(Box({children: level2Children})) => {
-                let level3Box = Belt.Array.getBy(level2Children, el => {
-                  switch el {
-                  | Box({name: Some(name)}) => Js.String2.includes(name, "Level3")
-                  | _ => false
-                  }
-                })
-                t->expect(level3Box)->Expect.not->Expect.toBe(None)
-
-                // Verify button is in Level 3
-                switch level3Box {
-                | Some(Box({children: level3Children})) => {
-                    let button = Belt.Array.getBy(level3Children, el => {
-                      switch el {
-                      | Button({text}) => Js.String2.includes(text, "Action Button")
-                      | _ => false
-                      }
-                    })
-                    t->expect(button)->Expect.not->Expect.toBe(None)
-                  }
-                | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Level 3 box to be a Box element
-                }
-              }
-            | _ => t->expect(true)->Expect.toBe(false) // fail: Expected Level 2 box to be a Box element
-            }
-          }
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected root box to be a Box element
-        }
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of nested boxes
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-04: Parse Wireframe with Dividers
-// =============================================================================
-
-describe("E2E-04: Parse Wireframe with Dividers", t => {
-  test("recognizes dividers as section separators", t => {
-    let dividerWireframe = `
-@scene: profile
-
-+--UserProfile---------+
-|                      |
-|  * John Doe          |
-|  john@example.com    |
-|                      |
-+======================+
-|                      |
-|  Settings            |
-|  [x] Email Updates   |
-|  [ ] SMS Alerts      |
-|                      |
-+======================+
-|                      |
-|  [ Save Profile ]    |
-|                      |
-+----------------------+
-`
-
-    let result = Parser.parse(dividerWireframe)
-
-    switch result {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Verify box with dividers exists
-        let profileBox = Belt.Array.getBy(scene.elements, el => {
-          switch el {
-          | Box({name: Some(boxName)}) => Js.String2.includes(boxName, "UserProfile")
-          | _ => false
-          }
-        })
-        t->expect(profileBox)->Expect.not->Expect.toBe(None)
-
-        // Count divider elements (search recursively inside boxes)
-        let dividerCount = countElements(scene.elements, el => {
-          switch el {
-          | Divider(_) => true
-          | _ => false
-          }
-        })
-
-        // Should have detected dividers
-        t->expect(dividerCount)->Expect.Int.toBeGreaterThan(0)
-
-        // Verify all content elements are present (search recursively)
-        let emphasisFound = hasElement(scene.elements, el => {
-          switch el {
-          | Text({emphasis: true}) => true
-          | _ => false
-          }
-        })
-        t->expect(emphasisFound)->Expect.toBe(true)
-
-        let checkboxesFound = hasElement(scene.elements, el => {
-          switch el {
-          | Checkbox(_) => true
-          | _ => false
-          }
-        })
-        t->expect(checkboxesFound)->Expect.toBe(true)
-
-        let buttonFound = hasElement(scene.elements, el => {
-          switch el {
-          | Button({text}) => Js.String2.includes(text, "Save Profile")
-          | _ => false
-          }
-        })
-        t->expect(buttonFound)->Expect.toBe(true)
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of wireframe with dividers
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-05: Parse Wireframe with Interactions
-// =============================================================================
-
-describe("E2E-05: Parse Wireframe with Interactions", t => {
-  test("merges interaction DSL with wireframe AST", t => {
-    let wireframe = `
-@scene: login
-
-+--Login---------+
-|                |
-|  #username     |
-|  #password     |
-|                |
-|  [ Submit ]    |
-|                |
-+----------------+
-`
-
-    let interactions = `
-@scene: login
-
-#username:
-  placeholder: "Enter username"
-  required: true
-
-#password:
-  type: "password"
-  placeholder: "Enter password"
-
-[ Submit ]:
-  variant: "primary"
-  @click -> validate(username, password)
-  @click -> goto(dashboard, fade)
-`
-
-    let result = Parser.parse(wireframe ++ "\n" ++ interactions)
-
-    switch result {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Verify username input exists (search recursively)
-        let usernameInput = findElement(scene.elements, el => {
-          switch el {
-          | Input({id: "username"}) => true
-          | _ => false
-          }
-        })
-        t->expect(usernameInput)->Expect.not->Expect.toBe(None)
-
-        // Verify password input exists (search recursively)
-        let passwordInput = findElement(scene.elements, el => {
-          switch el {
-          | Input({id: "password"}) => true
-          | _ => false
-          }
-        })
-        t->expect(passwordInput)->Expect.not->Expect.toBe(None)
-
-        // Verify submit button exists with actions (search recursively)
-        let submitButton = findElement(scene.elements, el => {
-          switch el {
-          | Button({text: "Submit", actions}) => Belt.Array.length(actions) > 0
-          | _ => false
-          }
-        })
-        t->expect(submitButton)->Expect.not->Expect.toBe(None)
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse with interactions
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-06: Detect Structural Errors (Unclosed Boxes)
-// =============================================================================
-
-describe("E2E-06: Detect Structural Errors", t => {
-  test("detects unclosed box errors", t => {
-    let unclosedBoxWireframe = `
-@scene: error-test
-
-+--Unclosed Box---+
-|                 |
-|  Content here   |
-+--
-`
-
-    let result = Parser.parse(unclosedBoxWireframe)
-
-    switch result {
-    | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected error for unclosed box
-    | Error(errors) => {
-        t->expect(Belt.Array.length(errors))->Expect.Int.toBeGreaterThan(0)
-
-        // Verify error is about unclosed box
-        let hasUncloseError = Belt.Array.some(errors, error => {
-          switch error.code {
-          | UncloseBox(_) => true
-          | _ => false
-          }
-        })
-        t->expect(hasUncloseError)->Expect.toBe(true)
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-07: Detect Width Mismatch Errors
-// =============================================================================
-
-describe("E2E-07: Detect Width Mismatch Errors", t => {
-  test("detects mismatched top and bottom widths", t => {
-    let mismatchedWidthWireframe = `
-@scene: error-test
-
-+--ShortTop--+
-|            |
-+--------------+
-`
-
-    let result = Parser.parse(mismatchedWidthWireframe)
-
-    switch result {
-    | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected error for width mismatch
-    | Error(errors) => {
-        t->expect(Belt.Array.length(errors))->Expect.Int.toBeGreaterThan(0)
-
-        // Verify error is about width mismatch
-        let hasMismatchError = Belt.Array.some(errors, error => {
-          switch error.code {
-          | MismatchedWidth({topWidth, bottomWidth}) => {
-              t->expect(topWidth)->Expect.not->Expect.toBe(bottomWidth)
-              true
-            }
-          | _ => false
-          }
-        })
-        t->expect(hasMismatchError)->Expect.toBe(true)
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-08: Detect Overlapping Boxes Error
-// NOTE: Overlapping box detection is not yet implemented in the parser.
-// This test is skipped until the feature is added (REQ-XX).
-// =============================================================================
-
-describe("E2E-08: Detect Overlapping Boxes", _t => {
-  test("detects overlapping non-nested boxes - feature not implemented", ~skip=true, t => {
-    let overlappingBoxesWireframe = `
-@scene: error-test
-
-+--Box1-------+
-|             |
-|  +--Box2----+---+
-|  |          |   |
-+--|----------+   |
-   |              |
-   +--------------+
-`
-
-    let result = Parser.parse(overlappingBoxesWireframe)
-
-    switch result {
-    | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected error for overlapping boxes
-    | Error(errors) => {
-        t->expect(Belt.Array.length(errors))->Expect.Int.toBeGreaterThan(0)
-
-        // Verify error is about overlapping boxes
-        let hasOverlapError = Belt.Array.some(errors, error => {
-          switch error.code {
-          | OverlappingBoxes(_) => true
-          | _ => false
-          }
-        })
-        t->expect(hasOverlapError)->Expect.toBe(true)
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-09: Generate Warnings for Deep Nesting
-// =============================================================================
-
-describe("E2E-09: Generate Warnings for Deep Nesting", t => {
-  test("generates warning for nesting depth > 4", t => {
-    let deepNestingWireframe = `
-@scene: warning-test
-
-+--L1------------------+
-|  +--L2-------------+ |
-|  |  +--L3--------+ | |
-|  |  |  +--L4----+ | | |
-|  |  |  |  +--L5-+ | | | |
-|  |  |  |  |     | | | | |
-|  |  |  |  +-----+ | | | |
-|  |  |  +---------+ | | |
-|  |  +-------------+ | |
-|  +-----------------+ |
-+-----------------------+
-`
-
-    let result = Parser.parse(deepNestingWireframe)
-
-    // Parsing should succeed even with warnings
-    switch result {
-    | Ok(ast) => {
-        // Check if warnings are included in result
-        // (Implementation may vary - warnings might be in a separate field)
-        t->expect(Belt.Array.length(ast.scenes))->Expect.toBe(1)
-      }
-    | Error(errors) => {
-        // Check if any errors are actually warnings
-        let hasDeepNestingWarning = Belt.Array.some(errors, error => {
-          switch error.code {
-          | DeepNesting({depth}) => {
-              t->expect(depth)->Expect.Int.toBeGreaterThan(4)
-              true
-            }
-          | _ => false
-          }
-        })
-
-        // If errors contain warnings, that's acceptable
-        if hasDeepNestingWarning {
-          pass
-        } else {
-          Console.error2("Parse errors:", errors)
-          t->expect(true)->Expect.toBe(false) // fail: Expected warning for deep nesting
-        }
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-10: Parse Complete Registration Flow
-// =============================================================================
-
-describe("E2E-10: Parse Complete Registration Flow", t => {
-  test("parses realistic registration scene", t => {
-    let registrationWireframe = `
-@scene: register
-@title: Create Account
-@transition: fade
-
-+--CreateAccount--------------------+
-|                                   |
-|  * Join our community             |
-|                                   |
-|  First Name:                      |
-|  #firstName                       |
-|                                   |
-|  Last Name:                       |
-|  #lastName                        |
-|                                   |
-|  Email Address:                   |
-|  #email                           |
-|                                   |
-|  Password:                        |
-|  #password                        |
-|                                   |
-|  Confirm Password:                |
-|  #confirmPassword                 |
-|                                   |
-|  [x] I agree to Terms of Service  |
-|  [x] Subscribe to newsletter      |
-|                                   |
-|        [ Create Account ]         |
-|                                   |
-|  "Already have an account?"       |
-|                                   |
-+-----------------------------------+
-`
-
-    let result = Parser.parse(registrationWireframe)
-
-    switch result {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        t->expect(scene.id)->Expect.toBe("register")
-        t->expect(scene.title)->Expect.toBe("Create Account")
-
-        // Count input fields (search recursively)
-        let inputCount = countElements(scene.elements, el => {
-          switch el {
-          | Input(_) => true
-          | _ => false
-          }
-        })
-        t->expect(inputCount)->Expect.toBe(5)
-
-        // Count checkboxes (search recursively)
-        let checkboxCount = countElements(scene.elements, el => {
-          switch el {
-          | Checkbox({checked: true}) => true
-          | _ => false
-          }
-        })
-        t->expect(checkboxCount)->Expect.toBe(2)
-
-        // Verify button is center-aligned (search recursively)
-        let centerButton = findElement(scene.elements, el => {
-          switch el {
-          | Button({text, align: Center}) => Js.String2.includes(text, "Create Account")
-          | _ => false
-          }
-        })
-        t->expect(centerButton)->Expect.not->Expect.toBe(None)
-
-        // Verify link exists (search recursively)
-        let linkFound = hasElement(scene.elements, el => {
-          switch el {
-          | Link(_) => true
-          | _ => false
-          }
-        })
-        t->expect(linkFound)->Expect.toBe(true)
-
-        // Verify emphasis text (search recursively)
-        let emphasisFound = hasElement(scene.elements, el => {
-          switch el {
-          | Text({emphasis: true}) => true
-          | _ => false
-          }
-        })
-        t->expect(emphasisFound)->Expect.toBe(true)
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of registration flow
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-11: Parse Dashboard with Multiple Components
-// =============================================================================
-
-describe("E2E-11: Parse Dashboard with Multiple Components", t => {
-  test("parses complex dashboard layout", t => {
-    let dashboardWireframe = `
-@scene: dashboard
-@title: Dashboard
-
-+--Dashboard------------------------+
-|                                   |
-|  +--Header---------------------+  |
-|  |  * Dashboard                |  |
-|  |               "Logout"      |  |
-|  +-----------------------------+  |
-|                                   |
-|  +--Stats----------------------+  |
-|  |                             |  |
-|  |  Users: 1,234               |  |
-|  |  Revenue: $45,678           |  |
-|  |                             |  |
-|  +-----------------------------+  |
-|                                   |
-|  +--Actions--------------------+  |
-|  |                             |  |
-|  |  [ Add User ]               |  |
-|  |  [ Generate Report ]        |  |
-|  |                             |  |
-|  +-----------------------------+  |
-|                                   |
-+-----------------------------------+
-`
-
-    let result = Parser.parse(dashboardWireframe)
-
-    switch result {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Find root dashboard box
-        let dashboardBox = Belt.Array.getBy(scene.elements, el => {
-          switch el {
-          | Box({name: Some(boxName)}) => Js.String2.includes(boxName, "Dashboard")
-          | _ => false
-          }
-        })
-        t->expect(dashboardBox)->Expect.not->Expect.toBe(None)
-
-        // Verify nested boxes
-        switch dashboardBox {
-        | Some(Box({children})) => {
-            // Should have 3 nested boxes: Header, Stats, Actions
-            let boxCount = Belt.Array.reduce(children, 0, (count, el) => {
-              switch el {
-              | Box(_) => count + 1
-              | _ => count
-              }
-            })
-            t->expect(boxCount)->Expect.toBe(3)
-
-            // Verify Header box has emphasis and link
-            let headerBox = Belt.Array.getBy(children, el => {
-              switch el {
-              | Box({name: Some(name)}) => Js.String2.includes(name, "Header")
-              | _ => false
-              }
-            })
-            t->expect(headerBox)->Expect.not->Expect.toBe(None)
-
-            // Verify Actions box has buttons
-            let actionsBox = Belt.Array.getBy(children, el => {
-              switch el {
-              | Box({name: Some(name), children: actionChildren}) => {
-                  if Js.String2.includes(name, "Actions") {
-                    let buttonCount = Belt.Array.reduce(actionChildren, 0, (count, child) => {
-                      switch child {
-                      | Button(_) => count + 1
-                      | _ => count
-                      }
-                    })
-                    buttonCount >= 2
-                  } else {
-                    false
-                  }
-                }
-              | _ => false
-              }
-            })
-            t->expect(actionsBox)->Expect.not->Expect.toBe(None)
-          }
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected dashboard box to be a Box element
-        }
-      }
-    | Error(errors) => {
-        Console.error2("Parse errors:", errors)
-        t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of dashboard
-      }
-    }
-  })
-})
-
-// =============================================================================
-// E2E-12: Handle Mixed Valid and Invalid Boxes
-// =============================================================================
-
-describe("E2E-12: Handle Mixed Valid and Invalid Boxes", t => {
-  test("continues parsing after errors and collects all issues", t => {
-    let mixedWireframe = `
-@scene: mixed
-
-+--Good Box 1-----+
-|                 |
-|  [ Button 1 ]   |
-|                 |
-+-----------------+
-
-+--Bad Box 1------+
-|                 |
-+-------
-
-+--Good Box 2-----+
-|                 |
-|  [ Button 2 ]   |
-|                 |
-+-----------------+
-
-+--Bad Box 2+
-|           |
-+-------------+
-`
-
-    let result = Parser.parse(mixedWireframe)
-
-    switch result {
-    | Ok(_) => t->expect(true)->Expect.toBe(false) // fail: Expected errors for invalid boxes
-    | Error(errors) => {
-        // Should have multiple errors
-        t->expect(Belt.Array.length(errors))->Expect.Int.toBeGreaterThan(1)
-
-        // Check for different error types
-        let hasUncloseError = Belt.Array.some(errors, error => {
-          switch error.code {
-          | UncloseBox(_) => true
-          | _ => false
-          }
-        })
-
-        let hasMismatchError = Belt.Array.some(errors, error => {
-          switch error.code {
-          | MismatchedWidth(_) => true
-          | _ => false
-          }
-        })
-
-        // Should have detected both error types
-        t->expect(hasUncloseError || hasMismatchError)->Expect.toBe(true)
-      }
-    }
-  })
-
-  test("successfully parses valid boxes even when errors exist", t => {
-    let mixedWireframe = `
-@scene: mixed
-
-+--Good Box 1-----+
-|                 |
-|  [ Button 1 ]   |
-|                 |
-+-----------------+
-
-+--Bad Box-------+
-|                |
-+-----
-
-+--Good Box 2-----+
-|                 |
-|  [ Button 2 ]   |
-|                 |
-+-----------------+
-`
-
-    let result = Parser.parse(mixedWireframe)
-
-    // Even with errors, should attempt to parse valid boxes
-    // (Implementation may return partial AST with errors)
-    switch result {
-    | Ok(_) => {
-        // If implementation returns Ok with warnings
-        pass
-      }
-    | Error(errors) => {
-        // Verify we collected errors
-        t->expect(Belt.Array.length(errors))->Expect.Int.toBeGreaterThan(0)
-
-        // Check that errors are reported
-        let hasStructuralError = Belt.Array.some(errors, error => {
-          switch error.code {
-          | UncloseBox(_) | MismatchedWidth(_) => true
-          | _ => false
-          }
-        })
-        t->expect(hasStructuralError)->Expect.toBe(true)
-      }
-    }
-  })
-})
-
-// Test Suite Summary
-//
-// This test suite validates:
-// 1. E2E-01: Simple login scene with all element types
-// 2. E2E-02: Multi-scene wireframe with transitions
-// 3. E2E-03: Deeply nested boxes (3 levels)
-// 4. E2E-04: Wireframe with dividers
-// 5. E2E-05: Wireframe with interactions DSL
-// 6. E2E-06: Unclosed box errors
-// 7. E2E-07: Width mismatch errors
-// 8. E2E-08: Overlapping boxes error
-// 9. E2E-09: Deep nesting warnings
-// 10. E2E-10: Complete registration flow
-// 11. E2E-11: Dashboard with multiple components
-// 12. E2E-12: Mixed valid and invalid boxes
-//
-// Total Test Cases: 14 (12 describe blocks with multiple assertions)
-// Coverage: Comprehensive integration validation of all parser stages
-//
-// To run:
-// npm test -- WyreframeParser_integration
-// npm run test:coverage