wyreframe 0.1.0 → 0.1.5

package/src/parser/Semantic/__tests__/SemanticParser_integration_test.res

@@ -1,1069 +0,0 @@
-// SemanticParser_integration_test.res
-// Integration tests for SemanticParser module
-//
-// Test Coverage:
-// - Login scene parsing
-// - Multiple scenes handling
-// - Nested box structures
-// - Horizontal dividers
-// - All element types recognition
-// - Element alignment calculation
-//
-// Requirements: REQ-25 (Testability - Unit Test Coverage)
-
-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 {
-    | Types.Box({children}) => Array.concat([el], collectAllElements(children))
-    | other => [other]
-    }
-  })
-}
-
-/**
- * Check if any element matches a predicate, searching recursively.
- */
-let hasElement = (elements: array<Types.element>, predicate: Types.element => bool): bool => {
-  let allElements = collectAllElements(elements)
-  allElements->Array.some(predicate)
-}
-
-// ============================================================================
-// TEST CASE SP-01: Simple Login Scene Parsing
-// ============================================================================
-
-describe("SemanticParser Integration - Login Scene", t => {
-  test("SP-01: parses complete login scene with all elements", t => {
-    let wireframe = `
-@scene: login
-@title: Login Page
-
-+--Login----------------+
-|                       |
-|  * Welcome            |
-|                       |
-|  Email: #email        |
-|                       |
-|  Password: #password  |
-|                       |
-|     [ Login ]         |
-|                       |
-+-----------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        // Verify scene count
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Verify scene metadata
-        t->expect(scene.id)->Expect.toBe("login")
-        t->expect(scene.title)->Expect.toBe("Login Page")
-
-        // Verify emphasis text element exists (search recursively inside boxes)
-        let emphasisFound = hasElement(scene.elements, el =>
-          switch el {
-          | Types.Text({emphasis: true, content}) => content->String.includes("Welcome")
-          | _ => false
-          }
-        )
-        t->expect(emphasisFound)->Expect.toBe(true)
-
-        // Verify email input exists (search recursively)
-        let emailInputFound = hasElement(scene.elements, el =>
-          switch el {
-          | Types.Input({id: "email"}) => true
-          | _ => false
-          }
-        )
-        t->expect(emailInputFound)->Expect.toBe(true)
-
-        // Verify password input exists (search recursively)
-        let passwordInputFound = hasElement(scene.elements, el =>
-          switch el {
-          | Types.Input({id: "password"}) => true
-          | _ => false
-          }
-        )
-        t->expect(passwordInputFound)->Expect.toBe(true)
-
-        // Verify login button exists (search recursively)
-        let loginButtonFound = hasElement(scene.elements, el =>
-          switch el {
-          | Types.Button({text: "Login"}) => true
-          | _ => false
-          }
-        )
-        t->expect(loginButtonFound)->Expect.toBe(true)
-
-        // Verify total element count (box + content elements)
-        t->expect(Array.length(scene.elements))->Expect.Int.toBeGreaterThan(0)
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-01: Expected successful parse of login scene
-      }
-    }
-  })
-
-  test("SP-01a: login scene elements have correct positions", t => {
-    let wireframe = `
-@scene: login
-
-+--Login---+
-|  #email  |
-|  [ OK ]  |
-+----------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Check that elements have position information
-        scene.elements->Array.forEach(el => {
-          switch el {
-          | Types.Input({position}) => {
-              t->expect(position.row)->Expect.Int.toBeGreaterThanOrEqual(0)
-              t->expect(position.col)->Expect.Int.toBeGreaterThanOrEqual(0)
-            }
-          | Types.Button({position}) => {
-              t->expect(position.row)->Expect.Int.toBeGreaterThanOrEqual(0)
-              t->expect(position.col)->Expect.Int.toBeGreaterThanOrEqual(0)
-            }
-          | _ => ()
-          }
-        })
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-02: Multiple Scenes Parsing
-// ============================================================================
-
-describe("SemanticParser Integration - Multiple Scenes", t => {
-  test("SP-02: parses multiple scenes separated by dividers", t => {
-    let wireframe = `
-@scene: home
-@title: Home Screen
-
-+----------+
-|  Home    |
-+----------+
-
----
-
-@scene: settings
-@title: Settings Screen
-
-+--------------+
-|  Settings    |
-+--------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        // Verify scene count
-        t->expect(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")
-
-        // Verify second scene
-        let settingsScene = ast.scenes->Array.getUnsafe(1)
-        t->expect(settingsScene.id)->Expect.toBe("settings")
-        t->expect(settingsScene.title)->Expect.toBe("Settings Screen")
-
-        // Verify scenes are separate
-        t->expect(homeScene.id)->Expect.not->Expect.toBe(settingsScene.id)
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-02: Expected successful parse of multiple scenes
-      }
-    }
-  })
-
-  test("SP-02a: handles three or more scenes", t => {
-    let wireframe = `
-@scene: one
-+----+
-| 1  |
-+----+
-
----
-
-@scene: two
-+----+
-| 2  |
-+----+
-
----
-
-@scene: three
-+----+
-| 3  |
-+----+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        t->expect(Array.length(ast.scenes))->Expect.toBe(3)
-        t->expect((ast.scenes->Array.getUnsafe(0)).id)->Expect.toBe("one")
-        t->expect((ast.scenes->Array.getUnsafe(1)).id)->Expect.toBe("two")
-        t->expect((ast.scenes->Array.getUnsafe(2)).id)->Expect.toBe("three")
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of three scenes
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-03: Nested Boxes Structure
-// ============================================================================
-
-describe("SemanticParser Integration - Nested Boxes", t => {
-  test("SP-03: parses nested box hierarchy correctly", t => {
-    let wireframe = `
-@scene: nested
-
-+--Outer-------------+
-|                    |
-| +--Inner-------+   |
-| |              |   |
-| |  [ Button ]  |   |
-| |              |   |
-| +--------------+   |
-|                    |
-+--------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Find outer box
-        let outerBox = scene.elements->Array.find(el =>
-          switch el {
-          | Types.Box({name: Some("Outer")}) => true
-          | _ => false
-          }
-        )
-
-        switch outerBox {
-        | Some(Types.Box({name, children})) => {
-            t->expect(name)->Expect.toBe(Some("Outer"))
-            t->expect(Array.length(children))->Expect.Int.toBeGreaterThan(0)
-
-            // Check for inner box in children
-            let hasInnerBox = children->Array.some(child =>
-              switch child {
-              | Types.Box({name: Some("Inner")}) => true
-              | _ => false
-              }
-            )
-            t->expect(hasInnerBox)->Expect.toBe(true)
-          }
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find outer box
-        }
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-03: Expected successful parse of nested boxes
-      }
-    }
-  })
-
-  test("SP-03a: handles three-level nesting", t => {
-    let wireframe = `
-@scene: deep
-
-+--Level1---------------+
-|                       |
-| +--Level2-----------+ |
-| |                   | |
-| | +--Level3------+  | |
-| | |   [ OK ]     |  | |
-| | +--------------+  | |
-| |                   | |
-| +-------------------+ |
-|                       |
-+-----------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Verify level 1 box exists
-        let hasLevel1 = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Box({name: Some(n)}) => n->String.includes("Level1")
-          | _ => false
-          }
-        )
-        t->expect(hasLevel1)->Expect.toBe(true)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of deeply nested boxes
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-04: Horizontal Dividers
-// ============================================================================
-
-describe("SemanticParser Integration - Dividers", t => {
-  test("SP-04: detects horizontal dividers within boxes", t => {
-    let wireframe = `
-@scene: sections
-
-+------------------+
-|  Section 1       |
-|                  |
-+==================+
-|  Section 2       |
-|                  |
-+------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Check for divider element
-        let hasDivider = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Divider(_) => true
-          | _ => false
-          }
-        )
-
-        // Note: Dividers might be represented as box boundaries
-        // or as separate elements depending on implementation
-        t->expect(Array.length(scene.elements))->Expect.Int.toBeGreaterThan(0)
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-04: Expected successful parse with dividers
-      }
-    }
-  })
-
-  test("SP-04a: handles multiple dividers in one box", t => {
-    let wireframe = `
-@scene: multi
-
-+----------+
-|  Part 1  |
-+==========+
-|  Part 2  |
-+==========+
-|  Part 3  |
-+----------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-
-        // Verify scene has content
-        let scene = ast.scenes->Array.getUnsafe(0)
-        t->expect(Array.length(scene.elements))->Expect.Int.toBeGreaterThan(0)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse with multiple dividers
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-05: All Element Types Recognition
-// ============================================================================
-
-describe("SemanticParser Integration - All Element Types", t => {
-  test("SP-05: recognizes all supported element types in one scene", t => {
-    let wireframe = `
-@scene: alltypes
-
-+----------------------+
-|  * Emphasis Text     |
-|                      |
-|  Plain Text          |
-|                      |
-|  [ Button ]          |
-|                      |
-|  #input              |
-|                      |
-|  "Link Text"         |
-|                      |
-|  [x] Checked Box     |
-|                      |
-|  [ ] Unchecked Box   |
-+----------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Check for emphasis text
-        let hasEmphasis = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Text({emphasis: true}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasEmphasis)->Expect.toBe(true)
-
-        // Check for plain text
-        let hasPlainText = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Text({emphasis: false}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasPlainText)->Expect.toBe(true)
-
-        // Check for button
-        let hasButton = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Button(_) => true
-          | _ => false
-          }
-        )
-        t->expect(hasButton)->Expect.toBe(true)
-
-        // Check for input
-        let hasInput = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Input(_) => true
-          | _ => false
-          }
-        )
-        t->expect(hasInput)->Expect.toBe(true)
-
-        // Check for link
-        let hasLink = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Link(_) => true
-          | _ => false
-          }
-        )
-        t->expect(hasLink)->Expect.toBe(true)
-
-        // Check for checked checkbox
-        let hasCheckedBox = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Checkbox({checked: true}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasCheckedBox)->Expect.toBe(true)
-
-        // Check for unchecked checkbox
-        let hasUncheckedBox = scene.elements->Array.some(el =>
-          switch el {
-          | Types.Checkbox({checked: false}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasUncheckedBox)->Expect.toBe(true)
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-05: Expected successful parse of all element types
-      }
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-06: Element Alignment Calculation
-// ============================================================================
-
-describe("SemanticParser Integration - Alignment", t => {
-  test("SP-06: calculates element alignment based on position", t => {
-    let wireframe = `
-@scene: alignment
-
-+---------------------------+
-|  [ Left ]                 |
-|                           |
-|       [ Center ]          |
-|                           |
-|                 [ Right ] |
-+---------------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Collect all buttons
-        let buttons = scene.elements->Array.filter(el =>
-          switch el {
-          | Types.Button(_) => true
-          | _ => false
-          }
-        )
-
-        t->expect(Array.length(buttons))->Expect.toBe(3)
-
-        // Check alignments (order may vary)
-        let hasLeft = buttons->Array.some(el =>
-          switch el {
-          | Types.Button({align: Types.Left}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasLeft)->Expect.toBe(true)
-
-        let hasCenter = buttons->Array.some(el =>
-          switch el {
-          | Types.Button({align: Types.Center}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasCenter)->Expect.toBe(true)
-
-        let hasRight = buttons->Array.some(el =>
-          switch el {
-          | Types.Button({align: Types.Right}) => true
-          | _ => false
-          }
-        )
-        t->expect(hasRight)->Expect.toBe(true)
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-06: Expected successful parse with alignment
-      }
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-07-11: Individual Element Type Tests
-// ============================================================================
-
-describe("SemanticParser Integration - Button Elements", t => {
-  test("SP-07: parses button with simple text", t => {
-    let wireframe = `
-@scene: btn
-+------------+
-| [ Submit ] |
-+------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        let button = scene.elements->Array.find(el =>
-          switch el {
-          | Types.Button(_) => true
-          | _ => false
-          }
-        )
-
-        switch button {
-        | Some(Types.Button({text, id})) => {
-            t->expect(text)->Expect.toBe("Submit")
-            t->expect(id)->Expect.toBe("submit")
-          }
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find button
-        }
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-
-  test("SP-07a: parses button with multi-word text", t => {
-    let wireframe = `
-@scene: btn
-+--------------------+
-| [ Create Account ] |
-+--------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let button = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Button({text}) => text === "Create Account"
-          | _ => false
-          }
-        )
-
-        switch button {
-        | Some(Types.Button({id})) => t->expect(id)->Expect.toBe("create-account")
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find multi-word button
-        }
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-})
-
-describe("SemanticParser Integration - Input Elements", t => {
-  test("SP-08: parses input field with ID", t => {
-    let wireframe = `
-@scene: inp
-+----------+
-|  #email  |
-+----------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let input = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Input(_) => true
-          | _ => false
-          }
-        )
-
-        switch input {
-        | Some(Types.Input({id})) => t->expect(id)->Expect.toBe("email")
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find input
-        }
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-
-  test("SP-08a: parses input with label prefix", t => {
-    let wireframe = `
-@scene: inp
-+-----------------+
-|  Email: #email  |
-+-----------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let input = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Input({id: "email"}) => true
-          | _ => false
-          }
-        )
-
-        t->expect(input)->Expect.not->Expect.toBe(None)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-})
-
-describe("SemanticParser Integration - Link Elements", t => {
-  test("SP-09: parses link with quoted text", t => {
-    let wireframe = `
-@scene: lnk
-+------------------+
-|  "Click Here"    |
-+------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let link = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Link(_) => true
-          | _ => false
-          }
-        )
-
-        switch link {
-        | Some(Types.Link({text, id})) => {
-            t->expect(text)->Expect.toBe("Click Here")
-            t->expect(id)->Expect.toBe("click-here")
-          }
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find link
-        }
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-})
-
-describe("SemanticParser Integration - Checkbox Elements", t => {
-  test("SP-10: parses checked checkbox", t => {
-    let wireframe = `
-@scene: chk
-+-------------------+
-|  [x] Accept terms |
-+-------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let checkbox = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Checkbox({checked: true}) => true
-          | _ => false
-          }
-        )
-
-        switch checkbox {
-        | Some(Types.Checkbox({label})) => t->expect(label)->Expect.toBe("Accept terms")
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find checked checkbox
-        }
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-
-  test("SP-10a: parses unchecked checkbox", t => {
-    let wireframe = `
-@scene: chk
-+---------------------+
-|  [ ] Decline offer  |
-+---------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let checkbox = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Checkbox({checked: false}) => true
-          | _ => false
-          }
-        )
-
-        t->expect(checkbox)->Expect.not->Expect.toBe(None)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-})
-
-describe("SemanticParser Integration - Emphasis Text", t => {
-  test("SP-11: parses emphasis text with asterisk", t => {
-    let wireframe = `
-@scene: emp
-+-----------------+
-|  * Important    |
-+-----------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let emphasisText = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Text({emphasis: true}) => true
-          | _ => false
-          }
-        )
-
-        switch emphasisText {
-        | Some(Types.Text({content})) => t->expect(content)->Expect.String.toContain("Important")
-        | _ => t->expect(true)->Expect.toBe(false) // fail: Expected to find emphasis text
-        }
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-12: Mixed Content Scene
-// ============================================================================
-
-describe("SemanticParser Integration - Mixed Content", t => {
-  test("SP-12: parses complex scene with mixed element types", t => {
-    let wireframe = `
-@scene: mixed
-
-+-------------------------+
-|  * Registration Form    |
-|                         |
-|  Name: #name            |
-|  Email: #email          |
-|                         |
-|  [x] Accept terms       |
-|                         |
-|     [ Sign Up ]         |
-|                         |
-|  "Already registered?"  |
-+-------------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        // Count different element types
-        let emphasisCount = scene.elements->Array.filter(el =>
-          switch el {
-          | Types.Text({emphasis: true}) => true
-          | _ => false
-          }
-        )->Array.length
-
-        let inputCount = scene.elements->Array.filter(el =>
-          switch el {
-          | Types.Input(_) => true
-          | _ => false
-          }
-        )->Array.length
-
-        let checkboxCount = scene.elements->Array.filter(el =>
-          switch el {
-          | Types.Checkbox(_) => true
-          | _ => false
-          }
-        )->Array.length
-
-        let buttonCount = scene.elements->Array.filter(el =>
-          switch el {
-          | Types.Button(_) => true
-          | _ => false
-          }
-        )->Array.length
-
-        let linkCount = scene.elements->Array.filter(el =>
-          switch el {
-          | Types.Link(_) => true
-          | _ => false
-          }
-        )->Array.length
-
-        // Verify all types are present
-        t->expect(emphasisCount)->Expect.Int.toBeGreaterThan(0)
-        t->expect(inputCount)->Expect.Int.toBeGreaterThanOrEqual(2) // name and email
-        t->expect(checkboxCount)->Expect.Int.toBeGreaterThan(0)
-        t->expect(buttonCount)->Expect.Int.toBeGreaterThan(0)
-        t->expect(linkCount)->Expect.Int.toBeGreaterThan(0)
-
-        // Verify scene has substantial content
-        t->expect(Array.length(scene.elements))->Expect.Int.toBeGreaterThan(5)
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-12: Expected successful parse of mixed content scene
-      }
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-14: Scene Directives Parsing
-// ============================================================================
-
-describe("SemanticParser Integration - Scene Directives", t => {
-  test("SP-14: parses scene directives correctly", t => {
-    let wireframe = `
-@scene: test
-@title: Test Scene
-@transition: fade
-
-+----------+
-|  Content |
-+----------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        t->expect(scene.id)->Expect.toBe("test")
-        t->expect(scene.title)->Expect.toBe("Test Scene")
-        t->expect(scene.transition)->Expect.toBe("fade")
-      }
-    | Error(errors) => {
-        Console.error(errors)
-        t->expect(true)->Expect.toBe(false) // fail: SP-14: Expected successful parse of scene directives
-      }
-    }
-  })
-
-  test("SP-14a: handles missing optional directives", t => {
-    let wireframe = `
-@scene: minimal
-
-+----------+
-|  Content |
-+----------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let scene = ast.scenes->Array.getUnsafe(0)
-
-        t->expect(scene.id)->Expect.toBe("minimal")
-        // Title and transition should have defaults or be empty
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse with minimal directives
-    }
-  })
-})
-
-// ============================================================================
-// TEST CASE SP-15: Empty Scene Handling
-// ============================================================================
-
-describe("SemanticParser Integration - Empty Scenes", t => {
-  test("SP-15: handles empty scene gracefully", t => {
-    let wireframe = `
-@scene: empty
-
-+-------+
-|       |
-+-------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-
-        let scene = ast.scenes->Array.getUnsafe(0)
-        t->expect(scene.id)->Expect.toBe("empty")
-
-        // Empty scene should still have valid structure
-        t->expect(Array.isArray(scene.elements))->Expect.toBe(true)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: SP-15: Expected successful parse of empty scene
-    }
-  })
-
-  test("SP-15a: handles scene with only whitespace", t => {
-    let wireframe = `
-@scene: whitespace
-
-+-----------+
-|           |
-|           |
-|           |
-+-----------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-
-        let scene = ast.scenes->Array.getUnsafe(0)
-        t->expect(scene.id)->Expect.toBe("whitespace")
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected successful parse of whitespace-only scene
-    }
-  })
-})
-
-// ============================================================================
-// EDGE CASES AND ERROR HANDLING
-// ============================================================================
-
-describe("SemanticParser Integration - Edge Cases", t => {
-  test("handles very long element text", t => {
-    let wireframe = `
-@scene: long
-
-+---------------------------------------------------+
-|  [ Very Long Button Text That Spans ]             |
-+---------------------------------------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        let button = (ast.scenes->Array.getUnsafe(0)).elements->Array.find(el =>
-          switch el {
-          | Types.Button(_) => true
-          | _ => false
-          }
-        )
-
-        t->expect(button)->Expect.not->Expect.toBe(None)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected to handle long text
-    }
-  })
-
-  test("handles special characters in text", t => {
-    let wireframe = `
-@scene: special
-
-+-------------------+
-|  "Sign Up & Go!"  |
-+-------------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected to handle special characters
-    }
-  })
-
-  test("handles unicode characters", t => {
-    let wireframe = `
-@scene: unicode
-
-+-------------+
-|  * Hello    |
-+-------------+
-`
-
-    switch Parser.parse(wireframe) {
-    | Ok(ast) => {
-        t->expect(Array.length(ast.scenes))->Expect.toBe(1)
-      }
-    | Error(_) => t->expect(true)->Expect.toBe(false) // fail: Expected to handle unicode
-    }
-  })
-})
-
-// ============================================================================
-// SUMMARY
-// ============================================================================
-
-/*
- * Test Coverage Summary:
- *
- * SP-01: Simple Login Scene - ✓
- * SP-02: Multiple Scenes - ✓
- * SP-03: Nested Boxes - ✓
- * SP-04: Dividers - ✓
- * SP-05: All Element Types - ✓
- * SP-06: Alignment - ✓
- * SP-07: Buttons - ✓
- * SP-08: Inputs - ✓
- * SP-09: Links - ✓
- * SP-10: Checkboxes - ✓
- * SP-11: Emphasis - ✓
- * SP-12: Mixed Content - ✓
- * SP-14: Scene Directives - ✓
- * SP-15: Empty Scenes - ✓
- *
- * Additional Coverage:
- * - Edge cases (long text, special chars, unicode)
- * - Error handling (partial parses)
- * - Position information validation
- * - Element property validation
- *
- * Total Tests: 30+
- * Coverage Target: ≥90% for SemanticParser module
- */