@wular/pnext 0.0.10 → 0.0.11

package/src/compat/cache-control.ts

@@ -5,162 +5,92 @@ import type { ResolvedConfig } from '../config'
 import type { ResponseFinalizer, ResponseFinalizerContext } from '../extensions'
 import { getNextConfig } from './next/config-loader'
 import { escapeRegex } from '../utils/code'
+import { canonicalUrlHref } from './next/canonical-url'
 import {
-  evaluateConditions,
-  parseConditions,
-  substitute,
-  type RewriteCondition,
-  type RewriteRequestContext,
-} from './next/rewrites'
+  appPathname,
+  loadCompatHeaders,
+  resolveCompatHeaders,
+  type CompatHeaderPair,
+  type CompatHeaderRule,
+} from './next/config-headers'
+import type { RewriteRequestContext } from './next/rewrites'
 
 const DEFAULT_EXPIRE_TIME = 31536000
 
-interface HeaderRule {
-  regex: RegExp
-  paramNames: string[]
-  headers: [string, string][]
-  has: RewriteCondition[]
-  missing: RewriteCondition[]
-}
-
-interface HeaderEntry {
-  source?: string
-  headers?: unknown
-  has?: unknown
-  missing?: unknown
-}
-
 interface RevalidateRule {
   regex: RegExp
   revalidateSeconds: number
 }
 
-interface ConfigHeader {
-  key?: unknown
-  value?: unknown
-}
-
 export function cacheControlFinalizers(config: ResolvedConfig): ResponseFinalizer[] {
   if (!nextCompatEnabled(config)) return []
 
-  let rules: Promise<HeaderRule[]> | undefined
+  let rules: Promise<CompatHeaderRule[]> | undefined
   let pagesRevalidateRules: RevalidateRule[] | undefined
   const finalizer: ResponseFinalizer = async ctx => {
-    rules ??= loadHeaderRules()
-    applyConfigHeaders(ctx, await rules)
+    rules ??= loadCompatHeaders(config.root)
+    applyConfigHeaders(ctx, await rules, config.basePath)
+    applyPoweredByHeader(ctx)
     pagesRevalidateRules ??= loadPagesRevalidateRules(config.root)
     applyDefaultIsrHeader(ctx, pagesRevalidateRules)
   }
   return [finalizer]
 }
 
-async function loadHeaderRules(): Promise<HeaderRule[]> {
-  const producer = getNextConfig().headers
-  if (typeof producer !== 'function') return []
-
-  let entries: unknown
-  try {
-    entries = await (producer as () => unknown)()
-  } catch {
-    return []
-  }
-  if (!Array.isArray(entries)) return []
-
-  const rules: HeaderRule[] = []
-  for (const entry of entries as HeaderEntry[]) {
-    if (!entry?.source || !Array.isArray(entry.headers)) continue
-    const compiled = compileHeaderSource(entry.source)
-    if (!compiled) continue
-    const has = parseConditions(entry.has)
-    const missing = parseConditions(entry.missing)
-    if (!has || !missing) continue
-    const headers = headerPairs(entry.headers)
-    if (headers.length === 0) continue
-    rules.push({ ...compiled, headers, has, missing })
-  }
-  return rules
-}
-
 /**
- * Compile a next.config `headers`/`redirects` source pattern into a pathname regex. Mirrors the
- * rewrites source compiler for `:param` tokens but, unlike it, escapes literal regex-special characters
- * in plain segments (the `.` in `/favicon.ico`, say) instead of rejecting the rule - Next's
- * path-to-regexp treats those as literals. Raw regex bodies still only appear inside `:param(...)`.
+ * Next sends `X-Powered-By: Next.js` on HTML payloads (send-payload.ts gates on the HTML content
+ * type) and omits it entirely under `poweredByHeader: false`.
  */
