@wular/pnext 0.0.4 → 0.0.6

package/src/compat/register/index.ts

@@ -10,42 +10,39 @@
 // own. This file re-runs that registrar (idempotent) so calling it alone still yields a fully wired
 // compat layer.
 
-import type { ResolvedConfig } from '../../config';
-import { registerCompatBootExtensions } from './boot';
-import type * as BuildTier from './build-tier';
-import { registerCacheExtensions } from './cache';
-import { registerActionExtensions } from './actions';
-import { registerRenderExtensions } from './render';
-import { registerProxyExtensions } from './proxy';
-import { registerConfigSource } from './config';
-import {
-  registerProtocolExtensions,
-  registerProtocolRequestValidation,
-} from './protocol';
-import { registerLifecycleExtensions } from './lifecycle';
-import { registerImageExtensions } from './image';
-import { registerErrorExtensions } from './errors';
-import { registerFontExtensions } from './font';
-import { registerStaticImageExtensions } from './static-image';
-import { registerUseCacheExtensions } from './usecache';
-import { registerClientErrorExtensions } from './client-errors';
-import { registerPprExtensions } from './ppr';
-import { registerMdxExtensions } from './mdx';
-import { registerOtelExtensions, registerOtelRootInterceptor } from './otel';
-import { registerInstrumentationClientExtensions } from './instrumentation-client';
-import { registerMiscExtensions } from './misc';
-import { registerCssExtrasExtensions } from './css-extras';
-import { registerSegmentExtensions } from './segment';
-import { registerBundlerExtensions } from './bundler';
-import { registerPagesApiExtensions } from './pages-api';
-import { registerEdgeRuntimeExtensions } from './edge-runtime';
+import type { ResolvedConfig } from '../../config'
+import { registerCompatBootExtensions } from './boot'
+import type * as BuildTier from './build-tier'
+import { registerCacheExtensions } from './cache'
+import { registerActionExtensions } from './actions'
+import { registerRenderExtensions } from './render'
+import { registerProxyExtensions } from './proxy'
+import { registerConfigSource } from './config'
+import { registerProtocolExtensions, registerProtocolRequestValidation } from './protocol'
+import { registerLifecycleExtensions } from './lifecycle'
+import { registerImageExtensions } from './image'
+import { registerErrorExtensions } from './errors'
+import { registerFontExtensions } from './font'
+import { registerStaticImageExtensions } from './static-image'
+import { registerUseCacheExtensions } from './use-cache'
+import { registerClientErrorExtensions } from './client-errors'
+import { registerPprExtensions } from './ppr'
+import { registerMdxExtensions } from './mdx'
+import { registerOtelExtensions, registerOtelRootInterceptor } from './otel'
+import { registerInstrumentationClientExtensions } from './instrumentation-client'
+import { registerMiscExtensions } from './taint'
+import { registerCssExtrasExtensions } from './css-extras'
+import { registerSegmentExtensions } from './segment'
+import { registerBundlerExtensions } from './bundler'
+import { registerPagesApiExtensions } from './pages-api'
+import { registerEdgeRuntimeExtensions } from './edge-runtime'
 
 export interface RegisterCompatOptions {
   /**
    * Serving only (the dev server). Skips the build-only domains — nothing on a
    * request path reads what they register — so their module graphs never load.
    */
-  serve?: boolean;
+  serve?: boolean
 }
 
 export async function registerCompatExtensions(
@@ -56,56 +53,56 @@ export async function registerCompatExtensions(
   // outright when only serving (see RegisterCompatOptions.serve).
   const build: typeof BuildTier | undefined = options.serve
     ? undefined
-    : await import('./build-tier');
+    : await import('./build-tier')
   // Route conventions, page/CSS extensions, module aliases, proxy names and the
   // lifecycle init hooks — already done when the boot tier ran first.
-  registerCompatBootExtensions(config);
-  build?.registerBuildCompatExtensions();
-  registerConfigSource();
+  registerCompatBootExtensions(config)
+  build?.registerBuildCompatExtensions()
+  registerConfigSource()
   // The otel ROOT-span interceptor must run before every short-circuiting
   // interceptor (segment prefetch, RSC protocol, action dispatch) so those
   // responses are traced too; the rest of otel registers last (below).
-  registerOtelRootInterceptor(config);
+  registerOtelRootInterceptor(config)
   // Protocol validation next: an invalid next-router-state-tree must 500 before
   // the segment/action interceptors answer the request.
-  registerProtocolRequestValidation(config);
+  registerProtocolRequestValidation(config)
   // Typed-routes typegen and typecheck run before structural validation so a type error surfaces ahead of
   // runtime checks, matching `next build`, which runs tsc before its own validations. The typecheck only
   // covers .ts/.tsx pages/layouts/handlers via the generated validator, so JS-only fixtures still fall
   // through to the structural validation below with their runtime error message.
-  build?.registerTypedRoutesExtensions(config);
+  build?.registerTypedRoutesExtensions(config)
   // Build validation fails fast before the remaining build steps run.
-  build?.registerValidationExtensions(config);
-  registerCacheExtensions(config);
+  build?.registerValidationExtensions(config)
+  registerCacheExtensions(config)
   // Before actions: the /_tree prefetch responder must intercept ahead of the
   // action dispatch interceptor.
-  registerSegmentExtensions(config);
-  registerActionExtensions(config);
-  registerPagesApiExtensions(config);
-  registerEdgeRuntimeExtensions();
-  registerRenderExtensions(config);
-  registerProxyExtensions(config);
-  registerProtocolExtensions(config);
-  registerLifecycleExtensions(config);
-  registerImageExtensions(config);
-  registerErrorExtensions(config);
-  registerFontExtensions(config);
-  build?.registerMiddlewareExtensions();
-  build?.registerExportExtensions(config);
-  registerStaticImageExtensions();
-  registerUseCacheExtensions(config);
-  registerClientErrorExtensions(config);
-  registerPprExtensions(config);
-  registerMiscExtensions(config);
-  registerBundlerExtensions(config);
+  registerSegmentExtensions(config)
+  registerActionExtensions(config)
+  registerPagesApiExtensions(config)
+  registerEdgeRuntimeExtensions()
+  registerRenderExtensions(config)
+  registerProxyExtensions(config)
+  registerProtocolExtensions(config)
+  registerLifecycleExtensions(config)
+  registerImageExtensions(config)
+  registerErrorExtensions(config)
+  registerFontExtensions(config)
+  build?.registerMiddlewareExtensions()
+  build?.registerExportExtensions(config)
+  registerStaticImageExtensions()
+  registerUseCacheExtensions(config)
+  registerClientErrorExtensions(config)
+  registerPprExtensions(config)
+  registerMiscExtensions(config)
+  registerBundlerExtensions(config)
   // After registerActionExtensions: composes (not clobbers) clientEsbuildPlugins.
-  registerCssExtrasExtensions(config);
+  registerCssExtrasExtensions(config)
   // MDX last: it composes (not clobbers) clientEsbuildPlugins, so it must
   // capture every previously-registered plugin factory.
-  registerMdxExtensions(config);
+  registerMdxExtensions(config)
   // Otel after everything: its route re-stamp interceptor must observe the
   // post-rewrite request (the root span opens in the EARLY interceptor above).
-  registerOtelExtensions(config);
+  registerOtelExtensions(config)
   // After otel: composes (not clobbers) the documentHeadTags extension.
-  registerInstrumentationClientExtensions(config);
+  registerInstrumentationClientExtensions(config)
 }

package/src/compat/register/instrumentation-client.ts

@@ -11,25 +11,25 @@
 // The router-side hook is surfaced through the `window.__PNEXT_ON_ROUTER_TRANSITION_START__` global the
 // bundle registers; the client router calls it at the start of push/replace/traverse navigations.
 
-import type { ResolvedConfig } from '../../config';
-import { registerBuildSteps } from '../../extensions';
-import { getDocumentScriptExtensions, setDocumentScriptExtensions } from '../../render/hooks';
-import { nextCompatEnabled } from '../index';
+import type { ResolvedConfig } from '../../config'
+import { registerBuildSteps } from '../../extensions'
+import { getDocumentScriptExtensions, setDocumentScriptExtensions } from '../../render/hooks'
+import { nextCompatEnabled } from '../aliases'
 import {
   buildInstrumentationClient,
   instrumentationClientHeadTag,
-} from '../lifecycle/instrumentation-client';
+} from '../lifecycle/instrumentation-client'
 
 export function registerInstrumentationClientExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
 
   registerBuildSteps(async ctx => {
-    await buildInstrumentationClient(ctx.config);
-  });
+    await buildInstrumentationClient(ctx.config)
+  })
 
