@wular/pnext 0.0.4 → 0.0.6

package/src/compat/pages/router-state.ts

@@ -5,24 +5,24 @@
 // wrapper also serializes the state into a `<script type="application/json">` node so the browser-side
 // shim reads the same values after hydration and after soft navigations.
 
-import type { RouteParamValue } from '../../types';
+import type { RouteParamValue } from '../../types'
 
 export interface PagesRouterSsrState {
   /** Pages-route pattern, e.g. `/blog/[slug]`. */
-  pathname: string;
+  pathname: string
   /** The as-requested URL (path + original search), pre-rewrite. */
-  asPath: string;
+  asPath: string
   /** Rewrite-destination search params merged with dynamic route params. */
-  query: Record<string, string | string[]>;
+  query: Record<string, string | string[]>
 }
 
-const STATE_KEY = Symbol.for('pnext.pagesRouterState');
-const REQUEST_STORAGE = Symbol.for('pnext.requestStorage');
-const WORK_UNIT_STORAGE = Symbol.for('pnext.workUnitStorage');
-const CANONICAL_URL_KEY = Symbol.for('pnext.compat.navigation.canonicalUrl');
+const STATE_KEY = Symbol.for('pnext.pagesRouterState')
+const REQUEST_STORAGE = Symbol.for('pnext.requestStorage')
+const WORK_UNIT_STORAGE = Symbol.for('pnext.workUnitStorage')
+const CANONICAL_URL_KEY = Symbol.for('pnext.compat.navigation.canonicalUrl')
 
 interface StorageLike {
-  getStore(): Record<PropertyKey, unknown> | undefined;
+  getStore(): Record<PropertyKey, unknown> | undefined
 }
 
 // All reads go through the globalThis-anchored storages (never module-local
