• url: Path to the client JavaScript (e.g., "/static/counter.js")
• props: Component props (must be ToJson serializable)
• wc: Whether this is a Web Components based Island
• trigger: When to hydrate the component

test {
  let count = @signal.signal(0)
  inspect(count.get(), content="0")
  count.set(5)
  inspect(count.get(), content="5")
}

• Child component rendering
• Effects and memos within children Does NOT catch:
• Event handler errors
• Async errors outside render cycle

• cases: array of condition-content pairs, evaluated in order
• fallback: optional content when no case matches

pub enum MyAction { Increment; Decrement } derive(Show)
@luna.h("button", [("onclick", action(Increment))], [...])

test {
  let a = @signal.signal(true)
  let b = @signal.signal(true)
  let c = @signal.signal(false)
  let all_true = @signal.all([a, b, c])
  inspect(all_true(), content="false")
  c.set(true)
  inspect(all_true(), content="true")
  a.set(false)
  inspect(all_true(), content="false")
}

test {
  let a = @signal.signal(false)
  let b = @signal.signal(false)
  let any_true = @signal.any([a, b])
  inspect(any_true(), content="false")
  a.set(true)
  inspect(any_true(), content="true")
}

• render: async function that produces the content (may raise errors)
• fallback: shown while loading or on error (if no on_error handler)
• on_error: optional custom error UI handler

test {
  let count = @signal.signal(0)
  let attr : @luna.Attr[Unit] = @luna.attr_dynamic(fn() {
    "count-" + count.get().to_string()
  })
  guard attr is @luna.VDynamic(getter) else { fail("expected VDynamic") }
  inspect(getter(), content="count-0")
  count.set(5)
  inspect(getter(), content="count-5")
}

test {
  let attr : @luna.Attr[Unit] = @luna.attr_static("my-class")
  guard attr is @luna.VStatic(v) else { fail("expected VStatic") }
  inspect(v, content="my-class")
}

test {
  let a = @signal.signal(0)
  let b = @signal.signal(0)
  let runs : Ref[Int] = { val: 0 }
  let _ = @signal.render_effect(fn() {
    let _ = a.get() + b.get()
    runs.val = runs.val + 1
  })
  inspect(runs.val, content="1") // Initial run
  @signal.batch(fn() {
    a.set(1)
    b.set(2)
  })
  // Only one additional run, not two
  inspect(runs.val, content="2")
}

test {
  let first = @signal.signal("Hello")
  let last = @signal.signal("World")
  let full = @signal.combine2(first, last, fn(f, l) { f + " " + l })
  inspect(full(), content="Hello World")
  first.set("Hi")
  inspect(full(), content="Hi World")
}

test {
  let node : @luna.Node[Unit] = @luna.component(fn() {
    @luna.h("div", [], [@luna.text("Component")])
  })
  guard node is @luna.Component(render~) else { fail("expected Component") }
  guard render() is @luna.Element(el) else { fail("expected Element") }
  inspect(el.tag, content="div")
}

test {
  let count = @signal.signal(5)
  let doubled = @signal.computed(fn() { count.get() * 2 })
  inspect(doubled(), content="10")
  count.set(7)
  inspect(doubled(), content="14")
}

test {
  let count = @signal.signal(0)
  let log : Array[Int] = []
  let result = @signal.create_root(fn(dispose) {
    let _ = @signal.render_effect(fn() { log.push(count.get()) })
    dispose // Return dispose function
  })
  count.set(1)
  result() // Dispose the root
  count.set(2) // Won't trigger effect
  inspect(log, content="[0, 1]")
}

// Note: effect() uses microtasks, so testing requires async handling
let count = @signal.signal(0)
let _ = @signal.effect(fn() {
println("count changed to: " + count.get().to_string())
})
count.set(1) // Effect will run after current task completes

test {
  let count = @signal.signal(0)
  let runs : Ref[Int] = { val: 0 }
  @signal.effect_once(fn() {
    let _ = count.get()
    runs.val = runs.val + 1
  })
  count.set(1)
  count.set(2)
  inspect(runs.val, content="2")
}

test {
  let enabled = @signal.signal(false)
  let count = @signal.signal(0)
  let log : Array[Int] = []
  let _ = @signal.effect_when(fn() { enabled.get() }, fn() {
    log.push(count.get())
  })
  count.set(1) // Won't run, enabled is false
  enabled.set(true)
  count.set(2)
  inspect(log, content="[1, 2]")
}

