@nifrajs/web 2.13.0 → 3.1.0

package/src/build.ts

@@ -8,10 +8,15 @@
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
 import { cp, lstat, mkdir, realpath } from "node:fs/promises"
 import { dirname, join, relative, resolve as resolvePath, sep } from "node:path"
+import {
+  singleCopyPlugin as declaredSingleCopyPlugin,
+  readSingleCopyDeclaration,
+} from "@nifrajs/core/single-copy"
 import { type BunPlugin, Glob } from "bun"
 import { sanitizeOutputNames } from "./chunk-names.ts"
 import { discoverRoutes } from "./fs.ts"
 import { generateClientEntry, generateServerManifest } from "./index.ts"
+import { dedupePolicyFor } from "./internal/identity-policy.ts"
 import {
   assertDevelopmentProductionParity,
   assertIdentityParity,
@@ -789,28 +794,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()
 }
@@ -885,7 +898,7 @@ export function resyncServerManifestSource(
     clientEntry: parseManifestClientEntry(source) ?? "",
     styles: parseManifestStyles(source),
     routeStyles: parseManifestRouteStyles(source),
-    lazy: source.includes("const loaders ="),
+    lazy: MANIFEST_IS_LAZY.test(source),
   })
 }
 
@@ -1007,6 +1020,7 @@ export async function buildClient(options: BuildClientOptions): Promise<BuildMan
         ...buildExtras,
         minify: options.minify ?? true,
         plugins: [
+          ...declaredSingleCopyPlugins(root),
           reactDedupePlugin(routesDir),
           preactDedupePlugin(routesDir),
           svelteDedupePlugin(routesDir),
@@ -1097,12 +1111,17 @@ export async function buildClient(options: BuildClientOptions): Promise<BuildMan
     const base = basename(path)
     return base.slice(0, base.lastIndexOf("-")) // strip `-${hash}.css`
   }
+  // `css` is the union of every emitted stylesheet, matching the Vite pipeline (build-vite.ts) so the
+  // field means the same thing on both bundlers. The bootstrap aggregate lists first, preserving the
+  // fallback link order `createWebApp` uses (whole-app stylesheet before any route-scoped one); the
+  // per-route `cssBundle` outputs follow. Dropping those per-route outputs (the old `aggregate`-only
+  // shape) left them in `manifest.assets` but not `css`, so a route-scoped stylesheet normalized to
+  // `asset:css` and tripped the module-graph parity contract - a bundler-dependent divergence.
   const cssAssets = result.outputs.filter((o) => o.kind === "asset" && o.path.endsWith(".css"))
-  const aggregate = cssAssets
-    .filter((o) => cssNameOf(o.path) === bootstrapName)
-    .map((o) => toUrl(o.path))
-  const css: readonly string[] =
-    aggregate.length > 0 ? aggregate : cssAssets.map((o) => toUrl(o.path))
+  const css: readonly string[] = [
+    ...cssAssets.filter((o) => cssNameOf(o.path) === bootstrapName),
+    ...cssAssets.filter((o) => cssNameOf(o.path) !== bootstrapName),
+  ].map((o) => toUrl(o.path))
 
   // CSS - per-route: each route/layout file is its own entrypoint, so the build metafile records its
   // `cssBundle` - exactly the CSS that file's subtree uses (shared-component CSS is inlined into each
@@ -1236,7 +1255,7 @@ const reactDomEdgePlugin = (from: string): BunPlugin => ({
  * condition-agnostic, so pinning it doesn't disturb the edge/browser/server conditions that select
  * react-dom's build.
  */
-const REACT_DEDUPE_SPECS = ["react", "react/jsx-runtime", "react/jsx-dev-runtime"] as const
+const REACT_DEDUPE_SPECS = dedupePolicyFor("react").bunSpecs ?? []
 export const reactDedupePlugin = (from: string): BunPlugin => ({
   name: "nifra-react-dedupe",
   setup(build) {
@@ -1264,13 +1283,7 @@ export const reactDedupePlugin = (from: string): BunPlugin => ({
  * skipped). Preact core is condition-agnostic, so pinning it doesn't disturb any condition selection - and
  * unlike react-dom there is no edge-vs-server build to preserve, so pinning the subpaths is safe.
  */
-const PREACT_DEDUPE_SPECS = [
-  "preact",
-  "preact/hooks",
-  "preact/compat",
-  "preact/jsx-runtime",
-  "preact/jsx-dev-runtime",
-] as const
+const PREACT_DEDUPE_SPECS = dedupePolicyFor("preact").bunSpecs ?? []
 export const preactDedupePlugin = (from: string): BunPlugin => ({
   name: "nifra-preact-dedupe",
   setup(build) {
@@ -1287,6 +1300,7 @@ export const preactDedupePlugin = (from: string): BunPlugin => ({
   },
 })
 
+const SVELTE_DEDUPE_PATTERN = dedupePolicyFor("svelte").bunPattern ?? /^svelte($|\/internal\/)/
 /**
  * Dedupe Svelte to a single copy - the Svelte analogue of `reactDedupePlugin`/`preactDedupePlugin`, closing
  * the same class of bug for Svelte (which had NO build-time dedup before). A workspace- or file-linked
@@ -1305,7 +1319,7 @@ export const preactDedupePlugin = (from: string): BunPlugin => ({
 export const svelteDedupePlugin = (from: string): BunPlugin => ({
   name: "nifra-svelte-dedupe",
   setup(build) {
-    build.onResolve({ filter: /^svelte($|\/internal\/)/ }, (args) => {
+    build.onResolve({ filter: SVELTE_DEDUPE_PATTERN }, (args) => {
       try {
         return { path: Bun.resolveSync(args.path, from) }
       } catch {
@@ -1315,6 +1329,21 @@ export const svelteDedupePlugin = (from: string): BunPlugin => ({
   },
 })
 
+/**
+ * The app's declared single-copy rule, applied to the bundle.
+ *
+ * The three plugins above cover the framework runtimes by name, which is the case that bites hardest
+ * and needs no configuration. This one covers what a name list cannot know: `@nifrajs/*` (two copies
+ * of `@nifrajs/core` are two `Server` classes, and `Server` has private members, so `.merge()` stops
+ * accepting the other's app) and whatever else the app named in
+ * `"nifra": { "singleCopy": [...] }`.
+ *
+ * Nothing declared means no plugin at all - the plan does filesystem work, so it is not built for the
+ * majority of apps that have a single copy of everything and never think about this.
+ */
+const declaredSingleCopyPlugins = (root: string): readonly BunPlugin[] =>
+  readSingleCopyDeclaration(root) === undefined ? [] : [declaredSingleCopyPlugin({ cwd: root })]
+
 /**
  * Remix-style `.server` convention for the CLIENT build. A module named `*.server.ts(x)` (`db.server.ts`,
  * `auth.server.ts`, …) is server-only - empty it in the browser bundle so its (possibly `node:` / native /
@@ -1431,6 +1460,7 @@ export async function buildServer(options: BuildServerOptions): Promise<ServerBu
     // Lazy → one chunk per route (loaded on first request); eager → a single self-contained file.
     splitting: lazy,
     plugins: [
+      ...declaredSingleCopyPlugins(resolvePath(dirname(routesDir))),
       ...(edge ? [reactDomEdgePlugin(entryDir), solidWebServerPlugin(entryDir)] : []),
       reactDedupePlugin(entryDir),
       preactDedupePlugin(entryDir),

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)
 }