@@ -30,21 +30,21 @@ interface StorageLike {
 // their own compiled copy of this module, and only the anchored instances are
 // shared between them.
 function anchoredScope(key: symbol): Record<PropertyKey, unknown> | undefined {
-  const storage = (globalThis as Record<PropertyKey, unknown>)[key] as StorageLike | undefined;
-  return storage?.getStore?.();
+  const storage = (globalThis as Record<PropertyKey, unknown>)[key] as StorageLike | undefined
+  return storage?.getStore?.()
 }
 
 function currentRequestUrl(): string | undefined {
-  const scope = anchoredScope(REQUEST_STORAGE);
-  const request = scope?.request as { url?: string } | undefined;
-  return typeof request?.url === 'string' ? request.url : undefined;
+  const scope = anchoredScope(REQUEST_STORAGE)
+  const request = scope?.request as { url?: string } | undefined
+  return typeof request?.url === 'string' ? request.url : undefined
 }
 
 function canonicalHref(): string | undefined {
-  const unit = anchoredScope(WORK_UNIT_STORAGE);
-  const compat = unit?.compat as Record<symbol, unknown> | undefined;
-  const value = compat?.[CANONICAL_URL_KEY];
-  return typeof value === 'string' ? value : undefined;
+  const unit = anchoredScope(WORK_UNIT_STORAGE)
+  const compat = unit?.compat as Record<symbol, unknown> | undefined
+  const value = compat?.[CANONICAL_URL_KEY]
+  return typeof value === 'string' ? value : undefined
 }
 
 /**
@@ -57,38 +57,38 @@ export function pagesRouterSsrState(
   pattern: string,
   params: Record<string, RouteParamValue> | undefined,
 ): PagesRouterSsrState {
-  const requestUrl = currentRequestUrl();
-  const canonical = canonicalHref() ?? requestUrl;
-  const query: Record<string, string | string[]> = {};
+  const requestUrl = currentRequestUrl()
+  const canonical = canonicalHref() ?? requestUrl
+  const query: Record<string, string | string[]> = {}
   if (requestUrl) {
     for (const [key, value] of new URL(requestUrl).searchParams) {
       // The router-fetch cache key rides soft-navigation request URLs; it is
       // never part of the page's query.
-      if (key !== '_rsc') query[key] = value;
+      if (key !== '_rsc') query[key] = value
     }
   }
   for (const [key, value] of Object.entries(params ?? {})) {
-    if (value !== undefined) query[key] = value;
+    if (value !== undefined) query[key] = value
   }
-  let asPath = pattern;
+  let asPath = pattern
   if (canonical) {
-    const url = new URL(canonical);
-    asPath = `${url.pathname}${url.search}`;
+    const url = new URL(canonical)
+    asPath = `${url.pathname}${url.search}`
   }
-  const state: PagesRouterSsrState = { pathname: pattern, asPath, query };
-  const scope = anchoredScope(REQUEST_STORAGE);
-  if (scope) scope[STATE_KEY] = state;
-  return state;
+  const state: PagesRouterSsrState = { pathname: pattern, asPath, query }
+  const scope = anchoredScope(REQUEST_STORAGE)
+  if (scope) scope[STATE_KEY] = state
+  return state
 }
 
 /** The state stashed by the active render's page wrapper, if any. */
 export function currentPagesRouterState(): PagesRouterSsrState | undefined {
-  const scope = anchoredScope(REQUEST_STORAGE);
-  const state = scope?.[STATE_KEY];
-  return state ? (state as PagesRouterSsrState) : undefined;
+  const scope = anchoredScope(REQUEST_STORAGE)
+  const state = scope?.[STATE_KEY]
+  return state ? (state as PagesRouterSsrState) : undefined
 }
 
 /** Serialize state for the inline JSON node (script-safe: `<` escaped). */
 export function serializePagesRouterState(state: PagesRouterSsrState): string {
-  return JSON.stringify(state).replace(/</g, '\\u003c');
+  return JSON.stringify(state).replace(/</g, '\\u003c')
 }

package/src/compat/pages/{index.ts → router.ts}

@@ -1,23 +1,23 @@
-import { createHash } from 'node:crypto';
-import { existsSync, statSync } from 'node:fs';
-import { copyFile, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { hasUseClientDirective } from '../../client/reference-stub';
-import { listFiles, toPosixPath } from '../../utils/fs';
-import { getNextConfig } from '../next/config-loader';
+import { createHash } from 'node:crypto'
+import { existsSync, statSync } from 'node:fs'
+import { copyFile, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { tmpdir } from 'node:os'
+import { hasUseClientDirective } from '../../client/reference-stub'
+import { listFiles, toPosixPath } from '../../utils/fs'
+import { getNextConfig } from '../next/config-loader'
 
-const basePageExtensions = ['tsx', 'ts', 'jsx', 'js', 'mjs'];
+const basePageExtensions = ['tsx', 'ts', 'jsx', 'js', 'mjs']
 
 // The app's configured pageExtensions (e.g. @next/mdx appending mdx/md) must
 // apply to materialization too, or hybrid apps lose their .mdx routes — this
 // runs during config resolution, before registerMdxExtensions.
 function materializeExtensions(): string[] {
-  const configured = getNextConfig().pageExtensions;
+  const configured = getNextConfig().pageExtensions
   const extras = Array.isArray(configured)
     ? configured.filter((ext): ext is string => typeof ext === 'string' && ext.length > 0)
-    : [];
-  return [...new Set([...basePageExtensions, ...extras])];
+    : []
+  return [...new Set([...basePageExtensions, ...extras])]
 }
 const appConventions = new Set([
   'default',
@@ -31,15 +31,15 @@ const appConventions = new Set([
   'route',
   'template',
   'unauthorized',
-]);
+])
 
 // Metadata code routes (manifest.js, opengraph-image.tsx, icon2.tsx, ...) are
 // app conventions too and must survive materialization in hybrid apps.
 const metadataConventionPattern =
-  /^(robots|sitemap|manifest|icon\d*|apple-icon\d*|opengraph-image\d*|twitter-image\d*)$/;
+  /^(robots|sitemap|manifest|icon\d*|apple-icon\d*|opengraph-image\d*|twitter-image\d*)$/
 
 function isAppConvention(name: string): boolean {
-  return appConventions.has(name) || metadataConventionPattern.test(name);
+  return appConventions.has(name) || metadataConventionPattern.test(name)
 }
 
 /**
@@ -48,62 +48,61 @@ function isAppConvention(name: string): boolean {
  * conflict validation; linked sources and node_modules keep normal resolution.
  */
 export async function materializePagesApp(root: string): Promise<string | undefined> {
-  const pagesPath = path.join(root, 'pages');
-  if (!existsSync(pagesPath)) return undefined;
+  const pagesPath = path.join(root, 'pages')
+  if (!existsSync(pagesPath)) return undefined
 
   const generatedRoot = path.join(
     tmpdir(),
     'pnext-pages-compat',
     createHash('sha256').update(root).digest('hex').slice(0, 16),
-  );
-  const appPath = path.join(generatedRoot, 'app');
-  const sourcePages = path.join(generatedRoot, 'source-pages');
-  const sourceApp = path.join(generatedRoot, 'source-app');
-  const pages = await discoverPages(pagesPath);
-  const apiRoutes = await discoverPagesApi(pagesPath);
-  if (pages.length === 0 && apiRoutes.length === 0) return undefined;
+  )
+  const appPath = path.join(generatedRoot, 'app')
+  const sourcePages = path.join(generatedRoot, 'source-pages')
+  const sourceApp = path.join(generatedRoot, 'source-app')
+  const pages = await discoverPages(pagesPath)
+  const apiRoutes = await discoverPagesApi(pagesPath)
+  if (pages.length === 0 && apiRoutes.length === 0) return undefined
 
-  await rm(generatedRoot, { recursive: true, force: true });
-  await mkdir(appPath, { recursive: true });
-  await symlink(pagesPath, sourcePages, 'dir');
-  const nodeModules = path.join(root, 'node_modules');
+  await rm(generatedRoot, { recursive: true, force: true })
+  await mkdir(appPath, { recursive: true })
+  await symlink(pagesPath, sourcePages, 'dir')
+  const nodeModules = path.join(root, 'node_modules')
   if (existsSync(nodeModules))
-    await symlink(nodeModules, path.join(generatedRoot, 'node_modules'), 'dir');
+    await symlink(nodeModules, path.join(generatedRoot, 'node_modules'), 'dir')
 
   // Static assets referenced from materialized routes (e.g. an app route's
   // `new URL('../../public/vercel.png', import.meta.url)` or a `public/*` asset
   // import) resolve relative to the generated root; without the symlink the
   // bundler can't find them and the route 500s.
-  const publicDir = path.join(root, 'public');
-  if (existsSync(publicDir))
-    await symlink(publicDir, path.join(generatedRoot, 'public'), 'dir');
+  const publicDir = path.join(root, 'public')
+  if (existsSync(publicDir)) await symlink(publicDir, path.join(generatedRoot, 'public'), 'dir')
 
-  const nativeApp = path.join(root, 'app');
+  const nativeApp = path.join(root, 'app')
   if (existsSync(nativeApp)) {
-    await symlink(nativeApp, sourceApp, 'dir');
-    await materializeNativeApp(sourceApp, appPath);
+    await symlink(nativeApp, sourceApp, 'dir')
+    await materializeNativeApp(sourceApp, appPath)
   }
   if (!existsSync(path.join(appPath, 'layout.js'))) {
     await writeFile(
       path.join(appPath, 'layout.js'),
       'export default function PagesLayout({ children }) {\n  return <html><body>{children}</body></html>\n}\n',
-    );
+    )
   }
 
   for (const page of pages) {
-    const destination = path.join(appPath, ...encodePrivateSegments(page.segments), 'page.js');
-    if (existsSync(destination)) continue;
-    await mkdir(path.dirname(destination), { recursive: true });
-    const pagesPattern = `/${page.segments.join('/')}`.replace(/\/+$/, '') || '/';
-    const sourceSpecifier = relativeImport(destination, path.join(sourcePages, page.relative));
-    let clientSpecifier: string | undefined;
+    const destination = path.join(appPath, ...encodePrivateSegments(page.segments), 'page.js')
+    if (existsSync(destination)) continue
+    await mkdir(path.dirname(destination), { recursive: true })
+    const pagesPattern = `/${page.segments.join('/')}`.replace(/\/+$/, '') || '/'
+    const sourceSpecifier = relativeImport(destination, path.join(sourcePages, page.relative))
+    let clientSpecifier: string | undefined
     if (page.hasStaticProps || page.hasServerSideProps) {
-      const clientDestination = path.join(path.dirname(destination), 'pnext-page-client.js');
+      const clientDestination = path.join(path.dirname(destination), 'pnext-page-client.js')
       await writeFile(
         clientDestination,
         `'use client';\nexport { default } from ${JSON.stringify(sourceSpecifier)};\n`,
-      );
-      clientSpecifier = './pnext-page-client.js';
+      )
+      clientSpecifier = './pnext-page-client.js'
     }
     await writeFile(
       destination,
@@ -122,44 +121,44 @@ export async function materializePagesApp(root: string): Promise<string | undefi
         page.maxDuration,
         pagesPattern,
       ),
-    );
+    )
   }
   for (const apiRoute of apiRoutes) {
-    const destination = path.join(appPath, 'api', ...apiRoute.segments, 'route.js');
-    if (existsSync(destination)) continue;
-    await mkdir(path.dirname(destination), { recursive: true });
+    const destination = path.join(appPath, 'api', ...apiRoute.segments, 'route.js')
+    if (existsSync(destination)) continue
+    await mkdir(path.dirname(destination), { recursive: true })
     await writeFile(
       destination,
       pagesApiWrapperSource(
         relativeImport(destination, path.join(sourcePages, apiRoute.relative)),
         apiRoute.runtime,
       ),
-    );
+    )
   }
 
