@reckona/mreact-router 0.0.81 → 0.0.83

package/src/route-hydration-contract.ts

@@ -0,0 +1,22 @@
+export const routeHydrationContract = {
+  clientReferencesScriptPrefix: "mreact-client-references-",
+  hydratedAttribute: "data-mreact-hydrated",
+  hotRouteHydrateExport: "__mreactHotHydrateRoute",
+  propsScriptPrefix: "mreact-props-",
+  routeHydrateExport: "__mreactHydrateRoute",
+  routeMarkerAttribute: "data-mreact-route-id",
+} as const;
+
+export function routeDataScriptIds(routeId: string): [string, string] {
+  return [
+    `${routeHydrationContract.propsScriptPrefix}${routeId}`,
+    `${routeHydrationContract.clientReferencesScriptPrefix}${routeId}`,
+  ];
+}
+
+export function routeDataScriptSelector(): string {
+  return [
+    `script[type="application/json"][id^="${routeHydrationContract.propsScriptPrefix}"]`,
+    `script[type="application/json"][id^="${routeHydrationContract.clientReferencesScriptPrefix}"]`,
+  ].join(", ");
+}

package/src/route-module-loader.ts

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import type { BuiltServerModuleArtifact } from "./build.js";
+import type { AppRouterImportPolicy } from "./import-policy.js";
+
+export type BuiltServerModuleOutputLike = NonNullable<BuiltServerModuleArtifact["request"]>;
+
+// Per-request hashText (SHA-256) is one of the hot path's dominant
+// costs. Cache hashes for `code` strings we have already seen this
+// process (common case: the prepared code is identical across requests
+// when the source file is unchanged).
+const codeHashCache = new Map<string, string>();
+const MAX_CODE_HASH_ENTRIES = 256;
+
+export function memoizedHashText(code: string): string {
+  const cached = codeHashCache.get(code);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const hash = hashText(code);
+  if (codeHashCache.size >= MAX_CODE_HASH_ENTRIES) {
+    // Simple LRU eviction: drop the oldest entry (Map keeps insertion order).
+    const oldestKey = codeHashCache.keys().next().value;
+    if (oldestKey !== undefined) {
+      codeHashCache.delete(oldestKey);
+    }
+  }
+  codeHashCache.set(code, hash);
+  return hash;
+}
+
+export function prebuiltRequestModuleArtifact(
+  serverModules: ReadonlyMap<string, BuiltServerModuleArtifact> | undefined,
+  file: string,
+  source: string,
+  kind: "request" | "routeMetadata" = "request",
+): BuiltServerModuleOutputLike | undefined {
+  const artifact = serverModules?.get(file)?.[kind];
+
+  return artifact !== undefined && artifact.sourceHash === memoizedHashText(source)
+    ? artifact
+    : undefined;
+}
+
+export function prebuiltRouteLoaderModuleArtifact(
+  serverModules: ReadonlyMap<string, BuiltServerModuleArtifact> | undefined,
+  file: string,
+  source: string,
+): BuiltServerModuleOutputLike | undefined {
+  const artifact = serverModules?.get(file)?.loader;
+
+  return artifact !== undefined && artifact.sourceHash === memoizedHashText(source)
+    ? artifact
+    : prebuiltRequestModuleArtifact(serverModules, file, source);
+}
+
+export function prebuiltServerComponentModuleCode(
+  artifact: BuiltServerModuleArtifact["string"] | BuiltServerModuleArtifact["stream"] | undefined,
+  code: string,
+  codeHash: string,
+): string | undefined {
+  if (artifact === undefined) {
+    return undefined;
+  }
+
+  if (!prebuiltServerModuleOutputMatches(artifact, code, codeHash)) {
+    return undefined;
+  }
+
+  return artifact.bundleCode;
+}
+
+export function prebuiltServerModuleOutputMatches(
+  artifact: BuiltServerModuleOutputLike,
+  code: string,
+  codeHash: string,
+): boolean {
+  return artifact.sourceHash === codeHash || artifact.code === code;
+}
+
+export function importPolicyCacheKey(policy: AppRouterImportPolicy | undefined): string {
+  if (policy === undefined) {
+    return "";
+  }
+
+  return JSON.stringify({
+    allowedPackages: [...(policy.allowedPackages ?? [])].sort(),
+    allowedSourceDirs: [...(policy.allowedSourceDirs ?? [])].sort(),
+    projectRoot: policy.projectRoot ?? "",
+  });
+}
+
+function hashText(text: string): string {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}

package/src/routes.ts