-  const previousHeadTags = getDocumentScriptExtensions().documentHeadTags;
+  const previousHeadTags = getDocumentScriptExtensions().documentHeadTags
   setDocumentScriptExtensions({
     documentHeadTags: (cfg, ctx) =>
       `${previousHeadTags?.(cfg, ctx) ?? ''}${instrumentationClientHeadTag(cfg)}`,
-  });
+  })
 }

package/src/compat/register/lifecycle.ts

@@ -14,73 +14,70 @@
 // registerLifecycleBootHooks(), while the request interceptor registers with the rest of the graph so its
 // position in the interceptor chain is unchanged.
 
-import type { ResolvedConfig } from '../../config';
+import type { ResolvedConfig } from '../../config'
 import {
   registerInitHooks,
   registerRequestInterceptors,
   setRequestExtensions,
   type RequestInterceptor,
-} from '../../extensions';
-import { nextCompatEnabled } from '../index';
-import { getNextConfig } from '../next/config-loader';
-import { instrumentationReady, loadInstrumentation } from '../lifecycle/instrumentation';
-import {
-  installUnhandledRejectionGuard,
-  reportRequestErrorToUser,
-} from '../lifecycle/error-funnel';
-import { activateTestProxy, installTestProxyFetch } from '../lifecycle/testmode';
-import { recordRequestPath } from '../lifecycle/after-scope';
-import { installNodeConsoleFormat } from '../lifecycle/node-console';
+} from '../../extensions'
+import { nextCompatEnabled } from '../aliases'
+import { getNextConfig } from '../next/config-loader'
+import { instrumentationReady, loadInstrumentation } from '../lifecycle/instrumentation'
+import { installUnhandledRejectionGuard, reportRequestErrorToUser } from '../lifecycle/error-funnel'
+import { activateTestProxy, installTestProxyFetch } from '../lifecycle/testmode'
+import { recordRequestPath } from '../lifecycle/after-scope'
+import { installNodeConsoleFormat } from '../lifecycle/node-console'
 
 /** experimental.testProxy from the loaded next.config. */
 function testProxyEnabled(): boolean {
-  const experimental = getNextConfig().experimental as { testProxy?: boolean } | undefined;
-  return experimental?.testProxy === true;
+  const experimental = getNextConfig().experimental as { testProxy?: boolean } | undefined
+  return experimental?.testProxy === true
 }
 
 /** Boot tier: everything that must be installed before the server starts. */
 export function registerLifecycleBootHooks(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
-  installNodeConsoleFormat();
+  if (!nextCompatEnabled(config)) return
+  installNodeConsoleFormat()
 
   // The user's onRequestError hook (once instrumentation has loaded) receives
   // every real request error; control-flow errors are filtered in the funnel.
-  setRequestExtensions({ onRequestError: reportRequestErrorToUser });
+  setRequestExtensions({ onRequestError: reportRequestErrorToUser })
 
   // Keep the server alive when an SSR error escapes as an unhandled rejection
   // (a client component that throws during server render — preact resolves the
   // string pass to '' and floats the rejection). Without this the process
   // crashes and every later request in the shared harness server fails.
-  installUnhandledRejectionGuard();
+  installUnhandledRejectionGuard()
 
   // Load instrumentation and patch fetch at server start. The fetch patch is a no-op until a request
   // activates the test proxy. Instrumentation register() must NOT run during a build: Next only detects
   // the file at build and runs register() at server boot, so build prerenders see a noop tracer - a live
   // TracerProvider at build would bake real span ids into the static shell and 'use cache' entries.
   registerInitHooks((cfg, context) => {
-    if (!context.build) loadInstrumentation(cfg);
-    installTestProxyFetch();
-  });
+    if (!context.build) loadInstrumentation(cfg)
+    installTestProxyFetch()
+  })
 }
 
 export function registerLifecycleExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
 
   const lifecycleInterceptor: RequestInterceptor = async request => {
     // Block the very first requests until instrumentation register() settles.
-    await instrumentationReady();
+    await instrumentationReady()
     // Remember the route pathname so an after() callback that runs detached
     // (after a page render) can name the route in its "used ... inside after()"
     // error, matching Next's message.
     try {
-      recordRequestPath(new URL(request.url).pathname);
+      recordRequestPath(new URL(request.url).pathname)
     } catch {
       // ignore malformed URLs
     }
     // Route this request's outgoing fetch through the test proxy when it carries
     // Next-Test-* headers (gated on experimental.testProxy in next.config).
-    if (testProxyEnabled()) activateTestProxy(request.headers);
-    return undefined;
-  };
-  registerRequestInterceptors(lifecycleInterceptor);
+    if (testProxyEnabled()) activateTestProxy(request.headers)
+    return undefined
+  }
+  registerRequestInterceptors(lifecycleInterceptor)
 }

