@nifrajs/web 5.1.0 → 5.2.0

package/src/internal/codegen.ts

@@ -5,9 +5,12 @@ import {
   ACTION_GLOBAL,
   BOUNDARY_GLOBAL,
   COMPONENT_GLOBAL,
+  COPY_CHUNKS_GLOBAL,
+  COPY_REALM,
   DATA_GLOBAL,
   HANDOVER_ID,
   LAYOUT_DATA_GLOBAL,
+  LOCALES_GLOBAL,
   ROOT_ATTRIBUTE,
   ROUTE_GLOBAL,
 } from "../render-seam.ts"
@@ -23,6 +26,7 @@ const HANDOVER_GLOBALS = [
   BOUNDARY_GLOBAL,
   COMPONENT_GLOBAL,
   PRERENDERED_GLOBAL,
+  LOCALES_GLOBAL,
 ]
 export interface GenerateClientEntryOptions {
   /**
@@ -39,6 +43,9 @@ export interface GenerateClientEntryOptions {
   /** Turn a route/layout source file (relative to the routes dir) into an import specifier. */
   readonly resolve: (file: string) => string
   readonly serverComponents?: boolean
+  /** The build moved copy tables into per-locale chunks: the handover carries the chunk URLs, and a
+   * navigation loads the copy of the URL it goes to beside the route's code. */
+  readonly copyChunks?: boolean
 }
 
 /**
@@ -222,7 +229,7 @@ export function generateClientEntry(
     // routeId → the ids and `handle` exports `useMatches` reports (layouts, then the page).
     `const layoutIdsOf = ${jsValueLiteral(layoutIdsOf)}`,
     "const matchChains = {}",
-    "const loadModule = async (id) => {",
+    `const ${options.copyChunks === true ? "loadRoute" : "loadModule"} = async (id) => {`,
     "  if (chains[id]) return",
     "  const mods = await loaders[id]()",
     // For an error route the `_error` module is appended LAST: wrap the page (now second-to-last) in
@@ -260,6 +267,17 @@ export function generateClientEntry(
     "  routeHooks[id] = { clientLoader: page.clientLoader, clientAction: page.clientAction, boundaries }",
     "  if (page.ssr === false) holds[id] = [...chains[id].slice(0, -1), page.HydrateFallback ?? (() => null)]",
     "}",
+    ...(options.copyChunks === true
+      ? [
+          `const copyRealm = () => globalThis[Symbol.for(${jsStringLiteral(COPY_REALM)})]`,
+          // A second prepare covers a copy definition the route's own code brought in.
+          "const loadModule = async (id, path) => {",
+          "  if (path === undefined) return loadRoute(id)",
+          "  await Promise.all([loadRoute(id), copyRealm()?.prepare(path)])",
+          "  await copyRealm()?.prepare(path)",
+          "}",
+        ]
+      : []),
     // The server hands page state over as one inert JSON script; lift it onto the globals the
     // router, the deferred mapper and the adapters read, before any of them runs. Only the LAST
     // matching <script> counts, and only known keys: page HTML (sanitized user content) can carry an
@@ -268,7 +286,7 @@ export function generateClientEntry(
     "const handover = handovers[handovers.length - 1]",
     "if (handover !== undefined) {",
     '  const state = JSON.parse(handover.textContent || "{}")',
-    `  for (const key of ${jsValueLiteral(HANDOVER_GLOBALS)}) {`,
+    `  for (const key of ${jsValueLiteral(options.copyChunks === true ? [...HANDOVER_GLOBALS, COPY_CHUNKS_GLOBAL] : HANDOVER_GLOBALS)}) {`,
     "    if (Object.prototype.hasOwnProperty.call(state, key)) Reflect.set(window, key, state[key])",
     "  }",
     "}",
@@ -383,7 +401,7 @@ export function generateClientEntry(
     // page URL), so a soft-nav re-resolves the SAME absolute canonical/og:url - no head drift.
     "      const nonce = currentDocumentNonce()",
     "      const args = { data: s.data, pageData: s.data, params: s.params, origin: location.origin, ...(nonce === undefined ? {} : { nonce }) }",
-    "      applyHead(mergeHeads(resolveChainMeta(metas[s.routeId] ?? [undefined], s.layoutData, args)))",
+    "      applyHead(mergeHeads(resolveChainMeta(metas[s.routeId] ?? [undefined], s.layoutData, args)), s.path)",
     "    }",
     "  })",
     "}).catch((error) => console.error('[nifra/web] hydration failed:', error))",
@@ -453,6 +471,9 @@ export interface GenerateServerManifestOptions {
   readonly routeStyles?: Readonly<Record<string, readonly string[]>> | undefined
   /** How framework-owned stylesheet links should activate before the generated client mounts. */
   readonly cssLoading?: CssLoadingMode
