@wular/pnext 0.1.5 → 0.1.7

package/src/render/renderer.ts

@@ -3,7 +3,6 @@ import { stat, unlink, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative, sep } from 'node:path'
 import { createHash } from 'node:crypto'
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { drainPreplanBuilds } from '../runtime/vendor'
 import {
   Component,
   Fragment,
@@ -29,10 +28,13 @@ import { markErrorLogged } from '../utils/error-log'
 import {
   devClientModuleHref,
   devServerModuleHref,
+  drainPreplanBuilds,
   importDevModule,
   importModuleOnce,
-} from '../runtime/modules'
-import { serverBundleTargetForRuntime } from '../runtime/loader'
+  registerServerRuntime,
+  serverBundleTargetForRuntime,
+} from '../runtime/load'
+import { conventionFileExists, productionRelease, servedConventions } from '../runtime/production'
 import {
   getActionModuleExtensions,
   getActiveMetadataExtensions,
@@ -63,7 +65,7 @@ import {
   routeCssAssetNames,
   routeCssHref,
   withAssetPrefix,
-} from '../css/build'
+} from '../css/assets'
 import { dynamicReferenceSymbol, type DynamicReference } from '../api/dynamic'
 import {
   isForbiddenError,
@@ -98,13 +100,11 @@ import {
   trackPrerenderDynamic,
 } from './ppr'
 import {
-  collectFileCss,
-  collectNotFoundCss,
   findConventionFiles,
   findGlobalError,
   findLayouts,
   serverActionsUnsupportedMessage,
-} from '../routing/routes'
+} from '../routing/match'
 import { matchSegments, pathnameSegments, slotDirectoriesIn } from '../routing/slots'
 import { getRequestRuntime } from '../routing/request-environment'
 import { toNextRequest } from '../api/server'
@@ -121,7 +121,6 @@ import {
   ISLAND_BOUNDARY_ERROR_MESSAGE_ATTRIBUTE,
 } from './boundary-error'
 import { captureCacheScope, runWithCacheScope } from '../request/cache'