package/src/compat/register/mdx.ts

@@ -22,18 +22,18 @@
 //    extensions at boot, so the registration itself lives in register-boot.ts; only the compilation
 //    wiring is here.
 
-import type { Plugin } from 'esbuild';
-import type { ResolvedConfig } from '../../config';
-import { getBundlerExtensions, setBundlerExtensions } from '../../extensions';
-import { nextCompatEnabled } from '../../render/hooks';
-import { mdxEsbuildPlugin } from '../mdx/plugin';
+import type { Plugin } from 'esbuild'
+import type { ResolvedConfig } from '../../config'
+import { getBundlerExtensions, setBundlerExtensions } from '../../extensions'
+import { nextCompatEnabled } from '../../render/hooks'
+import { mdxEsbuildPlugin } from '../mdx/plugin'
 
 export function registerMdxExtensions(config: ResolvedConfig): void {
-  if (!nextCompatEnabled(config)) return;
+  if (!nextCompatEnabled(config)) return
 
-  const existing = getBundlerExtensions();
-  const priorClient = existing.clientEsbuildPlugins;
-  const priorServer = existing.serverEsbuildPlugins;
+  const existing = getBundlerExtensions()
+  const priorClient = existing.clientEsbuildPlugins
+  const priorServer = existing.serverEsbuildPlugins
 
   setBundlerExtensions({
     clientEsbuildPlugins: (cfg: ResolvedConfig): Plugin[] => [
@@ -44,5 +44,5 @@ export function registerMdxExtensions(config: ResolvedConfig): void {
       ...priorServer(cfg, opts),
       mdxEsbuildPlugin(config.root),
     ],
-  });
+  })
 }