+  /** Locale key -> copy chunk URL (`buildClient`'s `BuildManifest.copyChunks`) - baked as
+   * `export const copyChunks` when the client build split copy tables, for `createWebApp`. */
+  readonly copyChunks?: Readonly<Record<string, string>> | undefined
   /** Emit **lazy** per-route loaders (`() => import("./routes/x")`, a static specifier) instead of
    * eager `import * as`, so a bundler with code-splitting emits one chunk per route - loaded on the
    * first request to it, not all at boot (smaller cold-start parse). Default `false` (eager). Both
@@ -500,6 +521,7 @@ export function generateServerManifest(
     styles,
     routeStyles,
     cssLoading: requestedCssLoading,
+    copyChunks,
     lazy = false,
   } = options
   // A missing entry would bake `clientEntry = undefined` and the build would still succeed, leaving
@@ -541,6 +563,11 @@ export function generateServerManifest(
   const stylesLine = `export const styles = ${jsValueLiteral(styles ?? [])}`
   const routeStylesLine = `export const routeStyles = ${jsValueLiteral(routeStyles ?? {})}`
   const cssLoadingLine = `export const cssLoading = ${jsStringLiteral(cssLoading)}`
+  // Only a build that split copy tables has the line; its server entry is the one that imports it.
+  const copyChunksLines =
+    copyChunks === undefined || Object.keys(copyChunks).length === 0
+      ? []
+      : [`export const copyChunks = ${jsValueLiteral(copyChunks)}`]
   if (lazy) {
     // Lazy: `() => import("./routes/x")` per route (static specifier → one chunk per route under a
     // code-splitting bundler, loaded on first request). The map keys are the route-relative paths
@@ -558,6 +585,7 @@ export function generateServerManifest(
       stylesLine,
       routeStylesLine,
       cssLoadingLine,
+      ...copyChunksLines,
       `export const manifest = buildManifest(Object.keys(loaders), ${LAZY_IMPORTER})`,
     ].join("\n")}\n`
   }
@@ -577,6 +605,7 @@ export function generateServerManifest(
     stylesLine,
     routeStylesLine,
     cssLoadingLine,
+    ...copyChunksLines,
     `export const manifest = buildManifest(Object.keys(modules), ${EAGER_IMPORTER})`,
   ].join("\n")}\n`
 }

package/src/internal/copy-split.ts

@@ -0,0 +1,220 @@
+/**
+ * Copy tables (`@nifrajs/i18n/copy`) in a production client build. Each table a module declares is
+ * replaced by its chunk id, and its values move into one chunk per locale, so a page's JavaScript carries
+ * the copy of the locale it renders in and none of the others. The server bundle keeps every table whole.
+ *
+ * The tables are found by `@nifrajs/i18n/extract` with the app's own TypeScript, both resolved from the
+ * app root: `@nifrajs/web` depends on neither. An app with no `defineCopy` pays one source scan.
+ */
+import { createHash } from "node:crypto"
+import { type Dirent, readdirSync, readFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import { join, resolve as resolvePath } from "node:path"
+import { pathToFileURL } from "node:url"
+import type { BunPlugin } from "bun"
+import type * as TS from "typescript"
+import { addSourceTransform, normalizeFilePath } from "../plugins/kit.ts"
+import { isTypeScriptCompiler } from "./typescript-api.ts"
+
+const COPY_MODULE = "@nifrajs/i18n/copy"
+const EXTRACT_MODULE = "@nifrajs/i18n/extract"
+const SCRIPT = /\.[cm]?[jt]sx?$/
+const REWRITABLE = /\.m?[jt]sx?(\?|$)/
+const DEPENDENCY = /[\\/]node_modules[\\/]/
+const MAX_DEPTH = 32
+
+/** The part of `@nifrajs/i18n/extract` the build reads. */
+interface TableSite {
+  readonly id: string
+  readonly values?: Readonly<Record<string, unknown>>
+  readonly definition: { readonly file: string; readonly name: string }
+}
+interface Scanner {
+  tables(file: string): readonly TableSite[]
+  definition(ref: TableSite["definition"]): { readonly locales?: unknown } | undefined
+  rewrite(file: string): string | undefined
+}
+interface SplitTable {
+  readonly id: string
+  readonly values: Readonly<Record<string, unknown>>
+  readonly locales: unknown
+}
+interface Extract {
+  createCopyScanner(
+    ts: typeof TS,
+    host: {
+      readonly root: string
+      read(file: string): string | undefined
+      resolve(specifier: string, from: string): string | undefined
+    },
+  ): Scanner
+  copyChunks(tables: Iterable<SplitTable>): ReadonlyMap<string, unknown>
+}
+
+const isExtract = (value: unknown): value is Extract =>
+  typeof value === "object" &&
+  value !== null &&
+  "createCopyScanner" in value &&
+  typeof value.createCopyScanner === "function" &&
+  "copyChunks" in value &&
+  typeof value.copyChunks === "function"
+
+/** A chunk file the build wrote. */
+export interface CopyChunkFile {
+  /** The file name, served under the build's public path. */
+  readonly name: string
+  readonly text: string
+}
+
+export interface CopySplit {
+  /** The client build's plugin, registered after every other one. */
+  readonly plugin: BunPlugin
+  /** A module with its tables replaced by chunk ids, or `undefined` when it has none to split. */
+  rewrite(file: string, source: string): string | undefined
+  /** One chunk per locale for the tables this build split, and each one's URL by locale key. */
+  chunks(publicPath: string): {
+    readonly urls: Readonly<Record<string, string>>
+    readonly files: readonly CopyChunkFile[]
+  }
+}
+
+const readText = (file: string): string | undefined => {
+  try {
+    return readFileSync(file, "utf8")
+  } catch {
+    return undefined
+  }
+}
+
+/** Whether a module under `dir` imports the copy module: the only way an app defines copy tables. */
+function definesCopy(dir: string, skip: ReadonlySet<string>, depth = 0): boolean {
+  let entries: Dirent[]
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return false
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue
+    const path = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      if (depth < MAX_DEPTH && !skip.has(path) && definesCopy(path, skip, depth + 1)) return true
+    } else if (entry.isFile() && SCRIPT.test(entry.name)) {
+      if (readText(path)?.includes(COPY_MODULE) === true) return true
+    }
+  }
+  return false
+}
+
+const loaderOf = (path: string): "js" | "jsx" | "ts" | "tsx" => {
+  if (path.endsWith("x")) return path.endsWith(".tsx") ? "tsx" : "jsx"
+  return /\.m?ts$/.test(path) ? "ts" : "js"
+}
+
+/**
+ * The copy split for an app, or `undefined` when it defines no copy tables. An app that does, but whose
+ * TypeScript has no compiler API, builds with its tables whole, with a warning.
+ */
+export async function loadCopySplit(
+  root: string,
+  options: { readonly skip?: readonly string[]; readonly warn?: (message: string) => void } = {},
+): Promise<CopySplit | undefined> {
+  const appRoot = resolvePath(root)
+  const require = createRequire(join(appRoot, "package.json"))
+  let extractPath: string
+  try {
+    extractPath = require.resolve(EXTRACT_MODULE)
+  } catch {
+    return undefined
+  }
+  if (!definesCopy(appRoot, new Set((options.skip ?? []).map((dir) => resolvePath(dir))))) {
+    return undefined
+  }
+  const warn = options.warn ?? console.warn
+  let ts: unknown
+  try {
+    ts = require("typescript")
+  } catch {
+    ts = undefined
+  }
+  if (!isTypeScriptCompiler(ts)) {
+    warn(
+      "[nifra/web] copy tables ship every locale in the client bundle: splitting them by locale reads the source with the TypeScript compiler API, and the app's TypeScript has none (TypeScript 7 ships none; install typescript@^6 as a dev dependency).",
+    )
+    return undefined
+  }
+  const extract: unknown = await import(pathToFileURL(extractPath).href)
+  if (!isExtract(extract)) {
+    warn(
+      `[nifra/web] copy tables ship every locale in the client bundle: ${EXTRACT_MODULE} at ${extractPath} predates the client split; update @nifrajs/i18n.`,
+    )
+    return undefined
+  }
+  const scanner = extract.createCopyScanner(ts, {
+    root: appRoot.replaceAll("\\", "/"),
+    read: readText,
+    resolve: (specifier, from) => {
+      try {
+        return createRequire(from).resolve(specifier)
+      } catch {
+        return undefined
+      }
+    },
+  })
+
+  const split = new Map<string, readonly SplitTable[]>()
+  const rewrite = (file: string, source: string): string | undefined => {
+    const path = normalizeFilePath(file)
+    // The scanner reads the file off disk: text another transform changed first is left alone, since
+    // its tables' positions are no longer the file's.
+    if (!REWRITABLE.test(path) || DEPENDENCY.test(path) || readText(path) !== source) {
+      return undefined
+    }
+    const out = scanner.rewrite(path)
+    if (out === undefined) return undefined
+    split.set(
+      path,
+      scanner.tables(path).flatMap((site) => {
+        const locales =
+          site.values === undefined ? undefined : scanner.definition(site.definition)?.locales
+        return site.values === undefined || locales === undefined
+          ? []
+          : [{ id: site.id, values: site.values, locales }]
+      }),
+    )
+    return out
+  }
+
+  return {
+    plugin: {
+      name: "nifra-copy-split",
+      setup(build) {
+        addSourceTransform(build, rewrite)
+        build.onLoad({ filter: REWRITABLE }, async (args) => {
+          if (args.namespace !== "file") return undefined
+          const path = normalizeFilePath(args.path)
+          const contents = rewrite(path, await Bun.file(path).text())
+          return contents === undefined ? undefined : { contents, loader: loaderOf(path) }
+        })
+      },
+    },
+    rewrite,
+    chunks(publicPath) {
+      // Sorted, so a chunk's bytes, and so its name, do not depend on the order modules loaded in.
+      const tables = [...split.values()].flat().sort((a, b) => (a.id < b.id ? -1 : 1))
+      const urls: Record<string, string> = {}
+      const files: CopyChunkFile[] = []
+      if (tables.length === 0) return { urls, files }
+      const chunks = [...extract.copyChunks(tables)].sort(([a], [b]) => (a < b ? -1 : 1))
+      for (const [locale, chunk] of chunks) {
+        // A JSON string parses faster than the same object as a literal.
+        const text = `export default JSON.parse(${JSON.stringify(JSON.stringify(chunk))})\n`
+        const hash = createHash("sha256").update(text).digest("hex").slice(0, 12)
+        const name = `copy-${locale.replace(/[^A-Za-z0-9-]/g, "_")}-${hash}.js`
+        urls[locale] = `${publicPath}${name}`
+        files.push({ name, text })
+      }
+      return { urls, files }
+    },
+  }
+}

