@wular/pnext 0.0.20 → 0.0.22

package/src/client/entry.ts

@@ -139,6 +139,142 @@ function islandVNodeExpr(
     : `h(${componentExpr}, ${propsExpr}, ${childrenExpr})`
 }
 
+/**
+ * A streamed Suspense hole is the one region a live island stops owning: `$RC` replaces the hole's
+ * children wholesale before the graft's materialize pass turns the arriving island markers into
+ * hosts. Rendering the hole through this component leaves a seam that pass can re-adopt through -
+ * INSIDE the parent island's tree, so the new islands keep the parent's whole context chain. Mounting
+ * such a host as its own preact root instead severs it from every provider the parent renders.
+ */
+function holeSeamSource() {
+  return `
+class PnextHole extends Component {
+  componentDidMount() {
+    if (this.base) this.base.__pnextHole = this;
+  }
+  componentWillUnmount() {
+    if (this.base && this.base.__pnextHole === this) this.base.__pnextHole = undefined;
+  }
+  componentWillReceiveProps(next) {
+    // A soft navigation re-adopts the parent from the incoming document's DOM;
+    // the previous document's grafted content must not outlive its children.
+    if (next.children !== this.props.children) this.setState({ adopted: undefined });
+  }
+  render(props, state) {
+    return h('pnext-hole', props.attrs, state.adopted !== undefined ? state.adopted : props.children);
+  }
+}
+`
+}
+
+/**
+ * The late-host half of the seam. `adoptHoleSeam` re-renders one hole through its live parent;
+ * `claimNestedIslandRoot` is what the island scan calls instead of mounting a nested host.
+ */
+function lateIslandClaimSource() {
+  return `
+// The graft ($RC) swapped this hole's DOM wholesale, so re-adopting ALL of it is total: nothing in
+// the hole is still preact-owned. The re-render lands inside the parent island's tree, which is what
+// makes the new islands inherit its context.
+// Detaching an element costs it every piece of state the browser keeps outside the DOM - a lazy
+// image's deferred load observation, an iframe's document, playing media, focus - and re-inserting
+// it does not bring any of that back. moveBefore is the state-preserving move (Chrome 133+); it
+// needs both ends connected and refuses some moves outright, so a plain insert stays the fallback.
+function movePnextNode(parent, node) {
+  if (parent.moveBefore && parent.isConnected && node.isConnected) {
+    try {
+      parent.moveBefore(node, null);
+      return;
+    } catch (error) {}
+  }
+  parent.append(node);
+}
+
+// A subtree rebuilt from adopted vnodes is made of freshly created elements, and a graft can bring
+// in ones the browser had already deferred. Either way a lazy image can end up in the document with
+// no live intersection observation - no request ever fires, and it stays blank forever. Re-running
+// its source selection re-arms it WITHOUT giving up laziness; one already loading (currentSrc set)
+// or already loaded is left alone, so this never forces a fetch or duplicates one.
+// Drop the capture holder, moving its nodes into \`into\` first when the adoption cannot use them.
+function releaseHoleCapture(hole, into) {
+  const captured = hole.__pnextCaptured;
+  if (!captured) return;
+  hole.__pnextCaptured = undefined;
+  if (into) for (const node of [...captured.childNodes]) movePnextNode(into, node);
+  captured.remove();
+}
+
+function rekickLazyLoadables(root) {
+  for (const img of root.querySelectorAll('img[loading=lazy]')) {
+    if (img.complete || img.currentSrc) continue;
+    for (const name of ['src', 'srcset']) {
+      const value = img.getAttribute(name);
+      if (value === null) continue;
+      img.removeAttribute(name);
+      img.setAttribute(name, value);
+    }
+  }
+}
+
+async function adoptHoleSeam(hole) {
+  const pending = hole.__pnextAdopting;
+  if (pending) return pending;
+  const seam = hole.__pnextHole;
+  // No seam ever appeared: put the captured nodes back rather than losing them.
+  if (!seam) return releaseHoleCapture(hole, hole);
+  const adopting = (async () => {
+    const captured = hole.__pnextCaptured;
+    const children = await domChildren(captured ?? hole);
+    // Preact rebuilds the subtree from the adopted vnodes, so the server nodes they were read from
+    // would survive as unowned duplicates. Clearing and re-rendering within one task keeps the swap
+    // inside a single frame - preact's rerender is a microtask, so no paint sees the empty hole.
+    releaseHoleCapture(hole);
+    hole.replaceChildren();
+    seam.setState({ adopted: children ?? null }, () => rekickLazyLoadables(hole));
+  })();
+  hole.__pnextAdopting = adopting;
+  try {
+    await adopting;
+  } finally {
+    if (hole.__pnextAdopting === adopting) hole.__pnextAdopting = undefined;
+  }
+}
+
+// A nested host belongs to its parent island's DOM adoption pass, never to a mount of its own. Wait
+// out an adoption already in flight (its walk may still reach this host), and claim only what the
+// parent can no longer see - a host the graft materialized after the parent went live - through the
+// hole seam that owns the grafted DOM. A host under a parent that has not mounted yet stays put.
+async function claimNestedIslandRoot(root, parent) {
+  // The innermost hole whose seam is live owns this host. A nearer hole with no seam is raw grafted
+  // DOM inside an outer seam's region, so that outer one is the tree to re-adopt through.
+  let hole;
+  for (let node = root.parentElement; node && node !== parent; node = node.parentElement) {
+    if (node.localName !== 'pnext-hole') continue;
+    if (node.__pnextHole) { hole = node; break; }
+    hole ??= node;
+  }
+  // The parent is mid-adoption and has no seam here yet: its walk may already have snapshotted this
+  // hole's fallback, and its hydration then drops the DOM the graft just landed. Park the grafted
+  // nodes synchronously - ahead of that render - and adopt them from the holder once the tree is
+  // live. A walk that had NOT reached the hole yet simply adopts an empty one and gets the same
+  // content back through the seam. The holder is a hidden ELEMENT rather than a fragment: a
+  // disconnected parent is exactly what strips browser state, and moveBefore refuses one.
+  if (hole && !hole.__pnextHole && !hole.__pnextCaptured && parent.__pnextMounting) {
+    const holder = document.createElement('pnext-hole-capture');
+    holder.hidden = true;
+    document.body.append(holder);
+    hole.__pnextCaptured = holder;
+    for (const node of [...hole.childNodes]) movePnextNode(holder, node);
+  }
+  // A parent whose module failed still settles: the claim has to release its capture rather than
+  // leave the grafted nodes parked in a holder nobody will ever adopt from.
+  await parent.__pnextMounting?.catch(() => {});
+  if (!hole || (!hole.__pnextCaptured && !root.isConnected)) return;
+  return adoptHoleSeam(hole);
+}
+`
+}
+
 // Two mount passes can reach the same island root concurrently - mountRoute and the streamed-Suspense
 // re-scan both walk the document, and their "already live" guard runs BEFORE mountIsland awaits the
 // component module. Without a synchronous claim both passes mount: the first tree is orphaned over the
