@nifrajs/web 2.12.1 → 2.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nifrajs/web",
-  "version": "2.12.1",
+  "version": "2.14.1",
   "description": "Framework-agnostic SSR core for nifra - the render seam + HTML document orchestration.",
   "keywords": [
     "bun",
@@ -154,6 +154,11 @@
       "bun": "./src/fn-state.ts",
       "types": "./dist/fn-state.d.ts",
       "default": "./dist/fn-state.js"
+    },
+    "./internal/parity": {
+      "bun": "./src/internal/parity.ts",
+      "types": "./dist/internal/parity.d.ts",
+      "default": "./dist/internal/parity.js"
     }
   },
   "files": [
@@ -171,7 +176,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@nifrajs/core": "2.12.1"
+    "@nifrajs/core": "2.14.1"
   },
   "peerDependencies": {
     "sass": "^1.0.0",

package/src/build-vite.ts

@@ -33,6 +33,11 @@ import {
 } from "./build.ts"
 import { discoverRoutes } from "./fs.ts"
 import { generateClientEntry, generateServerManifest } from "./index.ts"
+import {
+  assertDevelopmentProductionParity,
+  assertIdentityParity,
+  collectDevelopmentParityInput,
+} from "./internal/parity.ts"
 import { vitePublicEnvPrefix } from "./internal/server-boundary.ts"
 import { importVite, isViteUnresolved } from "./internal/vite-import.ts"
 import { scopedName } from "./plugins/css-modules.ts"
@@ -128,6 +133,7 @@ export interface BuildClientViteOptions extends Omit<BuildClientOptions, "plugin
 export async function buildClientVite(options: BuildClientViteOptions): Promise<BuildManifest> {
   const { routesDir, outDir, clientModule } = options
   const root = resolvePath(options.root ?? dirname(routesDir))
+  await assertIdentityParity(root)
   const resolve = options.resolve ?? ((file: string) => `${routesDir}/${file}`)
   const publicPath = options.publicPath ?? "/assets/"
   mkdirSync(outDir, { recursive: true })
@@ -325,6 +331,7 @@ export async function buildClientVite(options: BuildClientViteOptions): Promise<
     ...(css.length > 0 ? { css } : {}),
     ...(Object.keys(routeStyles).length > 0 ? { routeStyles } : {}),
   }
+  assertDevelopmentProductionParity(collectDevelopmentParityInput(routesDir, publicDir), manifest)
   writeFileSync(`${outDir}/manifest.json`, JSON.stringify(manifest, null, 2))
   return manifest
 }

package/src/build.ts

@@ -12,6 +12,11 @@ import { type BunPlugin, Glob } from "bun"
 import { sanitizeOutputNames } from "./chunk-names.ts"
 import { discoverRoutes } from "./fs.ts"
 import { generateClientEntry, generateServerManifest } from "./index.ts"