package/src/compat/register/middleware.ts

@@ -3,21 +3,29 @@
 // functions-config-manifest.json). The middleware runtime itself is the existing proxy machinery; this
 // module owns only the build-time manifest output.
 
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { registerBuildSteps } from '../../extensions';
-import { nextCompatEnabled } from '../../compat';
-import { findProxyFile, proxyExternalLoadTarget } from '../../proxy';
-import { devServerModuleHref } from '../../dev/imports';
-import { toPosixPath } from '../../utils/fs';
-import type { RouteManifestEntry } from '../../types';
-import { writeMiddlewareManifests } from '../middleware/manifest';
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { registerBuildSteps } from '../../extensions'
+import { nextCompatEnabled } from '../../compat/aliases'
+import {
+  findProxyFile,
+  proxyExternalLoadTarget,
+  type ProxyConfig,
+  type ProxyModule,
+} from '../../routing/proxy'
+import { devServerModuleHref } from '../../runtime/modules'
+import { pathToFileHref, type ResolvedConfig } from '../../config'
+import { toPosixPath } from '../../utils/fs'
+import type { RouteManifestEntry } from '../../types'
+import { readMiddlewareWasmBindingsForOutPath } from '../bundler/wasm'
+import { preferredRegionForRoute } from '../next/preferred-region'
 
 export function registerMiddlewareExtensions(): void {
   registerBuildSteps(async ({ config, routes }) => {
-    if (!nextCompatEnabled(config)) return;
-    const file = findProxyFile(config);
-    let relative: string | undefined;
+    if (!nextCompatEnabled(config)) return
+    const file = findProxyFile(config)
+    let relative: string | undefined
     if (file) {
       // Must name the SAME artifact buildProxyModule emits (the build copies it to
       // .next/server/middleware.js), so every option that keys the compile profile is spelled out here - a
@@ -27,10 +35,212 @@ export function registerMiddlewareExtensions(): void {
         conditionTarget: 'edge',
         externalLoadTarget: proxyExternalLoadTarget(file),
         reactServerLayer: true,
-      });
-      relative = toPosixPath(path.relative(config.outPath, fileURLToPath(href)));
+      })
+      relative = toPosixPath(path.relative(config.outPath, fileURLToPath(href)))
     }
     // Edge-runtime segments produce manifest entries even with no middleware.