-  return appPath;
+  return appPath
 }
 
 async function materializeNativeApp(sourceApp: string, appPath: string): Promise<void> {
   for (const file of await listFiles(sourceApp)) {
-    const relative = toPosixPath(path.relative(sourceApp, file));
-    const parsed = path.parse(relative);
+    const relative = toPosixPath(path.relative(sourceApp, file))
+    const parsed = path.parse(relative)
     // Non-code files (favicon.ico, robots.txt, sitemap.xml, og images, ...)
     // are static metadata routes discovered by scanning the app dir — carry
     // them into the merged view or they 404 in hybrid apps. Copied, not
     // symlinked: the file listers skip symlink dirents.
     if (!materializeExtensions().includes(parsed.ext.slice(1))) {
-      const destination = path.join(appPath, relative);
-      await mkdir(path.dirname(destination), { recursive: true });
-      await copyFile(file, destination);
-      continue;
+      const destination = path.join(appPath, relative)
+      await mkdir(path.dirname(destination), { recursive: true })
+      await copyFile(file, destination)
+      continue
     }
-    if (!isAppConvention(parsed.name)) continue;
-    const destination = path.join(appPath, parsed.dir, `${parsed.name}.js`);
-    await mkdir(path.dirname(destination), { recursive: true });
-    const source = await readFile(file, 'utf8');
+    if (!isAppConvention(parsed.name)) continue
+    const destination = path.join(appPath, parsed.dir, `${parsed.name}.js`)
+    await mkdir(path.dirname(destination), { recursive: true })
+    const source = await readFile(file, 'utf8')
     const client =
-      hasUseClientDirective(source) || (await defaultExportImportsClientModule(file, source));
+      hasUseClientDirective(source) || (await defaultExportImportsClientModule(file, source))
     await writeFile(
       destination,
       wrapperSource(
@@ -170,31 +169,31 @@ async function materializeNativeApp(sourceApp: string, appPath: string): Promise
         undefined,
         runtimeFromSource(source),
       ),
-    );
+    )
   }
 }
 
 async function defaultExportImportsClientModule(file: string, source: string): Promise<boolean> {
-  const defaultExport = /export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/.exec(source);
-  if (!defaultExport?.[1]) return false;
+  const defaultExport = /export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/.exec(source)
+  if (!defaultExport?.[1]) return false
 
-  const binding = defaultExport[1];
-  const imports = /import\s*\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g;
-  let match: RegExpExecArray | null;
+  const binding = defaultExport[1]
+  const imports = /import\s*\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g
+  let match: RegExpExecArray | null
   while ((match = imports.exec(source))) {
     const importsBinding = (match[1] ?? '').split(',').some(value => {
-      const names = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(value);
-      return (names?.[2] ?? names?.[1]) === binding;
-    });
-    if (!importsBinding || !match[2]?.startsWith('.')) continue;
-    const imported = resolveSourceImport(file, match[2]);
-    if (imported && hasUseClientDirective(await readFile(imported, 'utf8'))) return true;
+      const names = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(value)
+      return (names?.[2] ?? names?.[1]) === binding
+    })
+    if (!importsBinding || !match[2]?.startsWith('.')) continue
+    const imported = resolveSourceImport(file, match[2])
+    if (imported && hasUseClientDirective(await readFile(imported, 'utf8'))) return true
   }