+import {
+  assertDevelopmentProductionParity,
+  assertIdentityParity,
+  collectDevelopmentParityInput,
+} from "./internal/parity.ts"
 import {
   generateServerFnStub,
   SERVER_FN_MODULE,
@@ -784,28 +789,36 @@ export interface ManifestDrift {
   readonly extra: readonly string[]
 }
 
-// The route-relative specifiers the generated manifest imports. Both shapes `generateServerManifest`
-// emits are matched: eager `import * as m0 from "./routes/x.tsx"` and lazy `() => import("./routes/x")`.
-// Captures the path inside the quotes; the caller strips the routes-dir prefix to compare with discovery.
-// `\s*(?:\(\s*)?` rather than `\s*\(?\s*`: two adjacent unbounded whitespace runs with an optional
-// token between them are ambiguous, and that ambiguity backtracks quadratically on a long space run.
-const MANIFEST_IMPORT = /(?:import\s+\*\s+as\s+\w+\s+from|import)\s*(?:\(\s*)?["']([^"']+)["']\)?/g
+// The route-relative file keys the generated manifest's route map declares. Both shapes are matched by
+// their VALUE: eager `  "routes/x.tsx": m0,` and lazy `  "routes/x.tsx": () => import("./routes/x"),`.
+// The KEY (not the import specifier) is the route identity `discoverRoutes` produces, extension and all;
+// the import specifier is emitted extensionless (so a bare `tsc` compiles the manifest) and could not be
+// mapped back to the exact `.tsx`/`.ts` key. The baked `routeStyles` JSON is a single line, so its keys
+// are never at an indented line start and never match. `[ \t]+` (not `\s+`) so the `m` anchor stays on
+// the same line and one route-map entry cannot span two lines of source.
+const MANIFEST_ROUTE_ENTRY = /^[ \t]+(["'])([^"'\n]+)\1\s*:\s*(?:m\d+\b|\(\s*\)\s*=>\s*import\b)/gm
+// The lazy shape declares `const loaders`, the eager shape `const modules`. Anchored at a line start,
+// NOT `.includes("const loaders =")`: the real emit is `const loaders: Record<...> = {`, whose `:` type
+// annotation sits between the name and the `=`, so the ` =` substring never matched and every lazy
+// manifest was re-synced as eager (silently converting `import()` splitting into a single eager bundle).
+const MANIFEST_IS_LAZY = /^const loaders\b/m
 // The baked client-entry line: `export const clientEntry = "…"`.
 const MANIFEST_CLIENT_ENTRY = /export\s+const\s+clientEntry\s*=\s*["']([^"']+)["']/
 
 /**
- * Extract the route-relative file list the committed server-manifest imports, normalized to the same
- * `routes/`-relative keys `discoverRoutes` produces (e.g. `docs/index.tsx`). `routesPrefix` is the
- * specifier prefix the manifest used for the routes dir (default `./routes/`, what `buildServer`'s
- * default `resolve` emits). Only import specifiers under that prefix are route files; the
- * `@nifrajs/web` import (and any other bare specifier) is ignored. Pure - operates on source text.
+ * Extract the route-relative file list a committed server-manifest declares, as the same
+ * `routes/`-relative keys `discoverRoutes` produces (e.g. `docs/index.tsx`). Reads the route map's KEYS,
+ * which carry the file extension and no directory prefix - exactly discovery's shape - so the result is
+ * independent of the specifier prefix the manifest happened to import with. The `@nifrajs/web` import and
+ * the baked `clientEntry`/`styles`/`routeStyles` lines carry no route-map entry and are ignored.
+ *
+ * `_routesPrefix` is accepted for call-site compatibility but no longer needed: the keys are already
+ * prefix-free. Pure - operates on source text.
  */
-export function parseManifestRouteFiles(source: string, routesPrefix = "./routes/"): string[] {
+export function parseManifestRouteFiles(source: string, _routesPrefix?: string): string[] {
   const files = new Set<string>()
-  for (const match of source.matchAll(MANIFEST_IMPORT)) {
-    const spec = match[1]
-    if (spec === undefined || !spec.startsWith(routesPrefix)) continue
-    files.add(spec.slice(routesPrefix.length))
+  for (const match of source.matchAll(MANIFEST_ROUTE_ENTRY)) {
+    if (match[2] !== undefined) files.add(match[2])
   }
   return [...files].sort()
 }
@@ -880,7 +893,7 @@ export function resyncServerManifestSource(
     clientEntry: parseManifestClientEntry(source) ?? "",
     styles: parseManifestStyles(source),
     routeStyles: parseManifestRouteStyles(source),
-    lazy: source.includes("const loaders ="),
+    lazy: MANIFEST_IS_LAZY.test(source),
   })
 }
 
@@ -941,6 +954,8 @@ export function formatManifestDrift(
  */
 export async function buildClient(options: BuildClientOptions): Promise<BuildManifest> {
   const { routesDir, outDir, clientModule } = options
+  const root = resolvePath(dirname(routesDir))
+  await assertIdentityParity(root)
   const resolve = options.resolve ?? ((file: string) => `${routesDir}/${file}`)
   const publicPath = options.publicPath ?? "/assets/"
   mkdirSync(outDir, { recursive: true })
@@ -1141,6 +1156,7 @@ export async function buildClient(options: BuildClientOptions): Promise<BuildMan
     ...(css.length > 0 ? { css } : {}),
     ...(Object.keys(routeStyles).length > 0 ? { routeStyles } : {}),
   }
+  assertDevelopmentProductionParity(collectDevelopmentParityInput(routesDir, publicDir), manifest)
   writeFileSync(`${outDir}/manifest.json`, JSON.stringify(manifest, null, 2))
   return manifest
 }

package/src/dev-ssr-graph.ts

@@ -87,7 +87,7 @@ const appSourceFilter = (root: string): RegExp =>
  * including `export ... from`. What it matches is only a candidate: a hit counts as an import only if the
  * transpiler's own scan reported the same specifier, which is what keeps a lookalike string literal out.
  */
-const SPECIFIER = /\b(from|import|require)(\s*\(?\s*)(["'])([^"'\n]+)\3/g
+const SPECIFIER = /\b(from|import|require)((?:\s*\()?\s*)(["'])([^"'\n]+)\3/g
 
 export interface SsrGraphOptions {
   /** The app root. Only files under it (and outside `node_modules`) are tracked. */

package/src/fn.ts

@@ -45,7 +45,10 @@
  * bespoke dispatcher.
  */
 import {
+  type AnyServer,
   type Context,
+  defineIdentityPlugin,
+  type IdentityPlugin,
   isSameOriginRequest,
   type RouteSchema,
   type StandardSchemaV1,
@@ -151,10 +154,7 @@ export type ServerFnModule = Readonly<Record<string, unknown>>
  *
  * Exports that are not server functions are ignored, so `export type` and helpers can live alongside.
  */
-export function serverFunctions<S extends ServerFnHost>(
-  namespace: string,
-  module: ServerFnModule,
-): (app: S) => S {
+export function serverFunctions(namespace: string, module: ServerFnModule): IdentityPlugin {
   if (!NAMESPACE.test(namespace)) {
     throw new Error(
       `[nifra/fn] invalid server-function namespace ${JSON.stringify(namespace)} - use lowercase dot/dash segments (it becomes a URL path).`,
@@ -164,7 +164,7 @@ export function serverFunctions<S extends ServerFnHost>(
     (entry): entry is [string, ServerFn<unknown, unknown>] => isServerFn(entry[1]),
   )
 
-  const apply = (app: S): S => {
+  const apply = <S extends AnyServer>(app: S): S => {
     for (const [name, fn] of mounted) {
       if (!EXPORT_NAME.test(name)) {
         throw new Error(
@@ -197,5 +197,5 @@ export function serverFunctions<S extends ServerFnHost>(
     }
     return app
   }
-  return Object.assign(apply, { pluginName: `nifra:server-fn:${namespace}` })
+  return defineIdentityPlugin(`nifra:server-fn:${namespace}`, apply)
 }

package/src/index.ts

@@ -2617,6 +2617,18 @@ export interface GenerateServerManifestOptions {
  * `createWebApp`, unchanged) + `clientEntry` (baked). Write it to a file and bundle it into the worker
  * entry (see `buildServer` in `@nifrajs/web/build`).
  */
+// Route source files are emitted as EXTENSIONLESS import specifiers. An explicit `.tsx`/`.ts` in an
+// import is a hard error under a plain `tsc` (TS5097) unless `allowImportingTsExtensions` is set - which
+// only the nifra template tsconfig does - so the generated manifest failed a bare `tsc` with one error
+// per route. Every bundler and `moduleResolution` still resolves the extensionless form to the source
+// file, so dropping the extension costs nothing at build time and makes the output portable. Only a
+// known TS/JS source extension is stripped; the map KEY keeps its extension (it is the route identifier
+// `buildManifest` matches, not an import path).
+const SOURCE_EXTENSION = /\.(?:[mc]?tsx?|[mc]?jsx?)$/
+function moduleSpecifier(resolved: string): string {
+  return resolved.replace(SOURCE_EXTENSION, "")
+}
+
 export function generateServerManifest(
   manifest: Manifest,
   options: GenerateServerManifestOptions,
@@ -2636,7 +2648,7 @@ export function generateServerManifest(
     "// GENERATED by @nifrajs/web generateServerManifest - route manifest for the disk-less edge",
     "// (no filesystem; route imports are static specifiers the bundler resolves). buildManifest is",
     "// the same pure logic discoverRoutes feeds, so patterns + layout chains match exactly.",
-    'import { buildManifest } from "@nifrajs/web"',
+    'import { buildManifest, type RouteModule } from "@nifrajs/web"',
   ]
   const clientEntryLine = `export const clientEntry = ${JSON.stringify(clientEntry)}`
   // Baked stylesheet URLs so the server entry can pass them to createWebApp → <link rel="stylesheet">.
@@ -2648,11 +2660,12 @@ export function generateServerManifest(
     // code-splitting bundler, loaded on first request). The map keys are the route-relative paths
     // `buildManifest` expects; the importer it builds calls the per-file loader.
     const loaders = files.map(
-      (file) => `  ${jsStringLiteral(file)}: () => import(${jsStringLiteral(resolve(file))}),`,
+      (file) =>
+        `  ${jsStringLiteral(file)}: () => import(${jsStringLiteral(moduleSpecifier(resolve(file)))}),`,
     )
     return `${[
       ...header,
-      "const loaders = {",
+      "const loaders: Record<string, () => Promise<RouteModule>> = {",
       ...loaders,
       "}",
       clientEntryLine,
@@ -2663,12 +2676,14 @@ export function generateServerManifest(
   }
   // Eager: `import * as` per route (all bundled into the entry, parsed at boot). Index-based
   // identifiers are collision-proof regardless of filename.
-  const imports = files.map((file, i) => `import * as m${i} from ${JSON.stringify(resolve(file))}`)
+  const imports = files.map(
+    (file, i) => `import * as m${i} from ${JSON.stringify(moduleSpecifier(resolve(file)))}`,
+  )
   const entries = files.map((file, i) => `  ${JSON.stringify(file)}: m${i},`)
   return `${[
     ...header,
     ...imports,
-    "const modules = {",
+    "const modules: Record<string, RouteModule> = {",
     ...entries,
     "}",
     clientEntryLine,