@wular/pnext 0.1.4 → 0.1.6

package/config/ts/react.json

@@ -4,6 +4,7 @@
   "extends": "./base.json",
   "compilerOptions": {
     "lib": ["DOM", "DOM.Iterable", "ESNext"],
-    "jsx": "react-jsx"
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
   "type": "module",
   "bin": {

package/reference/navigation.md

@@ -92,7 +92,9 @@ Exported from `@wular/pnext/navigation/client`, for use in components marked `"u
 | `useSearchParams()`  | Read-only URL search params.                                  |
 | `useParams<Route>()` | Current route params from the initial route state.            |
 | `useRoute<Route>()`  | Pathname, route template, params, and search params together. |
-| `useLinkStatus()`    | Currently always `{ pending: false }`.                        |
+| `useLinkStatus()`    | `{ pending }` for the enclosing `<Link>`.                     |
+
+`useLinkStatus()` tracks the pending state of a `<Link>`, so call it in a component rendered inside one. `pending` turns true when the link is clicked and false once its navigation paints a loading state or the page, fails, or another navigation replaces it.
 
 Router pushes and replaces are typed like links. They soft-navigate when the path or query changes, and fall back to the History API for same-URL hash updates. Cross-origin targets become a full page load. Refreshing re-fetches the current route in place.
 

package/src/api/client-navigation.ts

@@ -1,6 +1,8 @@
+import { options } from 'preact'
 import { useEffect, useState } from 'preact/hooks'
 import { ReadonlyURLSearchParams, type HrefOptions } from './navigation'
 import { blockJavascriptUrl, prefetchRoute, softNavigate } from '../client/router'
+import { routerState } from '../client/router/hub'
 import { seedHistoryEntry } from '../client/router/history'
 import {
   emitLocationChange,
@@ -158,8 +160,31 @@ export function useRoute<Route extends RoutePath = RoutePath>(): CurrentRoute<Ro
   }
 }
 
+interface HookOptions {
+  __h?: (component: { __P?: Element }, ...rest: unknown[]) => void
+}
+
 export function useLinkStatus() {
-  return { pending: false }
+  // The router marks a link pending through its anchor, so find the Link this component renders in.
+  const hookOptions = options as HookOptions
+  const hook = hookOptions.__h
+  let parent: Element | undefined
+  hookOptions.__h = (component, ...rest) => {
+    parent = component.__P
+    hook?.(component, ...rest)
+  }
+  const [pending, setPending] = useState(false)
+  hookOptions.__h = hook
+  useEffect(() => {
+    const link = parent?.closest<HTMLAnchorElement & { __pnextHints?: Set<typeof setPending> }>(
+      'a[data-pnext-link]',
+    )
+    if (!link) return
+    const hints = (link.__pnextHints ??= new Set())
+    hints.add(setPending)
+    return () => hints.delete(setPending)
+  }, [])
+  return { pending }
 }
 
 function useLocation() {
@@ -196,11 +221,33 @@ function locationSignature(location: { pathname: string; search: string; hash: s
   return `${location.pathname}${location.search}${location.hash}`
 }
 
+// Server only: a request/context store, anchored on globalThis.
+interface ServerStore {
+  request?: { url: string }
+  params?: Record<string, RouteParamValue>
+  routeMode?: string
+}
+
+function serverStore(key: string) {
+  const storage = (globalThis as Record<symbol, { getStore(): ServerStore | undefined }>)[
+    Symbol.for(key)
+  ]
+  return storage?.getStore()
+}
+
 function currentLocation() {
   if (!process.browser && typeof window === 'undefined') {
+    const href = serverStore('pnext.requestStorage')?.request?.url
+    const url = href ? new URL(href) : undefined
     return {
-      pathname: '/',
-      search: '',
+      pathname: url?.pathname ?? '/',
+      // Like Next: dev and dynamic renders see the query; static and cached HTML must not bake it in.
+      search:
+        // eslint-disable-next-line turbo/no-undeclared-env-vars
+        process.env.NODE_ENV === 'development' ||
+        serverStore('pnext.workUnitStorage')?.routeMode === 'dynamic'
+          ? (url?.search ?? '')
+          : '',
       hash: '',
     }
   }
@@ -212,7 +259,8 @@ function currentLocation() {
 }
 
 function routeState() {
-  if (!process.browser && typeof window === 'undefined') return {}
+  if (!process.browser && typeof window === 'undefined')
+    return { params: serverStore('pnext.requestStorage')?.params } as RouteState
   const state = (history.state as Record<string, unknown> | null) ?? {}
   const routeState = window.__PNEXT_ROUTE__ ?? {}
   const bfcacheId = typeof state.__pnextBfcacheId === 'string' ? state.__pnextBfcacheId : undefined
@@ -242,6 +290,7 @@ function navigate(url: string, mode: 'push' | 'replace', scroll = true) {
   if (mode === 'replace') window.history.replaceState(history.state, '', next)
   else window.history.pushState(history.state, '', next)
   scheduleNavigationScroll(next, { scroll })
+  routerState.settleLink?.()
 }
 
 // Exported so compat's link-status can guarantee raw history.pushState /

package/src/api/link.tsx

@@ -1,7 +1,6 @@
 /** @jsxImportSource preact */
 import { h, type ComponentChildren, type JSX } from 'preact'
 import { useEffect, useRef } from 'preact/hooks'
-import type { AnchorHTMLAttributes, MouseEvent, ReactNode } from 'react'
 import { getDefaultPrefetchMode, routeHref, type SearchInput } from '../routing/href'
 import type { PrefetchMode, RouteParams, RoutePath } from '../types'
 
@@ -9,9 +8,9 @@ export interface NavigateEvent {
   preventDefault(): void
 }
 
-type LinkMouseEvent = MouseEvent<HTMLAnchorElement>
+type LinkMouseEvent = JSX.TargetedMouseEvent<HTMLAnchorElement>
 
-type BaseLinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | 'onClick'> & {
+type BaseLinkProps = Omit<JSX.IntrinsicElements['a'], 'href' | 'onClick' | 'ref'> & {
   prefetch?: PrefetchMode
   replace?: boolean
   scroll?: boolean
@@ -21,7 +20,7 @@ type BaseLinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | 'onC
   onNavigate?: (event: NavigateEvent) => void
   onPrefetchStart?: () => void
   onPrefetchFinish?: () => void
-  children?: ReactNode
+  children?: ComponentChildren
 }
 
 type ParamsProp<Route extends RoutePath> =
@@ -48,7 +47,7 @@ export function Link<Route extends RoutePath>({
   onPrefetchFinish,
   children,
   ...anchorProps
-}: LinkProps<Route>): ReactNode {
+}: LinkProps<Route>): ComponentChildren {
   const resolvedHref = routeHref(href, { params: params ?? {}, search, hash })
   // A link's own prefetch prop wins; otherwise the app-wide config default.
   const prefetchMode = prefetch ?? getDefaultPrefetchMode()
@@ -72,8 +71,8 @@ export function Link<Route extends RoutePath>({
         if (navEvent.defaultPrevented) clickEvent.preventDefault()
       },
     } as JSX.HTMLAttributes<HTMLAnchorElement>,
-    children as ComponentChildren,
-  ) as unknown as ReactNode
+    children,
+  )
 }
 
 // The prefetch runtime dispatches lifecycle events on the anchor that

package/src/cli/adapters/vercel-warm.ts

@@ -1,3 +1,4 @@
+import { resolveManifest } from '../../utils/fs'
 /**
  * Module warm-up for a production build - run in its own process.
  *
@@ -549,7 +550,11 @@ if (import.meta.main) {
   // only thing on stderr.
   const manifestFile = path.join(config.outPath, 'manifest.json')
   if (!request.skip || !existsSync(manifestFile)) process.exit(0)
-  const manifest = JSON.parse(await readFile(manifestFile, 'utf8')) as BuildManifest
+  const manifest = resolveManifest(
+    JSON.parse(await readFile(manifestFile, 'utf8')) as BuildManifest,
+    config.outPath,
+    config.root,
+  )
   await warmRouteModules(config, manifest, new Set(request.skip ?? []), mode)
   // App code reached through a route handler can leave the loop alive (a db
   // pool, a stray interval); the warm pass is done either way.

package/src/cli/adapters/vercel.ts

@@ -1012,7 +1012,7 @@ async function traceNodeModulesClosure(
         // packages - workspace source gets traced further. Bare package specifiers are also recorded
         // so the closure ships (or workspace-links) their node_modules entries; workspace packages
         // need the link even when their source is traced.
-        const resolved = resolveImport(config.root, file, specifier)
+        const resolved = resolveImport(config.root, file, specifier, config.workspaceRoot)
         if (
           resolved &&
           isInsideDir(workspaceRoot, resolved) &&

package/src/cli/build/cache.ts

@@ -1,3 +1,4 @@
+import { resolveManifest } from '../../utils/fs'
 import { createHash } from 'node:crypto'
 import { existsSync } from 'node:fs'
 import { lstat, mkdir, readFile, readdir, readlink } from 'node:fs/promises'
@@ -73,9 +74,13 @@ export async function lookupBuildCache(
     return { enabled: true, context, inputs, reason: `output (${changed || 'unknown'})` }
   }
   try {
-    const manifest = JSON.parse(
-      await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
-    ) as BuildManifest
+    const manifest = resolveManifest(
+      JSON.parse(
+        await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
+      ) as BuildManifest,
+      config.outPath,
+      config.root,
+    )
     return { enabled: true, context, inputs, manifest, reason: 'hit' }
   } catch {
     return { enabled: true, context, inputs, reason: 'manifest' }

package/src/cli/build.ts

@@ -1,3 +1,4 @@
+import { serializeBuildManifest } from '../utils/fs'
 import { copyFile, mkdir, rename, writeFile } from 'node:fs/promises'
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs'
 import { createRequire } from 'node:module'
@@ -90,6 +91,7 @@ import {
 import { interceptionMarkerLevels } from '../routing/slots'
 import { writeTypegen } from './typegen'
 import { lookupBuildCache, writeBuildCache } from './build/cache'
+import { emitServerEntry } from './serve/entry'
 import { createVerboseLogger, type VerboseLogger } from '../utils/verbose'
 import { bold, cyan, dim, green } from '../utils/ansi'
 import type {
@@ -229,15 +231,6 @@ async function runBuild(
     await ensureEmptyDir(config.outPath, [devOutSegment])
     await copyPublicDir(config.publicPath, path.join(config.outPath, 'public'))
   })
-  // Prebundled server entry for `pnext start`: framework-only, independent of the
-  // app build, so it runs in a child process for the whole build — its bundling
-  // heap never stacks on the build's peak RSS and its wall hides under the build.
-  // Best-effort — a failure only costs start time. Awaited before the summary.
-  const serverEntryDone = import('./serve/entry')
-    .then(entry => entry.emitServerEntryChild(config.outPath))
-    .catch((error: Error) => {
-      console.warn(`pnext build: server entry bundling skipped — ${error.message}`)
-    })
   // The document-level stylesheets run their postcss/Tailwind pass on the CSS
   // worker, so they overlap with the route scan below instead of serializing
   // ahead of it. Awaited before prepareRouteCssChunks — route CSS still builds
@@ -257,7 +250,7 @@ async function runBuild(
   const partytownLib = log.step('partytown lib', () => copyPartytownLib(config))
   partytownLib.catch(() => undefined)
 
-  let routes = await log.step('scan routes', () => scanRoutes(config.appPath))
+  let routes = await log.step('scan routes', () => scanRoutes(config.appPath, config.workspaceRoot))
   log.log(`found ${routes.length} route${routes.length === 1 ? '' : 's'}`)
   if (options.debugBuildPaths) {
     routes = filterDebugBuildRoutes(config.root, routes, options.debugBuildPaths)
@@ -937,7 +930,7 @@ async function runBuild(
   }
   await writeBuildManifest(config.outPath, manifest)
   log.log(`wrote manifest.json (${routes.length} route${routes.length === 1 ? '' : 's'})`)
-  await log.step('server entry', () => serverEntryDone)
+  await log.step('server entry', () => emitServerEntry(config.outPath))
   for (const hook of getBuildExtensions().completeHooks) {
     await hook({ config, manifest, log })
   }
@@ -1055,7 +1048,7 @@ async function writeBuildManifest(outPath: string, manifest: BuildManifest) {
   assertManifestServerArtifacts(outPath, manifest)
   const file = path.join(outPath, 'manifest.json')
   const temporary = path.join(outPath, `.manifest-${process.pid}.tmp`)
-  await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`)
+  await writeFile(temporary, serializeBuildManifest(manifest))
   await rename(temporary, file)
 }
 