-  return false;
+  return false
 }
 
 function resolveSourceImport(file: string, specifier: string): string | undefined {
-  const base = path.resolve(path.dirname(file), specifier);
+  const base = path.resolve(path.dirname(file), specifier)
   for (const candidate of [
     base,
     ...materializeExtensions().flatMap(extension => [
@@ -202,24 +201,24 @@ function resolveSourceImport(file: string, specifier: string): string | undefine
       path.join(base, `index.${extension}`),
     ]),
   ]) {
-    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate
   }
-  return undefined;
+  return undefined
 }
 
 interface PagesRoute {
-  relative: string;
-  segments: string[];
-  hasServerSideProps: boolean;
-  hasStaticProps: boolean;
-  runtime?: 'edge' | 'nodejs';
-  maxDuration?: number;
+  relative: string
+  segments: string[]
+  hasServerSideProps: boolean
+  hasStaticProps: boolean
+  runtime?: 'edge' | 'nodejs'
+  maxDuration?: number
 }
 
 interface PagesApiRoute {
-  relative: string;
-  segments: string[];
-  runtime?: 'edge' | 'nodejs';
+  relative: string
+  segments: string[]
+  runtime?: 'edge' | 'nodejs'
 }
 
 // A pages-router segment beginning with `_` is a real route (pages has no private-folder convention),
