@pyreon/core 0.24.4 → 0.24.6

package/src/tests/core.test.ts

@@ -1,1290 +0,0 @@
-import {
-  createContext,
-  createRef,
-  Dynamic,
-  defineComponent,
-  dispatchToErrorBoundary,
-  ErrorBoundary,
-  For,
-  ForSymbol,
-  Fragment,
-  h,
-  lazy,
-  Match,
-  MatchSymbol,
-  mapArray,
-  onErrorCaptured,
-  onMount,
-  onUnmount,
-  onUpdate,
-  Portal,
-  PortalSymbol,
-  popContext,
-  propagateError,
-  provide,
-  pushContext,
-  registerErrorHandler,
-  reportError,
-  runWithHooks,
-  Show,
-  Suspense,
-  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'
-
-// ─── h() ─────────────────────────────────────────────────────────────────────
-
-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('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 })
-    expect(node.key).toBe(42)
-  })
-
-  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('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')
-  })
-
-  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 component function type', () => {
-    const Comp = ((props: { name: string }) => h('span', null, props.name)) as ComponentFn<{
-      name: string
-    }>
-    const node = h(Comp, { name: 'test' })
-    expect(node.type as unknown).toBe(Comp)
-    expect(node.props).toEqual({ name: 'test' })
-  })
-
-  test('handles symbol type (Fragment)', () => {
-    const node = h(Fragment, null, 'a', 'b')
-    expect(node.type).toBe(Fragment)
-    expect(node.children).toEqual(['a', 'b'])
-  })
-
-  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')
-  })
-
-  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')
-  })
-})
-
-// ─── Fragment ────────────────────────────────────────────────────────────────
-
-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'))
-    expect(node.type).toBe(Fragment)
-    expect(node.children).toHaveLength(2)
-  })
-})
-
-// ─── defineComponent ────────────────────────────────────────────────────────
-
-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', () => {
-    const Comp = defineComponent<{ count: number }>((props) => {
-      return h('span', null, String(props.count))
-    })
-    const node = Comp({ count: 5 })
-    expect(node).not.toBeNull()
-    expect((node as VNode).type).toBe('span')
-  })
-})
-
-// ─── runWithHooks / lifecycle ────────────────────────────────────────────────
-
-describe('runWithHooks()', () => {
-  test('captures lifecycle hooks registered during component execution', () => {
-    const mountFn = () => undefined
-    const unmountFn = () => {}
-    const updateFn = () => {}
-    const errorFn = () => true
-
-    const Comp: ComponentFn = () => {
-      onMount(mountFn)
-      onUnmount(unmountFn)
-      onUpdate(updateFn)
-      onErrorCaptured(errorFn)
-      return h('div', null)
-    }
-
-    const { vnode, hooks } = runWithHooks(Comp, {})
-    expect(vnode).not.toBeNull()
-    expect(hooks.mount!).toHaveLength(1)
-    expect(hooks.mount![0]).toBe(mountFn)
-    expect(hooks.unmount!).toHaveLength(1)
-    expect(hooks.unmount![0]).toBe(unmountFn)
-    expect(hooks.update!).toHaveLength(1)
-    expect(hooks.update![0]).toBe(updateFn)
-    expect(hooks.error!).toHaveLength(1)
-    expect(hooks.error![0]).toBe(errorFn)
-  })
-
-  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)
-    runWithHooks(Comp, {})
-
-    // Calling lifecycle hooks outside a component should not throw
-    onMount(() => undefined)
-    onUnmount(() => {})
-    onUpdate(() => {})
-    onErrorCaptured(() => true)
-  })
-
-  test('multiple hooks of the same type are all captured', () => {
-    const Comp: ComponentFn = () => {
-      onMount(() => undefined)
-      onMount(() => undefined)
-      onMount(() => undefined)
-      return h('div', null)
-    }
-
-    const { hooks } = runWithHooks(Comp, {})
-    expect(hooks.mount!).toHaveLength(3)
-  })
-
-  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' })
-  })
-})
-
-// ─── propagateError ──────────────────────────────────────────────────────────
-
-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)
-  })
-
-  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)
-  })
-
-  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)
-  })
-
-  test('stops at first handler that returns true', () => {
-    let secondCalled = false
-    const hooks = {
-      mount: [],
-      unmount: [],
-      update: [],
-      error: [
-        (_err: unknown) => true as boolean | undefined,
-        (_err: unknown) => {
-          secondCalled = true
-          return true as boolean | undefined
-        },
-      ],
-    }
-    propagateError(new Error('test'), hooks)
-    expect(secondCalled).toBe(false)
-  })
-})
-
-// ─── Context ─────────────────────────────────────────────────────────────────
-
-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')
-  })
-
-  test('useContext returns default when no provider', () => {
-    const ctx = createContext('default-value')
-    expect(useContext(ctx)).toBe('default-value')
-  })
-
-  test('withContext provides value during callback', () => {
-    const ctx = createContext(0)
-    let captured = -1
-    withContext(ctx, 99, () => {
-      captured = useContext(ctx)
-    })
-    expect(captured).toBe(99)
-  })
-
-  test('withContext restores stack after callback (even on throw)', () => {
-    const ctx = createContext('original')
-    try {
-      withContext(ctx, 'override', () => {
-        throw new Error('boom')
-      })
-    } catch {}
-    expect(useContext(ctx)).toBe('original')
-  })
-
-  test('nested contexts override outer', () => {
-    const ctx = createContext(0)
-    withContext(ctx, 1, () => {
-      expect(useContext(ctx)).toBe(1)
-      withContext(ctx, 2, () => {
-        expect(useContext(ctx)).toBe(2)
-      })
-      expect(useContext(ctx)).toBe(1)
-    })
-  })
-
-  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']])
-    pushContext(frame)
-    expect(useContext(ctx)).toBe('pushed')
-    popContext()
-    expect(useContext(ctx)).toBe('default')
-  })
-
-  test('provide() pushes context and registers cleanup on unmount', () => {
-    const ctx = createContext('default')
-    const { hooks } = runWithHooks(
-      (() => {
-        provide(ctx, 'provided')
-        return null
-      }) as ComponentFn,
-      {} as Props,
-    )
-    // Context is available after provide()
-    expect(useContext(ctx)).toBe('provided')
-    // Running unmount hooks should pop the context
-    for (const fn of hooks.unmount!) fn()
-    expect(useContext(ctx)).toBe('default')
-  })
-})
-
-// ─── createRef ───────────────────────────────────────────────────────────────
-
-describe('createRef()', () => {
-  test('returns object with current = null', () => {
-    const ref = createRef()
-    expect(ref.current).toBeNull()
-  })
-
-  test('current is mutable', () => {
-    const ref = createRef<number>()
-    ref.current = 42
-    expect(ref.current).toBe(42)
-  })
-
-  test('typed ref works', () => {
-    const ref = createRef<string>()
-    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')
-  })
-
-  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
-    expect(getter()).toBeNull()
-  })
-
-  test('returns fallback when condition is falsy', () => {
-    const fallbackNode = h('span', null, 'nope')
-    const getter = Show({
-      when: () => false,
-      fallback: fallbackNode,
-      children: 'visible',
-    }) as unknown as () => VNodeChild
-    expect(getter()).toBe(fallbackNode)
-  })
-
-  test('reacts to condition changes', () => {
-    let flag = true
-    const getter = Show({
-      when: () => flag,
-      children: 'yes',
-      fallback: 'no',
-    }) as unknown as () => VNodeChild
-    expect(getter()).toBe('yes')
-    flag = false
-    expect(getter()).toBe('no')
-  })
-
-  test('returns null for children when children not provided and condition truthy', () => {
-    const getter = Show({ when: () => true }) as unknown as () => VNodeChild
-    expect(getter()).toBeNull()
-  })
-})
-
-// ─── Switch / Match ──────────────────────────────────────────────────────────
-
-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'),
-      ],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('second')
-  })
-
-  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')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe(fb)
-  })
-
-  test('returns null when no match and no fallback', () => {
-    const result = Switch({
-      children: [h(Match, { when: () => false }, 'a')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBeNull()
-  })
-
-  test('handles single child (not array)', () => {
-    const result = Switch({
-      children: h(Match, { when: () => true }, 'only'),
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('only')
-  })
-
-  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' })
-    expect(result).toBeNull()
-  })
-
-  test('MatchSymbol is a symbol', () => {
-    expect(typeof MatchSymbol).toBe('symbol')
-  })
-
-  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')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('none')
-    b = true
-    expect(getter()).toBe('B')
-    a = true
-    expect(getter()).toBe('A') // first match wins
-  })
-
-  test('handles multiple children in a Match branch', () => {
-    const result = Switch({
-      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'])
-  })
-})
-
-// ─── For ─────────────────────────────────────────────────────────────────────
-
-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)),
-    })
-    expect(node.type).toBe(ForSymbol)
-    expect(node.children).toEqual([])
-    expect(node.key).toBeNull()
-  })
-
-  test('ForSymbol is a symbol', () => {
-    expect(typeof ForSymbol).toBe('symbol')
-  })
-
-  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 node = For({ each: eachFn, by: keyFn, children: childFn })
-    const props = node.props as unknown as {
-      each: typeof eachFn
-      by: typeof keyFn
-      children: typeof childFn
-    }
-    expect(props.each).toBe(eachFn)
-    expect(props.by).toBe(keyFn)
-    expect(props.children).toBe(childFn)
-  })
-})
-
-// ─── Portal ──────────────────────────────────────────────────────────────────
-
-describe('Portal()', () => {
-  test('returns a VNode with PortalSymbol type', () => {
-    const fakeTarget = {} as Element
-    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('props contain target and children', () => {
-    const fakeTarget = {} as Element
-    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)
-    expect(props.children).toBe(child)
-  })
-})
-
-// ─── Suspense ────────────────────────────────────────────────────────────────
-
-describe('Suspense', () => {
-  test('returns a Fragment VNode', () => {
-    const node = Suspense({
-      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')
-    const node = Suspense({
-      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')
-    // 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 }
-    lazyFn.__loading = () => true
-    const child = h(lazyFn, null)
-
-    const node = Suspense({ fallback, children: child })
-    const getter = node.children[0] as () => VNodeChild
-    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 }
-    lazyFn.__loading = () => false
-    const child = h(lazyFn, null)
-
-    const node = Suspense({ fallback, children: child })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(child)
-  })
-
-  test('handles function children (reactive getter)', () => {
-    const child = h('div', null, 'content')
-    const node = Suspense({
-      fallback: h('span', null, 'loading'),
-      children: () => child,
-    })
-    const getter = node.children[0] as () => VNodeChild
-    // The getter should unwrap the function child
-    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>'))
-    warnSpy.mockRestore()
-  })
-})
-
-// ─── ErrorBoundary ───────────────────────────────────────────────────────────
-
-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(() => {})
-    runWithHooks(() => {
-      ErrorBoundary({
-        fallback: 'not a function' as unknown as (err: unknown, reset: () => void) => VNodeChild,
-        children: 'child',
-      })
-      return null
-    }, {})
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('<ErrorBoundary>'))
-    warnSpy.mockRestore()
-  })
-
-  test('returns a reactive getter', () => {
-    // Must run inside runWithHooks since ErrorBoundary calls onUnmount
-    const { vnode, hooks } = runWithHooks(() => {
-      return h(
-        'div',
-        null,
-        ErrorBoundary({
-          fallback: (err) => `Error: ${err}`,
-          children: 'child content',
-        }) as VNodeChild,
-      )
-    }, {})
-    expect(vnode).not.toBeNull()
-    // Should have registered onUnmount for cleanup
-    expect(hooks.unmount!.length).toBeGreaterThanOrEqual(1)
-  })
-
-  test('renders children when no error', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: 'child content',
-      })
-      return null
-    }, {})
-    expect(typeof result).toBe('function')
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('child content')
-  })
-
-  test('renders function children by calling them', () => {
-    let result: VNodeChild = null
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err) => `Error: ${err}`,
-        children: () => 'dynamic child',
-      })
-      return null
-    }, {})
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('dynamic child')
-  })
-})
-
-// ─── dispatchToErrorBoundary ─────────────────────────────────────────────────
-
-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')
-    push((err: unknown) => {
-      caughtErr = err
-      return true
-    })
-    expect(dispatchToErrorBoundary(new Error('caught'))).toBe(true)
-    expect((caughtErr as Error).message).toBe('caught')
-    pop()
-  })
-})
-
-// ─── mapArray ────────────────────────────────────────────────────────────────
-
-describe('mapArray()', () => {
-  test('maps items with caching', () => {
-    let callCount = 0
-    const items = [1, 2, 3]
-    const mapped = mapArray(
-      () => items,
-      (item) => item,
-      (item) => {
-        callCount++
-        return item * 10
-      },
-    )
-
-    const result1 = mapped()
-    expect(result1).toEqual([10, 20, 30])
-    expect(callCount).toBe(3)
-
-    // Second call should use cache
-    const result2 = mapped()
-    expect(result2).toEqual([10, 20, 30])
-    expect(callCount).toBe(3) // no new calls
-  })
-
-  test('only maps new keys on update', () => {
-    let callCount = 0
-    let items = [1, 2, 3]
-    const mapped = mapArray(
-      () => items,
-      (item) => item,
-      (item) => {
-        callCount++
-        return item * 10
-      },
-    )
-
-    mapped() // initial: 3 calls
-    expect(callCount).toBe(3)
-
-    items = [1, 2, 3, 4]
-    mapped() // only item 4 is new
-    expect(callCount).toBe(4)
-  })
-
-  test('evicts removed keys', () => {
-    let items = [1, 2, 3]
-    const mapped = mapArray(
-      () => items,
-      (item) => item,
-      (item) => item * 10,
-    )
-
-    mapped()
-    items = [1, 3] // remove key 2
-    const result = mapped()
-    expect(result).toEqual([10, 30])
-
-    // Re-add key 2 — should re-map since it was evicted
-    let callCount = 0
-    items = [1, 2, 3]
-    const mapped2 = mapArray(
-      () => items,
-      (item) => item,
-      (item) => {
-        callCount++
-        return item * 100
-      },
-    )
-    mapped2()
-    expect(callCount).toBe(3)
-  })
-
-  test('handles empty source', () => {
-    const mapped = mapArray(
-      () => [],
-      (item: number) => item,
-      (item) => item * 10,
-    )
-    expect(mapped()).toEqual([])
-  })
-
-  test('handles reordering', () => {
-    let items = [1, 2, 3]
-    let callCount = 0
-    const mapped = mapArray(
-      () => items,
-      (item) => item,
-      (item) => {
-        callCount++
-        return item * 10
-      },
-    )
-
-    mapped()
-    expect(callCount).toBe(3)
-
-    items = [3, 1, 2] // reorder
-    const result = mapped()
-    expect(result).toEqual([30, 10, 20])
-    expect(callCount).toBe(3) // no new calls — all cached
-  })
-})
-
-// ─── Telemetry ───────────────────────────────────────────────────────────────
-
-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'])
-
-    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', () => {
-    let count = 0
-    const unsub1 = registerErrorHandler(() => {
-      count++
-    })
-    const unsub2 = registerErrorHandler(() => {
-      count++
-    })
-
-    reportError({ component: 'X', phase: 'setup', error: 'err', timestamp: 0 })
-    expect(count).toBe(2)
-
-    unsub1()
-    unsub2()
-  })
-
-  test('handler errors are swallowed', () => {
-    let secondCalled = false
-    const unsub1 = registerErrorHandler(() => {
-      throw new Error('handler crash')
-    })
-    const unsub2 = registerErrorHandler(() => {
-      secondCalled = true
-    })
-
-    // Should not throw
-    reportError({ component: 'Y', phase: 'mount', error: 'err', timestamp: 0 })
-    expect(secondCalled).toBe(true)
-
-    unsub1()
-    unsub2()
-  })
-})
-
-// ─── 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' })
-    expect(node.children).toEqual([])
-  })
-
-  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 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.children).toEqual([])
-  })
-
-  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' })
-  })
-
-  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'])
-  })
-
-  test('jsxs is the same as jsx', () => {
-    expect(jsxs).toBe(jsx)
-  })
-
-  test('jsxDEV is the same as jsx', () => {
-    expect(jsxDEV).toBe(jsx)
-  })
-
-  test('JsxFragment is the same as Fragment', () => {
-    expect(JsxFragment).toBe(Fragment)
-  })
-
-  test('jsx with no children in props', () => {
-    const node = jsx('span', { id: 'test' })
-    expect(node.children).toEqual([])
-    expect(node.props).toEqual({ id: 'test' })
-  })
-
-  test('jsx component with no children', () => {
-    const Comp: ComponentFn = () => null
-    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()
-  })
-})
-
-// ─── Lifecycle hooks outside component ───────────────────────────────────────
-
-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'),
-    )
-    warnSpy.mockRestore()
-  })
-
-  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'),
-    )
-    warnSpy.mockRestore()
-  })
-
-  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'),
-    )
-    warnSpy.mockRestore()
-  })
-
-  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'),
-    )
-    warnSpy.mockRestore()
-  })
-})
-
-// ─── Edge cases ──────────────────────────────────────────────────────────────
-
-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')
-    expect(node.children).toHaveLength(5)
-    expect(node.children[0]).toBe('text')
-    expect(node.children[1]).toBe(42)
-    expect((node.children[2] as VNode).type).toBe('span')
-    expect(node.children[3]).toBeNull()
-    expect(typeof node.children[4]).toBe('function')
-  })
-
-  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', () => {
-    const Comp: ComponentFn = () => {
-      throw new Error('setup error')
-    }
-    expect(() => runWithHooks(Comp, {})).toThrow('setup error')
-  })
-
-  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' }
-    const ctx = createContext(defaultObj)
-    expect(useContext(ctx)).toBe(defaultObj)
-  })
-
-  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', () => {
-    const items = [
-      { 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),
-    })
-    expect(node.type).toBe(ForSymbol)
-    const props = node.props as unknown as { each: () => typeof items }
-    expect(props.each()).toBe(items)
-  })
-})
-
-// ─── lazy() ───────────────────────────────────────────────────────────────────
-
-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(Comp.__loading()).toBe(true)
-  })
-
-  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' })
-    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')))
-
-    await new Promise((r) => setTimeout(r, 0))
-
-    expect(Comp.__loading()).toBe(false)
-    expect(() => Comp({})).toThrow('load failed')
-  })
-
-  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')
-  })
-})
-
-// ─── setContextStackProvider ──────────────────────────────────────────────────
-
-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')
-
-    // 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.pop()
-    expect(useContext(ctx)).toBe('custom-default')
-
-    // Fully restore to module-level default stack
-    const { setContextStackProvider: restore } = await import('../context')
-    const _defaultStack: Map<symbol, unknown>[] = []
-    restore(() => _defaultStack)
-  })
-})
-
-// ─── ErrorBoundary advanced ──────────────────────────────────────────────────
-
-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',
-      })
-      return null
-    }, {})
-
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('child')
-
-    // First error should be handled
-    const handled1 = dispatchToErrorBoundary(new Error('first'))
-    expect(handled1).toBe(true)
-    expect(getter()).toBe('Error: Error: first')
-
-    // Second error while already in error state should NOT be handled
-    const handled2 = dispatchToErrorBoundary(new Error('second'))
-    expect(handled2).toBe(false)
-
-    // Clean up the boundary
-    const { popErrorBoundary: pop } = await import('../component')
-    pop()
-  })
-
-  test('reset function clears error and re-renders children', async () => {
-    let result: VNodeChild = null
-    let capturedReset: (() => void) | undefined
-
-    runWithHooks(() => {
-      result = ErrorBoundary({
-        fallback: (err, reset) => {
-          capturedReset = reset
-          return `Error: ${err}`
-        },
-        children: 'child content',
-      })
-      return null
-    }, {})
-
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('child content')
-
-    // Trigger error
-    dispatchToErrorBoundary(new Error('test error'))
-    expect(getter()).toBe('Error: Error: test error')
-    expect(capturedReset).toBeDefined()
-
-    // Reset
-    capturedReset?.()
-    expect(getter()).toBe('child content')
-
-    // Clean up
-    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 }
-    lazyFn.__loading = () => true
-    const child = h(lazyFn, null)
-
-    const node = Suspense({ fallback: () => fallbackVNode, children: child })
-    const getter = node.children[0] as () => VNodeChild
-    expect(getter()).toBe(fallbackVNode)
-  })
-
-  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')]
-    const node = Suspense({
-      fallback: h('span', null, 'loading'),
-      children: children as unknown as VNodeChild,
-    })
-    const getter = node.children[0] as () => VNodeChild
-    // Array is not a VNode with a type, so isLoading check should be false
-    const result = getter()
-    expect(result).toBe(children)
-  })
-})
-
-// ─── Show edge cases ────────────────────────────────────────────────────────
-
-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', () => {
-    const getter = Show({ when: () => false }) as unknown as () => VNodeChild
-    expect(getter()).toBeNull()
-  })
-})
-
-// ─── Switch edge cases ──────────────────────────────────────────────────────
-
-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')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    // Should skip the div and match the Match branch
-    expect(getter()).toBe('match-child')
-  })
-
-  test('skips null children in branches', () => {
-    const result = Switch({
-      fallback: 'default',
-      children: [null as unknown as VNodeChild, h(Match, { when: () => true }, 'found')],
-    })
-    const getter = result as unknown as () => VNodeChild
-    expect(getter()).toBe('found')
-  })
-
-  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' },
-      children: [],
-      key: null,
-    } as unknown as VNodeChild
-    const result = Switch({ children: [matchVNode] })
-    const getter = result as unknown as () => VNodeChild
-    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' })
-    expect(result).not.toBeNull()
-    expect((result as VNode).type).toBe(Greeting)
-    expect((result as VNode).props).toEqual({ name: 'world' })
-  })
-
-  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' })
-  })
-
-  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>'))
-    warnSpy.mockRestore()
-  })
-})