@nifrajs/web 5.1.0 → 5.3.0

package/src/csp.ts

@@ -175,6 +175,10 @@ export function cspDocumentNonce(
   return requested ?? policy[CSP_POLICY].generate()
 }
 
+/** A nonce for a render that may write a script of its own; the document carries it only if used. */
+export const cspCandidateNonce = (policy: CspPolicy, requested: string | undefined): string =>
+  requested ?? policy[CSP_POLICY].generate()
+
 /** The Content-Security-Policy value for one document, or `undefined` when the policy sends none. */
 export function cspHeaderValue(
   policy: CspPolicy,

package/src/deferred.ts

@@ -6,6 +6,7 @@
  * resolution scripts settle. The per-adapter `<Await>` lives in `@nifrajs/web-{solid,react}/client`.
  */
 import { plainJsonCodec, type TransportCodec } from "@nifrajs/core/transport-codec"
+import { isDeferredFree } from "./internal/deferred-free.ts"
 import { parsePageData } from "./internal/revive-dates.ts"
 
 /**
@@ -65,6 +66,7 @@ export function prepareDeferred(
   readonly deferred: ReadonlyArray<{ readonly id: number; readonly promise: Promise<unknown> }>
 } {
   const deferred: Array<{ id: number; promise: Promise<unknown> }> = []
+  if (isDeferredFree(data)) return { forComponent: data, forClient: data, deferred }
   // Structural sharing: a subtree with no deferred value returns the ORIGINAL node for
   // both sides (`fc`/`cl` identical to the input), so a deferred-free result - the common case - is
   // returned by reference with no persisted clone, no downstream copy, and no throwaway clone
@@ -321,6 +323,14 @@ export async function parseNdjsonData(
   // accumulate listeners across navigations (a per-nav signal would be GC'd, but don't rely on it).
   const onAbort = (): void => void reader.cancel()
   if (signal) signal.addEventListener("abort", onAbort, { once: true })
+  let ended = false
+  // Every way out, a malformed line included, detaches from the signal and the body: a source left
+  // streaming into a reader nobody reads, or still locked to it, would hold its response open.
+  const release = (): void => {
+    signal?.removeEventListener("abort", onAbort) // no-op if it already fired ({ once: true })
+    if (!ended) reader.cancel().catch(() => {})
+    reader.releaseLock()
+  }
 
   const readLine = async (): Promise<string | null> => {
     for (;;) {
@@ -332,6 +342,7 @@ export async function parseNdjsonData(
       }
       const { done, value } = await reader.read()
       if (done) {
+        ended = true
         const rest = buffer
         buffer = ""
         return rest === "" ? null : rest
@@ -344,8 +355,14 @@ export async function parseNdjsonData(
   // Only plain JSON carries t.date() tags; a richer codec decodes its own dates.
   const decode = (line: string): unknown =>
     codec === plainJsonCodec ? parsePageData(line) : codec.decode(line)
-  const first = await readLine()
-  const data = markersFromPlaceholders(first === null ? null : decode(first), pending)
+  let data: unknown
+  try {
+    const first = await readLine()
+    data = markersFromPlaceholders(first === null ? null : decode(first), pending)
+  } catch (error) {
+    release()
+    throw error
+  }
 
   void (async () => {
     try {
@@ -363,7 +380,7 @@ export async function parseNdjsonData(
     } catch {
       // stream errored - leftovers are rejected below (unless this was an abort)
     } finally {
-      signal?.removeEventListener("abort", onAbort) // no-op if it already fired ({ once: true })
+      release()
       // A natural stream end with markers unsettled = truncation → reject (so `<Await>` shows its
       // error). An `abort` = a superseded navigation → leave them pending: the markers are detached
       // (their data was never applied), so rejecting would only risk an error flash mid-transition.

package/src/index.ts

@@ -87,6 +87,7 @@ export {
 // Generated client entries intentionally import the browser router from the client subpath:
 // `import { createClientRouter, createMatcher, mergeHeads, resolveChainMeta } from "@nifrajs/web/client"`.
 export { mergeHeads, resolveChainMeta, resolveMeta } from "./internal/head-merge.ts"
+export type { PrerenderedPages } from "./internal/prerendered-pages.ts"
 export {
   gone,
   notFound,
@@ -121,6 +122,7 @@ export {
   type CreateWebAppOptions,
   createWebApp,
   type NonceResolver,
+  type WebAppI18n,
   webProjectEvidence,
 } from "./internal/web-app.ts"
 // ISR (incremental static regeneration): a pluggable cache store + the `withISR` stale-while-revalidate
@@ -223,7 +225,9 @@ export {
 } from "./nonce.ts"
 // public/ - user-authored static files, served identically in dev and production by one handler.
 export {
+  type PrerenderedPageReaderOptions,
   type PublicDirCache,
+  prerenderedPageReader,
   resolvePublicPath,
   type ServePublicDirOptions,
   servePublicDir,
@@ -256,7 +260,12 @@ export {
   type DocumentParts,
   HANDOVER_ID,
   LAYOUT_DATA_GLOBAL,
+  LOCALES_GLOBAL,
+  localeOfProps,
   type MatchChain,
+  type PageLocale,
+  type PageLocales,
+  pageLocaleIn,
   type RenderAdapter,
   type RenderProps,
   type RenderStreamOptions,

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/deferred-free.ts

@@ -0,0 +1,15 @@
+/**
+ * Values an output guard settled under a schema that cannot let a `defer()` marker through: no
+ * `t.deferred`, and no open or untyped node. `prepareDeferred` returns them without walking them.
+ * A marker the schema does declare is projected into a new object, so the value that holds it is
+ * a fresh copy, never one marked here.
+ */
+const deferredFree = new WeakSet<object>()
+
+export function markDeferredFree(value: unknown): void {
+  if (typeof value === "object" && value !== null) deferredFree.add(value)
+}
+
+export function isDeferredFree(value: unknown): boolean {
+  return typeof value === "object" && value !== null && deferredFree.has(value)
+}

package/src/internal/module-preparation.ts

@@ -0,0 +1,30 @@
+interface ModuleEntry<T extends object> {
+  readonly load: () => Promise<T>
+}
+
+/** Production imports are immutable; failed imports remain retryable. No loader data is cached. */
+export function prepareModules(
+  enabled: boolean,
+): <T extends object>(entry: ModuleEntry<T>) => T | Promise<T> {
+  const modules = new WeakMap<object, object | Promise<object>>()
+  return <T extends object>(entry: ModuleEntry<T>): T | Promise<T> => {
+    if (!enabled) return entry.load()
+    const known = modules.get(entry)
+    // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: Only this entry.load populates its slot, so the cached value retains that entry's module type.
+    if (known !== undefined) return known as T | Promise<T>
+    const pending = Promise.resolve()
+      .then(() => entry.load())
+      .then(
+        (module) => {
+          modules.set(entry, module)
+          return module
+        },
+        (error) => {
+          modules.delete(entry)
+          throw error
+        },
+      )
+    modules.set(entry, pending)
+    return pending
+  }
+}

package/src/internal/output-guard.ts

@@ -14,6 +14,7 @@
  * its own `validate` output, as zod and valibot objects do by default.
  */
 import type { StandardResult, StandardSchemaV1 } from "@nifrajs/core/server"
+import { markDeferredFree } from "./deferred-free.ts"
 import { wireDate } from "./wire-date.ts"
 
 // Registry symbols shared with core and `@nifrajs/schema`, so two copies of either still agree.
@@ -84,6 +85,8 @@ interface CompiledGuard {
   readonly validate: StandardSchemaV1["~standard"]["validate"]
   /** Dev only: name the keys the guard dropped, so a schema missing a field is not a silent blank. */
   readonly warnDropped: boolean
+  /** No value this guard passes can hold a `defer()` marker (see internal/deferred-free.ts). */
+  readonly deferredFree: boolean
 }
 
 interface Deferred {
@@ -200,7 +203,10 @@ function shapeOf(
 }
 
 class Compiler {
+  /** Some node may pass a `defer()` marker on: a deferred node, or one that lets any value through. */
+  mayPassMarker = false
   private readonly memo = new Map<Node, Project>()
+  private readonly issueFree = new WeakSet<Project>([LEAF, LEAF_ARRAY, DATE])
   private readonly ids = new Map<string, Node>()
   readonly sensitive: string[] = []
 
@@ -263,25 +269,33 @@ class Compiler {
       case "array":
         return this.array(node, where)
       case "leaf":
+        // `not` (or an object `const`) without a `type` can accept an object.
+        if (node.type === undefined) this.mayPassMarker = true
         return LEAF
       default:
-        return UNKNOWN
+        return this.unknown()
     }
   }
 
+  private unknown(): Project {
+    this.mayPassMarker = true
+    return UNKNOWN
+  }
+
   private extra(schema: unknown, where: string): Project | undefined {
-    if (schema === true || (isNode(schema) && Object.keys(schema).length === 0)) return UNKNOWN
+    if (schema === true || (isNode(schema) && Object.keys(schema).length === 0))
+      return this.unknown()
     return isNode(schema) ? this.compile(schema, `${where}/*`) : undefined
   }
 
   private object(node: Node, where: string): Project {
-    const declared = new Map<string, Project>()
+    const declared: Record<string, Project> = Object.create(null)
     for (const [key, sub] of Object.entries(isNode(node.properties) ? node.properties : {})) {
       if (!isNode(sub)) continue
       if (isSensitiveFieldName(key) && typeof sub[DECLASSIFIED_KEY] !== "string") {
         this.sensitive.push(`${where}/${key}`)
       }
-      declared.set(key, this.compile(sub, `${where}/${key}`))
+      declared[key] = this.compile(sub, `${where}/${key}`)
     }
     const patterns: Array<readonly [RegExp, Project]> = []
     for (const [pattern, sub] of Object.entries(
@@ -302,7 +316,7 @@ class Compiler {
     }
     // A closed object drops a deferred marker's keys unless it declares them, so only an open one, or
     // one declaring the marker key, could pass a marker on.
-    const checksMarker = open || declared.has("__nifra_deferred")
+    const checksMarker = open || declared.__nifra_deferred !== undefined
     const project: Project = (value, state) => {
       if (typeof value !== "object" || value === null || Array.isArray(value)) return value
       if (checksMarker && isDeferred(value)) {
@@ -325,7 +339,7 @@ class Compiler {
       for (const key in input) {
         // An inherited enumerable key (a polluted prototype) is never data.
         if (!Object.hasOwn(input, key)) continue
-        const projector = declared.get(key) ?? (open ? undeclared(key) : undefined)
+        const projector = declared[key] ?? (open ? undeclared(key) : undefined)
         if (projector === undefined) {
           out ??= copyBefore(input, key)
           continue
@@ -346,6 +360,8 @@ class Compiler {
       }
       return out ?? value
     }
+    if (!checksMarker && Object.values(declared).every((child) => this.issueFree.has(child)))
+      this.issueFree.add(project)
     return project
   }
 
@@ -356,13 +372,32 @@ class Compiler {
         ? node.items
         : []
     const head = prefixNodes.map((sub, i) =>
-      isNode(sub) ? this.compile(sub, `${where}/${i}`) : UNKNOWN,
+      isNode(sub) ? this.compile(sub, `${where}/${i}`) : this.unknown(),
     )
     const restSchema = Array.isArray(node.items) ? node.additionalItems : node.items
-    const rest = this.extra(restSchema, where) ?? UNKNOWN
+    const rest = this.extra(restSchema, where) ?? this.unknown()
     // An array of scalars is the validator's alone: no key to drop, and walking it here would cost
     // every `string[]` a loop. A `Date` inside one reaches the validator as it is.
     if (rest === LEAF && head.every((projector) => projector === LEAF)) return LEAF_ARRAY
+    // A uniform subtree that cannot emit deferred-marker issues needs no per-item path bookkeeping.
+    if (head.length === 0 && this.issueFree.has(rest)) {
+      const project: Project = (value, state) => {
+        if (!Array.isArray(value)) return value
+        let out: unknown[] | undefined
+        for (let i = 0; i < value.length; i++) {
+          const before = value[i]
+          const after = rest(before, state)
+          if (out !== undefined) out[i] = after
+          else if (after !== before) {
+            out = value.slice(0, i)
+            out[i] = after
+          }
+        }
+        return out ?? value
+      }
+      this.issueFree.add(project)
+      return project
+    }
     return (value, state) => {
       if (!Array.isArray(value)) return value
       let out: unknown[] | undefined
@@ -424,7 +459,7 @@ class Compiler {
     const branches: Node[] = []
     this.branches(node, where, branches, new Set())
     const kinds = branches.map(shapeOf)
-    if (kinds.includes("unknown")) return UNKNOWN
+    if (kinds.includes("unknown")) return this.unknown()
     const deferreds = branches.filter((_, i) => kinds[i] === "deferred")
     if (deferreds.length > 1) {
       throw new OutputGuardError(
@@ -463,6 +498,7 @@ class Compiler {
   }
 
   private deferred(node: Node, where: string): Project {
+    this.mayPassMarker = true
     const validate = (node as { readonly [DEFERRED_VALIDATE]?: unknown })[DEFERRED_VALIDATE]
     if (!isNode(node.inner) || typeof validate !== "function") {
       throw new OutputGuardError(
@@ -473,6 +509,7 @@ class Compiler {
       project: this.compile(node.inner, where),
       validate: validate as CompiledGuard["validate"],
       warnDropped: inDevelopment(),
+      deferredFree: false,
     }
     return (value, state) => {
       if (!isDeferred(value)) return value
@@ -591,9 +628,11 @@ export function outputGuard(schema: unknown, owner: string, exportName: string):
   const standard = schema as StandardSchemaV1
   const json = jsonSchemaOf(standard)
   let project: Project | undefined
+  let deferredFree = false
   if (json !== undefined) {
     const compiler = new Compiler(json)
     project = compiler.compile(json, "")
+    deferredFree = !compiler.mayPassMarker
     if (compiler.sensitive.length > 0) {
       throw new OutputGuardError(
         `${owner} declares sensitive field(s) ${compiler.sensitive.join(", ")} in ${exportName}. Remove them, or mark a field that must reach the browser with t.declassified("why it may", schema)`,
@@ -605,6 +644,7 @@ export function outputGuard(schema: unknown, owner: string, exportName: string):
     project,
     validate: standard["~standard"].validate,
     warnDropped: inDevelopment(),
+    deferredFree,
   }
   compiled.set(schema, guard)
   return guard
@@ -675,6 +715,8 @@ function settle(
     // No JSON Schema to project by: the schema's own validate stripped what it does not declare.
     if (guard.warnDropped) warnDropped(label, input, result.value)
   }
+  // Only the projected value itself: a validator that returns a new value (a transform) may add a marker.
+  if (guard.deferredFree && result.value === input) markDeferredFree(result.value)
   return result.value
 }