package/src/internal/page-execution.ts

@@ -34,7 +34,7 @@ import type {
   ShouldRevalidate,
 } from "../manifest.ts"
 import type { NonceResolver } from "../nonce.ts"
-import type { MatchChain, RenderAdapter } from "../render-seam.ts"
+import type { MatchChain, PageLocale, PageLocales, RenderAdapter } from "../render-seam.ts"
 import {
   createMatcher,
   DATA_HEADER,
@@ -54,9 +54,11 @@ import {
   isStatusSignal,
   type LoadedLayoutModules,
   layoutErrorId,
+  notFound,
   type RenderAssemblyCache,
   type RenderedPage,
   type RevalidateResult,
+  redirect,
   renderPageResult,
   STATUS_SIGNAL,
   STATUS_TEXT,
@@ -179,6 +181,24 @@ function appTarget(location: string, requestUrl: string): string {
     : target.pathname + target.search + target.hash
 }
 
+/** The app's locale routing, as page execution reads it. */
+export interface PageI18n {
+  readonly locales: PageLocales
+  /** The served locale key a `pathname + search` is in. */
+  localeOf(path: string): string
+  /** The answer for a `[lang]` / `[[lang]]` segment's value (`undefined` when an optional one is
+   * absent), as `@nifrajs/i18n/routing`'s `matchSegment` gives it. */
+  matchSegment(
+    value: string | undefined,
+    pathname: string,
+  ):
+    | { readonly kind: "ok" | "not-found" }
+    | { readonly kind: "redirect"; readonly location: string }
+}
+
+// The route directories whose first segment names the locale.
+const LOCALE_SEGMENTS: ReadonlySet<string> = new Set(["[lang]", "[[lang]]"])
+
 export interface PageExecutionOptions<Env = unknown> {
   readonly serverComponents?: import("../server-components/types.ts").ServerComponentRuntime
   readonly rerenderOwnerGET?: (
@@ -198,6 +218,10 @@ export interface PageExecutionOptions<Env = unknown> {
   readonly prerenderedPaths?: readonly string[]
   /** Where pages fetch {@link prerenderedPaths} from when the list is too large to inline. */
   readonly prerenderedListUrl?: string
+  /** Locale key -> copy chunk URL, from a build that split copy tables by locale. */
+  readonly copyChunks?: Readonly<Record<string, string>>
+  /** The app's locale routing: each document's locale, and the check on a `[lang]` segment. */
+  readonly i18n?: PageI18n
   readonly staticFallbacks?: Readonly<Record<string, "ssr" | "404">>
   readonly staticBoundaryCache?: StaticBoundaryCache
   /** Per-request CSP nonce for framework-owned executable document scripts. */
@@ -301,6 +325,23 @@ export function createPageRequestExecutor<Env = unknown>(
     options.prerenderedListUrl === undefined
       ? { prerenderedPaths: options.prerenderedPaths ?? [] }
       : { prerenderedListUrl: options.prerenderedListUrl }
+  const copyOption = options.copyChunks === undefined ? {} : { copyChunks: options.copyChunks }
+  const { i18n } = options
+  const pageLocales = new Map(i18n?.locales.locales.map((locale) => [locale.key, locale]))
+  /** The request's locale for a document, with the served locales the client names locales from. */
+  const localeOption = (req: Request): { locale?: PageLocale; locales?: PageLocales } => {
+    if (i18n === undefined) return {}
+    const locale = pageLocales.get(i18n.localeOf(pathOf(req)))
+    return locale === undefined ? { locales: i18n.locales } : { locale, locales: i18n.locales }
+  }
+  /** Whether a route sits under a `[lang]` or `[[lang]]` directory, which the locale routing checks. */
+  const localeGuarded = (route: RouteEntry): boolean => {
+    if (i18n === undefined) return false
+    for (const segment of route.id.split("/")) {
+      if (!(segment.startsWith("(") && segment.endsWith(")"))) return LOCALE_SEGMENTS.has(segment)
+    }
+    return false
+  }
   const matchManifestRoute = createMatcher(
     manifest.routes.map((route) => ({ routeId: route.id, pattern: route.pattern })),
   )
@@ -553,6 +594,21 @@ export function createPageRequestExecutor<Env = unknown>(
     ctx: LoaderContext,
     controls: PageResponseControls,
   ): Promise<void> => {
+    if (i18n !== undefined && localeGuarded(route)) {
+      // Before any app middleware, as a root `_middleware` would run: an unserved locale, or a page
+      // missing from it, never reaches the app's code.
+      const match = i18n.matchSegment(ctx.params.lang, pathOf(ctx.request))
+      if (match.kind === "redirect") {
+        throw tagLayoutError(redirect(match.location, { status: 308 }), "_layout")
+      }
+      if (match.kind === "not-found") {
+        try {
+          notFound()
+        } catch (signal) {
+          throw tagLayoutError(signal, "_layout")
+        }
+      }
+    }
     const ids = route.middlewareIds ?? []
     for (let i = 0; i < ids.length; i++) {
       const id = ids[i] as string
@@ -776,6 +832,7 @@ export function createPageRequestExecutor<Env = unknown>(
         chain: components,
         data,
         ...(wrapped === undefined ? {} : { head: wrapped.head }),
+        ...localeOption(req),
         clientEntry,
         routeId: errorId,
         status: 500,
@@ -939,6 +996,8 @@ export function createPageRequestExecutor<Env = unknown>(
       // The build keys stylesheets by route, so a page inside the root layout links the whole-app one.
       ...(chain === undefined ? stylesOf(routeId) : stylesFrom(options.styles)),
       ...prerenderedHandover,
+      ...copyOption,
+      ...localeOption(req),
       ...titleOption,
     }
     if (chain === undefined) return renderPageResult(statusPage)
@@ -1087,6 +1146,8 @@ export function createPageRequestExecutor<Env = unknown>(
         ...preloadOf(route.id),
         ...stylesOf(route.id),
         ...prerenderedHandover,
+        ...copyOption,
+        ...localeOption(req),
         ...(responseHeaders === undefined ? {} : { headers: responseHeaders }),
         // A response that sets a cookie is one visitor's: it never advertises ISR freshness.
         ...(mod.revalidate !== undefined && !personalized && options.cacheChannel?.enabled === true
@@ -1213,6 +1274,7 @@ export function createPageRequestExecutor<Env = unknown>(
       matchChain: matchChainOf(page.layoutIds, layoutModules, id, mod),
       status: 404,
       hydrate: false,
+      ...localeOption(req),
       ...(layoutData !== undefined ? { layoutData } : {}),
       ...stylesOf(id),
       ...(headers === undefined ? {} : { headers }),
@@ -1304,12 +1366,14 @@ export function createPageRequestExecutor<Env = unknown>(
   return {
     get: (route) => {
       const is404Fallback = options.staticFallbacks?.[route.pattern] === "404"
-      let assemblySlot: RenderAssemblyCache | undefined
+      // One shell per locale: `<html lang>` is in it, and one route serves every locale.
+      let assemblySlots = new Map<string, RenderAssemblyCache>()
       let assemblySlotMod: unknown
       let assemblySlotLayouts: LoadedLayoutModules | undefined
       const assemblyCacheFor = (
         mod: RouteModule,
         layouts: LoadedLayoutModules,
+        req: Request,
       ): RenderAssemblyCache | undefined => {
         if (typeof mod.meta === "function") return undefined
         for (const layout of layouts) if (typeof layout.meta === "function") return undefined
@@ -1318,11 +1382,17 @@ export function createPageRequestExecutor<Env = unknown>(
           assemblySlotLayouts.length === layouts.length &&
           assemblySlotLayouts.every((layout, index) => layout === layouts[index])
         if (assemblySlotMod !== mod || !layoutsUnchanged) {
-          assemblySlot = {}
+          assemblySlots = new Map()
           assemblySlotMod = mod
           assemblySlotLayouts = layouts
         }
-        return assemblySlot
+        const key = i18n === undefined ? "" : i18n.localeOf(pathOf(req))
+        let slot = assemblySlots.get(key)
+        if (slot === undefined) {
+          slot = {}
+          assemblySlots.set(key, slot)
+        }
+        return slot
       }
 
       return withResponseControls(async (c, controls) => {
@@ -1364,7 +1434,9 @@ export function createPageRequestExecutor<Env = unknown>(
             search: loaderSearch(mod.searchSchema, c.req),
             set: controls.scope(PAGE_SCOPE),
           }
-          if (route.middlewareIds !== undefined) await runMiddleware(route, ctx, controls)
+          if (route.middlewareIds !== undefined || localeGuarded(route)) {
+            await runMiddleware(route, ctx, controls)
+          }
           run = await runLayoutChain(
             route,
             ctx,
@@ -1510,7 +1582,7 @@ export function createPageRequestExecutor<Env = unknown>(
           layoutModules ?? (await loadLayoutModules(route)),
           layoutRetained,
           boundaryStates,
-          layoutModules === undefined ? undefined : assemblyCacheFor(mod, layoutModules),
+          layoutModules === undefined ? undefined : assemblyCacheFor(mod, layoutModules, c.req),
           responseHeaders,
           controls.personalized,
           componentState,
@@ -1569,7 +1641,9 @@ export function createPageRequestExecutor<Env = unknown>(
         let gated: GatedLayouts
         let result: unknown
         try {
-          if (route.middlewareIds !== undefined) await runMiddleware(route, actionContext, controls)
+          if (route.middlewareIds !== undefined || localeGuarded(route)) {
+            await runMiddleware(route, actionContext, controls)
+          }
           gated = await runLayoutGates(route, actionContext, controls)
           result = await mod.action(actionContext)
         } catch (err) {
@@ -1758,6 +1832,8 @@ export function createPageRequestExecutor<Env = unknown>(
           ...preloadOf(route.id),
           ...stylesOf(route.id),
           ...prerenderedHandover,
+          ...copyOption,
+          ...localeOption(c.req),
           ...(responseHeaders === undefined ? {} : { headers: responseHeaders }),
           ...(nonce === undefined ? {} : { nonce }),
           ...cspOption,