-    await writeMiddlewareManifests(config, relative, routes as RouteManifestEntry[]);
-  });
+    await writeMiddlewareManifests(config, relative, routes as RouteManifestEntry[])
+  })
+}
+
+// Middleware manifest emission.
+//
+// Writes the two Next-shaped manifests a few suites read directly from the build output:
+//   - `<out>/server/middleware-manifest.json`: the edge-middleware entry with its compiled matchers,
+//     entrypoint and files list.
+//   - `<out>/server/functions-config-manifest.json`: the node-runtime variant, when the middleware opts
+//     into `runtime: 'nodejs'`.
+//
+// Only the fields the tests read are populated. A pure-core app writes neither.
+
+interface ManifestMatcher {
+  regexp: string
+  originalSource: string
+}
+
+interface MiddlewareEntry {
+  name: string
+  page: string
+  matchers: ManifestMatcher[]
+  wasm: { name: string; filePath: string }[]
+  assets: never[]
+  files: string[]
+  entrypoint: string
+  env: Record<string, string>
+}
+
+interface MiddlewareManifest {
+  version: number
+  sortedMiddleware: string[]
+  middleware: Record<string, MiddlewareEntry>
+  functions: Record<string, unknown>
+}
+
+interface FunctionsConfigManifest {
+  version: number
+  functions: Record<string, { runtime: string; matchers: ManifestMatcher[] }>
+}
+
+/**
+ * Emit the middleware manifests for the resolved proxy file, if any. `entryFile`
+ * is the compiled proxy module path (relative to `outPath`, posix) produced by
+ * the build; it is recorded as the manifest `entrypoint` under `server/`.
+ */
+export async function writeMiddlewareManifests(
+  config: ResolvedConfig,
+  entryFile: string | undefined,
+  routes: RouteManifestEntry[] = [],
+): Promise<void> {
+  const source = findProxyFile(config)
+  // Edge-runtime app segments are manifest `functions` entries alongside the
+  // middleware, keyed by their app path (route groups included) — an app with
+  // an edge page and no middleware still writes the manifest for them.
+  const functions = edgeFunctionEntries(config, routes)
+  if (!source || !entryFile) {
+    if (Object.keys(functions).length === 0) return
+    const serverDir = path.join(config.outPath, 'server')
+    await mkdir(serverDir, { recursive: true })
+    await writeFile(
+      path.join(serverDir, 'middleware-manifest.json'),
+      `${JSON.stringify({ ...emptyMiddlewareManifest(), functions }, null, 2)}\n`,
+    )
+    return
+  }
+
+  const moduleFile = path.resolve(config.outPath, entryFile)
+  const module = (await import(pathToFileHref(moduleFile))) as ProxyModule
+  const matchers = manifestMatchers(module.config)
+  const runtime = proxyRuntime(module.config)
+  const entrypoint = toServerEntrypoint(entryFile)
+
+  const serverDir = path.join(config.outPath, 'server')
+  await mkdir(serverDir, { recursive: true })
+
+  if (runtime === 'nodejs') {
+    const functionsConfig: FunctionsConfigManifest = {
+      version: 1,
+      functions: { '/_middleware': { runtime: 'nodejs', matchers } },
+    }
+    await writeFile(
+      path.join(serverDir, 'functions-config-manifest.json'),
+      `${JSON.stringify(functionsConfig, null, 2)}\n`,
+    )
+    // A node-runtime middleware still lists an empty edge middleware manifest so
+    // consumers that always read it find a valid (empty) shape.
+    await writeFile(
+      path.join(serverDir, 'middleware-manifest.json'),
+      `${JSON.stringify({ ...emptyMiddlewareManifest(), functions }, null, 2)}\n`,
+    )
+    return
+  }
+
+  const entry: MiddlewareEntry = {
+    name: 'middleware',
+    page: '/',
+    matchers,
+    wasm: readMiddlewareWasmBindingsForOutPath(config.outPath),
+    assets: [],
+    files: [entrypoint],
+    entrypoint,
+    env: {},
+  }
+  const manifest: MiddlewareManifest = {
+    version: 3,
+    sortedMiddleware: ['/'],
+    middleware: { '/': entry },
+    functions,
+  }
+  await writeFile(
+    path.join(serverDir, 'middleware-manifest.json'),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+  )
+}
+
+function emptyMiddlewareManifest(): MiddlewareManifest {
+  return { version: 3, sortedMiddleware: [], middleware: {}, functions: {} }
+}
+
+/**
+ * Manifest `functions` entries for app segments that declared
+ * `export const runtime = 'edge'`. Next keys them by the segment's app path
+ * (route groups kept, e.g. `/(group)/group/page`) and records the URL the
+ * segment answers as its matcher.
+ */
+function edgeFunctionEntries(
+  config: ResolvedConfig,
+  routes: RouteManifestEntry[],
+): Record<string, unknown> {
+  const entries: Record<string, unknown> = {}
+  if (!config.appPath) return entries
+  for (const route of routes) {
+    const runtime = route.segmentConfig?.runtime
+    if (runtime !== 'edge' && runtime !== 'experimental-edge') continue
+    const page = appManifestKey(config.appPath, route.file)
+    if (!page) continue
+    const regions = preferredRegionForRoute(route)
+    entries[page] = {
+      files: [],
+      name: `app${page}`,
+      page,
+      matchers: [{ regexp: `^${routeMatcherRegexp(route.route)}$`, originalSource: route.route }],
+      wasm: [],
+      assets: [],
+      env: {},
+      ...(regions ? { regions } : {}),
+    }
+  }
+  return entries
+}
+
+// `<app>/(group)/group/page.tsx` → `/(group)/group/page`.
+function appManifestKey(appPath: string, file: string): string | undefined {
+  const relative = toPosixPath(path.relative(appPath, file))
+  if (!relative || relative.startsWith('..')) return undefined
+  return `/${relative.replace(/\.[^./]+$/, '')}`
+}
+
+// The URL regexp Next records for a segment: literal path with each dynamic
+// segment widened to a single path part.
+function routeMatcherRegexp(route: string): string {
+  return route.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/:([^/\\]+)/g, '[^/]+')
+}
+
+// Compile config.matcher entries into { regexp, originalSource } pairs. With no
+// matcher, the middleware runs on every path: Next records the `/:path*` source
+// and its `^/.*$` regexp.
+function manifestMatchers(config: ProxyConfig | undefined): ManifestMatcher[] {
+  const matcher = config?.matcher
+  if (!matcher) return [{ regexp: '^/.*$', originalSource: '/:path*' }]
+  const list = Array.isArray(matcher) ? matcher : [matcher]
+  return list.map(item => {
+    const originalSource = typeof item === 'string' ? item : item.source
+    return { regexp: `^${matcherRegexp(originalSource)}$`, originalSource }
+  })
+}
+
+// Mirror src/proxy.ts matcherPattern for the manifest regexp string (kept in
+// sync with the runtime matcher). Raw regex sources pass through unchanged.
+function matcherRegexp(matcher: string): string {
+  if (matcher.includes('(')) return matcher
+  if (matcher === '/') return '/'
+  let source = ''
+  for (const segment of matcher.split('/').filter(Boolean)) {
+    if (/^:[^/]+\*$/.test(segment)) source += '(?:/.*)?'
+    else if (/^:[^/]+$/.test(segment)) source += '/[^/]+'
+    else source += `/${segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`
+  }
+  return source || '/'
+}
+
+function proxyRuntime(config: ProxyConfig | undefined): 'edge' | 'nodejs' {
+  const runtime = (config as { runtime?: unknown } | undefined)?.runtime
+  return runtime === 'nodejs' ? 'nodejs' : 'edge'
+}
+
+// Record the compiled entry under the `server/` prefix Next uses, forcing a
+// `.js` extension (the manifest tests assert `^server/.+\.(js|mjs|cjs)$`).
+function toServerEntrypoint(entryFile: string): string {
+  const posix = toPosixPath(entryFile).replace(/^\.?\//, '')
+  const withinServer = posix.startsWith('server/') ? posix : `server/${path.posix.basename(posix)}`
+  return withinServer.replace(/\.[^./]+$/, '.js')
 }