package/src/cli/index.ts

@@ -90,14 +90,7 @@ try {
   } else if (command === 'start') {
     warnUnknownFlags(command, args)
     const root = positionalRoot(args)
-    // The build emits src/cli/start.ts prebundled into one file; parsing that
-    // instead of walking the framework's source graph is most of `start`'s
-    // spawn→first-200. Absent (no build yet, custom outDir) → source path.
-    const { prebuiltServerEntry } = await import('./serve/entry')
-    const prebuilt = prebuiltServerEntry(root)
-    const { start } = prebuilt
-      ? ((await import(prebuilt)) as typeof import('./start'))
-      : await import('./start')
+    const { start } = await import('./start')
     await start({
       root,
       port: optionNumber(args, '--port'),

package/src/cli/serve/entry.ts

@@ -1,12 +1,11 @@
 /**
- * Prebundled production server entry: `pnext build` bundles the framework's server graph into one JS
- * file (entry point IS src/cli/start.ts, so the identical `start()` runs) and `pnext start` parses
- * that instead of walking hundreds of source modules - the dominant share of spawn->first-200.
+ * Server entry for hosts that serve a build through `createRequestHandler`: a thin loader that
+ * resolves `@wular/pnext` from the output's own location (as `.next/server` loads `next`), so the
+ * output carries no framework code and no build-machine paths.
  */
-import { existsSync, readFileSync } from 'node:fs'
+import { readFileSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import type { Plugin as EsbuildPlugin } from 'esbuild'
 import { frameworkFingerprint } from '../../runtime/fingerprint'
 
 const frameworkRoot = path.resolve(import.meta.dirname, '..', '..', '..')
@@ -28,163 +27,19 @@ function frameworkVersion(): string {
  * cache-root record so a restart pays one stat per file rather than re-reading the tree.
  */
 export function serverEntryDir(outPath: string): string {
-  // Cache root spelled inline, not imported: this module is parsed before anything else on the
-  // start path, and pulling in the module cache for one path.join would drag its whole graph along.
   const generation = frameworkFingerprint(path.join(outPath, 'cache', 'server'))
   return path.join(outPath, 'server', `bundle-${frameworkVersion()}-${generation}`)
 }
 
-function serverEntryFile(outPath: string): string {
-  return path.join(serverEntryDir(outPath), 'entry.js')
-}
-
-/**
- * The prebuilt entry for a project root, or undefined when there is none to
- * use (no build, a custom `outDir`, a version or source-generation mismatch, or the opt-out). The
- * caller then falls back to importing src/cli/start.ts directly, so a miss only
- * costs speed. Deliberately cheap: one existsSync and one package.json read,
- * because it runs before anything else on the start path.
- */
-export function prebuiltServerEntry(root = process.cwd()): string | undefined {
-  // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (process.env.PNEXT_NO_SERVER_BUNDLE === '1') return undefined
-  const file = serverEntryFile(path.resolve(root, '.pnext'))
-  return existsSync(file) ? pathToFileURL(file).href : undefined
-}
-
-/**
- * Bundle src/cli/start.ts under `<outPath>/server/bundle-<version>-<fingerprint>/`. Bare
- * specifiers stay external (the framework's deps are already plain JS), so only
- * the framework's own source is inlined. Splitting is on so the graph behind a
- * dynamic import (compat, dev, build) stays in its own chunk — folding it into
- * the entry would evaluate eagerly what the source graph never even reads.
- * Returns the emitted entry, or undefined when bundling failed — the build must
- * not fail over a start-time optimization.
- */
-export async function emitServerEntry(outPath: string): Promise<string | undefined> {
-  const { build } = await import('../../utils/esbuild')
-  try {
-    await build({
-      entryPoints: [path.join(import.meta.dirname, '..', 'start.ts')],
-      outdir: serverEntryDir(outPath),
-      entryNames: 'entry',
-      chunkNames: '[name]-[hash]',
-      bundle: true,
-      splitting: true,
-      format: 'esm',
-      platform: 'node',
-      target: 'esnext',
-      sourcemap: false,
-      tsconfig: path.join(frameworkRoot, 'tsconfig.json'),
-      logLevel: 'silent',
-      // esbuild's ESM `require` shim throws for anything it did not bundle; the
-      // framework's lazy `require('esbuild' | 'oxc-*')` facades need a real one,
-      // anchored at the framework so they load ITS copy, not the app's.
-      banner: {
-        js:
-          'import { createRequire as __pnextCreateRequire } from "node:module";\n' +
-          `const require = __pnextCreateRequire(${JSON.stringify(
-            pathToFileURL(path.join(frameworkRoot, 'package.json')).href,
-          )});`,
-      },
-      plugins: [await serverEntryPlugin(outPath)],
-    })
-    return serverEntryFile(outPath)
-  } catch (error) {
-    console.warn(`pnext build: server entry bundling skipped — ${(error as Error).message}`)
-    return undefined
-  }
-}
-
-/**
- * Emit in a short-lived child process: the bundle's source strings and parse
- * allocations land in the child's heap (well under the build's own peak), not
- * on top of it. Falls back to in-process emission if the spawn fails.
- */
-export async function emitServerEntryChild(outPath: string): Promise<void> {
-  try {
-    const child = Bun.spawn([process.execPath, import.meta.filename, outPath], {
-      stdout: 'ignore',
-      stderr: 'inherit',
-    })
-    if ((await child.exited) === 0) return
-  } catch {
-    // fall through to in-process emission
-  }
-  await emitServerEntry(outPath)
-}
-
-async function serverEntryPlugin(outPath: string): Promise<EsbuildPlugin> {
-  const { rewriteFacts } = await import('../../resolve/scan-facts')
-  const { spliceSource } = await import('../../runtime/module-transform')
-  return {
-    name: 'pnext-server-entry',
-    setup(build) {
-      // Bare specifiers (and node builtins) stay out of the bundle. They must
-      // still resolve to the SAME file the framework's own source graph would
-      // reach: keep the specifier bare when the output directory resolves it
-      // identically (portable), otherwise pin the absolute path.
-      build.onResolve({ filter: /^[^./]/ }, args => {
-        if (args.path.startsWith('node:')) return { path: args.path, external: true }
-        const target = resolveFrom(args.path, frameworkRoot)
-        if (!target) return { path: args.path, external: true }
-        const fromOutput = resolveFrom(args.path, serverEntryDir(outPath))
-        return { path: fromOutput === target ? args.path : target, external: true }
-      })
-      // `import.meta` in a bundled module still means the ORIGINAL source file
-      // (the framework locates its own runtime shims that way). oxc's exact
-      // spans keep occurrences in strings and comments untouched.
-      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async args => {
-        const source = await Bun.file(args.path).text()
-        if (!source.includes('import.meta')) return undefined
-        const facts = rewriteFacts(args.path, source)
-        if (facts.unreliable) return undefined
-        const edits = facts.importMetas.flatMap(meta => {
-          const value = importMetaValue(source.slice(meta.end, meta.end + 16), args.path)
-          return value
-            ? [{ start: meta.start, end: meta.end + value.length, value: value.code }]
-            : []
-        })
-        if (edits.length === 0) return undefined
-        return { contents: spliceSource(source, edits), loader: loaderFor(args.path) }
-      })
-    },
-  }
-}
-
-const importMetaProperties = ['dirname', 'filename', 'resolve', 'url', 'dir'] as const
-
-/** The literal a bundled `import.meta.<prop>` must become, given the tail after `import.meta`. */
-function importMetaValue(tail: string, file: string): { code: string; length: number } | undefined {
-  const property = importMetaProperties.find(name => new RegExp(`^\\.${name}\\b`).test(tail))
-  if (!property) return undefined
-  const length = property.length + 1
-  const dir = path.dirname(file)
-  if (property === 'dirname' || property === 'dir') return { code: JSON.stringify(dir), length }
-  if (property === 'filename') return { code: JSON.stringify(file), length }
-  if (property === 'url') return { code: JSON.stringify(pathToFileURL(file).href), length }
-  return {
-    code: `(specifier => Bun.pathToFileURL(Bun.resolveSync(specifier, ${JSON.stringify(dir)})).href)`,
-    length,
-  }
-}
-
-function loaderFor(file: string): 'ts' | 'tsx' | 'js' | 'jsx' {
-  if (file.endsWith('.tsx')) return 'tsx'
-  if (file.endsWith('.jsx')) return 'jsx'
-  return /\.[cm]?ts$/.test(file) ? 'ts' : 'js'
-}
-
-function resolveFrom(specifier: string, dir: string): string | undefined {
-  try {
-    return Bun.resolveSync(specifier, dir)
-  } catch {
-    return undefined
-  }
-}
-
-// Child-process entry for emitServerEntryChild; last so every binding above is initialized.
-if (import.meta.main && process.argv[2]) {
-  const emitted = await emitServerEntry(process.argv[2])
-  process.exit(emitted ? 0 : 1)
+/** Write `<outPath>/server/bundle-<version>-<fingerprint>/entry.js`, re-exporting src/cli/start.ts. */
+export async function emitServerEntry(outPath: string): Promise<void> {
+  const start = await Bun.file(path.join(import.meta.dirname, '..', 'start.ts')).text()
+  const names = new Bun.Transpiler({ loader: 'ts' }).scan(start).exports
+  const dir = serverEntryDir(outPath)
+  await mkdir(dir, { recursive: true })
+  await writeFile(
+    path.join(dir, 'entry.js'),
+    `const pnext = await import(new URL('./cli/start.ts', import.meta.resolve('@wular/pnext')).href)\n` +
+      `export const { ${names.join(', ')} } = pnext\n`,
+  )
 }

package/src/cli/serve/pipeline.ts

@@ -1,3 +1,4 @@
+import { resolveManifest } from '../../utils/fs'
 /**
  * The production request pipeline. Split out of `start.ts` so the prebundled
  * server entry parses only what listening needs: this module (renderer,
@@ -99,9 +100,16 @@ export async function createRequestHandler(
   const manifestPath = path.join(config.outPath, 'manifest.json')
   // `start` reads the manifest before binding the port (a missing build must
   // still fail there, not on the first request) and hands it over.
-  const manifest =
-    options.manifest ?? (JSON.parse(await readFile(manifestPath, 'utf8')) as BuildManifest)
-  const persistManifest = () => writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+  const manifest = resolveManifest(
+    options.manifest ?? (JSON.parse(await readFile(manifestPath, 'utf8')) as BuildManifest),
+    config.outPath,
+    config.root,
+  )
+  const persistManifest = async () => {
+    const stored = JSON.parse(await readFile(manifestPath, 'utf8')) as BuildManifest
+    stored.staticFiles = manifest.staticFiles
+    await writeFile(manifestPath, `${JSON.stringify(stored, null, 2)}\n`)
+  }
   // Compat action-registry arming + serverActions.bodySizeLimit resolution +
   // fetch-cache install now run through the extension registry: the action
   // dispatch interceptor rebuilds the registry from manifest.actions on the

package/src/cli/start.ts

@@ -2,7 +2,7 @@
  * `pnext start`: the listen path only. Everything a request needs — renderer,
  * routing, server runtime — lives in `./serve/pipeline` and is imported
  * dynamically once the port is bound, so neither the listen syscall nor the
- * ready banner waits on parsing it (it is ~700 KB of the prebundled entry).
+ * ready banner waits on parsing it.
  */
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'

package/src/cli/typegen.ts

@@ -3,7 +3,8 @@ import { readFile, rm, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import type { ResolvedConfig } from '../config'
 import { loadConfig } from '../config'
-import { ensureDir, toPosixPath } from '../utils/fs'
+import { bootstrapCompatBoot, generateCompatRouteTypes } from '../compat-bootstrap'
+import { ensureDir, includeTypes, toPosixPath, writeFileAtomic } from '../utils/fs'
 import { scanRoutes } from '../routing/routes'
 import type { RouteManifestEntry } from '../types'
 
@@ -16,8 +17,11 @@ export interface TypegenResult {
 
 export async function typegenProject(root?: string): Promise<TypegenResult> {
   const config = await loadConfig(root)
-  const routes = await scanRoutes(config.appPath)
-  return writeTypegen(config, routes)
+  await bootstrapCompatBoot(config)
+  const routes = await scanRoutes(config.appPath, config.workspaceRoot)
+  const result = await writeTypegen(config, routes)
+  await generateCompatRouteTypes(config, routes)
+  return result
 }
 
 export async function writeTypegen(
@@ -28,6 +32,7 @@ export async function writeTypegen(
   const file = path.join(config.typesPath, 'pnext.gen.d.ts')
   const source = typegenSource(routes)
   await writeIfChanged(file, source)
+  await writeCoreEnv(config, file, allRoutes)
   const aliases = await writeRouteAliases(config, routes)
   const checks = await writeChecks(config, routes)
   return { file, routes: routes.length, checks, aliases }
@@ -162,3 +167,60 @@ async function writeIfChanged(file: string, source: string) {
   await ensureDir(path.dirname(file))
   await writeFile(file, source)
 }
+
+async function writeCoreEnv(
+  config: ResolvedConfig,
+  typesFile: string,
+  routes: RouteManifestEntry[],
+) {
+  if (config.compat?.next) return
+  const file = path.join(config.root, 'tsconfig.json')
+  const exists = existsSync(file)
+  if (!exists && !routes.some(route => route.sourceFiles.some(file => /\.[cm]?tsx?$/.test(file))))
+    return
+  const reference = toPosixPath(path.relative(config.root, typesFile))
+  await writeIfChanged(
+    path.join(config.root, 'pnext-env.d.ts'),
+    `/// <reference types="@wular/pnext" />\n/// <reference path="${reference}" />\n\n// This file is generated by PNext. Do not edit.\n`,
+  )
+  if (!exists) return
+  let source: string
+  let tsconfig: { include?: unknown }
+  try {
+    source = await readFile(file, 'utf8')
+    tsconfig = Bun.JSONC.parse(source) as typeof tsconfig
+  } catch {
+    return
+  }
+  if (!tsconfig || !Array.isArray(tsconfig.include)) return
+  const typesGlob = `${toPosixPath(path.relative(config.root, config.typesPath))}/**/*.ts`
+  const added = includeTypes(tsconfig, ['pnext-env.d.ts', typesGlob], [])
+  if (added.length) await writeFileAtomic(file, updateTypeSelection(source, added))
+}
+
+function updateTypeSelection(source: string, added: string[]) {
+  // Token offsets preserve comments, whitespace and escaped strings outside the edited selection.
+  const tokens = [
+    ...source.matchAll(/"(?:\\[\s\S]|[^"\\])*"|\/\/[^\r\n]*|\/\*[\s\S]*?\*\/|[^\s]/g),
+  ].filter(token => !token[0].startsWith('//') && !token[0].startsWith('/*'))
+  let depth = 0
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index]!
+    if (
+      depth === 1 &&
+      token[0].startsWith('"') &&
+      JSON.parse(token[0]) === 'include' &&
+      tokens[index + 1]?.[0] === ':'
+    ) {
+      let end = index + 3
+      while (tokens[end]?.[0] !== ']') end++
+      const close = tokens[end]!
+      const previous = tokens[end - 1]![0]
+      const insertion = `${previous === '[' || previous === ',' ? '' : ','} ${added.map(value => JSON.stringify(value)).join(', ')}`
+      return source.slice(0, close.index) + insertion + source.slice(close.index)
+    }
+    if (token[0] === '[' || token[0] === '{') depth++
+    if (token[0] === ']' || token[0] === '}') depth--
+  }
+  return source
+}