• children: lazy function that produces child content (may throw)
• fallback: function receiving (error, reset) that produces fallback UI
  • error: the caught Error
  • reset: function to retry rendering children

error_boundary(
  children=fn() { risky_component() },
  fallback=fn(err, reset) {
    h("div", [], [
      text("Error: " + err.to_string()),
      h("button", [("onclick", handler(fn(_) { reset() }))], [text("Retry")])
    ])
  }
)

test {
  let inner1 = @signal.signal(10)
  let inner2 = @signal.signal(20)
  let outer = @signal.signal(inner1)
  let flat = @signal.flatten(outer)
  inspect(flat(), content="10")
  outer.set(inner2)
  inspect(flat(), content="20")
  inner2.set(30)
  inspect(flat(), content="30")
}

test {
  let items = @signal.signal(["a", "b", "c"])
  let node : @luna.Node[Unit] = @luna.for_each(fn() {
    items.get().map(fn(s) { @luna.text(s) })
  })
  guard node is @luna.For(render~) else { fail("expected For") }
  inspect(render().length(), content="3")
}

test {
  let node : @luna.Node[Unit] = @luna.fragment([
    @luna.text("Hello"),
    @luna.text(" "),
    @luna.text("World"),
  ])
  guard node is @luna.Fragment(children) else { fail("expected Fragment") }
  inspect(children.length(), content="3")
}

test {
  let node : @luna.Node[Unit] = @luna.h(
    "div",
    [("class", @luna.attr_static("container"))],
    [@luna.text("Hello")],
  )
  guard node is @luna.Element(el) else { fail("expected Element") }
  inspect(el.tag, content="div")
}

test {
  let h : @luna.EventHandler[Int] = @luna.handler(fn(x) {
    let _ = x * 2

  })
  inspect(h.get_callback()(5), content="()")
}

• when: condition function, evaluated lazily
• render: content to render when condition is true

test {
  let a = @signal.signal(2)
  let b = @signal.signal(3)
  let compute_count : Ref[Int] = { val: 0 }
  let sum = @signal.memo(fn() {
    compute_count.val = compute_count.val + 1
    a.get() + b.get()
  })
  inspect(sum(), content="5")
  inspect(sum(), content="5") // Cached, no recompute
  inspect(compute_count.val, content="1")
  a.set(10)
  inspect(sum(), content="13") // Recomputes
  inspect(compute_count.val, content="2")
}

test {
  let count = @signal.signal(0)
  let values : Array[Int] = []
  let unsub = @signal.on(count, fn(v) { values.push(v) })
  count.set(1)
  count.set(2)
  unsub()
  count.set(3) // This won't be captured
  inspect(values, content="[1, 2]")
}

• Effects: cleanup runs before effect re-runs or when effect disposes
• Components: cleanup runs when component unmounts (Solid.js style - can be called directly in component body)

test {
  let count = @signal.signal(0)
  let log : Array[String] = []
  let dispose = @signal.render_effect(fn() {
    let v = count.get()
    log.push("run:" + v.to_string())
    @signal.on_cleanup(fn() { log.push("cleanup:" + v.to_string()) })
  })
  count.set(1)
  dispose()
  inspect(
    log,
    content=(
      #|["run:0", "cleanup:0", "run:1", "cleanup:1"]
    ),
  )
}

test {
  let count = @signal.signal(10)
  let values : Array[Int] = []
  let unsub = @signal.on_immediate(count, fn(v) { values.push(v) })
  count.set(20)
  unsub()
  // First value (10) was captured immediately, then 20 on update
  inspect(values, content="[10, 20]")
}

test {
  let count = @signal.signal(0)
  let runs : Ref[Int] = { val: 0 }
  @signal.on_mount(fn() {
    let _ = count.get() // This read won't create subscription
    runs.val = runs.val + 1
  })
  count.set(1)
  count.set(2)
  // on_mount only ran once, signal changes don't trigger re-run
  inspect(runs.val, content="1")
}

test {
  let count = @signal.signal(1)
  let prev = @signal.previous(count)
  inspect(prev(), content="None") // No previous value yet
  count.set(2)
  inspect(prev(), content="Some(1)")
  count.set(3)
  inspect(prev(), content="Some(2)")
}