@pyreon/core 0.11.5 → 0.11.7

package/src/tests/core.test.ts

@@ -31,104 +31,104 @@ import {
   Switch,
   useContext,
   withContext,
-} from "../index"
-import { jsxDEV } from "../jsx-dev-runtime"
-import { Fragment as JsxFragment, jsx, jsxs } from "../jsx-runtime"
-import type { ComponentFn, Props, VNode, VNodeChild } from "../types"
+} from '../index'
+import { jsxDEV } from '../jsx-dev-runtime'
+import { Fragment as JsxFragment, jsx, jsxs } from '../jsx-runtime'
+import type { ComponentFn, Props, VNode, VNodeChild } from '../types'
 
 // ─── h() ─────────────────────────────────────────────────────────────────────
 
-describe("h()", () => {
-  test("creates a VNode with string type", () => {
-    const node = h("div", null)
-    expect(node.type).toBe("div")
+describe('h()', () => {
+  test('creates a VNode with string type', () => {
+    const node = h('div', null)
+    expect(node.type).toBe('div')
     expect(node.props).toEqual({})
     expect(node.children).toEqual([])
     expect(node.key).toBeNull()
   })
 
-  test("passes props through", () => {
-    const node = h("div", { class: "foo", id: "bar" })
-    expect(node.props).toEqual({ class: "foo", id: "bar" })
+  test('passes props through', () => {
+    const node = h('div', { class: 'foo', id: 'bar' })
+    expect(node.props).toEqual({ class: 'foo', id: 'bar' })
   })
 
-  test("extracts key from props", () => {
-    const node = h("li", { key: "item-1" })
-    expect(node.key).toBe("item-1")
+  test('extracts key from props', () => {
+    const node = h('li', { key: 'item-1' })
+    expect(node.key).toBe('item-1')
   })
 
-  test("numeric key", () => {
-    const node = h("li", { key: 42 })
+  test('numeric key', () => {
+    const node = h('li', { key: 42 })
     expect(node.key).toBe(42)
   })
 
-  test("null props becomes empty object", () => {
-    const node = h("span", null)
+  test('null props becomes empty object', () => {
+    const node = h('span', null)
     expect(node.props).toEqual({})
   })
 
-  test("children are stored in vnode.children", () => {
-    const node = h("div", null, "hello", "world")
-    expect(node.children).toEqual(["hello", "world"])
+  test('children are stored in vnode.children', () => {
+    const node = h('div', null, 'hello', 'world')
+    expect(node.children).toEqual(['hello', 'world'])
   })
 
-  test("nested array children are flattened", () => {
-    const node = h("ul", null, [h("li", null, "a"), h("li", null, "b")])
+  test('nested array children are flattened', () => {
+    const node = h('ul', null, [h('li', null, 'a'), h('li', null, 'b')])
     expect(node.children).toHaveLength(2)
-    expect((node.children[0] as VNode).type).toBe("li")
-    expect((node.children[1] as VNode).type).toBe("li")
+    expect((node.children[0] as VNode).type).toBe('li')
+    expect((node.children[1] as VNode).type).toBe('li')
   })
 
-  test("deeply nested arrays are flattened", () => {
-    const node = h("div", null, [[["deep"]]] as unknown as VNodeChild)
-    expect(node.children).toEqual(["deep"])
+  test('deeply nested arrays are flattened', () => {
+    const node = h('div', null, [[['deep']]] as unknown as VNodeChild)
+    expect(node.children).toEqual(['deep'])
   })
 
-  test("handles boolean/null/undefined children", () => {
-    const node = h("div", null, true, false, null, undefined, "text")
-    expect(node.children).toEqual([true, false, null, undefined, "text"])
+  test('handles boolean/null/undefined children', () => {
+    const node = h('div', null, true, false, null, undefined, 'text')
+    expect(node.children).toEqual([true, false, null, undefined, 'text'])
   })
 
-  test("handles component function type", () => {
-    const Comp = ((props: { name: string }) => h("span", null, props.name)) as ComponentFn<{
+  test('handles component function type', () => {
+    const Comp = ((props: { name: string }) => h('span', null, props.name)) as ComponentFn<{
       name: string
     }>
-    const node = h(Comp, { name: "test" })
+    const node = h(Comp, { name: 'test' })
     expect(node.type as unknown).toBe(Comp)
-    expect(node.props).toEqual({ name: "test" })
+    expect(node.props).toEqual({ name: 'test' })
   })
 
-  test("handles symbol type (Fragment)", () => {
-    const node = h(Fragment, null, "a", "b")
+  test('handles symbol type (Fragment)', () => {
+    const node = h(Fragment, null, 'a', 'b')
     expect(node.type).toBe(Fragment)
-    expect(node.children).toEqual(["a", "b"])
+    expect(node.children).toEqual(['a', 'b'])
   })
 
-  test("function children are preserved (reactive getters)", () => {
-    const getter = () => "dynamic"
-    const node = h("div", null, getter)
+  test('function children are preserved (reactive getters)', () => {
+    const getter = () => 'dynamic'
+    const node = h('div', null, getter)
     expect(node.children).toHaveLength(1)
-    expect(typeof node.children[0]).toBe("function")
-    expect((node.children[0] as () => string)()).toBe("dynamic")
+    expect(typeof node.children[0]).toBe('function')
+    expect((node.children[0] as () => string)()).toBe('dynamic')
   })
 
-  test("VNode children are preserved", () => {
-    const child = h("span", null, "inner")
-    const parent = h("div", null, child)
+  test('VNode children are preserved', () => {
+    const child = h('span', null, 'inner')
+    const parent = h('div', null, child)
     expect(parent.children).toHaveLength(1)
-    expect((parent.children[0] as VNode).type).toBe("span")
+    expect((parent.children[0] as VNode).type).toBe('span')
   })
 })
 
 // ─── Fragment ────────────────────────────────────────────────────────────────
 
-describe("Fragment", () => {
-  test("is a symbol", () => {
-    expect(typeof Fragment).toBe("symbol")
+describe('Fragment', () => {
+  test('is a symbol', () => {
+    expect(typeof Fragment).toBe('symbol')
   })
 
-  test("Fragment VNode wraps children without a DOM element", () => {
-    const node = h(Fragment, null, h("span", null, "a"), h("span", null, "b"))
+  test('Fragment VNode wraps children without a DOM element', () => {
+    const node = h(Fragment, null, h('span', null, 'a'), h('span', null, 'b'))
     expect(node.type).toBe(Fragment)
     expect(node.children).toHaveLength(2)
   })
@@ -136,27 +136,27 @@ describe("Fragment", () => {
 
 // ─── defineComponent ────────────────────────────────────────────────────────
 
-describe("defineComponent()", () => {
-  test("returns the same function", () => {
-    const fn: ComponentFn = () => h("div", null)
+describe('defineComponent()', () => {
+  test('returns the same function', () => {
+    const fn: ComponentFn = () => h('div', null)
     const defined = defineComponent(fn)
     expect(defined).toBe(fn)
   })
 
-  test("preserves typed props", () => {
+  test('preserves typed props', () => {
     const Comp = defineComponent<{ count: number }>((props) => {
-      return h("span", null, String(props.count))
+      return h('span', null, String(props.count))
     })
     const node = Comp({ count: 5 })
     expect(node).not.toBeNull()
-    expect((node as VNode).type).toBe("span")
+    expect((node as VNode).type).toBe('span')
   })
 })
 
 // ─── runWithHooks / lifecycle ────────────────────────────────────────────────
 
-describe("runWithHooks()", () => {
-  test("captures lifecycle hooks registered during component execution", () => {
+describe('runWithHooks()', () => {
+  test('captures lifecycle hooks registered during component execution', () => {
     const mountFn = () => undefined
     const unmountFn = () => {}
     const updateFn = () => {}
@@ -167,7 +167,7 @@ describe("runWithHooks()", () => {
       onUnmount(unmountFn)
       onUpdate(updateFn)
       onErrorCaptured(errorFn)
-      return h("div", null)
+      return h('div', null)
     }
 
     const { vnode, hooks } = runWithHooks(Comp, {})
@@ -182,14 +182,14 @@ describe("runWithHooks()", () => {
     expect(hooks.error[0]).toBe(errorFn)
   })
 
-  test("returns null vnode when component returns null", () => {
+  test('returns null vnode when component returns null', () => {
     const Comp: ComponentFn = () => null
     const { vnode } = runWithHooks(Comp, {})
     expect(vnode).toBeNull()
   })
 
-  test("clears hooks context after execution (hooks outside component are no-ops)", () => {
-    const Comp: ComponentFn = () => h("div", null)
+  test('clears hooks context after execution (hooks outside component are no-ops)', () => {
+    const Comp: ComponentFn = () => h('div', null)
     runWithHooks(Comp, {})
 
     // Calling lifecycle hooks outside a component should not throw
@@ -199,63 +199,63 @@ describe("runWithHooks()", () => {
     onErrorCaptured(() => true)
   })
 
-  test("multiple hooks of the same type are all captured", () => {
+  test('multiple hooks of the same type are all captured', () => {
     const Comp: ComponentFn = () => {
       onMount(() => undefined)
       onMount(() => undefined)
       onMount(() => undefined)
-      return h("div", null)
+      return h('div', null)
     }
 
     const { hooks } = runWithHooks(Comp, {})
     expect(hooks.mount).toHaveLength(3)
   })
 
-  test("passes props to component function", () => {
+  test('passes props to component function', () => {
     let received: unknown = null
     const Comp: ComponentFn<{ msg: string }> = (props) => {
       received = props
       return null
     }
-    runWithHooks(Comp, { msg: "hello" })
-    expect(received).toEqual({ msg: "hello" })
+    runWithHooks(Comp, { msg: 'hello' })
+    expect(received).toEqual({ msg: 'hello' })
   })
 })
 
 // ─── propagateError ──────────────────────────────────────────────────────────
 
-describe("propagateError()", () => {
-  test("returns true when handler marks error as handled", () => {
+describe('propagateError()', () => {
+  test('returns true when handler marks error as handled', () => {
     const hooks = {
       mount: [],
       unmount: [],
       update: [],
       error: [(_err: unknown) => true as boolean | undefined],
     }
-    expect(propagateError(new Error("test"), hooks)).toBe(true)
+    expect(propagateError(new Error('test'), hooks)).toBe(true)
   })
 
-  test("returns false when no handlers", () => {
+  test('returns false when no handlers', () => {
     const hooks = {
       mount: [],
       unmount: [],
       update: [],
       error: [] as ((err: unknown) => boolean | undefined)[],
     }
-    expect(propagateError(new Error("test"), hooks)).toBe(false)
+    expect(propagateError(new Error('test'), hooks)).toBe(false)
   })
 
-  test("returns false when handler does not return true", () => {
+  test('returns false when handler does not return true', () => {
     const hooks = {
       mount: [],
       unmount: [],
       update: [],
       error: [(_err: unknown) => undefined as boolean | undefined],
     }
-    expect(propagateError(new Error("test"), hooks)).toBe(false)
+    expect(propagateError(new Error('test'), hooks)).toBe(false)
   })
 
-  test("stops at first handler that returns true", () => {
+  test('stops at first handler that returns true', () => {
     let secondCalled = false
     const hooks = {
       mount: [],
@@ -269,26 +269,26 @@ describe("propagateError()", () => {
         },
       ],
     }
-    propagateError(new Error("test"), hooks)
+    propagateError(new Error('test'), hooks)
     expect(secondCalled).toBe(false)
   })
 })
 
 // ─── Context ─────────────────────────────────────────────────────────────────
 
-describe("createContext / useContext", () => {
-  test("createContext returns context with default value", () => {
+describe('createContext / useContext', () => {
+  test('createContext returns context with default value', () => {
     const ctx = createContext(42)
     expect(ctx.defaultValue).toBe(42)
-    expect(typeof ctx.id).toBe("symbol")
+    expect(typeof ctx.id).toBe('symbol')
   })
 
-  test("useContext returns default when no provider", () => {
-    const ctx = createContext("default-value")
-    expect(useContext(ctx)).toBe("default-value")
+  test('useContext returns default when no provider', () => {
+    const ctx = createContext('default-value')
+    expect(useContext(ctx)).toBe('default-value')
   })
 
-  test("withContext provides value during callback", () => {
+  test('withContext provides value during callback', () => {
     const ctx = createContext(0)
     let captured = -1
     withContext(ctx, 99, () => {
@@ -297,17 +297,17 @@ describe("createContext / useContext", () => {
     expect(captured).toBe(99)
   })
 
-  test("withContext restores stack after callback (even on throw)", () => {
-    const ctx = createContext("original")
+  test('withContext restores stack after callback (even on throw)', () => {
+    const ctx = createContext('original')
     try {
-      withContext(ctx, "override", () => {
-        throw new Error("boom")
+      withContext(ctx, 'override', () => {
+        throw new Error('boom')
       })
     } catch {}
-    expect(useContext(ctx)).toBe("original")
+    expect(useContext(ctx)).toBe('original')
   })
 
-  test("nested contexts override outer", () => {
+  test('nested contexts override outer', () => {
     const ctx = createContext(0)
     withContext(ctx, 1, () => {
       expect(useContext(ctx)).toBe(1)
@@ -318,105 +318,105 @@ describe("createContext / useContext", () => {
     })
   })
 
-  test("multiple contexts are independent", () => {
-    const ctxA = createContext("a")
-    const ctxB = createContext("b")
-    withContext(ctxA, "A", () => {
-      withContext(ctxB, "B", () => {
-        expect(useContext(ctxA)).toBe("A")
-        expect(useContext(ctxB)).toBe("B")
+  test('multiple contexts are independent', () => {
+    const ctxA = createContext('a')
+    const ctxB = createContext('b')
+    withContext(ctxA, 'A', () => {
+      withContext(ctxB, 'B', () => {
+        expect(useContext(ctxA)).toBe('A')
+        expect(useContext(ctxB)).toBe('B')
       })
     })
   })
 
-  test("pushContext / popContext work directly", () => {
-    const ctx = createContext("default")
-    const frame = new Map<symbol, unknown>([[ctx.id, "pushed"]])
+  test('pushContext / popContext work directly', () => {
+    const ctx = createContext('default')
+    const frame = new Map<symbol, unknown>([[ctx.id, 'pushed']])
     pushContext(frame)
-    expect(useContext(ctx)).toBe("pushed")
+    expect(useContext(ctx)).toBe('pushed')
     popContext()
-    expect(useContext(ctx)).toBe("default")
+    expect(useContext(ctx)).toBe('default')
   })
 
-  test("provide() pushes context and registers cleanup on unmount", () => {
-    const ctx = createContext("default")
+  test('provide() pushes context and registers cleanup on unmount', () => {
+    const ctx = createContext('default')
     const { hooks } = runWithHooks(
       (() => {
-        provide(ctx, "provided")
+        provide(ctx, 'provided')
         return null
       }) as ComponentFn,
       {} as Props,
     )
     // Context is available after provide()
-    expect(useContext(ctx)).toBe("provided")
+    expect(useContext(ctx)).toBe('provided')
     // Running unmount hooks should pop the context
     for (const fn of hooks.unmount) fn()
-    expect(useContext(ctx)).toBe("default")
+    expect(useContext(ctx)).toBe('default')
   })
 })
 
 // ─── createRef ───────────────────────────────────────────────────────────────
 
-describe("createRef()", () => {
-  test("returns object with current = null", () => {
+describe('createRef()', () => {
+  test('returns object with current = null', () => {
     const ref = createRef()
     expect(ref.current).toBeNull()
   })
 
-  test("current is mutable", () => {
+  test('current is mutable', () => {
     const ref = createRef<number>()
     ref.current = 42
     expect(ref.current).toBe(42)
   })
 
-  test("typed ref works", () => {
+  test('typed ref works', () => {
     const ref = createRef<string>()
-    ref.current = "hello"
-    expect(ref.current).toBe("hello")
+    ref.current = 'hello'
+    expect(ref.current).toBe('hello')
   })
 })
 
 // ─── Show ────────────────────────────────────────────────────────────────────
 
-describe("Show", () => {
-  test("returns a reactive getter", () => {
-    const result = Show({ when: () => true, children: "visible" })
-    expect(typeof result).toBe("function")
+describe('Show', () => {
+  test('returns a reactive getter', () => {
+    const result = Show({ when: () => true, children: 'visible' })
+    expect(typeof result).toBe('function')
   })
 
-  test("returns children when condition is truthy", () => {
-    const getter = Show({ when: () => true, children: "visible" }) as unknown as () => VNodeChild
-    expect(getter()).toBe("visible")
+  test('returns children when condition is truthy', () => {
+    const getter = Show({ when: () => true, children: 'visible' }) as unknown as () => VNodeChild
+    expect(getter()).toBe('visible')
   })
 
-  test("returns null when condition is falsy and no fallback", () => {
-    const getter = Show({ when: () => false, children: "visible" }) as unknown as () => VNodeChild
+  test('returns null when condition is falsy and no fallback', () => {
+    const getter = Show({ when: () => false, children: 'visible' }) as unknown as () => VNodeChild
     expect(getter()).toBeNull()
   })
 
-  test("returns fallback when condition is falsy", () => {
-    const fallbackNode = h("span", null, "nope")
+  test('returns fallback when condition is falsy', () => {
+    const fallbackNode = h('span', null, 'nope')
     const getter = Show({
       when: () => false,
       fallback: fallbackNode,
-      children: "visible",
+      children: 'visible',
     }) as unknown as () => VNodeChild
     expect(getter()).toBe(fallbackNode)
   })
 
-  test("reacts to condition changes", () => {
+  test('reacts to condition changes', () => {
     let flag = true
     const getter = Show({
       when: () => flag,
-      children: "yes",
-      fallback: "no",
+      children: 'yes',
+      fallback: 'no',
     }) as unknown as () => VNodeChild
-    expect(getter()).toBe("yes")
+    expect(getter()).toBe('yes')
     flag = false
-    expect(getter()).toBe("no")
+    expect(getter()).toBe('no')
   })
 
-  test("returns null for children when children not provided and condition truthy", () => {
+  test('returns null for children when children not provided and condition truthy', () => {
     const getter = Show({ when: () => true }) as unknown as () => VNodeChild
     expect(getter()).toBeNull()
   })
@@ -424,108 +424,108 @@ describe("Show", () => {
 
 // ─── Switch / Match ──────────────────────────────────────────────────────────
 
-describe("Switch / Match", () => {
-  test("renders first matching branch", () => {
+describe('Switch / Match', () => {
+  test('renders first matching branch', () => {
     const result = Switch({
       children: [
-        h(Match, { when: () => false }, "first"),
-        h(Match, { when: () => true }, "second"),
-        h(Match, { when: () => true }, "third"),
+        h(Match, { when: () => false }, 'first'),
+        h(Match, { when: () => true }, 'second'),
+        h(Match, { when: () => true }, 'third'),
       ],
     })
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("second")
+    expect(getter()).toBe('second')
   })
 
-  test("renders fallback when no branch matches", () => {
-    const fb = h("p", null, "404")
+  test('renders fallback when no branch matches', () => {
+    const fb = h('p', null, '404')
     const result = Switch({
       fallback: fb,
-      children: [h(Match, { when: () => false }, "a"), h(Match, { when: () => false }, "b")],
+      children: [h(Match, { when: () => false }, 'a'), h(Match, { when: () => false }, 'b')],
     })
     const getter = result as unknown as () => VNodeChild
     expect(getter()).toBe(fb)
   })
 
-  test("returns null when no match and no fallback", () => {
+  test('returns null when no match and no fallback', () => {
     const result = Switch({
-      children: [h(Match, { when: () => false }, "a")],
+      children: [h(Match, { when: () => false }, 'a')],
     })
     const getter = result as unknown as () => VNodeChild
     expect(getter()).toBeNull()
   })
 
-  test("handles single child (not array)", () => {
+  test('handles single child (not array)', () => {
     const result = Switch({
-      children: h(Match, { when: () => true }, "only"),
+      children: h(Match, { when: () => true }, 'only'),
     })
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("only")
+    expect(getter()).toBe('only')
   })
 
-  test("handles no children", () => {
+  test('handles no children', () => {
     const result = Switch({})
     const getter = result as unknown as () => VNodeChild
     expect(getter()).toBeNull()
   })
 
-  test("Match function returns null (marker only)", () => {
-    const result = Match({ when: () => true, children: "content" })
+  test('Match function returns null (marker only)', () => {
+    const result = Match({ when: () => true, children: 'content' })
     expect(result).toBeNull()
   })
 
-  test("MatchSymbol is a symbol", () => {
-    expect(typeof MatchSymbol).toBe("symbol")
+  test('MatchSymbol is a symbol', () => {
+    expect(typeof MatchSymbol).toBe('symbol')
   })
 
-  test("reacts to condition changes", () => {
+  test('reacts to condition changes', () => {
     let a = false
     let b = false
     const result = Switch({
-      fallback: "none",
-      children: [h(Match, { when: () => a }, "A"), h(Match, { when: () => b }, "B")],
+      fallback: 'none',
+      children: [h(Match, { when: () => a }, 'A'), h(Match, { when: () => b }, 'B')],
     })
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("none")
+    expect(getter()).toBe('none')
     b = true
-    expect(getter()).toBe("B")
+    expect(getter()).toBe('B')
     a = true
-    expect(getter()).toBe("A") // first match wins
+    expect(getter()).toBe('A') // first match wins
   })
 
-  test("handles multiple children in a Match branch", () => {
+  test('handles multiple children in a Match branch', () => {
     const result = Switch({
-      children: [h(Match, { when: () => true }, "child1", "child2")],
+      children: [h(Match, { when: () => true }, 'child1', 'child2')],
     })
     const getter = result as unknown as () => VNodeChild
     const value = getter()
     expect(Array.isArray(value)).toBe(true)
-    expect(value as unknown).toEqual(["child1", "child2"])
+    expect(value as unknown).toEqual(['child1', 'child2'])
   })
 })
 
 // ─── For ─────────────────────────────────────────────────────────────────────
 
-describe("For()", () => {
-  test("returns a VNode with ForSymbol type", () => {
+describe('For()', () => {
+  test('returns a VNode with ForSymbol type', () => {
     const node = For({
       each: () => [1, 2, 3],
       by: (item) => item,
-      children: (item) => h("li", null, String(item)),
+      children: (item) => h('li', null, String(item)),
     })
     expect(node.type).toBe(ForSymbol)
     expect(node.children).toEqual([])
     expect(node.key).toBeNull()
   })
 
-  test("ForSymbol is a symbol", () => {
-    expect(typeof ForSymbol).toBe("symbol")
+  test('ForSymbol is a symbol', () => {
+    expect(typeof ForSymbol).toBe('symbol')
   })
 
-  test("props contain each, by, children functions", () => {
+  test('props contain each, by, children functions', () => {
     const eachFn = () => [1, 2]
     const keyFn = (item: number) => item
-    const childFn = (item: number) => h("span", null, String(item))
+    const childFn = (item: number) => h('span', null, String(item))
     const node = For({ each: eachFn, by: keyFn, children: childFn })
     const props = node.props as unknown as {
       each: typeof eachFn
@@ -540,22 +540,22 @@ describe("For()", () => {
 
 // ─── Portal ──────────────────────────────────────────────────────────────────
 
-describe("Portal()", () => {
-  test("returns a VNode with PortalSymbol type", () => {
+describe('Portal()', () => {
+  test('returns a VNode with PortalSymbol type', () => {
     const fakeTarget = {} as Element
-    const node = Portal({ target: fakeTarget, children: h("div", null) })
+    const node = Portal({ target: fakeTarget, children: h('div', null) })
     expect(node.type).toBe(PortalSymbol)
     expect(node.key).toBeNull()
     expect(node.children).toEqual([])
   })
 
-  test("PortalSymbol is a symbol", () => {
-    expect(typeof PortalSymbol).toBe("symbol")
+  test('PortalSymbol is a symbol', () => {
+    expect(typeof PortalSymbol).toBe('symbol')
   })
 
-  test("props contain target and children", () => {
+  test('props contain target and children', () => {
     const fakeTarget = {} as Element
-    const child = h("span", null, "content")
+    const child = h('span', null, 'content')
     const node = Portal({ target: fakeTarget, children: child })
     const props = node.props as unknown as { target: Element; children: VNode }
     expect(props.target).toBe(fakeTarget)
@@ -565,32 +565,32 @@ describe("Portal()", () => {
 
 // ─── Suspense ────────────────────────────────────────────────────────────────
 
-describe("Suspense", () => {
-  test("returns a Fragment VNode", () => {
+describe('Suspense', () => {
+  test('returns a Fragment VNode', () => {
     const node = Suspense({
-      fallback: h("div", null, "loading..."),
-      children: h("div", null, "content"),
+      fallback: h('div', null, 'loading...'),
+      children: h('div', null, 'content'),
     })
     expect(node.type).toBe(Fragment)
   })
 
-  test("renders children when not loading", () => {
-    const child = h("div", null, "loaded")
+  test('renders children when not loading', () => {
+    const child = h('div', null, 'loaded')
     const node = Suspense({
-      fallback: h("span", null, "loading"),
+      fallback: h('span', null, 'loading'),
       children: child,
     })
     // The child of Fragment is a reactive getter
     expect(node.children).toHaveLength(1)
     const getter = node.children[0] as () => VNodeChild
-    expect(typeof getter).toBe("function")
+    expect(typeof getter).toBe('function')
     // Should return the child since it's not a lazy component
     expect(getter()).toBe(child)
   })
 
-  test("renders fallback when child type has __loading() returning true", () => {
-    const fallback = h("span", null, "loading")
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & { __loading: () => boolean }
+  test('renders fallback when child type has __loading() returning true', () => {
+    const fallback = h('span', null, 'loading')
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & { __loading: () => boolean }
     lazyFn.__loading = () => true
     const child = h(lazyFn, null)
 
@@ -599,9 +599,9 @@ describe("Suspense", () => {
     expect(getter()).toBe(fallback)
   })
 
-  test("renders children when __loading returns false", () => {
-    const fallback = h("span", null, "loading")
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & { __loading: () => boolean }
+  test('renders children when __loading returns false', () => {
+    const fallback = h('span', null, 'loading')
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & { __loading: () => boolean }
     lazyFn.__loading = () => false
     const child = h(lazyFn, null)
 
@@ -610,10 +610,10 @@ describe("Suspense", () => {
     expect(getter()).toBe(child)
   })
 
-  test("handles function children (reactive getter)", () => {
-    const child = h("div", null, "content")
+  test('handles function children (reactive getter)', () => {
+    const child = h('div', null, 'content')
     const node = Suspense({
-      fallback: h("span", null, "loading"),
+      fallback: h('span', null, 'loading'),
       children: () => child,
     })
     const getter = node.children[0] as () => VNodeChild
@@ -621,43 +621,43 @@ describe("Suspense", () => {
     expect(getter()).toBe(child)
   })
 
-  test("warns when fallback prop is missing", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
-    Suspense({ fallback: undefined as unknown as VNodeChild, children: h("div", null) })
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("<Suspense>"))
+  test('warns when fallback prop is missing', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    Suspense({ fallback: undefined as unknown as VNodeChild, children: h('div', null) })
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<Suspense>'))
     warnSpy.mockRestore()
   })
 })
 
 // ─── ErrorBoundary ───────────────────────────────────────────────────────────
 
-describe("ErrorBoundary", () => {
-  test("is a component function", () => {
-    expect(typeof ErrorBoundary).toBe("function")
+describe('ErrorBoundary', () => {
+  test('is a component function', () => {
+    expect(typeof ErrorBoundary).toBe('function')
   })
 
-  test("warns when fallback is not a function", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('warns when fallback is not a function', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     runWithHooks(() => {
       ErrorBoundary({
-        fallback: "not a function" as unknown as (err: unknown, reset: () => void) => VNodeChild,
-        children: "child",
+        fallback: 'not a function' as unknown as (err: unknown, reset: () => void) => VNodeChild,
+        children: 'child',
       })
       return null
     }, {})
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("<ErrorBoundary>"))
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<ErrorBoundary>'))
     warnSpy.mockRestore()
   })
 
-  test("returns a reactive getter", () => {
+  test('returns a reactive getter', () => {
     // Must run inside runWithHooks since ErrorBoundary calls onUnmount
     const { vnode, hooks } = runWithHooks(() => {
       return h(
-        "div",
+        'div',
         null,
         ErrorBoundary({
           fallback: (err) => `Error: ${err}`,
-          children: "child content",
+          children: 'child content',
         }) as VNodeChild,
       )
     }, {})
@@ -666,56 +666,56 @@ describe("ErrorBoundary", () => {
     expect(hooks.unmount.length).toBeGreaterThanOrEqual(1)
   })
 
-  test("renders children when no error", () => {
+  test('renders children when no error', () => {
     let result: VNodeChild = null
     runWithHooks(() => {
       result = ErrorBoundary({
         fallback: (err) => `Error: ${err}`,
-        children: "child content",
+        children: 'child content',
       })
       return null
     }, {})
-    expect(typeof result).toBe("function")
+    expect(typeof result).toBe('function')
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("child content")
+    expect(getter()).toBe('child content')
   })
 
-  test("renders function children by calling them", () => {
+  test('renders function children by calling them', () => {
     let result: VNodeChild = null
     runWithHooks(() => {
       result = ErrorBoundary({
         fallback: (err) => `Error: ${err}`,
-        children: () => "dynamic child",
+        children: () => 'dynamic child',
       })
       return null
     }, {})
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("dynamic child")
+    expect(getter()).toBe('dynamic child')
   })
 })
 
 // ─── dispatchToErrorBoundary ─────────────────────────────────────────────────
 
-describe("dispatchToErrorBoundary()", () => {
-  test("dispatches to the most recently pushed boundary", async () => {
+describe('dispatchToErrorBoundary()', () => {
+  test('dispatches to the most recently pushed boundary', async () => {
     // Previous ErrorBoundary tests may have left handlers on the stack,
     // so we test by pushing our own known handler.
     let caughtErr: unknown = null
-    const { pushErrorBoundary: push, popErrorBoundary: pop } = await import("../component")
+    const { pushErrorBoundary: push, popErrorBoundary: pop } = await import('../component')
     push((err: unknown) => {
       caughtErr = err
       return true
     })
-    expect(dispatchToErrorBoundary(new Error("caught"))).toBe(true)
-    expect((caughtErr as Error).message).toBe("caught")
+    expect(dispatchToErrorBoundary(new Error('caught'))).toBe(true)
+    expect((caughtErr as Error).message).toBe('caught')
     pop()
   })
 })
 
 // ─── mapArray ────────────────────────────────────────────────────────────────
 
-describe("mapArray()", () => {
-  test("maps items with caching", () => {
+describe('mapArray()', () => {
+  test('maps items with caching', () => {
     let callCount = 0
     const items = [1, 2, 3]
     const mapped = mapArray(
@@ -737,7 +737,7 @@ describe("mapArray()", () => {
     expect(callCount).toBe(3) // no new calls
   })
 
-  test("only maps new keys on update", () => {
+  test('only maps new keys on update', () => {
     let callCount = 0
     let items = [1, 2, 3]
     const mapped = mapArray(
@@ -757,7 +757,7 @@ describe("mapArray()", () => {
     expect(callCount).toBe(4)
   })
 
-  test("evicts removed keys", () => {
+  test('evicts removed keys', () => {
     let items = [1, 2, 3]
     const mapped = mapArray(
       () => items,
@@ -785,7 +785,7 @@ describe("mapArray()", () => {
     expect(callCount).toBe(3)
   })
 
-  test("handles empty source", () => {
+  test('handles empty source', () => {
     const mapped = mapArray(
       () => [],
       (item: number) => item,
@@ -794,7 +794,7 @@ describe("mapArray()", () => {
     expect(mapped()).toEqual([])
   })
 
-  test("handles reordering", () => {
+  test('handles reordering', () => {
     let items = [1, 2, 3]
     let callCount = 0
     const mapped = mapArray(
@@ -818,22 +818,22 @@ describe("mapArray()", () => {
 
 // ─── Telemetry ───────────────────────────────────────────────────────────────
 
-describe("registerErrorHandler / reportError", () => {
-  test("registerErrorHandler registers and calls handler", () => {
+describe('registerErrorHandler / reportError', () => {
+  test('registerErrorHandler registers and calls handler', () => {
     const errors: unknown[] = []
     const unregister = registerErrorHandler((ctx) => {
       errors.push(ctx.error)
     })
 
-    reportError({ component: "Test", phase: "render", error: "boom", timestamp: Date.now() })
-    expect(errors).toEqual(["boom"])
+    reportError({ component: 'Test', phase: 'render', error: 'boom', timestamp: Date.now() })
+    expect(errors).toEqual(['boom'])
 
     unregister()
-    reportError({ component: "Test", phase: "render", error: "after", timestamp: Date.now() })
-    expect(errors).toEqual(["boom"]) // not called after unregister
+    reportError({ component: 'Test', phase: 'render', error: 'after', timestamp: Date.now() })
+    expect(errors).toEqual(['boom']) // not called after unregister
   })
 
-  test("multiple handlers are all called", () => {
+  test('multiple handlers are all called', () => {
     let count = 0
     const unsub1 = registerErrorHandler(() => {
       count++
@@ -842,24 +842,24 @@ describe("registerErrorHandler / reportError", () => {
       count++
     })
 
-    reportError({ component: "X", phase: "setup", error: "err", timestamp: 0 })
+    reportError({ component: 'X', phase: 'setup', error: 'err', timestamp: 0 })
     expect(count).toBe(2)
 
     unsub1()
     unsub2()
   })
 
-  test("handler errors are swallowed", () => {
+  test('handler errors are swallowed', () => {
     let secondCalled = false
     const unsub1 = registerErrorHandler(() => {
-      throw new Error("handler crash")
+      throw new Error('handler crash')
     })
     const unsub2 = registerErrorHandler(() => {
       secondCalled = true
     })
 
     // Should not throw
-    reportError({ component: "Y", phase: "mount", error: "err", timestamp: 0 })
+    reportError({ component: 'Y', phase: 'mount', error: 'err', timestamp: 0 })
     expect(secondCalled).toBe(true)
 
     unsub1()
@@ -869,70 +869,70 @@ describe("registerErrorHandler / reportError", () => {
 
 // ─── JSX Runtime ─────────────────────────────────────────────────────────────
 
-describe("jsx / jsxs / jsxDEV", () => {
-  test("jsx creates VNode for DOM element", () => {
-    const node = jsx("div", { class: "x" })
-    expect(node.type).toBe("div")
-    expect(node.props).toEqual({ class: "x" })
+describe('jsx / jsxs / jsxDEV', () => {
+  test('jsx creates VNode for DOM element', () => {
+    const node = jsx('div', { class: 'x' })
+    expect(node.type).toBe('div')
+    expect(node.props).toEqual({ class: 'x' })
     expect(node.children).toEqual([])
   })
 
-  test("jsx handles children in props for DOM elements", () => {
-    const node = jsx("div", { children: "hello" })
-    expect(node.children).toEqual(["hello"])
+  test('jsx handles children in props for DOM elements', () => {
+    const node = jsx('div', { children: 'hello' })
+    expect(node.children).toEqual(['hello'])
     // children should not be in props for DOM elements
     expect(node.props).toEqual({})
   })
 
-  test("jsx handles array children for DOM elements", () => {
-    const node = jsx("div", { children: ["a", "b", "c"] })
-    expect(node.children).toEqual(["a", "b", "c"])
+  test('jsx handles array children for DOM elements', () => {
+    const node = jsx('div', { children: ['a', 'b', 'c'] })
+    expect(node.children).toEqual(['a', 'b', 'c'])
   })
 
-  test("jsx passes children in props for component functions", () => {
-    const Comp: ComponentFn = (props) => h("span", null, String(props.children))
-    const node = jsx(Comp, { children: "content" })
+  test('jsx passes children in props for component functions', () => {
+    const Comp: ComponentFn = (props) => h('span', null, String(props.children))
+    const node = jsx(Comp, { children: 'content' })
     expect(node.type).toBe(Comp)
     // For components, children stay in props
-    expect(node.props.children).toBe("content")
+    expect(node.props.children).toBe('content')
     expect(node.children).toEqual([])
   })
 
-  test("jsx handles key parameter", () => {
-    const node = jsx("li", { id: "x" }, "my-key")
-    expect(node.key).toBe("my-key")
+  test('jsx handles key parameter', () => {
+    const node = jsx('li', { id: 'x' }, 'my-key')
+    expect(node.key).toBe('my-key')
     // key is added to props by jsx runtime
-    expect(node.props).toEqual({ id: "x", key: "my-key" })
+    expect(node.props).toEqual({ id: 'x', key: 'my-key' })
   })
 
-  test("jsx handles Fragment (symbol type) with children", () => {
-    const node = jsx(Fragment, { children: ["a", "b"] })
+  test('jsx handles Fragment (symbol type) with children', () => {
+    const node = jsx(Fragment, { children: ['a', 'b'] })
     expect(node.type).toBe(Fragment)
-    expect(node.children).toEqual(["a", "b"])
+    expect(node.children).toEqual(['a', 'b'])
   })
 
-  test("jsxs is the same as jsx", () => {
+  test('jsxs is the same as jsx', () => {
     expect(jsxs).toBe(jsx)
   })
 
-  test("jsxDEV is the same as jsx", () => {
+  test('jsxDEV is the same as jsx', () => {
     expect(jsxDEV).toBe(jsx)
   })
 
-  test("JsxFragment is the same as Fragment", () => {
+  test('JsxFragment is the same as Fragment', () => {
     expect(JsxFragment).toBe(Fragment)
   })
 
-  test("jsx with no children in props", () => {
-    const node = jsx("span", { id: "test" })
+  test('jsx with no children in props', () => {
+    const node = jsx('span', { id: 'test' })
     expect(node.children).toEqual([])
-    expect(node.props).toEqual({ id: "test" })
+    expect(node.props).toEqual({ id: 'test' })
   })
 
-  test("jsx component with no children", () => {
+  test('jsx component with no children', () => {
     const Comp: ComponentFn = () => null
-    const node = jsx(Comp, { name: "test" })
-    expect(node.props).toEqual({ name: "test" })
+    const node = jsx(Comp, { name: 'test' })
+    expect(node.props).toEqual({ name: 'test' })
     // children should not be injected if not provided
     expect(node.props.children).toBeUndefined()
   })
@@ -940,39 +940,39 @@ describe("jsx / jsxs / jsxDEV", () => {
 
 // ─── Lifecycle hooks outside component ───────────────────────────────────────
 
-describe("lifecycle hooks", () => {
-  test("onMount outside component warns and is a no-op", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+describe('lifecycle hooks', () => {
+  test('onMount outside component warns and is a no-op', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     expect(() => onMount(() => {})).not.toThrow()
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onMount() called outside component setup"),
+      expect.stringContaining('onMount() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 
-  test("onUnmount outside component warns and is a no-op", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('onUnmount outside component warns and is a no-op', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     expect(() => onUnmount(() => {})).not.toThrow()
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onUnmount() called outside component setup"),
+      expect.stringContaining('onUnmount() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 
-  test("onUpdate outside component warns and is a no-op", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('onUpdate outside component warns and is a no-op', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     expect(() => onUpdate(() => {})).not.toThrow()
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onUpdate() called outside component setup"),
+      expect.stringContaining('onUpdate() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
 
-  test("onErrorCaptured outside component warns and is a no-op", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  test('onErrorCaptured outside component warns and is a no-op', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
     expect(() => onErrorCaptured(() => true)).not.toThrow()
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("onErrorCaptured() called outside component setup"),
+      expect.stringContaining('onErrorCaptured() called outside component setup'),
     )
     warnSpy.mockRestore()
   })
@@ -980,64 +980,64 @@ describe("lifecycle hooks", () => {
 
 // ─── Edge cases ──────────────────────────────────────────────────────────────
 
-describe("edge cases", () => {
-  test("h() with empty children array", () => {
-    const node = h("div", null, ...[])
+describe('edge cases', () => {
+  test('h() with empty children array', () => {
+    const node = h('div', null, ...[])
     expect(node.children).toEqual([])
   })
 
-  test("h() with mixed children types", () => {
-    const node = h("div", null, "text", 42, h("span", null), null, () => "reactive")
+  test('h() with mixed children types', () => {
+    const node = h('div', null, 'text', 42, h('span', null), null, () => 'reactive')
     expect(node.children).toHaveLength(5)
-    expect(node.children[0]).toBe("text")
+    expect(node.children[0]).toBe('text')
     expect(node.children[1]).toBe(42)
-    expect((node.children[2] as VNode).type).toBe("span")
+    expect((node.children[2] as VNode).type).toBe('span')
     expect(node.children[3]).toBeNull()
-    expect(typeof node.children[4]).toBe("function")
+    expect(typeof node.children[4]).toBe('function')
   })
 
-  test("nested Fragments", () => {
-    const node = h(Fragment, null, h(Fragment, null, "a", "b"), h(Fragment, null, "c"))
+  test('nested Fragments', () => {
+    const node = h(Fragment, null, h(Fragment, null, 'a', 'b'), h(Fragment, null, 'c'))
     expect(node.type).toBe(Fragment)
     expect(node.children).toHaveLength(2)
     expect((node.children[0] as VNode).type).toBe(Fragment)
     expect((node.children[1] as VNode).type).toBe(Fragment)
   })
 
-  test("component that throws during setup is propagated by runWithHooks", () => {
+  test('component that throws during setup is propagated by runWithHooks', () => {
     const Comp: ComponentFn = () => {
-      throw new Error("setup error")
+      throw new Error('setup error')
     }
-    expect(() => runWithHooks(Comp, {})).toThrow("setup error")
+    expect(() => runWithHooks(Comp, {})).toThrow('setup error')
   })
 
-  test("createContext with undefined default", () => {
+  test('createContext with undefined default', () => {
     const ctx = createContext<string | undefined>(undefined)
     expect(ctx.defaultValue).toBeUndefined()
     expect(useContext(ctx)).toBeUndefined()
   })
 
-  test("createContext with object default", () => {
-    const defaultObj = { a: 1, b: "two" }
+  test('createContext with object default', () => {
+    const defaultObj = { a: 1, b: 'two' }
     const ctx = createContext(defaultObj)
     expect(useContext(ctx)).toBe(defaultObj)
   })
 
-  test("Show with VNode children", () => {
-    const child = h("div", null, "content")
+  test('Show with VNode children', () => {
+    const child = h('div', null, 'content')
     const getter = Show({ when: () => true, children: child }) as unknown as () => VNodeChild
     expect(getter()).toBe(child)
   })
 
-  test("For with objects", () => {
+  test('For with objects', () => {
     const items = [
-      { id: 1, name: "a" },
-      { id: 2, name: "b" },
+      { id: 1, name: 'a' },
+      { id: 2, name: 'b' },
     ]
     const node = For<{ id: number; name: string }>({
       each: () => items,
       by: (item) => item.id,
-      children: (item) => h("span", null, item.name),
+      children: (item) => h('span', null, item.name),
     })
     expect(node.type).toBe(ForSymbol)
     const props = node.props as unknown as { each: () => typeof items }
@@ -1047,65 +1047,65 @@ describe("edge cases", () => {
 
 // ─── lazy() ───────────────────────────────────────────────────────────────────
 
-describe("lazy()", () => {
-  test("returns a LazyComponent with __loading flag", () => {
+describe('lazy()', () => {
+  test('returns a LazyComponent with __loading flag', () => {
     const Comp = lazy<Props>(() => new Promise(() => {})) // never resolves
-    expect(typeof Comp).toBe("function")
-    expect(typeof Comp.__loading).toBe("function")
+    expect(typeof Comp).toBe('function')
+    expect(typeof Comp.__loading).toBe('function')
     expect(Comp.__loading()).toBe(true)
   })
 
-  test("resolves to the loaded component", async () => {
-    const Inner: ComponentFn<{ name: string }> = (props) => h("span", null, props.name)
+  test('resolves to the loaded component', async () => {
+    const Inner: ComponentFn<{ name: string }> = (props) => h('span', null, props.name)
     const Comp = lazy(() => Promise.resolve({ default: Inner }))
 
     // Wait for microtask to resolve
     await new Promise((r) => setTimeout(r, 0))
 
     expect(Comp.__loading()).toBe(false)
-    const result = Comp({ name: "hello" })
+    const result = Comp({ name: 'hello' })
     expect(result).not.toBeNull()
     // lazy wraps via h(comp, props) so type is the component function
     expect((result as VNode).type).toBe(Inner)
   })
 
-  test("throws on import error so ErrorBoundary can catch", async () => {
-    const Comp = lazy<Props>(() => Promise.reject(new Error("load failed")))
+  test('throws on import error so ErrorBoundary can catch', async () => {
+    const Comp = lazy<Props>(() => Promise.reject(new Error('load failed')))
 
     await new Promise((r) => setTimeout(r, 0))
 
     expect(Comp.__loading()).toBe(false)
-    expect(() => Comp({})).toThrow("load failed")
+    expect(() => Comp({})).toThrow('load failed')
   })
 
-  test("wraps non-Error rejection in Error", async () => {
-    const Comp = lazy<Props>(() => Promise.reject("string error"))
+  test('wraps non-Error rejection in Error', async () => {
+    const Comp = lazy<Props>(() => Promise.reject('string error'))
 
     await new Promise((r) => setTimeout(r, 0))
 
-    expect(() => Comp({})).toThrow("string error")
+    expect(() => Comp({})).toThrow('string error')
   })
 })
 
 // ─── setContextStackProvider ──────────────────────────────────────────────────
 
-describe("setContextStackProvider", () => {
-  test("allows overriding the context stack provider", async () => {
-    const { setContextStackProvider } = await import("../context")
+describe('setContextStackProvider', () => {
+  test('allows overriding the context stack provider', async () => {
+    const { setContextStackProvider } = await import('../context')
     const customStack: Map<symbol, unknown>[] = []
-    const ctx = createContext("custom-default")
+    const ctx = createContext('custom-default')
 
     // Override with custom stack
     setContextStackProvider(() => customStack)
 
     // Push onto custom stack
-    customStack.push(new Map([[ctx.id, "custom-value"]]))
-    expect(useContext(ctx)).toBe("custom-value")
+    customStack.push(new Map([[ctx.id, 'custom-value']]))
+    expect(useContext(ctx)).toBe('custom-value')
     customStack.pop()
-    expect(useContext(ctx)).toBe("custom-default")
+    expect(useContext(ctx)).toBe('custom-default')
 
     // Fully restore to module-level default stack
-    const { setContextStackProvider: restore } = await import("../context")
+    const { setContextStackProvider: restore } = await import('../context')
     const _defaultStack: Map<symbol, unknown>[] = []
     restore(() => _defaultStack)
   })
@@ -1113,36 +1113,36 @@ describe("setContextStackProvider", () => {
 
 // ─── ErrorBoundary advanced ──────────────────────────────────────────────────
 
-describe("ErrorBoundary — advanced", () => {
-  test("handler returns false when already in error state (double error)", async () => {
+describe('ErrorBoundary — advanced', () => {
+  test('handler returns false when already in error state (double error)', async () => {
     let result: VNodeChild = null
 
     runWithHooks(() => {
       result = ErrorBoundary({
         fallback: (err) => `Error: ${err}`,
-        children: "child",
+        children: 'child',
       })
       return null
     }, {})
 
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("child")
+    expect(getter()).toBe('child')
 
     // First error should be handled
-    const handled1 = dispatchToErrorBoundary(new Error("first"))
+    const handled1 = dispatchToErrorBoundary(new Error('first'))
     expect(handled1).toBe(true)
-    expect(getter()).toBe("Error: Error: first")
+    expect(getter()).toBe('Error: Error: first')
 
     // Second error while already in error state should NOT be handled
-    const handled2 = dispatchToErrorBoundary(new Error("second"))
+    const handled2 = dispatchToErrorBoundary(new Error('second'))
     expect(handled2).toBe(false)
 
     // Clean up the boundary
-    const { popErrorBoundary: pop } = await import("../component")
+    const { popErrorBoundary: pop } = await import('../component')
     pop()
   })
 
-  test("reset function clears error and re-renders children", async () => {
+  test('reset function clears error and re-renders children', async () => {
     let result: VNodeChild = null
     let capturedReset: (() => void) | undefined
 
@@ -1152,35 +1152,35 @@ describe("ErrorBoundary — advanced", () => {
           capturedReset = reset
           return `Error: ${err}`
         },
-        children: "child content",
+        children: 'child content',
       })
       return null
     }, {})
 
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("child content")
+    expect(getter()).toBe('child content')
 
     // Trigger error
-    dispatchToErrorBoundary(new Error("test error"))
-    expect(getter()).toBe("Error: Error: test error")
+    dispatchToErrorBoundary(new Error('test error'))
+    expect(getter()).toBe('Error: Error: test error')
     expect(capturedReset).toBeDefined()
 
     // Reset
     capturedReset?.()
-    expect(getter()).toBe("child content")
+    expect(getter()).toBe('child content')
 
     // Clean up
-    const { popErrorBoundary: pop } = await import("../component")
+    const { popErrorBoundary: pop } = await import('../component')
     pop()
   })
 })
 
 // ─── Suspense advanced ──────────────────────────────────────────────────────
 
-describe("Suspense — advanced", () => {
-  test("evaluates function fallback when child is loading", () => {
-    const fallbackVNode = h("div", null, "fb-content")
-    const lazyFn = (() => h("div", null)) as unknown as ComponentFn & { __loading: () => boolean }
+describe('Suspense — advanced', () => {
+  test('evaluates function fallback when child is loading', () => {
+    const fallbackVNode = h('div', null, 'fb-content')
+    const lazyFn = (() => h('div', null)) as unknown as ComponentFn & { __loading: () => boolean }
     lazyFn.__loading = () => true
     const child = h(lazyFn, null)
 
@@ -1189,16 +1189,16 @@ describe("Suspense — advanced", () => {
     expect(getter()).toBe(fallbackVNode)
   })
 
-  test("handles null children", () => {
-    const node = Suspense({ fallback: h("span", null, "loading") })
+  test('handles null children', () => {
+    const node = Suspense({ fallback: h('span', null, 'loading') })
     const getter = node.children[0] as () => VNodeChild
     expect(getter()).toBeUndefined()
   })
 
-  test("handles array children (not loading)", () => {
-    const children = [h("div", null, "a"), h("div", null, "b")]
+  test('handles array children (not loading)', () => {
+    const children = [h('div', null, 'a'), h('div', null, 'b')]
     const node = Suspense({
-      fallback: h("span", null, "loading"),
+      fallback: h('span', null, 'loading'),
       children: children as unknown as VNodeChild,
     })
     const getter = node.children[0] as () => VNodeChild
@@ -1210,13 +1210,13 @@ describe("Suspense — advanced", () => {
 
 // ─── Show edge cases ────────────────────────────────────────────────────────
 
-describe("Show — edge cases", () => {
-  test("returns null when condition truthy but children is undefined", () => {
+describe('Show — edge cases', () => {
+  test('returns null when condition truthy but children is undefined', () => {
     const getter = Show({ when: () => true }) as unknown as () => VNodeChild
     expect(getter()).toBeNull()
   })
 
-  test("returns null when condition falsy and fallback is undefined", () => {
+  test('returns null when condition falsy and fallback is undefined', () => {
     const getter = Show({ when: () => false }) as unknown as () => VNodeChild
     expect(getter()).toBeNull()
   })
@@ -1224,67 +1224,67 @@ describe("Show — edge cases", () => {
 
 // ─── Switch edge cases ──────────────────────────────────────────────────────
 
-describe("Switch — edge cases", () => {
-  test("skips non-Match VNode children", () => {
+describe('Switch — edge cases', () => {
+  test('skips non-Match VNode children', () => {
     const result = Switch({
-      fallback: "default",
-      children: [h("div", null, "not-match"), h(Match, { when: () => true }, "match-child")],
+      fallback: 'default',
+      children: [h('div', null, 'not-match'), h(Match, { when: () => true }, 'match-child')],
     })
     const getter = result as unknown as () => VNodeChild
     // Should skip the div and match the Match branch
-    expect(getter()).toBe("match-child")
+    expect(getter()).toBe('match-child')
   })
 
-  test("skips null children in branches", () => {
+  test('skips null children in branches', () => {
     const result = Switch({
-      fallback: "default",
-      children: [null as unknown as VNodeChild, h(Match, { when: () => true }, "found")],
+      fallback: 'default',
+      children: [null as unknown as VNodeChild, h(Match, { when: () => true }, 'found')],
     })
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("found")
+    expect(getter()).toBe('found')
   })
 
-  test("Match with children in props.children (not vnode.children)", () => {
+  test('Match with children in props.children (not vnode.children)', () => {
     // When using explicit props.children instead of h() rest args
     const matchVNode = {
       type: Match,
-      props: { when: () => true, children: "from-props" },
+      props: { when: () => true, children: 'from-props' },
       children: [],
       key: null,
     } as unknown as VNodeChild
     const result = Switch({ children: [matchVNode] })
     const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe("from-props")
+    expect(getter()).toBe('from-props')
   })
 })
 
 // ─── Dynamic ──────────────────────────────────────────────────────────────────
 
-describe("Dynamic", () => {
-  test("renders the given component", () => {
-    const Greeting: ComponentFn = (props) => h("span", null, (props as { name: string }).name)
-    const result = Dynamic({ component: Greeting, name: "world" })
+describe('Dynamic', () => {
+  test('renders the given component', () => {
+    const Greeting: ComponentFn = (props) => h('span', null, (props as { name: string }).name)
+    const result = Dynamic({ component: Greeting, name: 'world' })
     expect(result).not.toBeNull()
     expect((result as VNode).type).toBe(Greeting)
-    expect((result as VNode).props).toEqual({ name: "world" })
+    expect((result as VNode).props).toEqual({ name: 'world' })
   })
 
-  test("renders a string element", () => {
-    const result = Dynamic({ component: "div", class: "box" })
+  test('renders a string element', () => {
+    const result = Dynamic({ component: 'div', class: 'box' })
     expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe("div")
-    expect((result as VNode).props).toEqual({ class: "box" })
+    expect((result as VNode).type).toBe('div')
+    expect((result as VNode).props).toEqual({ class: 'box' })
   })
 
-  test("returns null when component is falsy", () => {
-    const result = Dynamic({ component: "" })
+  test('returns null when component is falsy', () => {
+    const result = Dynamic({ component: '' })
     expect(result).toBeNull()
   })
 
-  test("warns when component prop is falsy", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
-    Dynamic({ component: "" })
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("<Dynamic>"))
+  test('warns when component prop is falsy', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    Dynamic({ component: '' })
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<Dynamic>'))
     warnSpy.mockRestore()
   })
 })