@pyreon/zero 0.24.5 → 0.24.6

package/src/isr.ts

@@ -1,394 +0,0 @@
-import type { ISRConfig } from './types'
-
-// Dev-mode counter sink — see packages/internals/perf-harness for contract.
-// Zero cost in prod (gate folds to `false`, optional-chain short-circuits).
-const __DEV__ = typeof process !== 'undefined' && process.env.NODE_ENV !== 'production'
-const _countSink = globalThis as { __pyreon_count__?: (name: string, n?: number) => void }
-
-// ─── ISR Cache ───────────────────────────────────────────────────────────────
-
-/** Serialized SSR response cached by the ISR layer (one per cache key). */
-export interface ISRCacheEntry {
-  html: string
-  headers: Record<string, string>
-  timestamp: number
-}
-
-/**
- * Pluggable backing store for the ISR cache. The default in-memory
- * implementation (`createMemoryStore`) is per-process — fine for
- * single-instance deploys, but multi-instance / horizontally-scaled
- * apps need a SHARED store (Redis, Vercel KV, Cloudflare KV, Upstash,
- * etc.) so revalidation in one instance is visible to all instances.
- *
- * The interface accepts BOTH sync and async returns: the in-memory
- * default stays cheap (sync `Map` ops, no `Promise` allocation per
- * request), while external stores return promises naturally. The
- * handler awaits the result either way (`await` on a non-promise just
- * returns the value).
- *
- * `get` is responsible for any LRU bookkeeping — external stores
- * typically rely on their own TTL/eviction policy and can `return
- * this.map.get(key)` directly; the in-memory store does a
- * delete + re-insert to keep the Map's insertion-order LRU correct.
- *
- * `delete` is optional. It's only used when a future on-demand
- * revalidation pathway needs to evict a specific key (the current
- * stale-while-revalidate flow does not call it). External stores that
- * don't support per-key invalidation can omit it.
- */
-export interface ISRStore<E = ISRCacheEntry> {
-  get(key: string): Promise<E | undefined> | E | undefined
-  set(key: string, entry: E): Promise<void> | void
-  delete?(key: string): Promise<void> | void
-  /**
-   * Drop EVERY entry. Optional — external stores (Redis with TTL-only,
-   * Vercel KV with per-key invalidation, etc.) may not support a
-   * blanket purge. When omitted, `ISRHandler.revalidateAll()` throws a
-   * clear error pointing at the missing method. The default
-   * `createMemoryStore` implements it.
-   */
-  clear?(): Promise<void> | void
-}
-
-/**
- * The default in-memory ISR store: a `Map` with insertion-order LRU
- * eviction, capped at `maxEntries` (default `1000`). Drop in as
- * `config.store` if you want to tweak the cap or wrap the store with
- * instrumentation; pass a different `ISRStore` impl for Redis / KV /
- * etc. backings.
- *
- * `get` does the LRU bump (re-inserts the touched entry at the
- * newest position) so hot paths survive eviction even when the cap is
- * small. Without that, `Map.get(...)` wouldn't update ordering and
- * frequently-read entries could be evicted by occasional writes.
- */
-export function createMemoryStore<E = ISRCacheEntry>(opts: {
-  maxEntries?: number
-} = {}): ISRStore<E> {
-  const cache = new Map<string, E>()
-  const maxEntries = Math.max(1, opts.maxEntries ?? 1000)
-  return {
-    get(key) {
-      const entry = cache.get(key)
-      if (entry !== undefined) {
-        cache.delete(key)
-        cache.set(key, entry)
-      }
-      return entry
-    },
-    set(key, entry) {
-      if (cache.has(key)) cache.delete(key)
-      cache.set(key, entry)
-      while (cache.size > maxEntries) {
-        const oldest = cache.keys().next().value
-        if (oldest === undefined) break
-        cache.delete(oldest)
-      }
-    },
-    delete(key) {
-      cache.delete(key)
-    },
-    clear() {
-      cache.clear()
-    },
-  }
-}
-
-// Internal alias for the default-shape entry — keeps function bodies tidy
-// while staying source-compatible with the public `ISRCacheEntry` export.
-type CacheEntry = ISRCacheEntry
-
-/**
- * ISR handler with stale-while-revalidate semantics.
- *
- * Wraps an SSR handler and caches responses per URL path. Serves stale
- * content immediately while revalidating in the background. The cache
- * backing is **pluggable** via `config.store` (default:
- * `createMemoryStore({ maxEntries: 1000 })`) — pass a custom `ISRStore`
- * implementation backed by Redis / Vercel KV / Cloudflare KV / Upstash
- * etc. to share state across horizontally-scaled instances. Without an
- * external store, each instance has its own per-process cache (which
- * is fine for single-instance deploys; behaviour-identical to the
- * pre-pluggable-store implementation).
- *
- * Default in-memory store: bounded by `config.maxEntries` (default
- * `1000`) with insertion-order LRU eviction. Without the cap, unbounded
- * URL spaces like `/user/:id` would grow cache memory without limit
- * over the server's lifetime — a real leak in long-running deployments.
- * `config.maxEntries` is ignored when a custom `config.store` is supplied
- * (the custom store owns its own eviction policy).
- */
-/**
- * The fetch handler `createISRHandler` returns is also a callable
- * carrying imperative invalidation methods. Webhooks, CMS notifications,
- * admin endpoints etc. call these methods to drop one or all cached
- * entries on demand — strictly more responsive than waiting for the
- * TTL-based stale-while-revalidate cycle.
- *
- * The shape is `(req) => Promise<Response>` PLUS the methods, so
- * existing consumers (`Bun.serve({ fetch: handler })`) keep working
- * byte-identically.
- */
-export interface ISRHandler {
-  (req: Request): Promise<Response>
-  /**
-   * Drop the cache entry for a single path (or `cacheKey`-derived key).
-   * The next request for that key will MISS and re-render fresh. Returns
-   * `{ dropped: true }` if an entry was found and deleted, `{ dropped: false }`
-   * if no entry existed.
-   *
-   * Useful for webhook-driven invalidation: a CMS notifies that a post
-   * was updated, the webhook handler calls `isrHandler.revalidateNow('/posts/123')`,
-   * and the very next visitor gets the fresh content — no stale window.
-   *
-   * Idempotent. Safe to call against keys that don't exist (returns
-   * `dropped: false` cleanly).
-   */
-  revalidateNow(key: string): Promise<{ dropped: boolean }>
-  /**
-   * Drop ALL cached entries. Useful for "purge cache" admin actions or
-   * deploy-completion hooks that want a clean slate.
-   *
-   * The default in-memory store supports this via repeated `delete`
-   * calls under the hood; custom stores that omit `delete` (Redis with
-   * TTL-only, etc.) throw a clear error pointing at the missing method
-   * so the caller knows their store implementation can't honor the call.
-   */
-  revalidateAll(): Promise<void>
-}
-
-export function createISRHandler(
-  handler: (req: Request) => Promise<Response>,
-  config: ISRConfig,
-): ISRHandler {
-  // Pluggable backing store. Default keeps the prior in-memory LRU
-  // behaviour byte-identical (same `maxEntries` default, same Map +
-  // delete+re-insert LRU bump) so existing callers see no behavioural
-  // change.
-  const store: ISRStore<CacheEntry>
-    = config.store
-      ?? createMemoryStore<CacheEntry>(
-        config.maxEntries !== undefined ? { maxEntries: config.maxEntries } : {},
-      )
-  const revalidating = new Set<string>()
-  const revalidateMs = config.revalidate * 1000
-  // Bounded background-revalidation timeout. Without it, a handler that
-  // hangs forever leaves its key permanently in `revalidating` (the
-  // `finally` that clears it never runs), so EVERY later request for
-  // that key short-circuits the `revalidating.has(key)` guard and the
-  // entry stays stale for the rest of the process lifetime — it can
-  // never recover. 30s default matches the Suspense streaming timeout;
-  // overridable via ISRConfig.revalidateTimeoutMs.
-  const REVALIDATE_TIMEOUT_MS = Math.max(1, config.revalidateTimeoutMs ?? 30_000)
-
-  // Only 2xx, cookie-free responses may be cached. Caching a transient
-  // 5xx/3xx/404 and replaying it as a 200 for the whole revalidate
-  // window is a self-inflicted outage / cache-poisoning bug. Caching a
-  // `Set-Cookie` response and replaying it to every visitor leaks one
-  // user's session/CSRF cookie cross-user — not covered by the
-  // documented "ISR-without-cacheKey is for non-personalized pages"
-  // caveat (that caveat is about key variance, not header stripping).
-  function isCacheable(res: Response): boolean {
-    return res.status >= 200 && res.status < 300 && !res.headers.has('set-cookie')
-  }
-  // M1.1 — cache-key derivation. Default keys by pathname only (the
-  // pre-M1 behaviour). User-supplied `cacheKey` opts in to varying
-  // by cookies / query / headers — required for auth-gated pages.
-  // See `ISRConfig.cacheKey` JSDoc for the auth-incompatibility caveat.
-  const deriveKey: (req: Request, url: URL) => string
-    = typeof config.cacheKey === 'function'
-      ? (req, _url) => (config.cacheKey as (r: Request) => string)(req)
-      : (_req, url) => url.pathname
-
-  async function revalidate(url: URL, originalReq: Request) {
-    // Re-derive key from the ORIGINAL request so cookies / headers /
-    // query that varied the cache entry are preserved across revalidation.
-    // Without this, a user-supplied `cacheKey` that reads cookies would
-    // re-render against a no-cookie request and stomp the cached entry
-    // with the wrong-user content.
-    const key = deriveKey(originalReq, url)
-    if (revalidating.has(key)) return
-    revalidating.add(key)
-
-    // Hold the timer id outside try/Promise.race so the finally block
-    // can `clearTimeout` it on the SUCCESS path. Pre-fix the rejection
-    // setTimeout was left pending until REVALIDATE_TIMEOUT_MS (default
-    // 30s) every time `handler(req)` won the race — i.e. every
-    // successful revalidation. Under sustained traffic this accumulates
-    // hundreds of pending timer closures + rejection callbacks before
-    // they self-clear.
-    let timeoutId: ReturnType<typeof setTimeout> | undefined
-    try {
-      // Default: forward the original request shape (headers + method)
-      // so the re-render sees the same auth context as the user's read.
-      // Opt-in `revalidateRequest` hook lets auth-gated callers scope
-      // the revalidation explicitly — e.g. return `null` to skip
-      // revalidation for authenticated entries (stale stays stale until
-      // the next live request), or return an anonymous Request for
-      // non-personalized entries.
-      let req: Request
-      if (typeof config.revalidateRequest === 'function') {
-        const custom = config.revalidateRequest(originalReq)
-        if (custom === null) {
-          revalidating.delete(key)
-          return
-        }
-        req = custom
-      } else {
-        req = new Request(url.href, {
-          method: 'GET',
-          headers: originalReq.headers,
-        })
-      }
-      // Bound the revalidation so a hung handler can't pin `key` in
-      // `revalidating` forever (which would freeze the entry stale).
-      const res = await Promise.race([
-        handler(req),
-        new Promise<never>((_, reject) => {
-          timeoutId = setTimeout(
-            () => reject(new Error('[Pyreon ISR] revalidation timeout')),
-            REVALIDATE_TIMEOUT_MS,
-          )
-        }),
-      ])
-      // Never overwrite a good stale entry with a bad re-render
-      // (5xx/3xx) or poison it with a Set-Cookie response.
-      if (isCacheable(res)) {
-        const html = await res.text()
-        const headers: Record<string, string> = {}
-        res.headers.forEach((v, k) => {
-          headers[k] = v
-        })
-        await store.set(key, { html, headers, timestamp: Date.now() })
-      }
-    } catch {
-      // Revalidation failed / timed out — stale cache entry remains valid
-    } finally {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId)
-        // Leak-class I diagnostic — emit one per cleared timer. Healthy
-        // count = revalidation-attempts (every attempt should clear its
-        // timer in finally). A LOWER count than revalidations means
-        // clearTimeout failed to fire — the orphan-timer leak is back.
-        if (__DEV__) _countSink.__pyreon_count__?.('isr.revalidate.timerClear')
-      }
-      revalidating.delete(key)
-    }
-  }
-
-  const fetch = async (req: Request): Promise<Response> => {
-    // Only cache GET requests
-    if (req.method !== 'GET') {
-      return handler(req)
-    }
-
-    const url = new URL(req.url)
-    const key = deriveKey(req, url)
-    // The store's `get` is responsible for any LRU bookkeeping — the
-    // default in-memory store does delete + re-insert so hot paths
-    // survive eviction. External stores (Redis/KV) rely on their own
-    // TTL/eviction policy and typically just read directly.
-    const entry = await store.get(key)
-
-    if (entry) {
-      const age = Date.now() - entry.timestamp
-
-      if (age > revalidateMs) {
-        // Stale — serve cached but revalidate in background
-        revalidate(url, req)
-      }
-
-      return new Response(entry.html, {
-        status: 200,
-        headers: {
-          ...entry.headers,
-          'content-type': 'text/html; charset=utf-8',
-          'x-isr-cache': age > revalidateMs ? 'STALE' : 'HIT',
-          'x-isr-age': String(Math.round(age / 1000)),
-        },
-      })
-    }
-
-    // Cache miss — render. Only cache (and only normalize to a 200
-    // text/html response) when the render is actually cacheable; a
-    // transient error / redirect / Set-Cookie response is passed
-    // through verbatim with its ORIGINAL status + headers and is NOT
-    // stored, so it can't be replayed as a 200 to later visitors.
-    const res = await handler(req)
-    const html = await res.text()
-    const headers: Record<string, string> = {}
-    res.headers.forEach((v, k) => {
-      headers[k] = v
-    })
-
-    if (!isCacheable(res)) {
-      return new Response(html, {
-        status: res.status,
-        statusText: res.statusText,
-        headers: { ...headers, 'x-isr-cache': 'BYPASS' },
-      })
-    }
-
-    await store.set(key, { html, headers, timestamp: Date.now() })
-
-    return new Response(html, {
-      status: 200,
-      headers: {
-        ...headers,
-        'content-type': 'text/html; charset=utf-8',
-        'x-isr-cache': 'MISS',
-      },
-    })
-  }
-
-  // Attach the imperative invalidation methods. The result is a
-  // callable (still works with `Bun.serve({ fetch: handler })`) plus
-  // `.revalidateNow(key)` and `.revalidateAll()` for webhook-driven
-  // cache busting.
-  const isrHandler = fetch as ISRHandler
-
-  isrHandler.revalidateNow = async (key: string) => {
-    // Get-then-delete so we can return an accurate `dropped` flag. The
-    // store's `delete` doesn't return whether anything existed, so the
-    // precheck is the only way to distinguish "actually dropped" from
-    // "no-op against missing key". For the default in-memory store the
-    // get is O(1); external stores pay one extra round-trip (acceptable
-    // for an invalidation API that fires on CMS webhooks, not on the
-    // hot path).
-    //
-    // `dropped: true` is only returned when (a) the entry existed AND
-    // (b) the store actually supported delete. A store without
-    // `delete?` returns `dropped: false` even if the entry existed —
-    // the caller's intent (make this key MISS next time) wasn't
-    // honored, so the honest answer is "no". Such stores rely on TTL
-    // for eviction.
-    const existed = (await store.get(key)) !== undefined
-    let dropped = false
-    if (existed && store.delete) {
-      await store.delete(key)
-      dropped = true
-    }
-    // Always clear the in-flight revalidation flag so the next request
-    // re-renders fresh rather than short-circuiting on the
-    // `revalidating.has(key)` guard — regardless of whether we
-    // physically dropped the entry.
-    revalidating.delete(key)
-    return { dropped }
-  }
-
-  isrHandler.revalidateAll = async () => {
-    if (!store.clear) {
-      throw new Error(
-        '[Pyreon ISR] revalidateAll() called against a store that does not implement `clear()`. The default in-memory store supports this; external stores (Redis/KV/etc.) must opt in by implementing `ISRStore.clear()`.',
-      )
-    }
-    await store.clear()
-    // Drop every in-flight revalidation flag — fresh requests should
-    // re-render rather than waiting on stale resolve callbacks pointing
-    // at entries we just purged.
-    revalidating.clear()
-  }
-
-  return isrHandler
-}