@@ -239,6 +239,10 @@ async function collectRouteFiles(directory: string, rootDirectory = directory):
     const path = join(directory, entry.name);
 
     if (entry.isDirectory()) {
+      if (shouldSkipRouteScanDirectory(entry.name)) {
+        continue;
+      }
+
       files.push(...(await collectRouteFiles(path, rootDirectory)));
       continue;
     }
@@ -257,6 +261,10 @@ async function collectRouteFiles(directory: string, rootDirectory = directory):
   return files;
 }
 
+function shouldSkipRouteScanDirectory(name: string): boolean {
+  return name === ".vite" || name === "node_modules";
+}
+
 function appFileConventionForRelativeFile(
   relativeFile: string,
 ): ReturnType<typeof appFileConventionForRootFilename> {

package/src/serve.ts

@@ -8,7 +8,7 @@ import type {
   BuiltServerModuleArtifact,
 } from "./build.js";
 import type { AppRouterCache } from "./cache.js";
-import type { ClientRouteManifestEntry } from "./client.js";
+import type { ClientRouteManifestEntry } from "./client-route-inference.js";
 import { createRouteMatcher, type AppRoute, type RouteMatcher } from "./routes.js";
 import type { AppRouterServerActionOptions } from "./actions.js";
 import type { AppRouterImportPolicy } from "./import-policy.js";
@@ -31,6 +31,7 @@ import {
   requestLogFields,
   type AppRouterLogger,
 } from "./logger.js";
+import { builtAppRuntimePreloadPlan } from "./preload-policy.js";
 import { routeShellCandidates } from "./route-shells.js";
 import { normalizeRoutePath } from "./route-path.js";
 import type { HttpUpgradeHandler } from "./upgrade.js";
@@ -116,11 +117,32 @@ export interface RenderBuiltAppRequestOptions {
   request: Request;
   routeCache?: AppRouterCache | undefined;
   runtimeDir?: string | undefined;
+  immutableRuntime?: boolean | undefined;
   serverActions?: AppRouterServerActionOptions | undefined;
   sinkStrategy?: ResponseSinkStrategy;
   preload?: AppRouterRenderPreload | undefined;
 }
 
+export interface BuiltRequestRuntimeOptions {
+  immutableRuntime?: boolean | undefined;
+  importPolicy?: AppRouterImportPolicy | undefined;
+  outDir: string;
+  runtimeDir?: string | undefined;
+}
+
+export type BuiltRequestRuntimeRenderOptions = Omit<
+  RenderBuiltAppRequestOptions,
+  "immutableRuntime" | "outDir" | "request" | "runtimeDir"
+>;
+
+export interface BuiltRequestRuntime {
+  preload(preload?: BuiltAppRuntimePreloadStrategy | undefined): Promise<void>;
+  render(
+    request: Request,
+    options?: BuiltRequestRuntimeRenderOptions | undefined,
+  ): Promise<Response>;
+}
+
 export type BuiltAppRuntimePreloadMode =
   | "all"
   | "hot-route-requests"
@@ -201,6 +223,40 @@ export interface AppRouterPrerenderStore {
   withLock?<T>(path: string, task: () => Promise<T>): Promise<T>;
 }
 
+export async function createBuiltRequestRuntime(
+  options: BuiltRequestRuntimeOptions,
+): Promise<BuiltRequestRuntime> {
+  const runtime = await readBuiltRuntime({
+    immutable: options.immutableRuntime,
+    outDir: options.outDir,
+    runtimeDir: options.runtimeDir,
+  });
+
+  return {
+    preload(preload) {
+      return preloadBuiltAppRuntimeWithRuntime({
+        importPolicy: options.importPolicy,
+        preload,
+        runtime,
+      });
+    },
+    async render(request, renderOptions = {}) {
+      const response = await renderBuiltAppRequestWithRuntime({
+        ...renderOptions,
+        importPolicy: renderOptions.importPolicy ?? options.importPolicy,
+        outDir: options.outDir,
+        request,
+        runtime,
+      });
+
+      return applyBuiltAppResponseHook(response, {
+        onResponse: renderOptions.onResponse,
+        request,
+      });
+    },
+  };
+}
+
 export async function preloadBuiltAppRuntime(options: {
   importPolicy?: AppRouterImportPolicy | undefined;
   outDir: string;
@@ -211,38 +267,57 @@ export async function preloadBuiltAppRuntime(options: {
     outDir: options.outDir,
     runtimeDir: options.runtimeDir,
   });
-  const strategy = options.preload ?? { mode: "all" };
+  await preloadBuiltAppRuntimeWithRuntime({
+    importPolicy: options.importPolicy,
+    preload: options.preload,
+    runtime,
+  });
+}
 
-  if (strategy.mode === "none") {
+async function preloadBuiltAppRuntimeWithRuntime(options: {
+  importPolicy?: AppRouterImportPolicy | undefined;
+  preload?: BuiltAppRuntimePreloadStrategy | undefined;
+  runtime: BuiltRuntime;
+}): Promise<void> {
+  const plan = builtAppRuntimePreloadPlan(options.preload);
+
+  if (!plan.shouldPreload) {
     return;
   }
 
-  const routes = builtRuntimePreloadRoutes(runtime, strategy);
-  if (strategy.mode === "all") {
-    await loadBuiltServerModuleArtifacts(runtime, allBuiltServerModuleFiles(runtime), "all");
+  const routes = builtRuntimePreloadRoutes(options.runtime, plan);
+  if (plan.loadAllArtifacts) {
+    await loadBuiltServerModuleArtifacts(
+      options.runtime,
+      allBuiltServerModuleFiles(options.runtime),
+      "all",
+    );
   } else {
-    await loadBuiltServerModuleArtifactsForRequest(runtime, undefined, {
-      includeRender: strategy.mode !== "hot-route-requests",
-    });
+    await loadBuiltServerModuleArtifactsForRequest(
+      options.runtime,
+      undefined,
+      plan.middlewareArtifacts,
+    );
     for (const route of routes) {
-      await loadBuiltServerModuleArtifactsForRequest(runtime, route.file, {
-        includeShells: strategy.mode !== "hot-route-requests",
-        includeRender: strategy.mode !== "hot-route-requests",
-      });
+      await loadBuiltServerModuleArtifactsForRequest(
+        options.runtime,
+        route.file,
+        plan.routeArtifacts,
+      );
     }
   }
   await preloadBuiltRequestModules({
-    appDir: runtime.appDir,
+    appDir: options.runtime.appDir,
     importPolicy: {
       ...options.importPolicy,
-      allowedSourceDirs: runtime.allowedSourceDirs,
-      projectRoot: runtime.projectRoot,
+      allowedSourceDirs: options.runtime.allowedSourceDirs,
+      projectRoot: options.runtime.projectRoot,
     },
     routes,
-    serverModules: runtime.serverModules,
-    serverModuleCacheVersion: runtime.serverModuleCacheVersion,
-    serverSourceFiles: runtime.serverSourceFiles,
-    includeRenderModules: strategy.mode !== "hot-route-requests",
+    serverModules: options.runtime.serverModules,
+    serverModuleCacheVersion: options.runtime.serverModuleCacheVersion,
+    serverSourceFiles: options.runtime.serverSourceFiles,
+    includeRenderModules: plan.includeRenderModules,
   });
 }
 
@@ -275,6 +350,7 @@ export async function renderBuiltAppRequest(
     ...options,
     runtime: await readBuiltRuntime({
       outDir: options.outDir,
+      immutable: options.immutableRuntime,
       runtimeDir: options.runtimeDir,
     }),
   });
@@ -470,7 +546,10 @@ export async function startServer(
   options: StartServerOptions,
 ): Promise<{ close(): Promise<void>; server: Server; url: string }> {
   warnIfImplicitHostTrust(options);
-  const runtime = await readBuiltRuntime({ outDir: options.outDir });
+  const runtime = await createBuiltRequestRuntime({
+    importPolicy: options.importPolicy,
+    outDir: options.outDir,
+  });
   const server = createServer(async (incoming, outgoing) => {
     const startedAt = logNow();
     const fallbackRequestFields = {
@@ -494,19 +573,15 @@ export async function startServer(
         ...logFields,
         type: "router:request:start",
       });
-      const response = await applyBuiltAppResponseHook(await renderBuiltAppRequestWithRuntime({
-        outDir: options.outDir,
-        importPolicy: options.importPolicy,
+      const response = await runtime.render(request, {
         instrumentation: options.instrumentation,
         logger: options.logger,
         onResponse: options.onResponse,
         prerenderStore: options.prerenderStore,
-        request,
         routeCache: options.routeCache,
-        runtime,
         serverActions: options.serverActions,
         ...(options.sinkStrategy === undefined ? {} : { sinkStrategy: options.sinkStrategy }),
-      }), { onResponse: options.onResponse, request });
+      });
       emitRouterLog(options.logger, "info", {
         ...logFields,
         durationMs: logDurationMs(startedAt),
@@ -632,17 +707,23 @@ async function readBuiltPublicAsset(
 }
 
 async function readBuiltRuntime(options: {
+  immutable?: boolean | undefined;
   outDir: string;
   runtimeDir?: string | undefined;
 }): Promise<BuiltRuntime> {
   const outDir = options.outDir;
   const runtimeDir = options.runtimeDir ?? join(outDir, "server", "runtime");
+  const cacheKey = `${outDir}\0${runtimeDir}`;
+  const cached = builtRuntimeCache.get(cacheKey);
+
+  if (options.immutable === true && cached !== undefined) {
+    return cached.runtime;
+  }
+
   const [serverManifestText, clientManifestText] = await Promise.all([
     readFile(join(outDir, "server", "manifest.json"), "utf8"),
     readFile(join(outDir, "client", "manifest.json"), "utf8"),
   ]);
-  const cacheKey = `${outDir}\0${runtimeDir}`;
-  const cached = builtRuntimeCache.get(cacheKey);
 
   if (
     cached !== undefined &&

package/src/server-action-inference.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { dirname, relative, sep } from "node:path";
 import {
+  analyzeBoundaryGraph,
   collectFormActionExpressionReferences,
   hasModuleDirective,
   type FormActionExpressionReference,
@@ -154,6 +155,14 @@ export async function collectBuildInferredServerActions(options: {
   const diagnostics: ServerActionInferenceDiagnostic[] = [];
   const references: InferredServerActionExpressionReference[] = [];
   const sourceHash = formActionSourceHash(options.source);
+  const graphReferences = await collectBuildBoundaryGraphServerActions({
+    file: options.file,
+    files: options.files,
+    relativeRoutesDir: options.relativeRoutesDir,
+    resolveSourceImport: options.resolveSourceImport,
+    source: options.source,
+    sourceHash,
+  });
 
   for (const formReference of formReferences) {
     const expression = findExpressionAt(sourceFile, formReference);
@@ -185,6 +194,13 @@ export async function collectBuildInferredServerActions(options: {
       continue;
     }
 
+    const graphReference = graphReferences.get(formActionOccurrenceKey(formReference));
+
+    if (graphReference !== undefined) {
+      references.push(graphReference);
+      continue;
+    }
+
     if (resolved.kind === "dynamic") {
       diagnostics.push({
         code: dynamicFormActionInferenceCode,
@@ -198,6 +214,39 @@ export async function collectBuildInferredServerActions(options: {
   return { diagnostics, references };
 }
 
+async function collectBuildBoundaryGraphServerActions(options: {
+  file: string;
+  files: Record<string, string>;
+  relativeRoutesDir: string;
+  resolveSourceImport: (importer: string, source: string) => string | undefined;
+  source: string;
+  sourceHash: string;
+}): Promise<Map<string, InferredServerActionExpressionReference>> {
+  const graph = await analyzeBoundaryGraph({
+    entries: [{ file: options.file, kind: "route-page" }],
+    readModule: (file) => (file === options.file ? options.source : options.files[file]),
+    resolveModule: ({ importer, source }) => options.resolveSourceImport(importer, source),
+  });
+  const references = new Map<string, InferredServerActionExpressionReference>();
+
+  for (const action of graph.serverActions) {
+    const reference = {
+      end: action.end,
+      exportName: action.exportName,
+      expression: action.expression,
+      expressionEnd: action.expressionEnd,
+      expressionStart: action.expressionStart,
+      inferred: action.inferred,
+      moduleId: moduleIdForBuildFile(action.moduleFile, options.relativeRoutesDir),
+      sourceHash: options.sourceHash,
+      start: action.start,
+    };
+    references.set(formActionOccurrenceKey(reference), reference);
+  }
+
+  return references;
+}
+
 type RuntimeResolveResult =
   | { kind: "dynamic" }
   | { kind: "resolved"; reference: InferredServerActionReference }

package/src/vite.ts

@@ -15,16 +15,18 @@ import {
   type ResolvedAppRouterProject,
 } from "./config.js";
 import type { AppRouterImportPolicy } from "./import-policy.js";
+import {
+  collectClientRouteReferences,
+  detectNavigationRuntimeHint,
+  isClientRouteSource,
+} from "./client-route-inference.js";
 import {
   buildNavigationRuntimeBundle,
   buildClientRouteBundle,
   buildClientRouteEntrySource,
   clientScriptForPath,
-  collectClientRouteReferences,
-  detectNavigationRuntimeHint,
-  isClientRouteSource,
   navigationRuntimeScriptForDev,
-} from "./client.js";
+} from "./navigation-runtime.js";
 import { nodeRequestToWebRequest, sendResponse } from "./http.js";
 import { renderAppRequest } from "./render.js";
 import { stripRouteClientOnlyExports } from "./route-source.js";