@@ -517,15 +653,21 @@ function keepsMountedRoot(root, keep) {
 // The per-route half of the lifecycle, closing over the route's own mount
 // state. mountRoute runs the steps the route actually has: an island scan, the
 // client-shell hydration, the client page.
-function routeLifecycleSource({ nextCompat, islands, page, shell }: ClientRuntimeFacts) {
+function routeLifecycleSource({ nextCompat, islands, page, shell, dev }: ClientRuntimeFacts) {
   const gate = nextCompat
     ? '  pnextGate(markRouteHydrated, pnextIslandMounts, pnextVisibleMount);\n'
     : ''
+  const islandMounts = dev
+    ? `pnextIslandScan.done.then(() => {
+      diagnoseSkippedIslands();
+      return pnextIslandScan.mounted;
+    })`
+    : 'pnextIslandScan.done.then(() => pnextIslandScan.mounted)'
   const mountBody = [
     islands
       ? `  if (islands.length > 0) {
     pnextIslandScan = scanIslands();
-    pnextIslandMounts = pnextIslandScan.done.then(() => pnextIslandScan.mounted);
+    pnextIslandMounts = ${islandMounts};
   }`
       : '',
     shell ? '  if (shell) pnextVisibleMount = hydrateClientShell();' : '',
@@ -655,6 +797,8 @@ ${overlay}installClientErrors({ errorComponent: ${
  * ships only when some route in the app can actually use it.
  */
 export interface ClientRuntimeFacts {
+  /** Development-only diagnostics; omitted entirely from production bundles. */
+  dev?: boolean
   nextCompat?: boolean
   /** Any route mounts islands (island scan, revival, static children). */
   islands?: boolean
@@ -710,7 +854,7 @@ export function clientRuntimeSource(facts: ClientRuntimeFacts) {
   // it revives island DOM exactly like an island mount does.
   const revival = Boolean(facts.islands || shell)
   return `
-import { h, hydrate, render } from 'preact';
+import { ${revival ? 'Component, ' : ''}h, hydrate, render } from 'preact';
 ${nextCompat ? "import { options as __pnextPreactOptions } from 'preact';" : ''}
 ${deferredIslands ? "import { useEffect, useState } from 'preact/hooks';" : ''}
 ${suspense ? "import { Suspense } from 'preact/compat';" : ''}
@@ -1137,6 +1281,10 @@ function domProps(element) {
   return props;
 }
 
+// A nested root belongs to its parent island's DOM adoption pass, never to a
+// mount of its own. This entry carries no streamed-hole seam (see the shared
+// runtime): its whole point is a preact-free first paint, and a host grafted in
+// after a visible island mounted would be dead weight in every bundle.
 function isNestedIslandRoot(root) {
   return root.parentElement?.closest('pnext-client') != null;
 }
@@ -1343,9 +1491,39 @@ function clientBoundaryHelperSource(nextCompat?: boolean, suspense?: boolean) {
 `
 }
 
-function hydrateIslandsSource({ nextCompat, visibleIslands, deferredIslands }: ClientRuntimeFacts) {
+function hydrateIslandsSource({
+  nextCompat,
+  visibleIslands,
+  deferredIslands,
+  dev,
+}: ClientRuntimeFacts) {
+  const diagnostic = dev
+    ? `
+function diagnoseSkippedIslands() {
+  for (const root of document.querySelectorAll('pnext-client[data-pnext-client]')) {
+    if (root.__pnextLive) continue;
+    const id = root.getAttribute('data-pnext-client');
+    const island = id ? islandById.get(id) : undefined;
+    const parent = nestedIslandParent(root);
+    // A visible island is deliberately inert until intersection. A nested
+    // island whose parent is still pending is likewise owned by that parent's
+    // adoption pass, one parked in a capture holder is mid-adoption, and one the
+    // claim pass adopted is no longer in the document. Everything else is a host
+    // this route can never hydrate.
+    if (island?.options?.load === 'visible') continue;
+    if (root.closest('pnext-hole-capture')) continue;
+    if (parent && !parent.__pnextLive) continue;
+    const reason = island
+      ? 'was materialized after its parent island mounted, outside any streamed hole this route can re-adopt'
+      : 'has no entry in the client island manifest';
+    console.warn('pnext: client island ' + (id ?? '<missing id>') + ' ' + reason);
+  }
+}
+`
+    : ''
   return `
 const islandById = new Map(islands.map(island => [island.id, island]));
+${lateIslandClaimSource()}${diagnostic}
 
 // The mounted count is known as soon as the scan loop finishes, before any
 // island module resolves — so the client shell can decide whether it owns the
@@ -1364,7 +1542,11 @@ for (const island of islands) {
   }
 for (const island of islands) {
   for (const root of document.querySelectorAll(\`[data-pnext-client="\${island.id}"]\`)) {
-    if (isNestedIslandRoot(root)) continue;
+    const parent = nestedIslandParent(root);
+    if (parent) {
+      pending.push(claimNestedIslandRoot(root, parent));
+      continue;
+    }
     // Already mounted (e.g. a re-scan after a streamed Suspense hole materialized new islands):
     // mount() stamps __pnextLive, so skipping these leaves the shell's live islands untouched. A root
     // preserved across a soft navigation is ALSO live, but carries the incoming placeholder (fresh SSR
@@ -1476,6 +1658,10 @@ async function domNode(node) {
 
   const element = node;
   if (element.localName === ${JSON.stringify(ISLAND_BOUNDARY_ERROR_ELEMENT)}) return pnextBoundaryErrorVNode(element);
+  // The seam a late streamed graft re-adopts through (see holeSeamSource).
+  if (element.localName === 'pnext-hole') {
+    return h(PnextHole, { attrs: domProps(element) }, await domChildren(element));
+  }
   if (element.localName === 'pnext-client') {
     const id = element.getAttribute('data-pnext-client');
     const island = id ? islandById.get(id) : undefined;
@@ -1522,12 +1708,15 @@ function domProps(element) {
   return props;
 }
 
-function isNestedIslandRoot(root) {
-  return root.parentElement?.closest('pnext-client') != null;
+// The island host that owns this root's DOM, if any. A nested root is never
+// mounted here: the parent adopts it, or claimNestedIslandRoot routes it through
+// the parent's hole seam.
+function nestedIslandParent(root) {
+  return root.parentElement?.closest('pnext-client');
 }
-${
-  visibleIslands
-    ? `
+${holeSeamSource()}${
+    visibleIslands
+      ? `
 function visibleTarget(root) {
   // The host's OWN box: hostMeasureSource delegates the patched one to the
   // parent, and IntersectionObserver never fires for a display:contents target.
@@ -1536,8 +1725,8 @@ function visibleTarget(root) {
   return root.parentElement ?? root;
 }
 `
-    : ''
-}${mountOnceSource()}${
+      : ''
+  }${mountOnceSource()}${
     deferredIslands
       ? `
 function DeferredIsland({ load, props, children }) {

package/src/client/router/runtime.ts

@@ -4810,9 +4810,11 @@ export async function softNavigate(href: string, options: SoftNavigateOptions =
   // Same-entry-identity navigation (a search-param nav on the same pathname, a refresh):
   // `key={bfcacheId}` subtrees do NOT remount, so typed values must survive. The commit can
   // still rebuild the page DOM under them (a PPR route streams its page slot in AFTER the
-  // swap), so re-apply the departure snapshot as the controls appear.
+  // swap), so re-apply the departure snapshot as the controls appear - but only to the DOM
+  // this swap replaced, never to a control a live island's own render owns (see
+  // islandOwnedControl).
   else if (departingBfcacheId && departingBfcacheId === historyBfcacheId()) {
-    restoreFormStateWhenMounted(departingBfcacheId, sequence)
+    restoreFormStateWhenMounted(departingBfcacheId, sequence, true)
   }
 
   // A navigation that only changed parallel slots (same children path AND unchanged search
@@ -4907,13 +4909,25 @@ function restoreControl(
   if (control.value !== saved.value) control.value = saved.value
 }
 
-function restoreFormState(bfcacheId: string | undefined, onlyEmpty = false) {
+/**
+ * A control inside a mounted island is owned by that island's preact diff, which reproduces
+ * React's reconciliation - including an app key (`key={searchParams.get('q')}`) that
+ * deliberately remounts the subtree with an EMPTY control. Re-applying the departure snapshot
+ * there fights the app; only DOM the raw swap replaced is pnext's own loss to compensate.
+ */
+function islandOwnedControl(control: Element): boolean {
+  const root: LiveIslandRoot | null = control.closest('pnext-client[data-pnext-client]')
+  return Boolean(root?.__pnextLive)
+}
+
+function restoreFormState(bfcacheId: string | undefined, onlyEmpty = false, skipIslands = false) {
   if (!bfcacheId) return
   const state = entryFormStateCache.get(bfcacheId)
   if (!state) return
   const controls = formControls()
   if (controls.length !== state.length) return
   for (const [index, control] of controls.entries()) {
+    if (skipIslands && islandOwnedControl(control)) continue
     // `onlyEmpty`: a freshly mounted control is empty, so filling it restores
     // what the remount lost — while anything already carrying a value (the app
     // set it, or the user typed after the commit) is left alone.
@@ -4951,10 +4965,10 @@ function restoreSharedLayoutFormState(
  * describes can appear after the swap. Keep trying while the DOM changes until the control
  * set matches the snapshot.
  */
-function restoreFormStateWhenMounted(bfcacheId: string, sequence: number): void {
+function restoreFormStateWhenMounted(bfcacheId: string, sequence: number, skipIslands = false) {
   const state = entryFormStateCache.get(bfcacheId)
   if (!state) return
-  restoreFormState(bfcacheId, true)
+  restoreFormState(bfcacheId, true, skipIslands)
   // The controls can be rebuilt more than once while the commit settles, so the restore stays
   // armed for a short window instead of firing once. It only ever fills EMPTY controls, so a
   // value the app or the user set after the commit is never clobbered.
@@ -4963,7 +4977,7 @@ function restoreFormStateWhenMounted(bfcacheId: string, sequence: number): void
       observer.disconnect()
       return
     }
-    restoreFormState(bfcacheId, true)
+    restoreFormState(bfcacheId, true, skipIslands)
   })
   observer.observe(document.body, { childList: true, subtree: true })
   window.setTimeout(() => observer.disconnect(), FORM_STATE_RESTORE_WINDOW_MS)

package/src/compat/metadata.ts

@@ -1,6 +1,7 @@
 import type { Metadata, MetadataOpenGraph, PageProps, RouteManifestEntry, Viewport } from '../types'
 import { staticMetadataForPathFromFiles, type StaticMetadataFile } from '../routing/metadata-files'
 import { coerceString } from '../render/metadata'
+import { legacyRequestAPIs } from '../request/context'
 import { readSourceText } from '../resolve/source-text'
 import { SPAN_TYPE, withChildSpan } from './otel/tracer'
 import { settledPromise } from '../render/renderer'
@@ -146,7 +147,9 @@ function resolvedParentMetadata(parent: Metadata): Metadata {
   }
 }
 
-function resolvedParentOpenGraph(openGraph: MetadataOpenGraph | undefined): MetadataOpenGraph {
+function resolvedParentOpenGraph(
+  openGraph: MetadataOpenGraph | null | undefined,
+): MetadataOpenGraph {
   if (!openGraph) return {}
   return {
     ...openGraph,
@@ -165,7 +168,7 @@ function resolvedParentOpenGraph(openGraph: MetadataOpenGraph | undefined): Meta
 }
 
 function normalizeKeywordList(value: Metadata['keywords']): (string | number)[] | undefined {
-  if (value === undefined) return undefined
+  if (value === undefined || value === null) return undefined
   return Array.isArray(value) ? value : [value]
 }
 
@@ -192,7 +195,8 @@ export async function warnNextMetadataBuildIssues(
     if (route.kind !== 'page') continue
     const routeFacts = await Promise.all(routeSourceFiles(appPath, route).map(factsFor))
     const some = (pick: (fact: MetadataSourceFacts) => boolean) => routeFacts.some(pick)
-    if (some(fact => fact.themeColor)) {
+    // themeColor-in-metadata deprecation is Next 15+; legacy (Next-14 era) apps never saw it.
+    if (!legacyRequestAPIs() && some(fact => fact.themeColor)) {
       warnOnce(
         warned,
         `themeColor:${route.route}`,
@@ -255,7 +259,7 @@ interface MetadataSourceFacts {
 
 function metadataSourceFacts(source: string): MetadataSourceFacts {
   return {
-    themeColor: source.includes('themeColor') && /\bthemeColor\s*:/.test(source),
+    themeColor: themeColorInMetadataExport(source),
     appleTouchFullscreen:
       source.includes('apple-touch-fullscreen') && /['"]apple-touch-fullscreen['"]/.test(source),
     appleTouchIconPrecomposed:
@@ -266,6 +270,35 @@ function metadataSourceFacts(source: string): MetadataSourceFacts {
   }
 }
 
+// A themeColor inside a viewport export is where the notice says to put it, so
+// only occurrences outside viewport/generateViewport blocks count.
+function themeColorInMetadataExport(source: string): boolean {
+  if (!source.includes('themeColor') || !/\bthemeColor\s*:/.test(source)) return false
+  return /\bthemeColor\s*:/.test(stripViewportExports(source))
+}
+
+function stripViewportExports(source: string): string {
+  const starts =
+    /export\s+(?:const|let|var)\s+viewport\b|export\s+(?:async\s+)?function\s+generateViewport\b/g
+  let out = ''
+  let last = 0
+  for (let match = starts.exec(source); match; match = starts.exec(source)) {
+    const open = source.indexOf('{', match.index)
+    if (open === -1) break
+    let depth = 0
+    let end = open
+    for (; end < source.length; end++) {
+      const char = source[end]
+      if (char === '{') depth++
+      else if (char === '}' && --depth === 0) break
+    }
+    out += source.slice(last, match.index)
+    last = end + 1
+    starts.lastIndex = last
+  }
+  return out + source.slice(last)
+}
+
 function routeUsesRelativeSocialImage(
   route: RouteManifestEntry,
   facts: MetadataSourceFacts[],

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

@@ -112,10 +112,16 @@ function findConfigPath(root: string): string | undefined {
   return undefined
 }
 
+// `Bun` through globalThis: pnext ships TypeScript source, so app compilers without
+// bun-types typecheck this file and a bare `Bun` identifier would fail them.
+const { Bun: bun } = globalThis as unknown as {
+  Bun: { hash(input: string | ArrayBufferView): { toString(radix?: number): string } }
+}
+
 /** Stable per config content, so the emitted bundle keeps one name per boot. */
 function configSourceKey(configPath: string): string {
   try {
-    return Bun.hash(readFileSync(configPath)).toString(36)
+    return bun.hash(readFileSync(configPath)).toString(36)
   } catch {
     return 'config'
   }

package/src/compat/register/proxy.ts

@@ -8,6 +8,7 @@ import { recordRewrite } from '../protocol'
 import { recordCanonicalUrl } from '../next/canonical-url'
 import { getNextConfig } from '../next/config-loader'
 import { activateTestProxy } from '../lifecycle/testmode'
+import { legacyRequestAPIs } from '../../request/context'
 
 export function registerProxyExtensions(_config: ResolvedConfig): void {
   setProxyResponseProtocol({
@@ -72,7 +73,8 @@ async function validateNextProxyFiles(config: ResolvedConfig) {
       `Both middleware file "${relativeProxyPath(config, middleware)}" and proxy file "${relativeProxyPath(config, proxy)}" are detected. Please use "${relativeProxyPath(config, proxy)}" only.`,
     )
   }
-  if (middleware && !proxy) {
+  // Proxy is a Next 16 migration; legacy request APIs explicitly target the middleware era.
+  if (middleware && !proxy && !legacyRequestAPIs()) {
     console.warn('The "middleware" file convention is deprecated. Please use "proxy" instead.')
   }
   await Promise.all(files.map(file => validateNextProxyFile(config, file)))

package/src/compat/register/typed-routes.ts

@@ -9,6 +9,7 @@ import {
   registerBuildSteps,
   type BuildStepContext,
 } from '../../extensions'
+import { legacyRequestAPIs } from '../../request/context'
 import type { RouteManifestEntry } from '../../types'
 import { nextCompatEnabled } from '../aliases'
 import { writeTsconfigDefaults } from '../tsconfig-defaults'
@@ -21,7 +22,8 @@ export function registerTypedRoutesExtensions(_config: ResolvedConfig): void {
 
 async function runTypedRoutesBuildStep(ctx: BuildStepContext): Promise<void> {
   if (!nextCompatEnabled(ctx.config)) return
-  await writeTsconfigDefaults(ctx.config)
+  // Legacy (Next-14 era) apps keep their tsconfig untouched; current apps get Next's defaults.
+  if (!legacyRequestAPIs()) await writeTsconfigDefaults(ctx.config)
   await generateTypedRoutes(ctx.config, ctx.routes as RouteManifestEntry[])
   // The typecheck reads only files that already exist on disk, so it runs on a worker thread
   // alongside client bundling and prerendering rather than ahead of them; the CLI awaits it before

package/src/compat/typecheck/check.ts

@@ -372,6 +372,10 @@ async function writeTypecheckProject(
         },
         include: [
           path.join(dir, 'next-shims.d.ts'),
+          // Generated per-route assignability checks (typegen writes them next to this
+          // project, not under the app-included `types/` dir, so only pnext's own compiler
+          // reads them). Included by hand to keep that coverage.
+          path.join(dir, 'checks', '**/*.ts'),
           ...(nodeTypes ? [path.join(nodeTypes, 'index.d.ts')] : []),
           path.join(config.root, 'next-env.d.ts'),
           // The build emits `.next/types/validator.ts` (page/layout/route-handler export validation) just
@@ -661,7 +665,7 @@ declare module 'react/jsx-runtime' {
 `
   const requestType = (type: string) =>
     legacyRequestTypes ? `Promise<${type}> & ${type}` : `Promise<${type}>`
-  const requestShims = `declare module 'next/headers'{interface CookieSetOptions{name?:string;value?:string;path?:string;maxAge?:number;expires?:Date|number;httpOnly?:boolean;secure?:boolean;sameSite?:'strict'|'lax'|'none'|boolean;domain?:string}interface CookieStore{get(name:string):{name:string;value:string}|undefined;get(options:{name:string;value?:string}):{name:string;value:string}|undefined;getAll(name?:string):{name:string;value:string}[];getAll(options:{name:string;value?:string}):{name:string;value:string}[];has(name:string):boolean;readonly size:number;set(name:string,value:string,options?:CookieSetOptions):CookieStore;set(options:CookieSetOptions):CookieStore;delete(name:string):boolean;clear():CookieStore;[Symbol.iterator]():IterableIterator<readonly[string,{name?:string;value:string}]>}export function cookies():${requestType('CookieStore')};export function headers():${requestType('Headers')};export function draftMode():${requestType(`{isEnabled:boolean;enable():void;disable():void}`)}}
+  const requestShims = `declare module 'next/headers'{interface CookieSetOptions{name?:string;value?:string;path?:string;maxAge?:number;expires?:Date|number;httpOnly?:boolean;secure?:boolean;sameSite?:'strict'|'lax'|'none'|boolean;domain?:string}interface CookieStore{get(name:string):{name:string;value:string}|undefined;get(options:{name:string;value?:string}):{name:string;value:string}|undefined;getAll(name?:string):{name:string;value:string}[];getAll(options:{name:string;value?:string}):{name:string;value:string}[];has(name:string):boolean;readonly size:number;set(options:CookieSetOptions):CookieStore;set(name:string,value:string,options?:CookieSetOptions):CookieStore;delete(name:string):boolean;clear():CookieStore;[Symbol.iterator]():IterableIterator<readonly[string,{name?:string;value:string}]>}export function cookies():${requestType('CookieStore')};export function headers():${requestType('Headers')};export function draftMode():${requestType(`{isEnabled:boolean;enable():void;disable():void}`)}}
 `
   const fontShims = hasRealNext
     ? ''

package/src/compat/validation/validate.ts

@@ -15,6 +15,7 @@ import path from 'node:path'
 import type { ResolvedConfig } from '../../config'
 import { extraPageExtensions } from '../../extensions'
 import type { RouteManifestEntry } from '../../types'
+import { legacyRequestAPIs } from '../../request/context'
 import { getNextConfig } from '../next/config-loader'
 import { stripComments } from '../../utils/code'
 import {
@@ -271,6 +272,7 @@ function warnBuildDiagnostics(config: ResolvedConfig, routes: RouteManifestEntry
     console.warn('Disabled SWC as replacement for Babel because of custom Babel configuration')
   }
   if (
+    !legacyRequestAPIs() &&
     typeof nextConfig.outputFileTracingRoot !== 'string' &&
     !(
       nextConfig.turbopack &&

package/src/config.ts

@@ -21,6 +21,12 @@ export type ResolvedConfig = Required<Pick<PNextConfig, 'outDir' | 'basePath'>>
     outRootPath: string
     /** Generated types — always under the out root, because tsconfig points at it. */
     typesPath: string
+    /**
+     * Generated per-route assignability checks. Deliberately OUTSIDE typesPath: an app's
+     * tsconfig includes `<outRoot>/types/**` and a foreign compiler must never see pnext's
+     * own internals. pnext's private typecheck project includes this directory instead.
+     */
+    checksPath: string
   }
 
 /**
@@ -146,6 +152,7 @@ export async function loadConfig(
     outPath: options.dev ? path.join(outRootPath, devOutSegment) : outRootPath,
     outRootPath,
     typesPath: path.join(outRootPath, 'types'),
+    checksPath: path.join(outRootPath, 'typecheck', 'checks'),
   }
 }
 

package/src/dev/server.ts

@@ -100,6 +100,7 @@ import {
 } from '../runtime/modules'
 import { ssrClientReference } from '../client/reference'
 import { cacheRoot, setDevWatcherFreshness } from '../runtime/module-cache'
+import { abortUpstreamFetchOnDisconnect } from '../runtime/fetch-host'
 import { markBoot } from '../cli/boot/trace'
 import { formatDuration } from '../utils/verbose'
 
@@ -454,6 +455,7 @@ export async function startDevServer(options: DevServerOptions) {
         syncWatchRoots()
       }, 0)
       if (profile) flushDevProfileLines()
+      abortUpstreamFetchOnDisconnect(logged.body, request.signal)
       return flushWorkUnitOnClose(logged, unit, request.signal)
     }
 

package/src/extensions.ts

@@ -15,6 +15,12 @@ import type { BuildManifest, ClientEntryReason, RouteManifestEntry, RouteParamVa
 import type { VerboseLogger } from './utils/verbose'
 import { escapeRegex } from './utils/code'
 
+// `Bun` through globalThis: pnext ships TypeScript source, so app compilers without
+// bun-types typecheck this file and a bare `Bun` identifier would fail them.
+const { Bun: bun } = globalThis as unknown as {
+  Bun: { hash(input: string | ArrayBufferView): { toString(radix?: number): string } }
+}
+
 /** Per-build wiring for the server plugin chain. */
 export interface ServerEsbuildPluginOptions {
   /**
@@ -1416,7 +1422,7 @@ export function classifyRouteDependencies(
 
 /** Every reason a registered detector requires a client entry for this source. */
 export function sourceClientEntryReasons(source: string): ClientEntryReason[] {
-  const key = `${source.length}\0${Bun.hash(source).toString(36)}`
+  const key = `${source.length}\0${bun.hash(source).toString(36)}`
   const cached = clientEntryReasonCache.get(key)
   if (cached) return cached
   const reasons: ClientEntryReason[] = []