@@ -227,38 +226,36 @@ interface PagesApiRoute {
 // private. Encoding the leading underscore to `%5F` keeps the materialized directory routable - the
 // scanner decodes it back.
 function encodePrivateSegments(segments: string[]): string[] {
-  return segments.map(segment =>
-    segment.startsWith('_') ? `%5F${segment.slice(1)}` : segment,
-  );
+  return segments.map(segment => (segment.startsWith('_') ? `%5F${segment.slice(1)}` : segment))
 }
 
 async function discoverPages(pagesPath: string): Promise<PagesRoute[]> {
-  const routes = new Map<string, PagesRoute>();
-  const files = await listFiles(pagesPath);
+  const routes = new Map<string, PagesRoute>()
+  const files = await listFiles(pagesPath)
   for (const extension of materializeExtensions()) {
     for (const file of files) {
-      if (!file.endsWith(`.${extension}`)) continue;
-      const relative = toPosixPath(path.relative(pagesPath, file));
-      const withoutExtension = relative.slice(0, -extension.length - 1);
-      const sourceSegments = withoutExtension.split('/');
+      if (!file.endsWith(`.${extension}`)) continue
+      const relative = toPosixPath(path.relative(pagesPath, file))
+      const withoutExtension = relative.slice(0, -extension.length - 1)
+      const sourceSegments = withoutExtension.split('/')
       // The pages router has no private-folder convention (that is app-router
       // only): a nested `_dashboard/index.tsx` routes at `/_dashboard`. Only the
       // reserved root components (`_app`/`_document`/`_error`) and the `api`
       // segment are excluded from route materialization.
-      if (sourceSegments[0] === 'api') continue;
+      if (sourceSegments[0] === 'api') continue
       if (
         sourceSegments.length === 1 &&
         (sourceSegments[0] === '_app' ||
           sourceSegments[0] === '_document' ||
           sourceSegments[0] === '_error')
       ) {
-        continue;
+        continue
       }
       const segments =
-        sourceSegments.at(-1) === 'index' ? sourceSegments.slice(0, -1) : sourceSegments;
-      const key = segments.join('/');
+        sourceSegments.at(-1) === 'index' ? sourceSegments.slice(0, -1) : sourceSegments
+      const key = segments.join('/')
       if (!routes.has(key)) {
-        const source = await readFile(file, 'utf8');
+        const source = await readFile(file, 'utf8')
         routes.set(key, {
           relative,
           segments,
@@ -266,35 +263,35 @@ async function discoverPages(pagesPath: string): Promise<PagesRoute[]> {
           hasStaticProps: /\bgetStaticProps\b/.test(source),
           runtime: runtimeFromSource(source),
           maxDuration: maxDurationFromSource(source),
-        });
+        })
       }
     }
   }
-  return [...routes.values()];
+  return [...routes.values()]
 }
 
 async function discoverPagesApi(pagesPath: string): Promise<PagesApiRoute[]> {
-  const routes = new Map<string, PagesApiRoute>();
-  const files = await listFiles(path.join(pagesPath, 'api'));
+  const routes = new Map<string, PagesApiRoute>()
+  const files = await listFiles(path.join(pagesPath, 'api'))
   for (const extension of materializeExtensions()) {
     for (const file of files) {
-      if (!file.endsWith(`.${extension}`)) continue;
-      const relative = toPosixPath(path.relative(pagesPath, file));
+      if (!file.endsWith(`.${extension}`)) continue
+      const relative = toPosixPath(path.relative(pagesPath, file))
       const segments = relative
         .slice(0, -extension.length - 1)
         .split('/')
-        .slice(1);
-      if (segments.some(segment => segment.startsWith('_'))) continue;
-      const key = segments.join('/');
-      if (routes.has(key)) continue;
+        .slice(1)
+      if (segments.some(segment => segment.startsWith('_'))) continue
+      const key = segments.join('/')
+      if (routes.has(key)) continue
       routes.set(key, {
         relative,
         segments,
         runtime: runtimeFromSource(await readFile(file, 'utf8')),
-      });
+      })
     }
   }
