@nifrajs/web 5.1.0 → 5.2.0

package/src/plugins/import-glob.ts

@@ -0,0 +1,392 @@
+/**
+ * `import.meta.glob` for the Bun build. Vite expands it at build time and Bun has no equivalent, so
+ * without this a module that loads its siblings through a glob bundles with the call left in place:
+ * `import.meta.glob` is `undefined` in the browser and every file it named is missing from the build.
+ */
+import { existsSync } from "node:fs"
+import { dirname, extname, relative, resolve, sep } from "node:path"
+import type { BunPlugin } from "bun"
+import { readSource } from "./kit.ts"
+
+const SOURCE = /\.[cm]?[jt]sx?$/
+const CALL = /\bimport\.meta\.glob\b/g
+const LOADERS: Readonly<Record<string, "ts" | "tsx" | "jsx" | "js">> = {
+  ".ts": "ts",
+  ".mts": "ts",
+  ".cts": "ts",
+  ".tsx": "tsx",
+  ".jsx": "jsx",
+  // Bun's own default: a `.js` module may hold JSX, a `.mjs` or `.cjs` one may not.
+  ".js": "jsx",
+}
+
+interface GlobOptions {
+  readonly eager: boolean
+  /** The export each entry takes: `"default"`, a name, or the whole module when unset. */
+  readonly pick: string | undefined
+}
+
+/** A literal the call's arguments may hold. */
+type Literal = string | boolean | readonly string[] | Readonly<Record<string, string | boolean>>
+
+/**
+ * `source` with every comment, string body and template text blanked to spaces, offsets kept, so a
+ * glob named in prose or inside a string is never read as a call. A template's `${}` stays code.
+ */
+function codeOnly(source: string): string {
+  const out = source.split("")
+  const blank = (from: number, to: number): void => {
+    for (let index = from; index < to; index++) if (out[index] !== "\n") out[index] = " "
+  }
+  // Reads code from `start`; inside a template's `${`, returns past the `}` that closes it.
+  const code = (start: number, nested: boolean): number => {
+    let index = start
+    let depth = 0
+    while (index < source.length) {
+      const char = source[index]
+      if (source.startsWith("//", index)) {
+        const end = source.indexOf("\n", index)
+        const stop = end === -1 ? source.length : end
+        blank(index, stop)
+        index = stop
+      } else if (source.startsWith("/*", index)) {
+        const end = source.indexOf("*/", index + 2)
+        const stop = end === -1 ? source.length : end + 2
+        blank(index, stop)
+        index = stop
+      } else if (char === '"' || char === "'") {
+        let end = index + 1
+        while (end < source.length && source[end] !== char) end += source[end] === "\\" ? 2 : 1
+        blank(index + 1, Math.min(end, source.length))
+        index = end + 1
+      } else if (char === "`") {
+        index = template(index + 1)
+      } else if (nested && char === "}" && depth === 0) {
+        return index + 1
+      } else {
+        if (nested && char === "{") depth += 1
+        if (nested && char === "}") depth -= 1
+        index += 1
+      }
+    }
+    return index
+  }
+  const template = (start: number): number => {
+    let index = start
+    while (index < source.length && source[index] !== "`") {
+      if (source.startsWith("${", index)) {
+        index = code(index + 2, true)
+      } else {
+        const step = source[index] === "\\" ? 2 : 1
+        blank(index, index + step)
+        index += step
+      }
+    }
+    return index + 1
+  }
+  code(0, false)
+  return out.join("")
+}
+
+/** A reader over the call's argument text: string, array of strings, `{ key: literal }`, booleans. */
+function argumentReader(text: string, start: number) {
+  let at = start
+  const space = (): void => {
+    while (at < text.length && /\s/.test(text[at] ?? "")) at += 1
+  }
+  const fail = (): never => {
+    throw new SyntaxError("not a literal")
+  }
+  const string = (): string => {
+    const quote = text[at]
+    if (quote !== '"' && quote !== "'" && quote !== "`") return fail()
+    let value = ""
+    at += 1
+    while (at < text.length && text[at] !== quote) {
+      const char = text[at] ?? ""
+      if (quote === "`" && char === "$" && text[at + 1] === "{") return fail()
+      if (char === "\\") {
+        value += text[at + 1] ?? ""
+        at += 2
+      } else {
+        value += char
+        at += 1
+      }
+    }
+    at += 1
+    return value
+  }
+  const literal = (): Literal => {
+    space()
+    const char = text[at]
+    if (char === "[") {
+      at += 1
+      const items: string[] = []
+      for (;;) {
+        space()
+        if (text[at] === "]") break
+        items.push(string())
+        space()
+        if (text[at] === ",") at += 1
+        else if (text[at] !== "]") return fail()
+      }
+      at += 1
+      return items
+    }
+    if (char === "{") {
+      at += 1
+      const entries: Record<string, string | boolean> = {}
+      for (;;) {
+        space()
+        if (text[at] === "}") break
+        const key = /^[A-Za-z_$][\w$]*/.exec(text.slice(at))?.[0]
+        const name = key ?? string()
+        if (key !== undefined) at += key.length
+        space()
+        if (text[at] !== ":") return fail()
+        at += 1
+        const value = literal()
+        if (typeof value !== "string" && typeof value !== "boolean") return fail()
+        entries[name] = value
+        space()
+        if (text[at] === ",") at += 1
+        else if (text[at] !== "}") return fail()
+      }
+      at += 1
+      return entries
+    }
+    if (text.startsWith("true", at) || text.startsWith("false", at)) {
+      const value = text.startsWith("true", at)
+      at += value ? 4 : 5
+      return value
+    }
+    return string()
+  }
+  return {
+    literal,
+    space,
+    get at() {
+      return at
+    },
+    expect(char: string): void {
+      space()
+      if (text[at] !== char) fail()
+      at += 1
+    },
+    peek(): string | undefined {
+      space()
+      return text[at]
+    },
+  }
+}
+
+const OPTION_NAMES = new Set(["eager", "import"])
+
+// `Array.isArray` does not narrow a readonly array out of a union.
+const isList = (value: Literal): value is readonly string[] => Array.isArray(value)
+
+function readOptions(value: Literal | undefined): GlobOptions {
+  if (value === undefined) return { eager: false, pick: undefined }
+  if (typeof value !== "object" || isList(value)) throw new SyntaxError("options")
+  const options: Readonly<Record<string, string | boolean>> = value
+  for (const name of Object.keys(options))
+    if (!OPTION_NAMES.has(name)) throw new SyntaxError(`option ${name}`)
+  const eager = options.eager ?? false
+  const pick = options.import
+  if (typeof eager !== "boolean" || (pick !== undefined && typeof pick !== "string"))
+    throw new SyntaxError("option types")
+  return { eager, pick }
+}
+
+/** The files a set of patterns matches from `importer`, by Vite's rules, sorted; `!` excludes. */
+function matchGlob(importer: string, root: string, patterns: readonly string[]): string[] {
+  // Globs read `\` as an escape, so on Windows every path is matched with forward slashes.
+  const slash = (path: string): string => (sep === "\\" ? path.replaceAll("\\", "/") : path)
+  const absolute = (pattern: string): string => {
+    if (pattern.startsWith("/")) return slash(resolve(root, `.${pattern}`))
+    if (pattern.startsWith("./") || pattern.startsWith("../"))
+      return slash(resolve(dirname(importer), pattern))
+    throw new SyntaxError(`pattern ${pattern}`)
+  }
+  const include = patterns.filter((pattern) => !pattern.startsWith("!")).map(absolute)
+  const exclude = patterns
+    .filter((pattern) => pattern.startsWith("!"))
+    .map((pattern) => new Bun.Glob(absolute(pattern.slice(1))))
+  const found = new Set<string>()
+  for (const pattern of include) {
+    const segments = pattern.split("/")
+    const wild = segments.findIndex((segment) => /[*?[\]{}]/.test(segment))
+    if (wild === -1) {
+      if (existsSync(pattern)) found.add(pattern)
+      continue
+    }
+    const base = segments.slice(0, wild).join("/") || "/"
+    const rest = segments.slice(wild).join("/")
+    for (const file of new Bun.Glob(rest).scanSync({ cwd: base, onlyFiles: true })) {
+      const path = slash(resolve(base, file))
+      if (!rest.includes("node_modules") && path.split("/").includes("node_modules")) continue
+      found.add(path)
+    }
+  }
+  const self = slash(importer)
+  return [...found]
+    .filter((path) => path !== self && !exclude.some((glob) => glob.match(path)))
+    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+}
+
+/** `value` as a JS string literal that stays on one line for every parser: before ES2019, U+2028 and
+ * U+2029 end a line even inside a string. */
+const stringLiteral = (value: string): string =>
+  JSON.stringify(value).replace(
+    /[\u2028\u2029]/g,
+    (char) => `\\u${char.charCodeAt(0).toString(16)}`,
+  )
+
+/** How a matched file is keyed, as Vite keys it: from the importer (`./x.ts`) or the root (`/x.ts`). */
+function keyOf(importer: string, root: string, file: string, rooted: boolean): string {
+  if (rooted) return `/${relative(root, file).replaceAll("\\", "/")}`
+  const path = relative(dirname(importer), file).replaceAll("\\", "/")
+  return path.startsWith(".") ? path : `./${path}`
+}
+
+/**
+ * How often `import.meta.glob` appears in the module's code as Bun reads it: types stripped and JSX
+ * text turned into strings, neither of which {@link codeOnly} can see in the source.
+ */
+function globsInCode(source: string, file: string): number {
+  const js = new Bun.Transpiler({ loader: LOADERS[extname(file)] ?? "js" }).transformSync(source)
+  return codeOnly(js).match(CALL)?.length ?? 0
+}
+
+const unclear = (file: string): Error =>
+  new Error(
+    `[nifra/web] ${file}: the Bun build cannot tell this module's import.meta.glob calls from text that names it (JSX text, or a quote inside a regular expression). Move the calls into a .ts module, or build with --vite.`,
+  )
+
+/**
+ * `source` (the module at `file`) with each `import.meta.glob(...)` call expanded into an object of
+ * the files it matches. Throws, naming the line, on a call this cannot read.
+ */
+export function expandImportGlobs(source: string, file: string, root: string): string {
+  const real = globsInCode(source, file)
+  // A docs page that shows the call in JSX text has no call to expand, and rewriting its text is wrong.
+  if (real === 0) return source
+  // JSX text is not a string to `codeOnly`: an apostrophe there flips what it reads as code.
+  const code = codeOnly(source)
+  if ((code.match(CALL)?.length ?? 0) !== real) throw unclear(file)
+  const edits: Array<{ start: number; end: number; text: string }> = []
+  const hoisted: string[] = []
+  let call = 0
+  for (const match of code.matchAll(CALL)) {
+    let start = match.index
+    const line = source.slice(0, start).split("\n").length
+    // A bundle that expands the call has the function: a `typeof` guard around it reads so.
+    const guard = /\btypeof\s+$/.exec(code.slice(Math.max(0, start - 32), start))
+    if (guard !== null) {
+      start -= guard[0].length
+      edits.push({ start, end: match.index + match[0].length, text: '"function"' })
+      continue
+    }
+    const refuse = (why: string): never => {
+      throw new Error(
+        `[nifra/web] ${file}:${line}: import.meta.glob ${why}. The Bun build reads a literal pattern (a string or an array of strings starting with ./, ../ or /, "!" excluding) and the options eager and import; write it that way, or build with --vite.`,
+      )
+    }
+    let after = start + match[0].length
+    if (!/^\s*[(<]/.test(code.slice(after))) refuse("is read as a value, not called")
+    // `import.meta.glob<T>(...)`: TypeScript's type argument, dropped with the call.
+    if (code[after] === "<") {
+      const close = code.indexOf(">(", after)
+      if (close === -1) refuse("has a type argument this cannot read")
+      after = close + 1
+    }
+    const reader = argumentReader(source, after)
+    let patterns: readonly string[]
+    let options: GlobOptions
+    try {
+      reader.expect("(")
+      const first = reader.literal()
+      patterns = typeof first === "string" ? [first] : isList(first) ? first : []
+      if (patterns.length === 0) throw new SyntaxError("patterns")
+      let second: Literal | undefined
+      if (reader.peek() === ",") {
+        reader.expect(",")
+        if (reader.peek() !== ")") second = reader.literal()
+      }
+      options = readOptions(second)
+      if (reader.peek() === ",") reader.expect(",")
+      reader.expect(")")
+    } catch (error) {
+      return refuse(
+        error instanceof SyntaxError && error.message.startsWith("option ")
+          ? `takes the ${error.message.slice(7)} option, which the Bun build does not support`
+          : "takes arguments that are not literals",
+      )
+    }
+    let files: string[]
+    try {
+      files = matchGlob(file, root, patterns)
+    } catch {
+      return refuse("takes a pattern that does not start with ./, ../ or /")
+    }
+    const rooted = patterns.some((pattern) => pattern.replace(/^!/, "").startsWith("/"))
+    const entries = files.map((target, index) => {
+      const key = stringLiteral(keyOf(file, root, target, rooted))
+      const specifier = stringLiteral(keyOf(file, root, target, false))
+      if (options.eager) {
+        const name = `__nifra_glob_${call}_${index}`
+        hoisted.push(`import * as ${name} from ${specifier}`)
+        return `${key}: ${options.pick === undefined ? name : `${name}[${stringLiteral(options.pick)}]`}`
+      }
+      const load = `import(${specifier})`
+      return `${key}: () => ${options.pick === undefined ? load : `${load}.then((m) => m[${stringLiteral(options.pick)}])`}`
+    })
+    edits.push({ start, end: reader.at, text: `({${entries.join(", ")}})` })
+    call += 1
+  }
+  let next = source
+  for (const edit of edits.reverse())
+    next = next.slice(0, edit.start) + edit.text + next.slice(edit.end)
+  // Equal counts can still pair a text mention with a missed call; one left in the code is that.
+  if (globsInCode(next, file) !== 0) throw unclear(file)
+  // Import declarations are hoisted wherever they sit, so appending keeps any directive prologue first.
+  return hoisted.length === 0 ? next : `${next}\n${hoisted.join("\n")}\n`
+}
+
+/**
+ * Expand `import.meta.glob` in the app's own modules, for `Bun.build`. `root` is the app root, which a
+ * pattern starting with `/` is read from. Installed packages are left as published. Register it after
+ * every plugin that loads app modules itself (a server-function stub must win over it); a module such
+ * a plugin loads keeps its call, which {@link assertNoImportGlob} then refuses in the output. Register
+ * it before a plugin that rewrites source through `addSourceTransform`: it reads through that rewrite.
+ */
+export function importGlobPlugin(options: { readonly root: string }): BunPlugin {
+  return {
+    name: "nifra-import-glob",
+    setup(build) {
+      build.onLoad({ filter: SOURCE }, async (args) => {
+        if (args.namespace !== "file" || args.path.split("/").includes("node_modules"))
+          return undefined
+        if (!(await Bun.file(args.path).text()).includes("import.meta.glob")) return undefined
+        // Claiming the module would skip a later plugin's rewrite of it (the copy split), so read
+        // through it.
+        const source = await readSource(build, args.path)
+        const contents = expandImportGlobs(source, args.path, options.root)
+        if (contents === source) return undefined
+        return { contents, loader: LOADERS[extname(args.path)] ?? "js" }
+      })
+    },
+  }
+}
+
+/** Refuse a bundle that still calls `import.meta.glob`: the browser has no such function, so every
+ * file the call named would be missing at run time. `outputs` are the emitted chunks, path to text. */
+export function assertNoImportGlob(outputs: ReadonlyArray<readonly [string, string]>): void {
+  const left = outputs
+    .filter(([, text]) => /\bimport\.meta\.glob\s*\(/.test(text))
+    .map(([path]) => path)
+  if (left.length === 0) return
+  throw new Error(
+    `[nifra/web] ${left.join(", ")} still call${left.length === 1 ? "s" : ""} import.meta.glob, which no browser or server runtime defines. A plugin that loads a module itself runs before the glob expansion and keeps its call; expand it in that plugin, or build with --vite.`,
+  )
+}

package/src/plugins/kit.ts

@@ -122,6 +122,42 @@ export function hash8(input: string): string {
   return h.toString(16).padStart(8, "0")
 }
 
+const SOURCE_TRANSFORMS = Symbol.for("nifra.build.source-transforms")
+
+/** A rewrite of a source file's text before any plugin compiles it; `undefined` leaves the text as is. */
+export type SourceTransform = (path: string, source: string) => string | undefined
+
+const isTransformList = (value: unknown): value is SourceTransform[] => Array.isArray(value)
+
+/**
+ * Register a source rewrite for one build. Bun runs only the first `onLoad` that returns contents, so
+ * a plugin that claims a file and reads it off disk would compile it without the rewrite: such a plugin
+ * reads through {@link readSource} instead. Stored on the build's config, which every plugin of one
+ * `Bun.build` shares.
+ */
+export function addSourceTransform(build: PluginBuilder, transform: SourceTransform): void {
+  const config: unknown = build.config
+  if (typeof config !== "object" || config === null) return
+  const existing: unknown = Reflect.get(config, SOURCE_TRANSFORMS)
+  if (isTransformList(existing)) existing.push(transform)
+  else Reflect.set(config, SOURCE_TRANSFORMS, [transform])
+}
+
+/** A source file's text as this build compiles it: off disk, through each {@link addSourceTransform}. */
+export async function readSource(build: PluginBuilder, path: string): Promise<string> {
+  let source = await Bun.file(path).text()
+  // A runtime plugin (`Bun.plugin`) has no build config.
+  const config: unknown = build.config
+  const transforms: unknown =
+    typeof config === "object" && config !== null
+      ? Reflect.get(config, SOURCE_TRANSFORMS)
+      : undefined
+  if (isTransformList(transforms)) {
+    for (const transform of transforms) source = transform(path, source) ?? source
+  }
+  return source
+}
+
 /**
  * Env flag a nifra dev server sets for its own lifetime, so a framework compiler plugin can tell a dev
  * compile from a `nifra build` one. Exported for the dev server that sets it; plugins ask

package/src/plugins/stylex.ts

@@ -11,6 +11,7 @@ import {
   devServerCompile,
   hash8,
   normalizeFilePath,
+  readSource,
   reproduciblePath,
   requirePeer,
 } from "./kit.ts"
@@ -236,7 +237,7 @@ export function stylexBunPlugin(
       const dependencies = dependenciesFor(options)
       build.onLoad({ filter: JS_FILTER }, async (args) => {
         const path = normalizeFilePath(args.path)
-        const source = await Bun.file(path).text()
+        const source = await readSource(build, path)
         const transformed = await transformModule(source, path, options, dependencies())
         if (transformed === undefined) return
         const contents =

package/src/render-seam.ts

@@ -33,6 +33,61 @@ export interface RenderProps {
   readonly boundaries?: BoundaryStates
   /** The rendered chain's module ids and `handle` exports, for the adapter's `useMatches`. */
   readonly matchChain?: MatchChain
+  /** The page's locale, when the app registers its locale routing (`createWebApp`'s `i18n`). Set on
+   * SSR only; the client names it from `path` (see {@link localeOfProps}). */
+  readonly locale?: PageLocale
+}
+
+/** A served locale as a page renders in it: from the app's locale registry. */
+export interface PageLocale {
+  /** The registry key, which is also the URL segment (`ur`). */
+  readonly key: string
+  /** The BCP-47 tag `<html lang>` and `Content-Language` carry (`ur-PK`). */
+  readonly lang: string
+  readonly dir: "ltr" | "rtl"
+}
+
+/** The served locales, handed to the client so it names a page's locale from its path the way the
+ * server does. */
+export interface PageLocales {
+  /** The default locale's key. */
+  readonly default: string
+  /** Every served locale, in registry order. */
+  readonly locales: readonly PageLocale[]
+}
+
+/** The handover global carrying {@link PageLocales}. */
+export const LOCALES_GLOBAL = "__NIFRA_LOCALES__"
+
+/**
+ * The locale a path is in, by the rule `@nifrajs/i18n/routing`'s `localeOf` follows: a first path
+ * segment that names a served locale, ignoring ASCII case, or else the default.
+ */
+export function pageLocaleIn(config: PageLocales, path: string): PageLocale | undefined {
+  // One linear pass: separators, then the segment up to the next separator, query or hash.
+  const first = /^[/\\]*([^/\\?#]*)/.exec(path.replace(/[\t\n\r]/g, ""))?.[1]?.toLowerCase()
+  return (
+    config.locales.find((locale) => first !== "" && locale.key.toLowerCase() === first) ??
+    config.locales.find((locale) => locale.key === config.default)
+  )
+}
+
+const isPageLocales = (value: unknown): value is PageLocales =>
+  typeof value === "object" && value !== null && "locales" in value && Array.isArray(value.locales)
+
+/** The locale of the page at `path`, from the served locales the server handed over; `undefined`
+ * outside a browser page, or when the app registers no locale routing. */
+export function handoverLocale(path: string): PageLocale | undefined {
+  const config: unknown = Reflect.get(globalThis, LOCALES_GLOBAL)
+  return isPageLocales(config) ? pageLocaleIn(config, path) : undefined
+}
+
+/** The locale of the page `props` render: the server's answer on SSR, else the one the client names
+ * from `props.path`. What every adapter's `useLocale` reads. */
+export function localeOfProps(props: RenderProps | undefined): PageLocale | undefined {
+  if (props === undefined) return undefined
+  if (props.locale !== undefined) return props.locale
+  return props.path === undefined ? undefined : handoverLocale(props.path)
 }
 
 /**
@@ -151,5 +206,10 @@ export const ACTION_GLOBAL = "__NIFRA_ACTION__"
 /** Dynamic-boundary states for hydration; absent when a route declares no boundaries. */
 export const BOUNDARY_GLOBAL = "__NIFRA_BOUNDARIES__"
 export const COMPONENT_GLOBAL = "__NIFRA_COMPONENTS__"
+/** Locale key -> copy chunk URL, in a production build that split copy tables by locale. The name
+ * `@nifrajs/i18n/copy` reads. */
+export const COPY_CHUNKS_GLOBAL = "__NIFRA_COPY__"
+/** The registry `@nifrajs/i18n/copy` keeps its loaded chunks and definitions in. */
+export const COPY_REALM = "nifra.copy"
 /** Marker attribute used to find a non-default hydration container. */
 export const ROOT_ATTRIBUTE = "data-nifra-root"

package/src/router.ts

@@ -310,8 +310,9 @@ export interface ClientRouterOptions {
   /** Override the loader-data fetch (tests inject a stub; defaults to a same-origin JSON GET). */
   readonly fetchData?: FetchRouteData
   /** Ensure a route's code chunk is loaded before rendering (code-splitting). Awaited in parallel
-   * with the loader data, so `pending` covers both. Omit when the bundle isn't split. */
-  readonly loadModule?: (routeId: string) => Promise<void>
+   * with the loader data, so `pending` covers both. Omit when the bundle isn't split. `path` is the URL
+   * the route is about to render, for code loaded per URL (a production build's copy chunks). */
+  readonly loadModule?: (routeId: string, path?: string) => Promise<void>
   /** Terminal status → client route id. Generated entries populate this from `_404` and
    * `_<status>` files so soft navigation renders the same boundary as a hard request. */
   readonly statusRoutes?: Readonly<Record<number, string>>
@@ -667,7 +668,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
     )
     if (mine !== generation) return
     if (loaded.terminalRouteId !== undefined) {
-      await loadModule?.(loaded.terminalRouteId)
+      await loadModule?.(loaded.terminalRouteId, state.path)
       state = { ...state, routeId: loaded.terminalRouteId, params: {}, data: null }
     } else {
       state = {
@@ -788,7 +789,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
         state = { ...state, pendingPath: at }
         emit()
       }
-      await loadModule?.(route.routeId)
+      await loadModule?.(route.routeId, at)
       // Prefetched server data is one-shot; a clientLoader still runs over it without another request.
       const prefetchedData = usePrefetch ? freshPrefetch(at) : undefined
       if (usePrefetch) prefetched.delete(at)
@@ -801,7 +802,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
           prefetchedData,
         )
         if (loaded.terminalRouteId !== undefined) {
-          await loadModule?.(loaded.terminalRouteId)
+          await loadModule?.(loaded.terminalRouteId, at)
           if (options.layoutStatusRoutes?.[loaded.terminalRouteId] === true) {
             throw new Error(
               `[nifra/web] ${loaded.terminalRouteId} renders inside layouts; loading ${at} as a document`,
@@ -1215,7 +1216,7 @@ export function createClientRouter(options: ClientRouterOptions): ClientRouter {
         // Unwrapped here, so a prefetched entry is the same shape `navigate` builds state from -
         // otherwise a prefetch hit would publish an envelope where a miss publishes loader data.
         const [, loaded] = await Promise.all([
-          loadModule?.(matched.routeId),
+          loadModule?.(matched.routeId, path),
           loadRouteData(path, matched),
         ])
         prefetched.delete(path) // a stale entry re-enters as the newest

package/src/server-components/typescript.ts

@@ -1,18 +1,10 @@
 import { createRequire } from "node:module"
 import type * as TS from "typescript"
+import { isTypeScriptCompiler } from "../internal/typescript-api.ts"
 
 /** The code of the error a TypeScript without the in-process compiler API raises here. */
 export const UNSUPPORTED_TYPESCRIPT = "NIFRA_TS_UNSUPPORTED"
 
-function isCompiler(value: unknown): value is typeof TS {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "createSourceFile" in value &&
-    typeof value.createSourceFile === "function"
-  )
-}
-
 /**
  * The TypeScript compiler API, resolved from `from` the way `import "typescript"` there would be.
  * TypeScript 7's package ships no in-process compiler API (its root export is only `version`), so
@@ -20,7 +12,7 @@ function isCompiler(value: unknown): value is typeof TS {
  */
 export function loadTypeScript(from: string = import.meta.url): typeof TS {
   const loaded: unknown = createRequire(from)("typescript")
-  if (isCompiler(loaded)) return loaded
+  if (isTypeScriptCompiler(loaded)) return loaded
   const version =
     typeof loaded === "object" &&
     loaded !== null &&