@nifrajs/web 2.1.0 → 2.3.0

package/src/forms.ts

@@ -1,6 +1,6 @@
 /**
- * `@nifrajs/web/forms` — a typed form ↔ backend-schema binding. The three artifacts that must agree —
- * a form's `<input name>`, the action's `formData.get`, and the typed-client payload — all key off the
+ * `@nifrajs/web/forms` - a typed form ↔ backend-schema binding. The three artifacts that must agree -
+ * a form's `<input name>`, the action's `formData.get`, and the typed-client payload - all key off the
  * ONE route body schema, derived purely from `typeof backend`. A typo'd field name, or a field the
  * schema doesn't have, becomes a COMPILE error instead of a silent runtime empty.
  *
@@ -8,14 +8,14 @@
  *   import { formFor } from "@nifrajs/web/forms"
  *
  *   const f = formFor<typeof backend, "/todos">()   // method defaults to "post"
- *   // In the component (any framework — spread the props onto an input):
+ *   // In the component (any framework - spread the props onto an input):
  *   <input {...f.field("text")} />                  // "text" ∈ the body's keys, else a compile error
  *   // In the action:
  *   const text = f.read(await request.formData(), "text")   // an orphan key won't compile
  *   await api.todos.post({ text })                  // payload already typed by nifra
  *
  * Framework-agnostic + dependency-free: no codegen, no schema is bundled into the client, and the
- * runtime is a trivial pass-through — all the work is in the types. It checks the field KEY, never the
+ * runtime is a trivial pass-through - all the work is in the types. It checks the field KEY, never the
  * MEANING (a `field("email")` collecting a phone is still valid here); that stays an app/AI concern.
  */
 import type { RouteInfo, Server } from "@nifrajs/core/server"
@@ -28,7 +28,7 @@ type FormEntries = ReturnType<FormData["getAll"]>
 /** The route registry baked into a server's type (`typeof app`). */
 type RegistryOf<App> = App extends Server<infer R, infer _Ctx> ? R : never
 
-/** Every route path the app declares — constrains `Path`, so a wrong path is itself a type error. */
+/** Every route path the app declares - constrains `Path`, so a wrong path is itself a type error. */
 export type RoutePaths<App> = keyof RegistryOf<App> & string
 
 /** The body object type of `App`'s `Method Path` route (`never` when the route declares no body). */
@@ -42,7 +42,7 @@ export type RouteBody<
     : never
   : never
 
-/** The valid field names for that route's body — the schema's keys as a string union. */
+/** The valid field names for that route's body - the schema's keys as a string union. */
 export type FieldKey<App, Path extends string, Method extends string> = [
   RouteBody<App, Path, Method>,
 ] extends [never]
@@ -53,13 +53,13 @@ export type FieldKey<App, Path extends string, Method extends string> = [
 export type FieldProps = Record<string, unknown>
 
 export interface FormHandle<App, Path extends string, Method extends string> {
-  /** Input props for a schema field. `name` is constrained to the body's keys — a typo, or a field the
+  /** Input props for a schema field. `name` is constrained to the body's keys - a typo, or a field the
    * schema doesn't have, is a COMPILE error. Spread onto an element: `<input {...f.field("text")} />`. */
   field<K extends FieldKey<App, Path, Method>>(
     name: K,
     props?: FieldProps,
   ): FieldProps & { name: K }
-  /** `formData.get`, key-constrained to the body's fields — reading an orphan key won't compile. */
+  /** `formData.get`, key-constrained to the body's fields - reading an orphan key won't compile. */
   read<K extends FieldKey<App, Path, Method>>(form: FormData, name: K): FormEntry
   /** `formData.getAll`, key-checked the same way. */
   readAll<K extends FieldKey<App, Path, Method>>(form: FormData, name: K): FormEntries

package/src/fs.ts

@@ -1,5 +1,5 @@
 /**
- * @nifrajs/web/fs — filesystem route discovery. Separated from the main entry so `app.fetch`
+ * @nifrajs/web/fs - filesystem route discovery. Separated from the main entry so `app.fetch`
  * (and the rest of @nifrajs/web) stays fs-free + edge-portable: this runs at build/startup
  * only. It scans a routes dir and feeds the pure `buildManifest`.
  */
@@ -8,9 +8,22 @@ import { buildManifest, type Manifest, type RouteModule } from "./manifest.ts"
 
 /** Options for {@link discoverRoutes}. */
 export interface DiscoverRoutesOptions {
-  /** Appended (as `?<importQuery>`) to each route's dynamic import — the dev server sets a
-   * changing value to bust Bun's module cache so SSR picks up edited route files. */
+  /** Appended (as `?<importQuery>`) to each route's dynamic import - the dev server sets a
+   * changing value to bust Bun's module cache so SSR picks up edited route files. Ignored when
+   * {@link load} is supplied, which does its own cache handling. */
   readonly importQuery?: string
+  /**
+   * Load a route module by its absolute path, instead of a bare dynamic `import()`.
+   *
+   * This is what lets a pipeline own SSR resolution. A bare `import()` always resolves through the
+   * RUNTIME - Bun - so the Vite dev server ended up serving the client while Bun resolved the server,
+   * two resolvers disagreeing about one specifier in a single process. That is the dual-React bug and
+   * the reason `resolve.dedupe` never reached SSR: the alias governs Vite, and SSR never asked Vite.
+   *
+   * Pass `vite.ssrLoadModule` here and the Vite pipeline resolves both halves. Omit it and Bun does,
+   * which is correct for the Bun pipeline. Either way one toolchain owns the phase.
+   */
+  readonly load?: (absolutePath: string) => Promise<unknown>
 }
 
 /** Scan a `routes/` directory (recursively) and build the route manifest. */
@@ -19,8 +32,13 @@ export function discoverRoutes(dir: string, options: DiscoverRoutesOptions = {})
     .map((file) => file.replaceAll("\\", "/")) // normalize Windows separators
     .filter((file) => /\.(tsx|jsx|svelte|vue|mdx)$/.test(file))
   const query = options.importQuery ? `?${options.importQuery}` : ""
-  return buildManifest(
-    files,
-    (file) => () => import(`${dir}/${file}${query}`) as Promise<RouteModule>,
+  const load = options.load
+  return buildManifest(files, (file) =>
+    load === undefined
+      ? () => import(`${dir}/${file}${query}`) as Promise<RouteModule>
+      : // No `importQuery` here: an injected loader owns its own invalidation (Vite's module graph
+        // re-evaluates on change), and appending a cache-buster would defeat it by minting a new
+        // module id per request.
+        () => load(`${dir}/${file}`) as Promise<RouteModule>,
   )
 }