-  return [...routes.values()];
+  return [...routes.values()]
 }
 
 // The compat runtime module the data wrappers import (by absolute path — the
@@ -302,18 +299,18 @@ async function discoverPagesApi(pagesPath: string): Promise<PagesApiRoute[]> {
 // cannot reach it). It computes + stashes the SSR useRouter() state and
 // serializes it for the inline __PNEXT_PAGES_DATA__ JSON node.
 function routerStateModulePath(): string {
-  return path.join(import.meta.dirname, 'router-state.ts');
+  return path.join(import.meta.dirname, 'router-state.ts')
 }
 
 // The shared prologue/epilogue for data wrappers: emit the pages-router state
 // node alongside the page so the next/router shim (SSR and browser) sees the
 // pages-route pattern, canonical asPath, and merged query.
 function routerStateSnippet(pagesPattern: string | undefined): {
-  imports: string;
-  render: string;
+  imports: string
+  render: string
 } {
   if (!pagesPattern) {
-    return { imports: '', render: 'return createElement(Page, result?.props ?? {});' };
+    return { imports: '', render: 'return createElement(Page, result?.props ?? {});' }
   }
   return {
     imports: `import { pagesRouterSsrState, serializePagesRouterState } from ${JSON.stringify(
@@ -330,7 +327,7 @@ function routerStateSnippet(pagesPattern: string | undefined): {
     }),
     createElement(Page, result?.props ?? {}),
   );`,
-  };
+  }
 }
 
 function wrapperSource(
@@ -343,10 +340,10 @@ function wrapperSource(
   maxDuration?: number,
   pagesPattern?: string,
 ): string {
-  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};\n` : '';
+  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};\n` : ''
   const maxDurationExport =
-    maxDuration === undefined ? '' : `export const maxDuration = ${maxDuration};\n`;
-  const routerState = routerStateSnippet(pagesPattern);
+    maxDuration === undefined ? '' : `export const maxDuration = ${maxDuration};\n`
+  const routerState = routerStateSnippet(pagesPattern)
   if (hasStaticProps && clientSpecifier) {
     return `import { createElement, Fragment } from 'react';
 import { notFound, redirect } from 'next/navigation';
@@ -363,18 +360,18 @@ ${runtimeExport}${maxDurationExport}export default async function PagesCompatSta
   if (result?.redirect) redirect(result.redirect.destination);
   ${routerState.render}
 }
-`;
+`
   }
   if (!hasServerSideProps) {
     if (client) {
       return `'use client';
 export { default } from ${JSON.stringify(specifier)};
-${runtimeExport}${maxDurationExport}`;
+${runtimeExport}${maxDurationExport}`
     }
     return `import * as __pnext_page_ns from ${JSON.stringify(specifier)};
 export default __pnext_page_ns.default;
 export * from ${JSON.stringify(specifier)};
-${runtimeExport}${maxDurationExport}`;
+${runtimeExport}${maxDurationExport}`
   }
   return `import { createElement, Fragment } from 'react';
 import { notFound, redirect } from 'next/navigation';
@@ -423,23 +420,21 @@ ${runtimeExport}${maxDurationExport}export default async function PagesCompatPag
   if (result?.redirect) redirect(result.redirect.destination);
   ${routerState.render}
 }
