@pyreon/router 0.14.0 → 0.15.0

package/src/router.ts

@@ -1,6 +1,7 @@
 import { createContext, onUnmount, useContext } from '@pyreon/core'
 import { computed, signal } from '@pyreon/reactivity'
 import { buildNameIndex, buildPath, resolveRoute, stringifyQuery } from './match'
+import { getRedirectInfo } from './redirect'
 import { ScrollManager } from './scroll'
 import {
   type AfterEachHook,
@@ -26,8 +27,7 @@ import {
 const _isBrowser = typeof window !== 'undefined'
 // Dev-mode gate: see `pyreon/no-process-dev-gate` lint rule for why this
 // uses `import.meta.env.DEV` instead of `typeof process !== 'undefined'`.
-// @ts-ignore — `import.meta.env.DEV` is provided by Vite/Rolldown at build time
-const __DEV__ = import.meta.env?.DEV === true
+const __DEV__ = process.env.NODE_ENV !== 'production'
 
 // Dev-time counter sink — see packages/internals/perf-harness for contract.
 const _countSink = globalThis as { __pyreon_count__?: (name: string, n?: number) => void }
@@ -569,18 +569,24 @@ export function createRouter<TNames extends string = string>(
     record: RouteRecord,
     ac: AbortController,
     to: ResolvedRoute,
-  ): boolean {
+  ): GuardOutcome {
     if (result.status === 'fulfilled') {
       router._loaderData.set(record, result.value)
-      return true
+      return { action: 'continue' }
     }
-    if (ac.signal.aborted) return true
+    if (ac.signal.aborted) return { action: 'continue' }
+    // `redirect()` from a loader: propagate as a router-level redirect so the
+    // navigate flow re-runs against the target path BEFORE the matched route's
+    // layout / page mounts. Bypasses the user-supplied `_onError` hook — a
+    // redirect is intentional flow control, not an error.
+    const info = getRedirectInfo(result.reason)
+    if (info) return { action: 'redirect', target: info.url }
     if (router._onError) {
       const cancel = router._onError(result.reason, to)
-      if (cancel === false) return false
+      if (cancel === false) return { action: 'cancel' }
     }
     router._loaderData.set(record, undefined)
-    return true
+    return { action: 'continue' }
   }
 
   function syncBrowserUrl(path: string, replace: boolean): void {
@@ -633,6 +639,25 @@ export function createRouter<TNames extends string = string>(
     return Date.now() - entry.timestamp < gcTime
   }
 
+  /**
+   * Bounded set into `_loaderCache`: evicts the oldest entry (insertion-order
+   * FIFO) when the cap is exceeded. The `gcTime` TTL handles staleness, but
+   * without a size cap a long-running SPA navigating across many distinct
+   * loader keys (e.g. `/posts/:id` with hundreds of unique IDs) would
+   * accumulate cache entries indefinitely until manual `invalidateLoader()`
+   * — `_maxCacheSize` was wired through from `RouterOptions.maxCacheSize`
+   * (default 100) but the loader cache write paths never read it. Mirrors
+   * the same pattern used for `_componentCache` in `components.tsx`.
+   */
+  function loaderCacheSet(key: string, data: unknown): void {
+    router._loaderCache.set(key, { data, timestamp: Date.now() })
+    if (router._loaderCache.size > router._maxCacheSize) {
+      // Map iterates in insertion order — first key is oldest
+      const oldest = router._loaderCache.keys().next().value as string | undefined
+      if (oldest !== undefined) router._loaderCache.delete(oldest)
+    }
+  }
+
   /**
    * Execute a loader with cache + dedup:
    * 1. Cache hit + fresh → return cached data (skip loader entirely)
@@ -653,25 +678,41 @@ export function createRouter<TNames extends string = string>(
       }
     }
 
-    // 2. Dedup in-flight
+    // 2. Dedup in-flight — but only if the in-flight signal is still live.
+    // Pre-fix: nav-1 starts loader (signal=ac1.signal). User navigates again
+    // to the same path → nav-2's `router.push` first calls `_abortController?.abort()`
+    // (aborting ac1), then calls executeLoader. The Map still holds nav-1's
+    // promise (the .catch hasn't run yet); deduping returns it, but its
+    // signal is already aborted → nav-2 ends up with a rejected promise
+    // even though it has its own fresh ac2.signal. Now we check liveness.
     const inflight = router._loaderInflight.get(key)
-    if (inflight) return inflight
+    if (inflight && !inflight.signal.aborted) return inflight.promise
 
-    // 3. Execute
+    // 3. Execute. Wrap with `Promise.resolve().then(...)` so a SYNCHRONOUS
+    // throw from the loader (`redirect('/login')` / `notFound()` / a plain
+    // `throw new Error(...)`) becomes a rejected promise the `.catch` can
+    // handle — instead of escaping past the promise chain and surfacing as
+    // an unhandled exception in `runBlockingLoaders`'s `Promise.allSettled`.
     if (__DEV__) _countSink.__pyreon_count__?.('router.loaderRun')
-    const promise = record
-      .loader(loaderCtx)
+    const promise = Promise.resolve()
+      .then(() => record.loader!(loaderCtx))
       .then((data) => {
-        router._loaderCache.set(key, { data, timestamp: Date.now() })
-        router._loaderInflight.delete(key)
+        loaderCacheSet(key, data)
+        // Only delete if WE'RE still the registered in-flight (a later nav
+        // may have replaced the entry with a fresh promise).
+        if (router._loaderInflight.get(key)?.promise === promise) {
+          router._loaderInflight.delete(key)
+        }
         return data
       })
       .catch((err) => {
-        router._loaderInflight.delete(key)
+        if (router._loaderInflight.get(key)?.promise === promise) {
+          router._loaderInflight.delete(key)
+        }
         throw err
       })
 
-    router._loaderInflight.set(key, promise)
+    router._loaderInflight.set(key, { promise, signal: loaderCtx.signal })
     return promise
   }
 
@@ -680,17 +721,20 @@ export function createRouter<TNames extends string = string>(
     to: ResolvedRoute,
     gen: number,
     ac: AbortController,
-  ): Promise<boolean> {
+  ): Promise<GuardOutcome> {
     const loaderCtx: LoaderContext = { params: to.params, query: to.query, signal: ac.signal }
     const results = await Promise.allSettled(records.map((r) => executeLoader(r, loaderCtx)))
-    if (gen !== _navGen) return false
+    if (gen !== _navGen) return { action: 'cancel' }
     for (let i = 0; i < records.length; i++) {
       const result = results[i]
       const record = records[i]
       if (!result || !record) continue
-      if (!processLoaderResult(result, record, ac, to)) return false
+      const outcome = processLoaderResult(result, record, ac, to)
+      // Short-circuit on first redirect or cancel — later loaders' results
+      // are irrelevant once we know the navigation isn't committing here.
+      if (outcome.action !== 'continue') return outcome
     }
-    return true
+    return { action: 'continue' }
   }
 
   /** Fire-and-forget background revalidation for stale-while-revalidate routes. */
@@ -705,7 +749,7 @@ export function createRouter<TNames extends string = string>(
             router._loaderData.set(r, data)
             // Update cache with fresh data
             const key = getCacheKey(r, loaderCtx)
-            router._loaderCache.set(key, { data, timestamp: Date.now() })
+            loaderCacheSet(key, data)
             // Bump loadingSignal to trigger reactive re-render with fresh data
             loadingSignal.update((n) => n + 1)
             loadingSignal.update((n) => n - 1)
@@ -717,9 +761,13 @@ export function createRouter<TNames extends string = string>(
     }
   }
 
-  async function runLoaders(to: ResolvedRoute, gen: number, ac: AbortController): Promise<boolean> {
+  async function runLoaders(
+    to: ResolvedRoute,
+    gen: number,
+    ac: AbortController,
+  ): Promise<GuardOutcome> {
     const loadableRecords = to.matched.filter((r) => r.loader)
-    if (loadableRecords.length === 0) return true
+    if (loadableRecords.length === 0) return { action: 'continue' }
 
     const blocking: RouteRecord[] = []
     const swr: RouteRecord[] = []
@@ -732,11 +780,11 @@ export function createRouter<TNames extends string = string>(
     }
 
     if (blocking.length > 0) {
-      const ok = await runBlockingLoaders(blocking, to, gen, ac)
-      if (!ok) return false
+      const outcome = await runBlockingLoaders(blocking, to, gen, ac)
+      if (outcome.action !== 'continue') return outcome
     }
     if (swr.length > 0) revalidateSwrLoaders(swr, to, ac)
-    return true
+    return { action: 'continue' }
   }
 
   async function commitNavigation(
@@ -932,9 +980,12 @@ export function createRouter<TNames extends string = string>(
     const ac = new AbortController()
     router._abortController = ac
 
-    const loadersOk = await runLoaders(to, gen, ac)
-    if (!loadersOk) {
+    const loaderOutcome = await runLoaders(to, gen, ac)
+    if (loaderOutcome.action !== 'continue') {
       loadingSignal.update((n) => n - 1)
+      if (loaderOutcome.action === 'redirect') {
+        return navigate(sanitizePath(loaderOutcome.target), replace, redirectDepth + 1)
+      }
       return
     }
 
@@ -1046,7 +1097,7 @@ export function createRouter<TNames extends string = string>(
       return router._readyPromise
     },
 
-    async preload(path: string) {
+    async preload(path: string, request?: Request) {
       const resolved = resolveRoute(path, routes)
       // Load lazy components in parallel and populate the component cache so
       // the synchronous render pass finds ready components instead of kicking
@@ -1076,11 +1127,20 @@ export function createRouter<TNames extends string = string>(
         resolved.matched
           .filter((r) => r.loader)
           .map(async (r) => {
-            const data = await r.loader?.({
-              params: resolved.params,
-              query: resolved.query,
-              signal: ac.signal,
-            })
+            // Wrap with `Promise.resolve().then(...)` so a SYNCHRONOUS
+            // throw — `redirect('/login')` from a sync loader, `notFound()`,
+            // a plain `throw new Error(...)` — becomes a rejected promise
+            // the surrounding Promise.all surfaces. Bare `await r.loader(...)`
+            // would let synchronous throws escape past the `await` and
+            // surface as an uncaught exception in the Vite dev SSR pipeline.
+            const data = await Promise.resolve().then(() =>
+              r.loader!({
+                params: resolved.params,
+                query: resolved.query,
+                signal: ac.signal,
+                ...(request ? { request } : {}),
+              }),
+            )
             router._loaderData.set(r, data)
           }),
       )

package/src/tests/loader.test.ts

@@ -581,3 +581,152 @@ describe('router.preload', () => {
     expect(router._componentCache.get(routes[1] as RouteRecord)).toBe(Lazy)
   })
 })
+
+// ─── _loaderCache LRU cap (regression for missing _maxCacheSize wiring) ────
+describe('router — _loaderCache LRU cap', () => {
+  // Pre-fix: `_maxCacheSize` was wired through from `RouterOptions.maxCacheSize`
+  // (default 100) but the loader cache write paths in router.ts never read it
+  // — only `_componentCache` enforced the cap. Long-running SPAs navigating
+  // dynamic-param routes (`/posts/:id` with hundreds of unique IDs) would
+  // accumulate `_loaderCache` entries until manual `invalidateLoader()`.
+  // Post-fix: the helper `loaderCacheSet` evicts oldest (insertion-order FIFO)
+  // when over the cap, mirroring `_componentCache`.
+  test('caps _loaderCache at maxCacheSize, evicts oldest first', async () => {
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      {
+        path: '/posts/:id',
+        component: Page,
+        loader: async ({ params }) => `post-${params.id}`,
+        loaderKey: ({ params }) => `posts:${params.id}`,
+      },
+    ]
+    const router = createRouter({ routes, maxCacheSize: 3, url: '/' }) as RouterInstance
+
+    // Drive the loader through 4 distinct keys
+    await router.push('/posts/1')
+    await router.push('/posts/2')
+    await router.push('/posts/3')
+    await router.push('/posts/4')
+
+    // Cache must be capped at 3 (not 4).
+    expect(router._loaderCache.size).toBe(3)
+
+    // FIFO: the OLDEST insertion (posts:1) must have been evicted.
+    expect(router._loaderCache.has('posts:1')).toBe(false)
+    expect(router._loaderCache.has('posts:2')).toBe(true)
+    expect(router._loaderCache.has('posts:3')).toBe(true)
+    expect(router._loaderCache.has('posts:4')).toBe(true)
+  })
+
+  test('does not evict when cap is not exceeded', async () => {
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      {
+        path: '/posts/:id',
+        component: Page,
+        loader: async ({ params }) => `post-${params.id}`,
+        loaderKey: ({ params }) => `posts:${params.id}`,
+      },
+    ]
+    const router = createRouter({ routes, maxCacheSize: 100, url: '/' }) as RouterInstance
+
+    await router.push('/posts/1')
+    await router.push('/posts/2')
+    await router.push('/posts/3')
+
+    expect(router._loaderCache.size).toBe(3)
+    expect(router._loaderCache.has('posts:1')).toBe(true)
+    expect(router._loaderCache.has('posts:2')).toBe(true)
+    expect(router._loaderCache.has('posts:3')).toBe(true)
+  })
+
+  test('default maxCacheSize (100) caps cache after 100 unique keys', async () => {
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      {
+        path: '/posts/:id',
+        component: Page,
+        loader: async ({ params }) => `post-${params.id}`,
+        loaderKey: ({ params }) => `posts:${params.id}`,
+      },
+    ]
+    // No explicit maxCacheSize — uses default 100
+    const router = createRouter({ routes, url: '/' }) as RouterInstance
+
+    for (let i = 0; i < 105; i++) {
+      await router.push(`/posts/${i}`)
+    }
+
+    expect(router._loaderCache.size).toBe(100)
+    // Earliest 5 keys (0-4) evicted.
+    expect(router._loaderCache.has('posts:0')).toBe(false)
+    expect(router._loaderCache.has('posts:4')).toBe(false)
+    expect(router._loaderCache.has('posts:5')).toBe(true)
+    expect(router._loaderCache.has('posts:104')).toBe(true)
+  })
+})
+
+// ─── Regression: dedup must not return aborted in-flight promise ───────────
+//
+// Pre-fix: `router.push` aborts `_abortController` BEFORE starting the next
+// nav. If two pushes to the same path happen back-to-back, the in-flight
+// Map still holds nav-1's promise (its `.catch` hasn't run yet). The dedup
+// returned that promise to nav-2 — but its bound signal is already aborted,
+// so nav-2's data path is broken even though it has its own fresh signal.
+//
+// Post-fix: `_loaderInflight` stores `{ promise, signal }`. Dedup is gated
+// on `!signal.aborted`. Aborted entries fall through to a fresh execute
+// using nav-2's signal.
+describe('router — _loaderInflight aborted-signal dedup', () => {
+  test('back-to-back navigation re-executes loader with fresh signal when previous was aborted', async () => {
+    let invocations = 0
+    let resolveLoader1: ((data: unknown) => void) | null = null
+
+    const Page = () => null
+    const routes: RouteRecord[] = [
+      { path: '/', component: Page },
+      {
+        path: '/data',
+        component: Page,
+        loader: async ({ signal }) => {
+          invocations++
+          const myInvocation = invocations
+          // Wire signal-abort → reject so the nav actually fails on abort.
+          // The first invocation hangs until manually resolved; later
+          // invocations resolve immediately.
+          if (myInvocation === 1) {
+            return new Promise((_resolve, reject) => {
+              signal?.addEventListener('abort', () => reject(new Error('aborted')))
+              resolveLoader1 = _resolve
+            })
+          }
+          return `data-${myInvocation}`
+        },
+      },
+    ]
+    const router = createRouter({ routes, url: '/' }) as RouterInstance
+
+    // Nav 1 → /data. Loader invocation #1 starts, hangs.
+    const nav1 = router.push('/data').catch(() => {})
+    await new Promise<void>((r) => queueMicrotask(() => r()))
+
+    // Nav 2 → /data. router.push aborts ac1 first, then calls executeLoader.
+    // Pre-fix: dedup returns nav-1's promise (whose signal is now aborted).
+    // Post-fix: dedup skipped (signal.aborted=true), fresh loader runs.
+    const nav2 = router.push('/data')
+
+    // Resolve nav-1's hung promise (won't actually deliver — already aborted)
+    const r1 = resolveLoader1 as ((d: unknown) => void) | null
+    if (r1) r1('data-1')
+
+    await nav2
+    await nav1
+
+    // Post-fix: 2 invocations (nav-1 aborted, nav-2 ran fresh).
+    // Pre-fix: 1 invocation (nav-2 deduped to nav-1's aborted promise).
+    expect(invocations).toBe(2)
+    expect(router.currentRoute().path).toBe('/data')
+  })
+
+})

package/src/tests/manifest-snapshot.test.ts

@@ -87,8 +87,12 @@ describe('gen-docs — router snapshot', () => {
 
   it('renders @pyreon/router to MCP api-reference entries — one per api[] item', () => {
     const record = renderApiReferenceEntries(routerManifest)
-    expect(Object.keys(record).length).toBe(15)
+    expect(Object.keys(record).length).toBe(18)
     expect(Object.keys(record)).toContain('router/createRouter')
+    // PR-B added redirect/isRedirectError/getRedirectInfo entries.
+    expect(Object.keys(record)).toContain('router/redirect')
+    expect(Object.keys(record)).toContain('router/isRedirectError')
+    expect(Object.keys(record)).toContain('router/getRedirectInfo')
     // Spot-check the flagship API — createRouter is the factory
     const createRouter = record['router/createRouter']!
     expect(createRouter.notes).toContain('routes')

package/src/tests/native-markers.test.ts

@@ -0,0 +1,18 @@
+import { isNativeCompat } from '@pyreon/core'
+import { describe, expect, it } from 'vitest'
+import { RouterLink, RouterProvider, RouterView } from '../components'
+
+// Marker-presence assertion (PR 3 lock-in). Bisect-verified: removing
+// any of the `nativeCompat(...)` calls in components.tsx fails the
+// corresponding test.
+describe('native-compat markers — @pyreon/router', () => {
+  it('RouterProvider is marked native', () => {
+    expect(isNativeCompat(RouterProvider)).toBe(true)
+  })
+  it('RouterView is marked native', () => {
+    expect(isNativeCompat(RouterView)).toBe(true)
+  })
+  it('RouterLink is marked native', () => {
+    expect(isNativeCompat(RouterLink)).toBe(true)
+  })
+})

package/src/tests/redirect.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest'
+import { getRedirectInfo, isRedirectError, redirect } from '../redirect'
+
+describe('redirect()', () => {
+  it('throws an error branded with the REDIRECT symbol', () => {
+    expect(() => redirect('/login')).toThrow()
+  })
+
+  it('captures URL + default 307 status on the thrown error', () => {
+    let caught: unknown
+    try {
+      redirect('/login')
+    } catch (err) {
+      caught = err
+    }
+    const info = getRedirectInfo(caught)
+    expect(info).toEqual({ url: '/login', status: 307 })
+  })
+
+  it('captures the custom status when one is provided', () => {
+    let caught: unknown
+    try {
+      redirect('/perm', 308)
+    } catch (err) {
+      caught = err
+    }
+    expect(getRedirectInfo(caught)?.status).toBe(308)
+  })
+
+  it.each([301, 302, 303, 307, 308] as const)('accepts %s as a valid status', (status) => {
+    let caught: unknown
+    try {
+      redirect('/x', status)
+    } catch (err) {
+      caught = err
+    }
+    expect(getRedirectInfo(caught)?.status).toBe(status)
+  })
+
+  it('produces a human-readable Error message', () => {
+    let caught: Error | undefined
+    try {
+      redirect('/login')
+    } catch (err) {
+      caught = err as Error
+    }
+    expect(caught?.message).toBe('Redirect to /login')
+  })
+})
+
+describe('isRedirectError()', () => {
+  it('returns true for an error thrown by redirect()', () => {
+    let caught: unknown
+    try {
+      redirect('/x')
+    } catch (err) {
+      caught = err
+    }
+    expect(isRedirectError(caught)).toBe(true)
+  })
+
+  it('returns false for a plain Error', () => {
+    expect(isRedirectError(new Error('plain'))).toBe(false)
+  })
+
+  it('returns false for non-error values', () => {
+    expect(isRedirectError(null)).toBe(false)
+    expect(isRedirectError(undefined)).toBe(false)
+    expect(isRedirectError('string')).toBe(false)
+    expect(isRedirectError(42)).toBe(false)
+    expect(isRedirectError({})).toBe(false)
+  })
+
+  it('returns false for objects with a different brand', () => {
+    const fake = new Error('fake')
+    ;(fake as unknown as Record<symbol, unknown>)[Symbol.for('something.else')] = true
+    expect(isRedirectError(fake)).toBe(false)
+  })
+})
+
+describe('getRedirectInfo()', () => {
+  it('returns null for non-redirect errors', () => {
+    expect(getRedirectInfo(new Error('plain'))).toBeNull()
+    expect(getRedirectInfo(null)).toBeNull()
+  })
+
+  it('returns the redirect info for a thrown redirect()', () => {
+    let caught: unknown
+    try {
+      redirect('/destination', 303)
+    } catch (err) {
+      caught = err
+    }
+    expect(getRedirectInfo(caught)).toEqual({ url: '/destination', status: 303 })
+  })
+})

package/src/tests/router.browser.test.tsx

@@ -1,4 +1,4 @@
-import { h } from '@pyreon/core'
+import { h, onMount } from '@pyreon/core'
 import { flush, mountInBrowser } from '@pyreon/test-utils/browser'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import {
@@ -439,4 +439,71 @@ describe('router in real browser', () => {
     expect(container.querySelector('#home')).toBeNull()
     unmount()
   })
+
+  // ── Lock-in for the layout-remount loop fix (PR #406) ──────────────────────
+  //
+  // Pre-fix `RouterView`'s reactive child accessor read `_loadingSignal()` and
+  // the full `currentRoute` snapshot directly. Each navigation flow writes
+  // `_loadingSignal` at least twice (start tick + end tick) and writes
+  // `currentPath` once via `commitNavigation`. Any of those writes re-emitted
+  // the reactive child, and `mountReactive`'s teardown-then-mount cleanup
+  // remounted the entire matched-component subtree on each emission. So a
+  // single `router.push()` produced 2-3+ mounts of the destination component
+  // (instead of 1) — the "layout double/triple mount" loop.
+  //
+  // The fix routes the structural decision through a single
+  // `computed<DepthEntry>` keyed on `(rec, comp, errored, route)` reference
+  // equality. Within-navigation `_loadingSignal` ticks don't change
+  // `currentRoute` (it's `computed` memoized on `currentPath`), so the
+  // structural emission stays at exactly one per navigation.
+  //
+  // This test instruments a counter inside the destination component's
+  // `onMount` — an inflated count after a single `await router.push()` would
+  // mean the loop is back. Bisect-verifies against the structural decoupling
+  // commit: reverting that commit pushes the count to ≥ 2 and this assertion
+  // fails.
+  it('a single router.push() mounts the destination component exactly once (loop-prevention regression)', async () => {
+    let aboutMountCount = 0
+    const InstrumentedAbout = () => {
+      onMount(() => {
+        aboutMountCount++
+      })
+      return h('div', { id: 'about-instrumented' }, 'About Page')
+    }
+    const localRoutes = [
+      { path: '/', component: Home },
+      { path: '/about', component: InstrumentedAbout },
+    ]
+    const router = createRouter({ routes: localRoutes, mode: 'hash' })
+    const { container, unmount } = mountInBrowser(
+      h(RouterProvider, { router }, h(RouterView, {})),
+    )
+
+    // Sanity: starting at /, About is not yet mounted.
+    expect(aboutMountCount).toBe(0)
+    expect(container.querySelector('#about-instrumented')).toBeNull()
+
+    await router.push('/about')
+    await flush()
+
+    // The structural decoupling fix means a single navigation produces a
+    // single emission at this depth. If `RouterView` ever reverts to reading
+    // `_loadingSignal` reactively, every loadingSignal tick during the
+    // navigate flow will remount the destination subtree and this count
+    // jumps to 2 or 3.
+    expect(container.querySelector('#about-instrumented')?.textContent).toBe('About Page')
+    expect(aboutMountCount).toBe(1)
+
+    // And navigating BACK to / + forward again to /about produces exactly
+    // one more mount — covers the case where stale subscribers from a prior
+    // mount could double-fire across navigations.
+    await router.push('/')
+    await flush()
+    await router.push('/about')
+    await flush()
+    expect(aboutMountCount).toBe(2)
+
+    expect(unhandledRejections).toEqual([])
+    unmount()
+  })
 })