@wular/pnext 0.1.4 → 0.1.5

package/src/compat/bundler/symlink-imports.ts

@@ -104,7 +104,7 @@ export function serverSymlinkImportPlugin(config: ResolvedConfig): Plugin {
           return undefined
         }
         if (await isRealPath(args.importer)) return undefined
-        const target = resolveImport(config.root, args.importer, args.path)
+        const target = resolveImport(config.root, args.importer, args.path, config.workspaceRoot)
         if (!target) return undefined
         return build.resolve(target, {
           kind: args.kind,

package/src/compat/client/errors/bare-boundary.ts

@@ -24,7 +24,7 @@ export class BareErrorBoundary extends Component<{ children?: unknown }, BareBou
     // Everything else re-throws: unmarked, so the window last resort still sees
     // a genuinely uncaught error and drives it.
     if (error === null || typeof error !== 'object') {
-      void import('./global-error').then(module => module.escalateToGlobalError(error))
+      void import('./install').then(module => module.escalateToGlobalError(error))
       return null
     }
     throw error as Error

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

@@ -198,7 +198,7 @@ export class ClientErrorBoundary extends Component<BoundaryProps, BoundaryState>
       if (error === null || typeof error !== 'object') {
         // global-error rides the deferred tier (see ./lazy) — a primitive throw
         // with no error.js is the one path that reaches it from a render.
-        void import('./global-error').then(m => m.escalateToGlobalError(error))
+        void import('./install').then(m => m.escalateToGlobalError(error))
         return null
       }
       throw error as Error

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

@@ -121,22 +121,10 @@ function renderBuiltinFallback(root: HTMLElement, error: unknown): void {
     : 'Reload to try again, or go back.'
 
   ensureThemeStyle()
-  Object.assign(root.style, {
-    fontFamily:
-      'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',
-    height: '100vh',
-    display: 'flex',
-    alignItems: 'center',
-    justifyContent: 'center',
-  } as Partial<CSSStyleDeclaration>)
-
-  const card = document.createElement('div')
-  Object.assign(card.style, {
-    marginTop: '-32px',
-    maxWidth: '325px',
-    padding: '32px 28px',
-    textAlign: 'left',
-  } as Partial<CSSStyleDeclaration>)
+  root.style.cssText =
+    'font-family:system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";height:100vh;display:flex;align-items:center;justify-content:center'
+
+  const card = styled('div', 'margin-top:-32px;max-width:325px;padding:32px 28px;text-align:left')
 
   const icon = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
   icon.setAttribute('width', '32')
@@ -152,46 +140,30 @@ function renderBuiltinFallback(root: HTMLElement, error: unknown): void {
   path.setAttribute('fill', 'var(--next-error-title)')
   icon.append(path)
 
-  const title = document.createElement('h1')
-  title.textContent = 'This page couldn’t load'
-  Object.assign(title.style, {
-    fontSize: '24px',
-    fontWeight: '500',
-    letterSpacing: '-0.02em',
-    lineHeight: '32px',
-    margin: '0 0 12px 0',
-    color: 'var(--next-error-title)',
-  } as Partial<CSSStyleDeclaration>)
-
-  const body = document.createElement('p')
-  body.textContent = message
-  Object.assign(body.style, {
-    fontSize: '14px',
-    fontWeight: '400',
-    lineHeight: '21px',
-    margin: '0 0 20px 0',
-    color: 'var(--next-error-message)',
-  } as Partial<CSSStyleDeclaration>)
-
-  const buttonGroup = document.createElement('div')
-  Object.assign(buttonGroup.style, { display: 'flex', gap: '8px', alignItems: 'center' })
-  const reloadForm = document.createElement('form')
-  reloadForm.style.margin = '0'
+  const title = styled(
+    'h1',
+    'font-size:24px;font-weight:500;letter-spacing:-0.02em;line-height:32px;margin:0 0 12px 0;color:var(--next-error-title)',
+    'This page couldn’t load',
+  )
+  const body = styled(
+    'p',
+    'font-size:14px;font-weight:400;line-height:21px;margin:0 0 20px 0;color:var(--next-error-message)',
+    message,
+  )
+
+  const buttonGroup = styled('div', 'display:flex;gap:8px;align-items:center')
+  const reloadForm = styled('form', 'margin:0')
   reloadForm.addEventListener('submit', event => {
     event.preventDefault()
     location.reload()
   })
-  const reload = document.createElement('button')
+  const reload = styled('button', buttonStyle(''), 'Reload')
   reload.type = 'submit'
-  reload.textContent = 'Reload'
-  Object.assign(reload.style, buttonStyle(false))
   reloadForm.append(reload)
   buttonGroup.append(reloadForm)
   if (!isServerError) {
-    const back = document.createElement('button')
+    const back = styled('button', buttonStyle('secondary-'), 'Back')
     back.type = 'button'
-    back.textContent = 'Back'
-    Object.assign(back.style, buttonStyle(true))
     back.addEventListener('click', () => {
       if (window.history.length > 1) window.history.back()
       else window.location.href = '/'
@@ -203,42 +175,31 @@ function renderBuiltinFallback(root: HTMLElement, error: unknown): void {
   if (isServerError) {
     // Next's DefaultGlobalError digest footer (`ERROR <digest>`), fixed to the
     // bottom so operators can correlate the redacted UI with server logs.
-    const footer = document.createElement('p')
-    footer.textContent = `ERROR ${digest}`
-    Object.assign(footer.style, {
-      position: 'fixed',
-      bottom: '32px',
-      left: '0',
-      right: '0',
-      textAlign: 'center',
-      fontFamily: 'ui-monospace,SFMono-Regular,"SF Mono",Menlo,Consolas,monospace',
-      fontSize: '12px',
-      lineHeight: '18px',
-      fontWeight: '400',
-      margin: '0',
-      color: 'var(--next-error-digest)',
-    } as Partial<CSSStyleDeclaration>)
-    root.append(footer)
+    root.append(
+      styled(
+        'p',
+        'position:fixed;bottom:32px;left:0;right:0;text-align:center;font-family:ui-monospace,SFMono-Regular,"SF Mono",Menlo,Consolas,monospace;font-size:12px;line-height:18px;font-weight:400;margin:0;color:var(--next-error-digest)',
+        `ERROR ${digest}`,
+      ),
+    )
   }
   if (typeof document.title !== 'undefined') document.title = '500: This page couldn’t load'
 }
 
-function buttonStyle(secondary: boolean): Partial<CSSStyleDeclaration> {
-  return {
-    display: 'inline-flex',
-    alignItems: 'center',
-    justifyContent: 'center',
-    height: '32px',
-    padding: '0 12px',
-    fontSize: '14px',
-    fontWeight: '500',
-    lineHeight: '20px',
-    borderRadius: '6px',
-    cursor: 'pointer',
-    color: secondary ? 'var(--next-error-btn-secondary-text)' : 'var(--next-error-btn-text)',
-    background: secondary ? 'var(--next-error-btn-secondary-bg)' : 'var(--next-error-btn-bg)',
-    border: secondary ? 'var(--next-error-btn-secondary-border)' : 'var(--next-error-btn-border)',
-  }
+// Styles go through CSSOM (style.cssText), never style attributes, so a strict style-src CSP allows them.
+function styled<K extends keyof HTMLElementTagNameMap>(
+  tag: K,
+  css: string,
+  text?: string,
+): HTMLElementTagNameMap[K] {
+  const element = document.createElement(tag)
+  element.style.cssText = css
+  if (text !== undefined) element.textContent = text
+  return element
+}
+
+function buttonStyle(variant: string): string {
+  return `display:inline-flex;align-items:center;justify-content:center;height:32px;padding:0 12px;font-size:14px;font-weight:500;line-height:20px;border-radius:6px;cursor:pointer;color:var(--next-error-btn-${variant}text);background:var(--next-error-btn-${variant}bg);border:var(--next-error-btn-${variant}border)`
 }
 
 const THEME_STYLE_ID = '__pnext_global_error_theme__'

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

@@ -42,7 +42,7 @@ export { ClientErrorBoundary, toClientError } from './error-boundary'
 export { markErrorHandled, wasErrorHandled } from './error-boundary'
 export type { RouteErrorComponent } from './error-boundary'
 export { isControlFlowError, handleControlFlowError } from './control-flow'
-export { mountGlobalError } from './global-error'
+export { escalateToGlobalError, mountGlobalError } from './global-error'
 export { softRefreshRoute } from './soft-refresh'
 
 export interface InstallOptions {

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

@@ -79,5 +79,12 @@ export function installClientErrors(installOptions: InstallOptions = {}): void {
   window.addEventListener('error', onError)
   window.addEventListener('unhandledrejection', onRejection)
 
+  // A streamed server error has already thrown: Next shows its boundary while hydrating, not on idle.
+  const pullForStreamError = () => {
+    if (document.querySelector('pnext-error')) void load()
+  }
+  pullForStreamError()
+  document.addEventListener('DOMContentLoaded', pullForStreamError)
+
   registerDeferredInstall(load)
 }

package/src/compat/client/errors/primitive-throw.ts

@@ -19,8 +19,7 @@ export interface TaggedPrimitiveThrow extends Error {
 }
 
 export function tagPrimitiveThrow(value: unknown): TaggedPrimitiveThrow {
-  const message = typeof value === 'string' ? value : String(value)
-  const error = new Error(message) as TaggedPrimitiveThrow
+  const error = new Error(String(value)) as TaggedPrimitiveThrow
   error[RAW_VALUE] = value
   return error
 }
@@ -58,6 +57,10 @@ function crashesPreactThenCheck(value: unknown): boolean {
   return value === null || value === undefined
 }
 
+function retagThrow(value: unknown): unknown {
+  return crashesPreactThenCheck(value) ? tagPrimitiveThrow(value) : value
+}
+
 /**
  * Wrap a function/class component so a thrown value that would crash preact's own `e.then` suspense
  * check is re-thrown as a tagged Error instead. Safe to call repeatedly on the same component type -
@@ -76,69 +79,49 @@ const wrapped = new WeakMap<object, unknown>()
 // unmount and remount of that subtree instead of an update.
 const ALREADY_WRAPPED = Symbol('pnext.primitiveThrowWrapped')
 
-function copyMetadata(from: object, to: object): void {
-  for (const key of Object.getOwnPropertyNames(from)) {
-    if (key === 'length' || key === 'name' || key === 'prototype') continue
-    const descriptor = Object.getOwnPropertyDescriptor(from, key)
-    if (descriptor) Object.defineProperty(to, key, descriptor)
-  }
-  for (const symbol of Object.getOwnPropertySymbols(from)) {
-    const descriptor = Object.getOwnPropertyDescriptor(from, symbol)
-    if (descriptor) Object.defineProperty(to, symbol, descriptor)
-  }
-}
-
 export function wrapComponentForPrimitiveThrows<T extends object>(type: T): T {
   if ((type as { [ALREADY_WRAPPED]?: true })[ALREADY_WRAPPED]) return type
   const cached = wrapped.get(type)
   if (cached) return cached as T
   if (typeof type !== 'function') return type
 
-  const isClassComponent = Boolean((type as { prototype?: { render?: unknown } }).prototype?.render)
-  let result: unknown
-
-  if (isClassComponent) {
-    // Class components: preact does `new Type(props, context)` then calls
-    // `.render()`. Subclass so `render()` is wrapped; static lifecycle methods
-    // (getDerivedStateFromError, etc.) and everything else pass through
-    // untouched via normal prototype-chain inheritance.
-    const Base = type as unknown as new (...args: unknown[]) => {
-      render(...args: unknown[]): unknown
-    }
-    class PrimitiveThrowSafe extends Base {
-      render(...args: unknown[]) {
+  const Base = type as unknown as new (...args: unknown[]) => {
+    render(...args: unknown[]): unknown
+  }
+  // Class components: preact does `new Type(props, context)` then calls
+  // `.render()`. Subclass so `render()` is wrapped; static lifecycle methods
+  // (getDerivedStateFromError, etc.) and everything else pass through
+  // untouched via normal prototype-chain inheritance.
+  const result: object = (type as { prototype?: { render?: unknown } }).prototype?.render
+    ? class PrimitiveThrowSafe extends Base {
+        render(...args: unknown[]) {
+          try {
+            return super.render(...args)
+          } catch (e) {
+            throw retagThrow(e)
+          }
+        }
+      }
+    : function pnextPrimitiveThrowSafe(this: unknown, ...args: unknown[]) {
         try {
-          return super.render(...args)
+          return (type as unknown as (...args: unknown[]) => unknown).apply(this, args)
         } catch (e) {
-          if (crashesPreactThenCheck(e)) throw tagPrimitiveThrow(e)
-          throw e
+          throw retagThrow(e)
         }
       }
-    }
-    Object.defineProperty(PrimitiveThrowSafe, 'name', { value: Base.name })
-    // Copy static properties AND symbol-keyed metadata (displayName, getDerivedStateFromError,
-    // contextType, defaultProps, plus the framework's own client-reference/dynamic-reference/params-
-    // scope symbol markers stashed directly on component function objects). resolveServerTree branches
-    // on those, so losing them mis-routes a client-reference class through the server-component call
-    // path instead of the island path.
-    copyMetadata(Base, PrimitiveThrowSafe)
-    result = PrimitiveThrowSafe
-  } else {
-    const fn = type as unknown as (...args: unknown[]) => unknown
-    const wrappedFn = function pnextPrimitiveThrowSafe(this: unknown, ...args: unknown[]) {
-      try {
-        return fn.apply(this, args)
-      } catch (e) {
-        if (crashesPreactThenCheck(e)) throw tagPrimitiveThrow(e)
-        throw e
-      }
-    }
-    Object.defineProperty(wrappedFn, 'name', { value: fn.name })
-    copyMetadata(fn, wrappedFn)
-    result = wrappedFn
+  Object.defineProperty(result, 'name', { value: Base.name })
+  // Copy static properties AND symbol-keyed metadata (displayName, getDerivedStateFromError,
+  // contextType, defaultProps, plus the framework's own client-reference/dynamic-reference/params-
+  // scope symbol markers stashed directly on component function objects). resolveServerTree branches
+  // on those, so losing them mis-routes a client-reference class through the server-component call
+  // path instead of the island path. ownKeys = string names, then symbols, in the same order as before.
+  for (const key of Reflect.ownKeys(Base)) {
+    if (key === 'length' || key === 'name' || key === 'prototype') continue
+    const descriptor = Object.getOwnPropertyDescriptor(Base, key)
+    if (descriptor) Object.defineProperty(result, key, descriptor)
   }
 
-  Object.defineProperty(result as object, ALREADY_WRAPPED, { value: true })
+  Object.defineProperty(result, ALREADY_WRAPPED, { value: true })
   wrapped.set(type, result)
   return result as T
 }

package/src/compat/client/segment-cache-policy.ts

@@ -5,7 +5,6 @@
 
 import type { SegmentCacheHit, SegmentCachePolicy, SegmentCacheRecord } from '../../client/router'
 import {
-  BODY_SEGMENT_PATHS,
   clearSegmentCache,
   composeFetchedLayoutFrame,
   composeCachedLayout,
@@ -20,7 +19,6 @@ import {
   recordSegment,
   resolvedRouteFor,
   segmentPrefetchCovered,
-  takeComposedSegment,
   takeSegment,
   type SegmentPayloadMeta,
 } from './segment-cache'
@@ -119,27 +117,12 @@ function take(input: {
   segmentPath: string
 }): SegmentCacheHit | null {
   const hit = takeSegment(input)
-  if (hit) {
-    return {
-      html: hit.html,
-      networkFree: hit.networkFree,
-      prefetchSatisfied: hit.prefetchSatisfied,
-      postponedShell: hit.postponedShell,
-    }
-  }
-  // w9-segment-split: the whole-document entry missed because ONE of the two
-  // frames varied. Compose the cached layout + page frames instead of going to
-  // the network for both. No-op until segment-split commit is enabled.
-  if (!BODY_SEGMENT_PATHS.includes(input.segmentPath as (typeof BODY_SEGMENT_PATHS)[number])) {
-    return null
-  }
-  const composed = takeComposedSegment({ pathname: input.pathname, search: input.search })
-  return composed
+  return hit
     ? {
-        html: composed.html,
-        networkFree: composed.networkFree,
-        prefetchSatisfied: composed.prefetchSatisfied,
-        postponedShell: composed.postponedShell,
+        html: hit.html,
+        networkFree: hit.networkFree,
+        prefetchSatisfied: hit.prefetchSatisfied,
+        postponedShell: hit.postponedShell,
       }
     : null
 }

package/src/compat/client/segment-cache.ts

@@ -300,11 +300,7 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
     // really did answer this pathname with that route, and the sibling guard
     // in `candidateKeys` reads it to keep other routes off this URL.
     resolvedRoutes.set(rawInput.pathname, rawInput.route)
-    while (resolvedRoutes.size > SEGMENT_ENTRY_LIMIT) {
-      const oldest = resolvedRoutes.keys().next().value
-      if (oldest === undefined) break
-      resolvedRoutes.delete(oldest)
-    }
+    trimOldest(resolvedRoutes)
   }
   const key = entryKey(input.segmentPath, input.route, input.params, input.search, input.vary, {
     pathname: input.pathname,
@@ -332,7 +328,7 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
     // LRU-bound like `entries`/`resolvedRoutes`: a route publishing a new vary
     // set per prefetch (dynamic params in the vary set) would otherwise grow this
     // map without limit (memory-pressure leak-slope test).
-    trimLearnedRoutes(byRoute)
+    trimOldest(byRoute)
   }
   const sharedAppShell = input.sharedAppShell === true || isRouteWideAppShell(input)
   const existing = entries.get(key)
@@ -363,7 +359,7 @@ function recordOneSegment(rawInput: SegmentRecordInput): void {
     sharedAppShell,
   })
   touch(key)
-  trim()
+  trimOldest(entries)
 }
 
 /**
@@ -620,11 +616,7 @@ export function recordDocumentLayoutFrame(input: {
     time: now(),
     staleTimeMs: input.staleTimeMs,
   })
-  while (documentLayoutFrames.size > DOCUMENT_LAYOUT_LIMIT) {
-    const oldest = documentLayoutFrames.keys().next().value
-    if (oldest === undefined) break
-    documentLayoutFrames.delete(oldest)
-  }
+  trimOldest(documentLayoutFrames, DOCUMENT_LAYOUT_LIMIT)
 }
 
 /**
@@ -968,12 +960,9 @@ function touch(key: string): void {
   entries.set(key, entry)
 }
 
-function trim(): void {
-  while (entries.size > SEGMENT_ENTRY_LIMIT) {
-    const oldest = entries.keys().next().value
-    if (oldest === undefined) return
-    entries.delete(oldest)
-  }
+// Drop insertion-order-oldest entries beyond `limit` (keys are never undefined).
+function trimOldest(map: Map<string, unknown>, limit = SEGMENT_ENTRY_LIMIT): void {
+  while (map.size > limit) map.delete(map.keys().next().value!)
 }
 
 function touchLearnedRoute(segmentPath: string, learnedKey: string): void {
@@ -984,14 +973,6 @@ function touchLearnedRoute(segmentPath: string, learnedKey: string): void {
   byRoute.set(learnedKey, learned)
 }
 
-function trimLearnedRoutes(byRoute: Map<string, LearnedRoute>): void {
-  while (byRoute.size > SEGMENT_ENTRY_LIMIT) {
-    const oldest = byRoute.keys().next().value
-    if (oldest === undefined) return
-    byRoute.delete(oldest)
-  }
-}
-
 /**
  * The route pattern the SERVER resolved `pathname` to (learned from a segment
  * or document payload), or null when this exact pathname was never answered.

package/src/compat/css/modules.ts

@@ -7,6 +7,7 @@ import { resolveImport } from '../../resolve/imports'
 import { hoistCssImports } from '../../css/build'
 import { maybeLightningcssTransform } from './lightningcss'
 import { escapeRegex } from '../../utils/code'
+import { cssModuleScopePath } from '../../utils/fs'
 
 interface ComposeRef {
   names: string[]
@@ -345,13 +346,6 @@ function cssModuleClassName(file: string, className: string) {
   return `${base}_${className}_${hash}`
 }
 
-function cssModuleScopePath(file: string) {
-  const normalized = file.split(path.sep).join('/')
-  const appIndex = normalized.lastIndexOf('/app/')
-  if (appIndex !== -1) return normalized.slice(appIndex + 1)
-  return normalized.split('/').slice(-3).join('/')
-}
-
 function rewriteClassSelector(css: string, scopedClassName: string, originalClassName: string) {
   const pattern = new RegExp(`\\.${escapeRegex(originalClassName)}(?![-_a-zA-Z0-9])`, 'g')
   return css.replace(pattern, `.${scopedClassName}`)

package/src/compat/css/sass.ts

@@ -22,6 +22,7 @@ import path from 'node:path'
 import { resolveImport } from '../../resolve/imports'
 import { nextCssSource } from './modules'
 import { escapeRegex } from '../../utils/code'
+import { cssModuleScopePath } from '../../utils/fs'
 
 // Structural typing of the slice of the Dart Sass JS API we use. Avoids a hard
 // type dependency on the optional `sass` package (mirrors how css.ts/runtime.ts
@@ -364,13 +365,6 @@ function keyframeNames(css: string): Set<string> {
   return names
 }
 
-function cssModuleScopePath(file: string): string {
-  const normalized = file.split(path.sep).join('/')
-  const appIndex = normalized.lastIndexOf('/app/')
-  if (appIndex !== -1) return normalized.slice(appIndex + 1)
-  return normalized.split('/').slice(-3).join('/')
-}
-
 function rewriteClassSelector(
   css: string,
   scopedClassName: string,

package/src/compat/react/parity.ts

@@ -3,7 +3,7 @@ import { wrapComponentForPrimitiveThrows } from '../client/errors/primitive-thro
 
 const reactForwardRefSymbol = Symbol.for('react.forward_ref')
 const react19RefCompatInstalled = Symbol.for('pnext.react19-ref-compat-installed')
-const reactTextSeparatorSymbol = Symbol.for('pnext.react-text-separator')
+const reactTextSeparatorSymbol = /* @__PURE__ */ Symbol.for('pnext.react-text-separator')
 
 type PNextPreactOptions = typeof options & {
   [react19RefCompatInstalled]?: true

package/src/compat/register/bundler.ts

@@ -35,6 +35,7 @@ import {
 } from '../../extensions'
 import {
   isEsmModuleFile,
+  findWorkspaceRoot,
   isWorkspacePackage,
   packageNameForFile,
   packageNameOfSpecifier,
@@ -593,5 +594,12 @@ function clientSourceRootPrefixes(config: ResolvedConfig): string[] {
 // First-party workspace source is implicitly transpiled. Hoisting puts the
 // package only in the workspace root's node_modules, so both roots are asked.
 function isLinkedWorkspacePackage(config: ResolvedConfig, name: string) {
-  return isWorkspacePackage(config.root, name) || isWorkspacePackage(config.workspaceRoot, name)
+  const boundary =
+    config.workspaceRoot === (findWorkspaceRoot(config.root) ?? config.root)
+      ? undefined
+      : config.workspaceRoot
+  return (
+    isWorkspacePackage(config.root, name, boundary) ||
+    isWorkspacePackage(config.workspaceRoot, name, boundary)
+  )
 }

package/src/compat/tsconfig-defaults.ts

@@ -14,7 +14,7 @@
 
 import { existsSync, readdirSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { writeFileAtomic } from '../utils/fs'
+import { includeTypes, writeFileAtomic } from '../utils/fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import type { ResolvedConfig } from '../config'
@@ -236,16 +236,13 @@ export async function writeTsconfigDefaults(config: ResolvedConfig): Promise<voi
       hasAppDir && !strictRouteTypes
         ? ['next-env.d.ts', ...nextTypes, '**/*.mts', '**/*.ts', '**/*.tsx']
         : ['next-env.d.ts', '**/*.mts', '**/*.ts', '**/*.tsx']
-    userTsConfig.include = defaultInclude
+    includeTypes(userTsConfig, [], defaultInclude)
     suggestedActions.push(
       `include was set to [${defaultInclude.map(type => `'${type}'`).join(', ')}]`,
     )
   } else if (hasAppDir && !strictRouteTypes && Array.isArray(userTsConfig.include)) {
-    for (const type of nextTypes) {
-      if (!userTsConfig.include.includes(type)) {
-        userTsConfig.include.push(type)
-        suggestedActions.push(`include was updated to add '${type}'`)
-      }
+    for (const type of includeTypes(userTsConfig, nextTypes, [])) {
+      suggestedActions.push(`include was updated to add '${type}'`)
     }
   }
 

package/src/compat-bootstrap.ts

@@ -19,6 +19,7 @@
 // compat/aliases.ts reactCompatEnabled/nextCompatEnabled.
 
 import type { ResolvedConfig } from './config'
+import type { RouteManifestEntry } from './types'
 import { onExtensionHostReset } from './extensions'
 import { installFetchHostNormalization } from './runtime/fetch-host'
 
@@ -69,3 +70,17 @@ export function bootstrapCompat(
     .then(module => module.registerCompatExtensions(config, options))
   return registration
 }
+
+/** Generate compat types without running build hooks or a typecheck. */
+export async function generateCompatRouteTypes(
+  config: ResolvedConfig,
+  routes: RouteManifestEntry[],
+): Promise<void> {
+  if (!config.compat?.next) return
+  const [{ writeTsconfigDefaults }, { generateTypedRoutes }] = await Promise.all([
+    import('./compat/tsconfig-defaults'),
+    import('./compat/typed-routes/generate'),
+  ])
+  await writeTsconfigDefaults(config)
+  await generateTypedRoutes(config, routes)
+}