-function compileHeaderSource(source: string): { regex: RegExp; paramNames: string[] } | null {
-  const paramNames: string[] = []
-  const parts: string[] = []
-  for (const segment of source.split('/').filter(Boolean)) {
-    const custom = /^:([A-Za-z_$][\w$]*)\((.*)\)$/.exec(segment)
-    if (custom?.[1] !== undefined && custom[2] !== undefined) {
-      paramNames.push(custom[1])
-      parts.push(`(${custom[2]})`)
-      continue
-    }
-    const catchAll = /^:([A-Za-z_$][\w$]*)[*+]$/.exec(segment)
-    if (catchAll?.[1]) {
-      paramNames.push(catchAll[1])
-      parts.push('(.*)')
-      continue
-    }
-    const optional = /^:([A-Za-z_$][\w$]*)\?$/.exec(segment)
-    if (optional?.[1]) {
-      paramNames.push(optional[1])
-      parts.push('([^/]*)')
-      continue
-    }
-    const param = /^:([A-Za-z_$][\w$]*)$/.exec(segment)
-    if (param?.[1]) {
-      paramNames.push(param[1])
-      parts.push('([^/]+)')
-      continue
-    }
-    // Plain literal segment: escape regex-special characters so `.` etc. match
-    // literally rather than acting as regex metacharacters.
-    parts.push(segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-  }
-  return { regex: new RegExp(`^/${parts.join('/')}/?$`), paramNames }
+function applyPoweredByHeader(ctx: ResponseFinalizerContext): void {
+  if (getNextConfig().poweredByHeader === false) return
+  if (!ctx.headers.get('content-type')?.startsWith('text/html')) return
+  ctx.headers.set('x-powered-by', 'Next.js')
 }
 
-function headerPairs(headers: unknown[]): [string, string][] {
-  const pairs: [string, string][] = []
-  for (const header of headers as ConfigHeader[]) {
-    if (typeof header?.key !== 'string' || typeof header.value !== 'string') continue
-    pairs.push([header.key, header.value])
-  }
-  return pairs
-}
-
-function applyConfigHeaders(ctx: ResponseFinalizerContext, rules: readonly HeaderRule[]): void {
+function applyConfigHeaders(
+  ctx: ResponseFinalizerContext,
+  rules: readonly CompatHeaderRule[],
+  basePath: string,
+): void {
   if (rules.length === 0) return
-  const url = ctx.request.url
+  // Header routes precede rewrites (and middleware) in Next's route list, so
+  // they match the URL the browser asked for, never a rewrite destination.
+  const url = new URL(canonicalUrlHref() ?? ctx.request.url.href)
   const requestCtx: RewriteRequestContext = {
     host: url.host,
     headers: ctx.request.headers,
     cookies: parseCookieHeader(ctx.request.headers.get('cookie')),
     query: url.searchParams,
   }
+  // `basePath: false` entries match the RAW path; every other entry's source is
+  // basePath-prefixed, i.e. matches the in-app path. The two passes are disjoint.
+  const inApp = appPathname(url.pathname, basePath)
+  const matched: CompatHeaderPair[] = [
+    ...(inApp === undefined
+      ? []
+      : resolveCompatHeaders(
+          rules.filter(rule => !rule.outsideBasePath),
+          inApp,
+          requestCtx,
+        )),
+    ...resolveCompatHeaders(
+      rules.filter(rule => rule.outsideBasePath),
+      url.pathname,
+      requestCtx,
+    ),
+  ]
 
   // Config `Set-Cookie` headers must be appended (each entry is its own header,
   // never overwriting) and must precede the response's own Set-Cookie headers —
   // Next applies config headers at the router layer before the route's own
   // cookies (set-cookies suite asserts [...nextConfigHeaders, ...cookies]).
   const configSetCookies: string[] = []
-  for (const rule of rules) {
-    const match = rule.regex.exec(url.pathname)
-    if (!match) continue
-    const params: Record<string, string> = {}
-    rule.paramNames.forEach((name, index) => {
-      params[name] = match[index + 1] ?? ''
-    })
-    const conditionParams = evaluateConditions(rule, requestCtx)
-    if (conditionParams === null) continue
-    Object.assign(params, conditionParams)
-    for (const [key, value] of rule.headers) {
-      const resolved = substitute(value, params).pathname
-      if (key.toLowerCase() === 'set-cookie') configSetCookies.push(resolved)
-      else ctx.headers.set(key, resolved)
-    }
+  // A route handler's Response headers are user code running AFTER the router
+  // set these, so those keys stay the handler's (Next: res.setHeader last wins).
+  const pageOwnsHeaders = ctx.routeKind === 'route-handler'
+  for (const { key, value } of matched) {
+    if (key.toLowerCase() === 'set-cookie') configSetCookies.push(value)
+    else if (!pageOwnsHeaders || !ctx.headers.has(key)) ctx.headers.set(key, value)
   }
   if (configSetCookies.length > 0) {
     const existing =

package/src/compat/client/errors/global-error.ts

@@ -16,7 +16,12 @@ import { softNavigate } from '../../../client/router'
 
 export type GlobalErrorComponent = ComponentType<{ error: unknown; reset: () => void }>
 
-let globalErrorMounted = false
+// Mounted PER DOCUMENT, not per process: idempotence is a property of the document being
+// replaced. Identical in a browser (one document per page lifetime); differs in multi-document
+// hosts (jsdom embedders, the test process), where a process boolean wrongly suppresses mounts.
+let globalErrorMountedIn: Document | undefined
+const globalErrorMounted = () =>
+  typeof document !== 'undefined' && globalErrorMountedIn === document
 
 // The app-root global-error.js component, registered by installClientErrors so the in-tree
 // ClientErrorBoundary can escalate straight to it WITHOUT bouncing a re-throw through the window
@@ -75,15 +80,15 @@ function reportUncaught(error: Error): void {
  * top-level replacement). A soft refresh via reset() clears the flag.
  */
 export function mountGlobalError(error: unknown, component?: GlobalErrorComponent): void {
-  if (typeof document === 'undefined' || globalErrorMounted) return
-  globalErrorMounted = true
+  if (typeof document === 'undefined' || globalErrorMounted()) return
+  globalErrorMountedIn = document
 
   document.documentElement.id = '__next_error__'
   const root = document.createElement('div')
   document.body.replaceChildren(root)
 
   const reset = () => {
-    globalErrorMounted = false
+    globalErrorMountedIn = undefined
     render(null, root)
     // Re-render the current URL from the server (recovers server + client errors).
     void softNavigate(location.href, { replace: true, scroll: false }).catch(() => {
@@ -98,7 +103,7 @@ export function mountGlobalError(error: unknown, component?: GlobalErrorComponen
       render(h(component, { error, reset }), root)
       return
     } catch {
-      globalErrorMounted = true // keep mounted; render the fallback below.
+      globalErrorMountedIn = document // keep mounted; render the fallback below.
     }
   }
 

package/src/compat/client/errors/install.ts

@@ -13,8 +13,12 @@
 //   1. CONTROL-FLOW errors that escape - driven to their navigation outcome, never shown.
 //   2. ACTION errors - left to the action-error overlay, ignored here.
 //   3. Errors ALREADY HANDLED by a boundary - ignored, so one failure is never rendered twice.
-//   4. Anything else - a genuinely UNCAUGHT client error with no route error.js - escapes the root and
-//      the global-error UI replaces the document.
+//   4. UNCAUGHT RENDER escapes (tagged at the preact boundary walk, see ./lazy) - the root render
+//      failed, so global-error replaces the document, exactly Next's root boundary.
+//   5. Anything else - event-handler throws, third-party script noise, benign browser error events
+//      (ResizeObserver loops report with `error: null`) - stays uncaught and the page SURVIVES.
+//      Next mounts global-error only from its root render boundary, never from window events
+//      (its only production window listeners drive redirect control flow).
 //
 // Client-escaped errors carry NO digest, matching Next.
 
@@ -60,6 +64,24 @@ export interface InstallOptions {
 
 let installed = false
 
+// Cross-chunk marker (./lazy tags before this chunk exists): a value the preact boundary walk
+// rethrew is a ROOT RENDER failure, the one case the window channel mounts global-error for.
+const RENDER_ESCAPE = Symbol.for('pnext.renderEscape')
+
+export function tagRenderEscape(error: unknown): void {
+  if (error !== null && typeof error === 'object') {
+    try {
+      ;(error as Record<symbol, unknown>)[RENDER_ESCAPE] = true
+    } catch {
+      // frozen throw value: the post-install escalation still mounts synchronously
+    }
+  }
+}
+
+function isRenderEscape(error: unknown): boolean {
+  return error !== null && typeof error === 'object' && RENDER_ESCAPE in error
+}
+
 // Set by installClientErrors so ./lazy can replay the errors that escaped
 // before this chunk landed (a throw during hydration or in a first-paint
 // effect) through exactly the same triage.
@@ -92,10 +114,11 @@ export function installClientErrors(options: InstallOptions = {}): void {
     // Action errors belong to the action-error overlay.
     if (isActionError?.(error)) return
 
-    // A genuinely uncaught client error with no route error.js to catch it —
-    // the global-error last resort replaces the document. Pass the raw value so
-    // a non-Error throw renders unwrapped in global-error.js (`${error}`).
-    mountGlobalError(error, globalErrorComponent)
+    // Only a RENDER escape (the preact boundary walk rethrew it — tagged in ./lazy before this
+    // chunk exists, escalated synchronously after install) replaces the document: that is Next's
+    // root render boundary. Every other uncaught value — event handlers, third-party scripts,
+    // browser noise — stays uncaught and the page survives, as it does under Next.
+    if (isRenderEscape(error)) mountGlobalError(error, globalErrorComponent)
   }
   escapedErrorHandler = onError
 
@@ -143,6 +166,7 @@ function installRenderEscapeEscalation(
       // have an owner — only a genuinely uncaught error escapes to global-error.
       // escalate (not mount): the error must also report as uncaught in THIS
       // task, not a task later via the natural unhandled rejection.
+      tagRenderEscape(error)
       if (!wasErrorHandled(error) && !isControlFlowError(error) && !isActionError?.(error)) {
         escalateToGlobalError(error)
       }

package/src/compat/client/errors/lazy.ts

@@ -6,13 +6,43 @@
 // a first-paint effect fires long before the idle tier lands, and Next still shows global-error for
 // it. They buffer the value, pull ./install right away, and hand it over - so a healthy page still
 // never fetches the chunk.
+import { options } from 'preact'
 import { registerDeferredInstall } from '../../../client/router'
 import type { InstallOptions } from './install'
 
+// Same key ./install reads (Symbol.for crosses the chunk boundary): only values the preact
+// boundary walk rethrew — a ROOT RENDER failure, Next's global-error case — may replace the
+// document. Every other uncaught window value (event handlers, third-party noise, ResizeObserver
+// loop events) is buffered for triage but the page survives, as it does under Next.
+const RENDER_ESCAPE = Symbol.for('pnext.renderEscape')
+
+/** Tag boundary-walk escapes before the deferred runtime exists (a hydration throw fires first). */
+function tagRenderEscapes(): void {
+  const hooks = options as unknown as Record<string, unknown>
+  const key = (['_catchError', '__e'] as const).find(name => typeof hooks[name] === 'function')
+  if (!key) return
+  const walkBoundaries = hooks[key] as (...args: unknown[]) => unknown
+  hooks[key] = function taggedCatchError(this: unknown, ...args: unknown[]) {
+    try {
+      return walkBoundaries.apply(this, args)
+    } catch (error) {
+      if (error !== null && typeof error === 'object') {
+        try {
+          ;(error as Record<symbol, unknown>)[RENDER_ESCAPE] = true
+        } catch {
+          // frozen throw value: the runtime's own escalation still mounts post-install
+        }
+      }
+      throw error
+    }
+  }
+}
+
 type ErrorRuntime = typeof import('./install')
 
-export function installClientErrors(options: InstallOptions = {}): void {
+export function installClientErrors(installOptions: InstallOptions = {}): void {
   if (!process.browser && typeof window === 'undefined') return
+  tagRenderEscapes()
 
   let runtime: Promise<ErrorRuntime> | undefined
   const load = () =>
@@ -21,7 +51,7 @@ export function installClientErrors(options: InstallOptions = {}): void {
       // error is triaged once rather than by both paths.
       window.removeEventListener('error', onError)
       window.removeEventListener('unhandledrejection', onRejection)
-      module.installClientErrors(options)
+      module.installClientErrors(installOptions)
       return module
     }))
 

package/src/compat/next/client-script.tsx

@@ -1,3 +1,4 @@
+/** @jsxImportSource preact */
 import type { JSX } from 'preact'
 import { useEffect } from 'preact/compat'
 import { registerResourceHint } from '../../render/resource-hints'

package/src/compat/next/config-headers.ts

@@ -0,0 +1,139 @@
+/**
+ * next.config `headers()` support (Next compat): every rule whose `source` matches the as-requested
+ * pathname contributes its `headers` to the response. Shares the source/condition/substitution
+ * machinery with rewrites and redirects (`:param`, `:param*`/`+`/`?`, `:param(regex)`, bare `(regex)`,
+ * has/missing of type host/header/query/cookie, `basePath: false`).
+ *
+ * Unlike redirects/rewrites, matching does NOT stop at the first hit: Next walks the whole header route
+ * list and accumulates, so a later rule overwrites an earlier one per key while `set-cookie` appends.
+ * Key AND value take `:param` substitution (Next's compileNonPath).
+ *
+ * The rules are applied by the cache-control finalizer (compat/cache-control.ts), which owns the
+ * response seam headers share with the ISR Cache-Control defaults - config headers land first, exactly
+ * as Next's router sets them on `res` before the render runs.
+ */
+import { loadNextConfig, loadResolvedNextConfig } from '../actions/config'
+import {
+  compileSource,
+  evaluateConditions,
+  parseConditions,
+  substitute,
+  type RewriteCondition,
+  type RewriteRequestContext,
+} from './rewrites'
+
+export interface CompatHeaderPair {
+  key: string
+  value: string
+}
+
+export interface CompatHeaderRule {
+  regex: RegExp
+  paramNames: string[]
+  headers: CompatHeaderPair[]
+  has: RewriteCondition[]
+  missing: RewriteCondition[]
+  /** `basePath: false`: the source matches the RAW path, outside the basePath. */
+  outsideBasePath: boolean
+}
+
+interface HeaderEntry {
+  source?: string
+  headers?: unknown
+  has?: unknown
+  missing?: unknown
+  basePath?: unknown
+}
+
+export async function loadCompatHeaders(root: string): Promise<CompatHeaderRule[]> {
+  let config = await loadResolvedNextConfig(root)
+  if (typeof config?.headers !== 'function') config = await loadNextConfig(root)
+  const producer = config?.headers
+  if (typeof producer !== 'function') return []
+  let value: unknown
+  try {
+    value = await producer()
+  } catch {
+    return []
+  }
+  if (!Array.isArray(value)) return []
+
+  const rules: CompatHeaderRule[] = []
+  for (const entry of value as HeaderEntry[]) {
+    if (!entry?.source || !Array.isArray(entry.headers)) continue
+    const headers = parseHeaderPairs(entry.headers)
+    if (headers.length === 0) continue
+    const has = parseConditions(entry.has)
+    const missing = parseConditions(entry.missing)
+    if (has === null || missing === null) continue // unsupported condition shape
+    const compiled = compileSource(entry.source)
+    if (!compiled) continue
+    rules.push({
+      ...compiled,
+      headers,
+      has,
+      missing,
+      outsideBasePath: entry.basePath === false,
+    })
+  }
+  return rules
+}
+
+function parseHeaderPairs(value: readonly unknown[]): CompatHeaderPair[] {
+  const pairs: CompatHeaderPair[] = []
+  for (const raw of value) {
+    if (!raw || typeof raw !== 'object') continue
+    const { key, value: headerValue } = raw as Record<string, unknown>
+    if (typeof key !== 'string' || typeof headerValue !== 'string') continue
+    pairs.push({ key, value: headerValue })
+  }
+  return pairs
+}
+
+/** Every matching rule's headers, in rule order (the caller resolves per-key precedence). */
+export function resolveCompatHeaders(
+  rules: readonly CompatHeaderRule[],
+  pathname: string,
+  ctx?: RewriteRequestContext,
+): CompatHeaderPair[] {
+  const context: RewriteRequestContext = ctx ?? {
+    host: '',
+    headers: new Headers(),
+    cookies: {},
+    query: new URLSearchParams(),
+  }
+  const resolved: CompatHeaderPair[] = []
+  for (const rule of rules) {
+    const match = rule.regex.exec(pathname)
+    if (!match) continue
+
+    const params: Record<string, string> = {}
+    rule.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? ''
+    })
+
+    const conditionParams = evaluateConditions(rule, context)
+    if (conditionParams === null) continue // has/missing gate failed
+    Object.assign(params, conditionParams)
+
+    const hasParams = Object.keys(params).length > 0
+    for (const pair of rule.headers) {
+      resolved.push(
+        hasParams
+          ? {
+              key: substitute(pair.key, params).pathname,
+              value: substitute(pair.value, params).pathname,
+            }
+          : pair,
+      )
+    }
+  }
+  return resolved
+}
+
+/** The in-app path for a raw request pathname, or undefined when it lies outside the basePath. */
+export function appPathname(pathname: string, basePath: string): string | undefined {
+  if (!basePath) return pathname
+  if (pathname === basePath) return '/'
+  return pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) : undefined
+}

package/src/compat/next/config-loader.ts

@@ -393,27 +393,54 @@ const VALID_DEV_INDICATOR_POSITIONS = new Set([
 
 const KNOWN_TOP_LEVEL_CONFIG_KEYS = new Set([
   'adapterPath',
+  'agentRules',
+  'allowedDevOrigins',
   'assetPrefix',
   'basePath',
+  'bundlePagesRouterDependencies',
   'cacheComponents',
   'cacheHandler',
   'cacheHandlers',
   'cacheLife',
+  'cacheMaxMemorySize',
+  'cleanDistDir',
   'compiler',
+  'compress',
+  'configFile',
+  'configFileName',
+  'configOrigin',
+  'crossOrigin',
+  'deploymentId',
   'devIndicators',
   'distDir',
+  'enablePrerenderSourceMaps',
   'env',
+  'excludeDefaultMomentLocales',
   'expireTime',
   'experimental',
+  'exportPathMap',
+  'generateBuildId',
+  'generateEtags',
+  'headers',
+  'htmlLimitedBots',
+  'httpAgentOptions',
   'images',
+  'logging',
+  'modularizeImports',
+  'onDemandEntries',
   'output',
+  'outputFileTracingExcludes',
+  'outputFileTracingIncludes',
   'outputFileTracingRoot',
   'pageExtensions',
   'partialPrefetching',
+  'poweredByHeader',
   'productionBrowserSourceMaps',
   'publicRuntimeConfig',
   'reactCompiler',
   'reactMaxHeadersLength',
+  'reactProductionProfiling',
+  'reactStrictMode',
   'resolveExtensions',
   'redirects',
   'rewrites',
@@ -422,6 +449,7 @@ const KNOWN_TOP_LEVEL_CONFIG_KEYS = new Set([
   'serverRuntimeConfig',
   'skipProxyUrlNormalize',
   'skipTrailingSlashRedirect',
+  'staticPageGenerationTimeout',
   'i18n',
   'instrumentationClientInject',
   'trailingSlash',
@@ -430,6 +458,8 @@ const KNOWN_TOP_LEVEL_CONFIG_KEYS = new Set([
   'turbopack',
   'typedRoutes',
   'typescript',
+  'useFileSystemPublicRoutes',
+  'watchOptions',
   'webpack',
 ])
 
@@ -523,12 +553,12 @@ function warnWebpackCompat(config: NextConfigObject, configFileName: string): vo
   console.warn(
     `\`webpack\` in ${configFileName} is not executed by pnext — esbuild is the only bundler. ` +
       '`transpilePackages`, `experimental.optimizePackageImports`, and `turbopack.resolveAlias` are ' +
-      'supported natively; see reference/compat.md.',
+      'supported natively; see https://pnext.dev/docs/compat.',
   )
   if (webpackReferencesSvgr(config)) {
     console.info(
       'pnext detected @svgr/webpack in `webpack()` and will compile `.svg` imports to inline Preact ' +
-        'components instead (see reference/compat.md).',
+        'components instead (see https://pnext.dev/docs/compat).',
     )
   }
 }

package/src/compat/next/dynamic.tsx

@@ -1,3 +1,4 @@
+/** @jsxImportSource preact */
 import { h, type ComponentType } from 'preact'
 import { lazy, Suspense } from 'preact/compat'
 import {

package/src/compat/next/error.tsx

@@ -1,4 +1,5 @@
 'use client'
+/** @jsxImportSource preact */
 
 import { Component, Fragment, h, type ComponentChildren, type ComponentType } from 'preact'
 import { isControlFlowError } from '../client/errors/control-flow'

package/src/compat/next/form.tsx

@@ -1,4 +1,5 @@
 'use client'
+/** @jsxImportSource preact */
 
 import { useEffect, useRef, type JSX, type ReactNode } from 'preact/compat'
 import { prefetchRoute, softNavigate } from '../../client/router'

package/src/compat/next/head.tsx

@@ -1,3 +1,4 @@
+/** @jsxImportSource preact */
 import type { ComponentChildren } from 'preact'
 
 /**