-import { registerServerRuntime } from '../runtime/loader'
 import { readText } from '../utils/fs'
 import { traceEnabled } from '../utils/trace-flags'
 import {
@@ -804,7 +803,7 @@ function moduleHref(file: string, options: ModuleLoadOptions) {
     ? devServerModuleHref(options.config, file, options.devImportVersion ?? String(Date.now()), {
         conditionTarget,
       })
-    : reactCompatEnabled(options.config)
+    : reactCompatEnabled(options.config) || productionRelease(options.config)
       ? devServerModuleHref(options.config, file, 'build', { conditionTarget })
       : pathToFileHref(file)
 }
@@ -851,6 +850,17 @@ async function importClientModule(file: string, options: ModuleLoadOptions) {
   return importModuleOnce<Record<string, unknown>>(href)
 }
 
+/** A synthetic route's CSS: in a release, the stylesheet its build emitted; else a source scan. */
+async function syntheticRouteCss(
+  config: ResolvedConfig,
+  id: string,
+  scan: (routes: typeof import('../routing/routes')) => Promise<string[]>,
+) {
+  if (!productionRelease(config)) return scan(await import('../routing/routes'))
+  const name = `${id}.css`
+  return emittedAssetName(config, name) === name ? [] : [name]
+}
+
 function clientScriptPath(route: RouteManifestEntry, dev?: boolean) {
   return dev
     ? `/__pnext/client/${route.id}.js`
@@ -1530,7 +1540,7 @@ async function serializablePageProps(props: PageProps, omitSearchParams = false)
 
 export async function staticParamsFor(config: ResolvedConfig, route: RouteManifestEntry) {
   const moduleFiles = [
-    ...findLayouts(config.appPath, route.file).filter(file => existsSync(file)),
+    ...findLayouts(config.appPath, route.file).filter(conventionFileExists),
     route.file,
   ]
   let paramSets: Record<string, RouteParamValue>[] = [{}]
@@ -1615,7 +1625,7 @@ export async function renderPage(options: RenderOptions) {
 export async function renderPageWithStatus(
   options: RenderOptions,
 ): Promise<{ html: string; status: number; location?: string }> {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   await seedPrerenderSidecar(options)
   const request = renderScopeRequest(options)
   return runWithRequest(
@@ -1648,7 +1658,7 @@ export async function renderPageWithStatus(
 }
 
 export async function renderPageStream(options: RenderOptions) {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   await seedPrerenderSidecar(options)
 
   const request = renderScopeRequest(options)
@@ -1666,7 +1676,7 @@ export async function renderPageStream(options: RenderOptions) {
 }
 
 export async function renderPageResponse(options: RenderOptions) {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   const method = options.request?.method.toUpperCase() ?? 'GET'
   if (method !== 'GET' && method !== 'HEAD') {
     return new Response('Method Not Allowed', {
@@ -1871,7 +1881,7 @@ const rejectedPprShellUpgrades = new Set<string>()
  * when dynamic data escapes every boundary - the route must then be served fully dynamically.
  */
 export async function renderPartialShell(options: RenderOptions): Promise<PrebuiltShell | null> {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   const sidecar = getRenderExtensions().prerenderSidecar
   const sidecarContext = prerenderSidecarContext(options)
   await sidecar.begin(sidecarContext)
@@ -1960,7 +1970,7 @@ export async function renderPartialShell(options: RenderOptions): Promise<Prebui
 export async function renderRuntimePrefetchDocument(
   options: RenderOptions,
 ): Promise<{ html: string; postponed: boolean } | null> {
-  registerServerRuntime(options.config, options.route.sourceFiles)
+  await registerServerRuntime(options.config, options.route.sourceFiles)
   // Seed (read-only) the resume-data sidecar so 'use cache' scopes resolve
   // their build-time fills; unlike renderPartialShell nothing is collected or
   // persisted back.
@@ -2512,7 +2522,7 @@ function hasParamFreeRootLayout(config: ResolvedConfig): boolean {
   const cached = paramFreeRootLayoutCache.get(config.appPath)
   if (cached !== undefined) return cached
   const found = ['tsx', 'jsx', 'ts', 'js'].some(ext =>
-    existsSync(join(config.appPath, `layout.${ext}`)),
+    conventionFileExists(join(config.appPath, `layout.${ext}`)),
   )
   paramFreeRootLayoutCache.set(config.appPath, found)
   return found
@@ -2636,7 +2646,7 @@ export async function renderGlobalNotFoundResponse(
 ) {
   const globalFile = ['tsx', 'ts', 'jsx', 'js']
     .map(ext => `${options.config.appPath}/global-not-found.${ext}`)
-    .find(candidate => existsSync(candidate))
+    .find(conventionFileExists)
   // Render as GET regardless of the original method: the 404 page is what a
   // browser should see for a stray POST too (Next's MPA fallback), not a 405.
   const notFoundRequest = options.request
@@ -2664,9 +2674,9 @@ export async function renderGlobalNotFoundResponse(
       // Include CSS shared with the root layout: this document replaces the
       // whole page (no root layout render), so the global sheet isn't linked
       // and anything it covered must ship in this route's own chunk.
-      cssImports: await collectFileCss(options.config.appPath, [globalFile], {
-        includeGlobalCss: true,
-      }),
+      cssImports: await syntheticRouteCss(options.config, 'global-not-found', routes =>
+        routes.collectFileCss(options.config.appPath, [globalFile], { includeGlobalCss: true }),
+      ),
       sourceFiles: [globalFile],
       synthetic: true,
     }
@@ -2706,7 +2716,9 @@ export async function renderGlobalNotFoundResponse(
       clientReferences: rootRoute?.clientReferences ?? [],
       // Root not-found ships its own CSS (`/assets/not-found.css`) alongside the
       // root-layout global sheet (`/assets/global.css`, emitted via globalCssHref).
-      cssImports: await collectNotFoundCss(options.config.appPath),
+      cssImports: await syntheticRouteCss(options.config, 'not-found', routes =>
+        routes.collectNotFoundCss(options.config.appPath),
+      ),
       sourceFiles: rootRoute?.sourceFiles ?? [anchor],
       ...(rootRoute?.needsRouterEntry ? { needsRouterEntry: true } : {}),
       // Serve the ROOT route's built client entry: the synthetic id has no
@@ -2863,6 +2875,8 @@ const documentLayoutDefaults = new Map<string, { mtimeMs: number; hasDefault: bo
 async function routeHasDocumentLayout(layoutFiles: string[]) {
   const rootLayout = layoutFiles[0]
   if (!rootLayout) return false
+  const served = servedConventions()
+  if (served) return served.documentLayouts.has(rootLayout)
   let mtimeMs: number
   try {
     mtimeMs = statSync(rootLayout).mtimeMs
@@ -2923,7 +2937,7 @@ async function pageRender(options: RenderOptions, stream: boolean): Promise<Page
       // Drop the non-existent anchor file so we don't try to import it; the
       // layout's `children` is supplied by the `@children` slot instead (see
       // childrenFromSlots).
-      if (pageFile && !existsSync(pageFile)) pageFile = undefined
+      if (pageFile && !conventionFileExists(pageFile)) pageFile = undefined
     }
     const props = profileRenderSyncStep(profile, 'create page props', () =>
       createPageProps(options),
@@ -3254,7 +3268,7 @@ async function renderAuthInterruptPage(
   const fallbackTree = httpAccessFallbackTree(status, message)
   const file = nearestConventionFile(options, `${kind}.tsx`)
   const boundaryOptions = optionsForNotFoundBoundary(options, file)
-  if (!file || !existsSync(file)) {
+  if (!file || !conventionFileExists(file)) {
     return renderTreeOrFallback(
       boundaryOptions,
       fallbackTree,
@@ -3322,7 +3336,7 @@ async function renderGlobalErrorPage(
     // global-error.js is a client component ('use client'): import it through
     // the client module loader and SSR it to a full document. Server components
     // (no directive) load through the server loader.
-    const clientDirective = hasUseClientDirective(await readText(file))
+    const clientDirective = await conventionUsesClient(file)
     const module = (
       clientDirective ? await importClientModule(file, options) : await importModule(file, options)
     ) as ErrorModule
@@ -3956,7 +3970,7 @@ async function renderTreeInFrame(
     // global-not-found replaces the document without the root layout, so the
     // root layout's global sheet must not load (its CSS ships in the route's
     // own chunk, built with includeGlobalCss).
-    options.route.id === 'global-not-found' ? undefined : globalCssHref(options.config)
+    options.route.id === 'global-not-found' ? undefined : await globalCssHref(options.config)
   let routeStylesheet = routeCssHref(options.route, options.config)
   // File names, not logical ones: the inline path READS these off disk, so it has
   // to spell them the way the build emitted them (content-hashed in production).
@@ -4378,7 +4392,7 @@ async function buildLoadingBoundaries(
     options.route.file,
     'loading.tsx',
   )) {
-    if (!existsSync(loadingFile)) continue
+    if (!conventionFileExists(loadingFile)) continue
     const fallback = await buildLoadingFallback(options, loadingFile)
     if (fallback) fallbackByDir.set(dirname(loadingFile), fallback)
   }
@@ -4485,7 +4499,7 @@ async function renderNotFoundPage(
   // A `'use client'` not-found.js with a discovered client reference renders as an island (same as
   // error.js) so it HYDRATES - its hooks must work on the 404 document. Server-rendering it would
   // serialize child event-handler props as dead action stubs.
-  const clientDirective = hasUseClientDirective(await readText(file))
+  const clientDirective = await conventionUsesClient(file)
   const clientReference = clientDirective
     ? conventionDefaultReference(notFoundOptions, file)
     : undefined
@@ -4598,7 +4612,7 @@ async function renderErrorPage(options: RenderOptions, error: unknown, stream: b
   if (!file) return renderGenericErrorPage(options, resolvedError, stream)
 
   try {
-    const clientDirective = hasUseClientDirective(await readText(file))
+    const clientDirective = await conventionUsesClient(file)
     const module = (
       clientDirective ? await importClientModule(file, options) : await importModule(file, options)
     ) as ErrorModule
@@ -4867,10 +4881,16 @@ function generatedFallbackPage(
   }
 }
 
+/** Whether a convention file is `'use client'`: the frozen fact in production, its source otherwise. */
+async function conventionUsesClient(file: string) {
+  const served = servedConventions()
+  return served ? served.client.has(file) : hasUseClientDirective(await readText(file))
+}
+
 function nearestConventionFile(options: RenderOptions, name: string) {
   return [...findConventionFiles(options.config.appPath, options.route.file, name)]
     .reverse()
-    .find(file => existsSync(file))
+    .find(conventionFileExists)
 }
 
 /**
@@ -6541,7 +6561,7 @@ function dynamicTargetReference(
   const target = dynamicReference.target
   if (!target) return undefined
   const stored = state.clientReferences.get(
-    `c-${clientReferenceId(target.file, target.exportName)}`,
+    target.id ?? `c-${clientReferenceId(target.file, target.exportName)}`,
   )
   if (stored) return stored
   for (const reference of state.clientReferences.values()) {
@@ -7616,7 +7636,7 @@ async function applyLayouts(
   await profileRenderStep(profile, 'import layouts', async () => {
     for (const layoutPath of options.layoutFiles ??
       findLayouts(options.config.appPath, options.route.file)) {
-      if (!options.moduleLoader && !existsSync(layoutPath)) continue
+      if (!options.moduleLoader && !conventionFileExists(layoutPath)) continue
       const layoutModule = (await importModule(layoutPath, options)) as LayoutModule
       markServerReference(layoutModule.default)
       // Cheap leaf span for the segment-module resolution (nested under the
@@ -8025,7 +8045,7 @@ function fullSegmentPrefetchSkipsSharedLayout(options: RenderOptions): boolean {
     options.config.appPath,
     options.route.file,
     'layout.tsx',
-  ).filter(file => existsSync(file))
+  ).filter(conventionFileExists)
   const documentDir = layoutFiles[0] ? dirname(layoutFiles[0]) : undefined
   return layoutFiles
     .slice(1)

package/src/request/context.ts

@@ -8,6 +8,7 @@ import {
   PostponeError,
 } from '../render/ppr'
 import type { NextRequest, RouteParamValue } from '../types'
+import type { Release } from '../runtime/production'
 
 // Request work-unit store (CORE seam for compat after()/onRequestError).
 //
@@ -46,6 +47,8 @@ export interface WorkUnit {
    * grows no dependency on compat.
    */
   compat?: Record<symbol, unknown>
+  /** The production release this request serves from; dev and build leave it unset. */
+  release?: Release
 }
 
 // Anchored on globalThis (like requestStorage below) so compiled compat
@@ -67,6 +70,12 @@ export function getWorkUnit(): WorkUnit | undefined {
   return workUnitStorage.getStore()
 }
 
+/** Mark the current work unit as serving `release` (production reads its app facts from it). */
+export function setWorkUnitRelease(release: Release): void {
+  const unit = workUnitStorage.getStore()
+  if (unit) unit.release = release
+}
+
 /** Set the current work-unit phase (compat toggles render/action/handler/...). */
 export function setPhase(phase: WorkUnitPhase): void {
   const unit = workUnitStorage.getStore()

package/src/resolve/dynamic.ts

@@ -1,3 +1,4 @@
+import { clientReferenceId } from '../client/reference'
 import { dynamicCallFacts, rewriteFacts, type DynamicCallFact } from './scan-facts'
 
 export interface DynamicCall {
@@ -132,7 +133,8 @@ export function rewriteDynamicCallTargets(
     const args = source.slice(call.open + 1, call.close)
     const argCount = topLevelArgCount(args)
     if (argCount < 1 || argCount > 2) continue
-    const literal = JSON.stringify({ file, exportName: target.exportName })
+    const id = `c-${clientReferenceId(file, target.exportName)}`
+    const literal = JSON.stringify({ file, exportName: target.exportName, id })
     const separator = /,\s*$/.test(args) ? '' : ', '
     edits.push({
       at: call.close,

package/src/resolve/imports.ts

@@ -10,6 +10,9 @@ import {
   tsConfigFileFor,
 } from './engine'
 import { onExtensionHostReset } from '../extensions'
+import { findWorkspaceRoot, readPackageJson, type PackageJson } from './package-json'
+
+export { findWorkspaceRoot }
 
 // `Bun` through globalThis: pnext ships TypeScript source, so app compilers without
 // bun-types typecheck this file and a bare `Bun` identifier would fail them.
@@ -45,6 +48,8 @@ export interface ExternalPackagePolicy {
    * transpile.
    */
   transpiled?: () => readonly string[]
+  /** Kept out of a release's server dependency graph beyond `external`: Next's built-in list. */
+  releaseExternal?: (packageName: string) => boolean
   /** ESM external mode for package exports interop. */
   esmExternals: () => boolean | 'loose'
 }
@@ -94,9 +99,14 @@ export function resolveExternalLoadTarget(context: ExternalLoadContext): string
   // `#imports` resolve from the importer's OWN package, so they are not
   // shareable across a resolution root; they stay uncached.
   if (context.specifier.startsWith('#')) return externalLoadResolver(context)
-  const key = `${context.target}\0${resolutionRootForFile(context.root, context.fromFile)}\0${context.specifier}`
+  // A node_modules importer resolves from its own directory, as Node does: a version nested under
+  // its package wins over the hoisted one.
+  const resolveContext = context.fromFile.includes(`${path.sep}node_modules${path.sep}`)
+    ? { ...context, root: path.dirname(context.fromFile) }
+    : context
+  const key = `${context.target}\0${resolutionRootForFile(resolveContext.root, context.fromFile)}\0${context.specifier}`
   if (externalLoadTargets.has(key)) return externalLoadTargets.get(key)
-  const target = externalLoadResolver(context)
+  const target = externalLoadResolver(resolveContext)
   externalLoadTargets.set(key, target)
   return target
 }
@@ -143,22 +153,6 @@ export function setTsConfigPath(file: string | undefined): void {
   clearVendorPackageResolutions()
 }
 
-interface PackageJson {
-  name?: string
-  type?: string
-  browser?: string
-  main?: string
-  module?: string
-  source?: string
-  exports?: PackageExport
-  imports?: Record<string, PackageExport>
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  optionalDependencies?: Record<string, string>
-  peerDependencies?: Record<string, string>
-  workspaces?: string[] | { packages?: string[] }
-}
-
 // Compat (or any bundler extension) registers its bare-specifier to file aliases here (e.g. `next/form` ->
 // `src/compat/next/form.tsx`). Core's own route scanner has no static knowledge of those aliases otherwise,
 // so a server component importing a 'use client' compat module would never be walked into and its client
@@ -886,25 +880,6 @@ export function commonJsModuleHasDefaultExport(source: string, file: string) {
   )
 }
 
-export function findWorkspaceRoot(root: string) {
-  const key = path.resolve(root)
-  if (workspaceRootCache.has(key)) return workspaceRootCache.get(key)
-
-  let dir = key
-  while (true) {
-    if (readPackageJson(dir).workspaces || existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
-      workspaceRootCache.set(key, dir)
-      return dir
-    }
-    const parent = path.dirname(dir)
-    if (parent === dir) {
-      workspaceRootCache.set(key, undefined)
-      return undefined
-    }
-    dir = parent
-  }
-}
-
 function isInside(root: string, file: string) {
   const relative = path.relative(root, file)
   return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
@@ -962,8 +937,6 @@ function readPnpmWorkspacePatterns(root: string) {
 }
 
 const tsConfigCache = new Map<string, TsConfig>()
-const packageJsonCache = new Map<string, PackageJson>()
-const workspaceRootCache = new Map<string, string | undefined>()
 const workspacePackageCache = new Map<string, Map<string, string>>()
 
 function readTsConfig(root: string) {
@@ -975,14 +948,6 @@ function readTsConfig(root: string) {
   return config
 }
 
-function readPackageJson(root: string) {
-  const existing = packageJsonCache.get(root)
-  if (existing) return existing
-  const config = readJson<PackageJson>(path.join(root, 'package.json')) ?? {}
-  packageJsonCache.set(root, config)
-  return config
-}
-
 function workspacePackages(root: string) {
   const existing = workspacePackageCache.get(root)
   if (existing) return existing
@@ -1027,11 +992,6 @@ export function workspacePackageRoots(root: string) {
   return [...workspacePackages(path.resolve(root)).values()].sort()
 }
 
-function readJson<T>(file: string) {
-  if (!existsSync(file)) return undefined
-  return JSON.parse(readFileSync(file, 'utf8')) as T
-}
-
 function readJsonc<T>(file: string) {
   if (!existsSync(file)) return undefined
   return JSON.parse(stripTrailingCommas(stripJsonComments(readFileSync(file, 'utf8')))) as T

package/src/resolve/package-json.ts

@@ -0,0 +1,56 @@
+// package.json reads and workspace-root discovery, which config loading needs without the resolver.
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+
+type PackageExport = unknown
+
+export interface PackageJson {
+  name?: string
+  type?: string
+  browser?: string
+  main?: string
+  module?: string
+  source?: string
+  exports?: PackageExport
+  imports?: Record<string, PackageExport>
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  optionalDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+  workspaces?: string[] | { packages?: string[] }
+}
+
+const packageJsonCache = new Map<string, PackageJson>()
+const workspaceRootCache = new Map<string, string | undefined>()
+
+export function readPackageJson(root: string) {
+  const existing = packageJsonCache.get(root)
+  if (existing) return existing
+  const config = readJson<PackageJson>(path.join(root, 'package.json')) ?? {}
+  packageJsonCache.set(root, config)
+  return config
+}
+
+export function findWorkspaceRoot(root: string) {
+  const key = path.resolve(root)
+  if (workspaceRootCache.has(key)) return workspaceRootCache.get(key)
+
+  let dir = key
+  while (true) {
+    if (readPackageJson(dir).workspaces || existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
+      workspaceRootCache.set(key, dir)
+      return dir
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) {
+      workspaceRootCache.set(key, undefined)
+      return undefined
+    }
+    dir = parent
+  }
+}
+
+function readJson<T>(file: string) {
+  if (!existsSync(file)) return undefined
+  return JSON.parse(readFileSync(file, 'utf8')) as T
+}

package/src/resolve/scan-facts.ts

@@ -581,6 +581,71 @@ function child(node: AstNode | undefined, key: string): AstNode | undefined {
   return isNode(value) ? value : undefined
 }
 
+/**
+ * Drop `type: "json"` attributes from the import declarations and `import()` calls whose target
+ * `compiled` claims: the target is JS, which a native load would parse as JSON.
+ */
+export function stripJsonImportAttributes(
+  source: string,
+  file: string,
+  compiled: (specifier: string) => boolean,
+) {
+  const result = parseSync(file, source, { lang: 'js', sourceType: 'module' })
+  if (result.errors.length > 0) return source
+  const edits: { start: number; end: number; value: string }[] = []
+  const visit = (node: AstNode) => {
+    const target = child(node, 'source')
+    const specifier = stringValue(target)
+    if (target && specifier !== undefined && compiled(specifier)) {
+      const attributes = node.attributes as AstNode[] | undefined
+      const options = child(node, 'options')
+      if (attributes?.length && attributes.every(jsonTypeAttribute)) {
+        const end = source.indexOf('}', attributes.at(-1)!.end) + 1
+        edits.push({ start: target.end, end, value: '' })
+      } else if (node.type === 'ImportExpression' && options && jsonImportOptions(options)) {
+        edits.push({ start: target.end, end: options.end, value: '' })
+      }
+    }
+    for (const value of Object.values(node)) {
+      if (isNode(value)) visit(value)
+      else if (Array.isArray(value)) for (const item of value) if (isNode(item)) visit(item)
+    }
+  }
+  visit(result.program as unknown as AstNode)
+  return edits.length > 0 ? spliceSource(source, edits) : source
+}
+
+function propertyName(node: AstNode | undefined) {
+  if (!node) return undefined
+  return node.type === 'Identifier' ? (node.name as string) : stringValue(node)
+}
+
+function jsonTypeAttribute(node: AstNode) {
+  return (
+    !node.computed &&
+    propertyName(child(node, 'key')) === 'type' &&
+    stringValue(child(node, 'value')) === 'json'
+  )
+}
+
+/** `{ with: { type: 'json' } }` (or `assert`) and nothing else. */
+function jsonImportOptions(options: AstNode) {
+  const [property, ...rest] = (options.properties as AstNode[] | undefined) ?? []
+  const attributes = child(property, 'value')
+  const entries = attributes?.properties as AstNode[] | undefined
+  return (
+    options.type === 'ObjectExpression' &&
+    !!property &&
+    rest.length === 0 &&
+    property.type === 'Property' &&
+    !property.computed &&
+    ['with', 'assert'].includes(propertyName(child(property, 'key')) ?? '') &&
+    attributes?.type === 'ObjectExpression' &&
+    !!entries?.length &&
+    entries.every(entry => entry.type === 'Property' && jsonTypeAttribute(entry))
+  )
+}
+
 function collectDynamicCalls(program: AstNode): DynamicCallFact[] {
   const calls: DynamicCallFact[] = []
   const visit = (value: unknown) => {

package/src/routing/href.ts

@@ -198,7 +198,16 @@ export function canonicalTrailingSlashPath(pathname: string, trailingSlash: bool
   if (/\.[^/]+$/.test(pathname)) return pathname
   const slashed = pathname.endsWith('/')
   if (trailingSlash ? slashed : !slashed) return pathname
-  return trailingSlash ? `${pathname.replace(/\/+$/, '')}/` : pathname.replace(/\/+$/, '') || '/'
+  // Collapsed, so a rewritten path can never read as protocol-relative (`//host`).
+  const bare = pathname.replace(/\/{2,}/g, '/').replace(/\/+$/, '')
+  return trailingSlash ? `${bare}/` : bare || '/'
+}
+
+/** Next 308s a path with repeated slashes to its collapsed form, for every method, before anything else. */
+export function repeatedSlashRedirect(url: URL): Response | null {
+  if (!url.pathname.includes('//')) return null
+  const target = `${url.pathname.replace(/\/{2,}/g, '/')}${url.search}`
+  return new Response(target, { status: 308, headers: { location: target } })
 }
 
 /**
@@ -210,13 +219,11 @@ export function canonicalTrailingSlashPath(pathname: string, trailingSlash: bool
 export function trailingSlashRedirect(
   config: { trailingSlash?: boolean; skipTrailingSlashRedirect?: boolean },
   url: URL,
-  method: string,
 ): Response | null {
   // skipTrailingSlashRedirect: the app serves both slashed and unslashed URLs
   // as-is, so no canonical redirect is ever emitted (route matching already
   // tolerates a trailing slash via normalizePathname).
   if (config.skipTrailingSlashRedirect) return null
-  if (method !== 'GET' && method !== 'HEAD') return null
   const pathname = url.pathname
   if (pathname === '/' || pathname === '') return null
   if (pathname.startsWith('/__pnext') || isBuildAssetPathname(pathname)) return null