package/src/link.tsx

@@ -1,304 +0,0 @@
-import { createRef } from '@pyreon/core'
-import { useRouter } from '@pyreon/router'
-import { useIntersectionObserver } from './utils/use-intersection-observer'
-
-// ─── Link component with prefetching ────────────────────────────────────────
-//
-// Provides client-side navigation, prefetching, and active state tracking.
-// Three levels of API:
-//
-// 1. useLink(props)   — composable returning handlers, state, and ref callback
-// 2. createLink(Comp) — HOC wrapping any component with link behavior
-// 3. Link             — default <a>-based link (built on createLink)
-
-export interface LinkProps {
-  /** Target URL path. */
-  href: string
-  /** Link content. */
-  children?: any
-  /** CSS class name. */
-  class?: string
-  /** Class applied when this link matches the current route. */
-  activeClass?: string
-  /** Class applied when this link exactly matches the current route. */
-  exactActiveClass?: string
-  /** Prefetch strategy. Default: "hover" */
-  prefetch?: 'hover' | 'viewport' | 'none'
-  /** Open in new tab. */
-  external?: boolean
-  /** Inline styles. */
-  style?: string
-  /** ARIA label. */
-  'aria-label'?: string
-  /** Additional click handler — called before navigation. Call e.preventDefault() to cancel. */
-  onClick?: ((e: MouseEvent) => void) | undefined
-}
-
-/** Props passed to a custom component via createLink. */
-export interface LinkRenderProps {
-  href: string
-  ref: import('@pyreon/core').Ref<HTMLAnchorElement>
-  onClick: (e: MouseEvent) => void
-  onMouseEnter: () => void
-  onTouchStart: () => void
-  isActive: () => boolean
-  isExactActive: () => boolean
-  /** Reactive class string — pass directly to element for auto-updates on route change. */
-  class: (() => string) | string | undefined
-  style?: string
-  target?: string
-  rel?: string
-  'aria-label'?: string
-  children?: any
-}
-
-/** Return type of useLink. */
-export interface UseLinkReturn {
-  /** Ref object — attach to the root element for viewport-based prefetch. */
-  ref: import('@pyreon/core').Ref<HTMLAnchorElement>
-  /** Click handler — performs client-side navigation. */
-  handleClick: (e: MouseEvent) => void
-  /** Mouse enter handler — triggers hover prefetch. */
-  handleMouseEnter: () => void
-  /** Touch start handler — triggers prefetch on mobile. */
-  handleTouchStart: () => void
-  /** Whether the link partially matches the current route. */
-  isActive: () => boolean
-  /** Whether the link exactly matches the current route. */
-  isExactActive: () => boolean
-  /** Resolved class string including active classes. */
-  classes: () => string
-}
-
-const MAX_PREFETCH_CACHE = 200
-// Maps href → list of <link> elements injected into <head>. When the
-// cache evicts an href (FIFO at MAX_PREFETCH_CACHE), the matching <link>
-// elements must be removed too — otherwise head bloats unboundedly
-// across long SPA sessions (every Link interaction added 2 <link> nodes
-// with no cleanup).
-const prefetched = new Map<string, Element[]>()
-
-function doPrefetch(href: string) {
-  // Prefetch only fires from browser-mounted Link interactions (hover /
-  // click intent). Explicit guard documents the SSR-safety contract.
-  if (typeof document === 'undefined') return
-  if (prefetched.has(href)) return
-  // Evict oldest entries when cache is full — AND remove their DOM nodes.
-  if (prefetched.size >= MAX_PREFETCH_CACHE) {
-    const firstEntry = prefetched.entries().next().value
-    if (firstEntry) {
-      const [oldestHref, oldestLinks] = firstEntry
-      for (const link of oldestLinks) link.remove()
-      prefetched.delete(oldestHref)
-    }
-  }
-
-  const injected: Element[] = []
-  const docLink = document.createElement('link')
-  docLink.rel = 'prefetch'
-  docLink.href = href
-  docLink.as = 'document'
-  document.head.appendChild(docLink)
-  injected.push(docLink)
-
-  try {
-    const chunkHint = document.createElement('link')
-    chunkHint.rel = 'modulepreload'
-    chunkHint.href = href
-    document.head.appendChild(chunkHint)
-    injected.push(chunkHint)
-  } catch {
-    // modulepreload is a hint, not critical
-  }
-
-  prefetched.set(href, injected)
-}
-
-/**
- * Prefetch a route's JS chunk by injecting `<link rel="prefetch">` into the
- * document head. Deduplicates — calling with the same href twice is a no-op.
- *
- * @example
- * prefetchRoute('/about')
- * prefetchRoute('/dashboard')
- */
-export function prefetchRoute(href: string): void {
-  doPrefetch(href)
-}
-
-/**
- * Composable that provides all link behavior — navigation, prefetching,
- * active state, and viewport observation.
- *
- * Use this for full control when `createLink` is too opinionated.
- *
- * @example
- * function MyLink(props: LinkProps) {
- *   const link = useLink(props)
- *   return (
- *     <button ref={link.ref} class={link.classes()} onClick={link.handleClick}>
- *       {props.children}
- *     </button>
- *   )
- * }
- */
-export function useLink(props: LinkProps): UseLinkReturn {
-  const router = useRouter()
-  const elementRef = createRef<HTMLAnchorElement>()
-  const strategy = props.prefetch ?? 'hover'
-
-  function handleClick(e: MouseEvent) {
-    // Call user's onClick first — they may call e.preventDefault()
-    if (props.onClick) {
-      ;(props.onClick as (e: MouseEvent) => void)(e)
-    }
-
-    if (
-      e.defaultPrevented ||
-      e.button !== 0 ||
-      e.metaKey ||
-      e.ctrlKey ||
-      e.shiftKey ||
-      e.altKey ||
-      props.external ||
-      !props.href
-    ) {
-      return
-    }
-    e.preventDefault()
-    router.push(props.href)
-  }
-
-  function handleMouseEnter() {
-    if (strategy === 'hover') {
-      doPrefetch(props.href)
-    }
-  }
-
-  function handleTouchStart() {
-    if (strategy === 'hover' || strategy === 'viewport') {
-      doPrefetch(props.href)
-    }
-  }
-
-  if (strategy === 'viewport') {
-    useIntersectionObserver(
-      () => elementRef.current ?? undefined,
-      () => doPrefetch(props.href),
-    )
-  }
-
-  const isActive = () => {
-    const currentPath = router.currentRoute()?.path
-    if (!currentPath || !props.href) return false
-    if (props.href === '/') return currentPath === '/'
-    return currentPath.startsWith(props.href)
-  }
-
-  const isExactActive = () => {
-    const currentPath = router.currentRoute()?.path
-    if (!currentPath) return false
-    return currentPath === props.href
-  }
-
-  const classes = () => {
-    const cls: string[] = []
-    if (props.class) cls.push(props.class)
-    if (props.activeClass && isActive()) cls.push(props.activeClass)
-    if (props.exactActiveClass && isExactActive()) cls.push(props.exactActiveClass)
-    return cls.join(' ')
-  }
-
-  return {
-    ref: elementRef,
-    handleClick,
-    handleMouseEnter,
-    handleTouchStart,
-    isActive,
-    isExactActive,
-    classes,
-  }
-}
-
-/**
- * Higher-order component that wraps any component with link behavior.
- *
- * The wrapped component receives {@link LinkRenderProps} with all handlers,
- * active state, and accessibility attributes pre-wired.
- *
- * @example
- * // Custom button link
- * const ButtonLink = createLink((props) => (
- *   <button
- *     ref={props.ref}
- *     class={props.class}
- *     onClick={props.onClick}
- *     onMouseEnter={props.onMouseEnter}
- *   >
- *     {props.children}
- *   </button>
- * ))
- *
- * // Custom styled component
- * const CardLink = createLink((props) => (
- *   <div
- *     ref={props.ref}
- *     class={`card ${props.isActive() ? "card--active" : ""}`}
- *     onClick={props.onClick}
- *     onMouseEnter={props.onMouseEnter}
- *   >
- *     {props.children}
- *   </div>
- * ))
- *
- * // Usage
- * <ButtonLink href="/about">About</ButtonLink>
- * <CardLink href="/posts" prefetch="viewport">Posts</CardLink>
- */
-export function createLink(Component: (props: LinkRenderProps) => any): (props: LinkProps) => any {
-  return function WrappedLink(props: LinkProps) {
-    const link = useLink(props)
-
-    return (
-      <Component
-        href={props.href}
-        ref={link.ref}
-        onClick={link.handleClick}
-        onMouseEnter={link.handleMouseEnter}
-        onTouchStart={link.handleTouchStart}
-        isActive={link.isActive}
-        isExactActive={link.isExactActive}
-        class={link.classes}
-        {...(props.style ? { style: props.style } : {})}
-        {...(props.external ? { target: '_blank', rel: 'noopener noreferrer' } : {})}
-        {...(props['aria-label'] ? { 'aria-label': props['aria-label'] } : {})}
-        children={props.children}
-      />
-    )
-  }
-}
-
-/**
- * Default navigation link built on an `<a>` tag.
- *
- * @example
- * <Link href="/about" prefetch="viewport">About</Link>
- * <Link href="/posts" activeClass="nav-active">Posts</Link>
- */
-export const Link = createLink((props: LinkRenderProps) => (
-  <a
-    ref={props.ref}
-    href={props.href}
-    {...(props.class ? { class: props.class } : {})}
-    {...(props.style ? { style: props.style } : {})}
-    {...(props.target ? { target: props.target } : {})}
-    {...(props.rel ? { rel: props.rel } : {})}
-    {...(props['aria-label'] ? { 'aria-label': props['aria-label'] } : {})}
-    {...(props.isExactActive() ? { 'aria-current': 'page' as const } : {})}
-    onClick={props.onClick}
-    onMouseEnter={props.onMouseEnter}
-    onTouchStart={props.onTouchStart}
-  >
-    {props.children}
-  </a>
-))