-`;
+`
 }
 
 function runtimeFromSource(source: string): 'edge' | 'nodejs' | undefined {
-  const runtime = /\bruntime\b\s*[:=]\s*(['"`])(edge|nodejs|experimental-edge)\1/.exec(
-    source,
-  )?.[2];
-  return runtime === 'experimental-edge' ? 'edge' : (runtime as 'edge' | 'nodejs' | undefined);
+  const runtime = /\bruntime\b\s*[:=]\s*(['"`])(edge|nodejs|experimental-edge)\1/.exec(source)?.[2]
+  return runtime === 'experimental-edge' ? 'edge' : (runtime as 'edge' | 'nodejs' | undefined)
 }
 
 function maxDurationFromSource(source: string): number | undefined {
-  const value = /\bmaxDuration\s*:\s*(\d+)\b/.exec(source)?.[1];
-  return value === undefined ? undefined : Number(value);
+  const value = /\bmaxDuration\s*:\s*(\d+)\b/.exec(source)?.[1]
+  return value === undefined ? undefined : Number(value)
 }
 
 function pagesApiWrapperSource(specifier: string, runtime?: 'edge' | 'nodejs'): string {
-  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};\n` : '';
+  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};\n` : ''
   return `import handler from ${JSON.stringify(specifier)};
 import { NextRequest } from 'next/server';
 import { Writable } from 'node:stream';
@@ -518,10 +513,10 @@ async function run(handler, request) {
   }
   return new Response(body, { status: state.status, headers: state.headers });
 }
-`;
+`
 }
 
 function relativeImport(fromFile: string, targetFile: string): string {
-  const relative = toPosixPath(path.relative(path.dirname(fromFile), targetFile));
-  return relative.startsWith('.') ? relative : `./${relative}`;
+  const relative = toPosixPath(path.relative(path.dirname(fromFile), targetFile))
+  return relative.startsWith('.') ? relative : `./${relative}`
 }

package/src/compat/ppr/io.ts

@@ -4,8 +4,8 @@
 // scope it is a no-op (the cache is filled at build, so post-io content is buildtime), and without
 // cacheComponents it is a no-op entirely.
 
-import { cacheComponents, hangingPromise, isPrerendering } from '../../ppr';
-import { insideDataCacheProducer } from '../cache/revalidate';
+import { cacheComponents, hangingPromise, isPrerendering } from '../../render/ppr'
+import { insideDataCacheProducer } from '../cache/revalidate'
 
 /**
  * A resolved promise pre-tagged with React's tracked-thenable state (`status: 'fulfilled'`).
@@ -16,12 +16,12 @@ import { insideDataCacheProducer } from '../cache/revalidate';
  */
 function resolvedIo(): Promise<void> {
   const promise = Promise.resolve() as Promise<void> & {
-    status?: string;
-    value?: undefined;
-  };
-  promise.status = 'fulfilled';
-  promise.value = undefined;
-  return promise;
+    status?: string
+    value?: undefined
+  }
+  promise.status = 'fulfilled'
+  promise.value = undefined
+  return promise
 }
 
 /**
@@ -29,10 +29,10 @@ function resolvedIo(): Promise<void> {
  * prerender / request / use-cache / no-cacheComponents matrix.
  */
 export function io(): Promise<void> {
-  if (!cacheComponents()) return resolvedIo();
+  if (!cacheComponents()) return resolvedIo()
   // Inside a `use cache` / unstable_cache producer the cache boundary wins: the
   // value is produced at build, so io() does not postpone.
-  if (insideDataCacheProducer()) return resolvedIo();
-  if (isPrerendering()) return hangingPromise<void>('io()');
-  return resolvedIo();
+  if (insideDataCacheProducer()) return resolvedIo()
+  if (isPrerendering()) return hangingPromise<void>('io()')
+  return resolvedIo()
 }