vite-plugin-react-server 1.2.0-alpha.1 → 1.2.0

package/dist/plugin/helpers/createUnifiedCssProcessor.d.ts

@@ -0,0 +1,70 @@
+import type { CssContent, ResolvedUserOptions } from "../types.js";
+import type { Logger } from "vite";
+/**
+ * Unified CSS Processor
+ *
+ * PURPOSE: Consolidate CSS processing logic used across:
+ * - processCssFilesForPages (plugin.server.ts, plugin.client.ts)
+ * - RSC worker message handler (messageHandler.tsx)
+ * - HTML worker message handler
+ *
+ * This helper provides consistent CSS processing behavior across all environments
+ * and reduces code duplication.
+ */
+export interface UnifiedCssProcessorOptions {
+    /** User options for CSS processing */
+    userOptions: ResolvedUserOptions;
+    /** Logger for verbose output */
+    logger?: Logger;
+    /** Whether to enable verbose logging */
+    verbose?: boolean;
+    /** Static build output directory */
+    staticOutDir?: string;
+    /** Static manifest for CSS file resolution */
+    staticManifest?: any;
+    /** Bundle containing CSS files */
+    bundle?: any;
+}
+export interface CssProcessingResult {
+    /** CSS files organized by page/route */
+    cssFilesByPage: Map<string, Map<string, CssContent>>;
+    /** Global CSS files */
+    globalCss: Map<string, CssContent>;
+    /** Combined CSS files for a specific route */
+    combinedCssFiles: Map<string, CssContent>;
+}
+/**
+ * Processes CSS files from static build output
+ *
+ * @param cssInputs - CSS file inputs from manifest
+ * @param options - Processing options
+ * @returns Processed CSS content map
+ */
+export declare function processCssFromStaticBuild(cssInputs: Record<string, string>, options: UnifiedCssProcessorOptions): Map<string, CssContent>;
+/**
+ * Combines CSS files from multiple sources
+ *
+ * @param sources - Array of CSS file maps to combine
+ * @returns Combined CSS file map
+ */
+export declare function combineCssFiles(...sources: Array<Map<string, CssContent> | undefined>): Map<string, CssContent>;
+/**
+ * Processes inline CSS content for stateful systems
+ *
+ * @param cssFiles - CSS files map
+ * @param addCssFileContent - Function to add CSS content to state
+ * @param userOptions - User options
+ */
+export declare function processInlineCssForState(cssFiles: Map<string, CssContent>, addCssFileContent: (id: string, content: string, userOptions: ResolvedUserOptions) => void, userOptions: ResolvedUserOptions): void;
+/**
+ * Creates a unified CSS processor instance
+ *
+ * @param options - Processing options
+ * @returns CSS processor functions
+ */
+export declare function createUnifiedCssProcessor(options: UnifiedCssProcessorOptions): {
+    processCssFromStaticBuild: (cssInputs: Record<string, string>) => Map<string, CssContent>;
+    combineCssFiles: typeof combineCssFiles;
+    processInlineCssForState: typeof processInlineCssForState;
+};
+//# sourceMappingURL=createUnifiedCssProcessor.d.ts.map

package/dist/plugin/helpers/createUnifiedCssProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUnifiedCssProcessor.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/createUnifiedCssProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,0BAA0B;IACzC,sCAAsC;IACtC,WAAW,EAAE,mBAAmB,CAAC;IACjC,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oCAAoC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,cAAc,CAAC,EAAE,GAAG,CAAC;IACrB,kCAAkC;IAClC,MAAM,CAAC,EAAE,GAAG,CAAC;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IACrD,uBAAuB;IACvB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,8CAA8C;IAC9C,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,OAAO,EAAE,0BAA0B,GAClC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAkEzB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,GAAG,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAAC,GACrD,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAYzB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EACjC,iBAAiB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,KAAK,IAAI,EAC1F,WAAW,EAAE,mBAAmB,GAC/B,IAAI,CAMN;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,0BAA0B;2CAElC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;EAKhE"}

package/dist/plugin/helpers/createUnifiedCssProcessor.js

@@ -0,0 +1,89 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createCssProps } from './createCssProps.js';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function processCssFromStaticBuild(cssInputs, options) {
+  const { userOptions, logger, verbose, staticOutDir, staticManifest } = options;
+  const cssMap = /* @__PURE__ */ new Map();
+  for (const [key] of Object.entries(cssInputs)) {
+    if (verbose) {
+      logger?.info(`[unified-css] Loading CSS content for ${key}`);
+    }
+    let cssContent = "";
+    if (staticManifest && staticOutDir) {
+      const cssFilePath = join(staticOutDir, key);
+      try {
+        cssContent = readFileSync(cssFilePath, "utf-8");
+        if (verbose) {
+          logger?.info(`[unified-css] Got CSS from static build file: ${cssFilePath}`);
+        }
+      } catch (error) {
+        if (verbose) {
+          logger?.info(`[unified-css] Failed to read CSS file: ${cssFilePath} - ${error}`);
+        }
+      }
+    } else {
+      if (verbose) {
+        logger?.info(`[unified-css] No static manifest available for CSS file: ${key}`);
+      }
+    }
+    if (verbose) {
+      logger?.info(
+        `[unified-css] CSS content for ${key}: ${typeof cssContent}, length: ${cssContent?.length}, preview: ${cssContent?.substring(0, 100)}`
+      );
+    }
+    if (typeof cssContent !== "string" || cssContent === "undefined" || !cssContent) {
+      if (verbose) {
+        logger?.info(`[unified-css] Skipping CSS file ${key} - invalid content`);
+      }
+      continue;
+    }
+    if (cssContent) {
+      cssMap.set(
+        key,
+        createCssProps({
+          id: key,
+          code: cssContent,
+          userOptions
+        })
+      );
+      if (verbose) {
+        logger?.info(`[unified-css] Added CSS file ${key} to map`);
+      }
+    }
+  }
+  return cssMap;
+}
+function combineCssFiles(...sources) {
+  const combined = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (source) {
+      for (const [key, value] of source.entries()) {
+        combined.set(key, value);
+      }
+    }
+  }
+  return combined;
+}
+function processInlineCssForState(cssFiles, addCssFileContent, userOptions) {
+  for (const [id, cssContent] of cssFiles.entries()) {
+    if (cssContent.children && typeof cssContent.children === "string") {
+      addCssFileContent(id, cssContent.children, userOptions);
+    }
+  }
+}
+function createUnifiedCssProcessor(options) {
+  return {
+    processCssFromStaticBuild: (cssInputs) => processCssFromStaticBuild(cssInputs, options),
+    combineCssFiles,
+    processInlineCssForState
+  };
+}
+
+export { combineCssFiles, createUnifiedCssProcessor, processCssFromStaticBuild, processInlineCssForState };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createUnifiedCssProcessor.js","sources":["../../../plugin/helpers/createUnifiedCssProcessor.ts"],"sourcesContent":["import type { CssContent, ResolvedUserOptions } from \"../types.js\";\nimport type { Logger } from \"vite\";\nimport { createCssProps } from \"./createCssProps.js\";\nimport { readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\n/**\n * Unified CSS Processor\n * \n * PURPOSE: Consolidate CSS processing logic used across:\n * - processCssFilesForPages (plugin.server.ts, plugin.client.ts)\n * - RSC worker message handler (messageHandler.tsx)\n * - HTML worker message handler\n * \n * This helper provides consistent CSS processing behavior across all environments\n * and reduces code duplication.\n */\n\nexport interface UnifiedCssProcessorOptions {\n  /** User options for CSS processing */\n  userOptions: ResolvedUserOptions;\n  /** Logger for verbose output */\n  logger?: Logger;\n  /** Whether to enable verbose logging */\n  verbose?: boolean;\n  /** Static build output directory */\n  staticOutDir?: string;\n  /** Static manifest for CSS file resolution */\n  staticManifest?: any;\n  /** Bundle containing CSS files */\n  bundle?: any;\n}\n\nexport interface CssProcessingResult {\n  /** CSS files organized by page/route */\n  cssFilesByPage: Map<string, Map<string, CssContent>>;\n  /** Global CSS files */\n  globalCss: Map<string, CssContent>;\n  /** Combined CSS files for a specific route */\n  combinedCssFiles: Map<string, CssContent>;\n}\n\n/**\n * Processes CSS files from static build output\n * \n * @param cssInputs - CSS file inputs from manifest\n * @param options - Processing options\n * @returns Processed CSS content map\n */\nexport function processCssFromStaticBuild(\n  cssInputs: Record<string, string>,\n  options: UnifiedCssProcessorOptions\n): Map<string, CssContent> {\n  const { userOptions, logger, verbose, staticOutDir, staticManifest } = options;\n  const cssMap = new Map<string, CssContent>();\n\n  for (const [key] of Object.entries(cssInputs)) {\n    if (verbose) {\n      logger?.info(`[unified-css] Loading CSS content for ${key}`);\n    }\n\n    // Get CSS content from static build output files\n    let cssContent = \"\";\n\n    // Try to get CSS from static build output directory\n    if (staticManifest && staticOutDir) {\n      const cssFilePath = join(staticOutDir, key);\n      try {\n        cssContent = readFileSync(cssFilePath, 'utf-8');\n        if (verbose) {\n          logger?.info(`[unified-css] Got CSS from static build file: ${cssFilePath}`);\n        }\n      } catch (error) {\n        if (verbose) {\n          logger?.info(`[unified-css] Failed to read CSS file: ${cssFilePath} - ${error}`);\n        }\n      }\n    } else {\n      if (verbose) {\n        logger?.info(`[unified-css] No static manifest available for CSS file: ${key}`);\n      }\n    }\n\n    if (verbose) {\n      logger?.info(\n        `[unified-css] CSS content for ${key}: ${typeof cssContent}, length: ${\n          cssContent?.length\n        }, preview: ${cssContent?.substring(0, 100)}`\n      );\n    }\n\n    if (\n      typeof cssContent !== \"string\" ||\n      cssContent === \"undefined\" ||\n      !cssContent\n    ) {\n      if (verbose) {\n        logger?.info(`[unified-css] Skipping CSS file ${key} - invalid content`);\n      }\n      continue;\n    }\n\n    if (cssContent) {\n      cssMap.set(\n        key,\n        createCssProps({\n          id: key,\n          code: cssContent,\n          userOptions: userOptions,\n        })\n      );\n      if (verbose) {\n        logger?.info(`[unified-css] Added CSS file ${key} to map`);\n      }\n    }\n  }\n\n  return cssMap;\n}\n\n/**\n * Combines CSS files from multiple sources\n * \n * @param sources - Array of CSS file maps to combine\n * @returns Combined CSS file map\n */\nexport function combineCssFiles(\n  ...sources: Array<Map<string, CssContent> | undefined>\n): Map<string, CssContent> {\n  const combined = new Map<string, CssContent>();\n  \n  for (const source of sources) {\n    if (source) {\n      for (const [key, value] of source.entries()) {\n        combined.set(key, value);\n      }\n    }\n  }\n  \n  return combined;\n}\n\n/**\n * Processes inline CSS content for stateful systems\n * \n * @param cssFiles - CSS files map\n * @param addCssFileContent - Function to add CSS content to state\n * @param userOptions - User options\n */\nexport function processInlineCssForState(\n  cssFiles: Map<string, CssContent>,\n  addCssFileContent: (id: string, content: string, userOptions: ResolvedUserOptions) => void,\n  userOptions: ResolvedUserOptions\n): void {\n  for (const [id, cssContent] of cssFiles.entries()) {\n    if (cssContent.children && typeof cssContent.children === 'string') {\n      addCssFileContent(id, cssContent.children, userOptions);\n    }\n  }\n}\n\n/**\n * Creates a unified CSS processor instance\n * \n * @param options - Processing options\n * @returns CSS processor functions\n */\nexport function createUnifiedCssProcessor(options: UnifiedCssProcessorOptions) {\n  return {\n    processCssFromStaticBuild: (cssInputs: Record<string, string>) => \n      processCssFromStaticBuild(cssInputs, options),\n    combineCssFiles,\n    processInlineCssForState,\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/plugin/helpers/getBundleManifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBundleManifest.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/getBundleManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAG,aAAa,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,SAAS,OAAO,EAAE,EACrD,MAAM,EACN,UAAU,GACX,EAAE;IACD,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,eAAe,CAAC;CAC7B,GAAG,GAAG,SAAS,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG;IAChD,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG;QAC7B,MAAM,EAAE,MAAM,CAAC;KAChB,CAAA;CACF,CA8GA"}
+{"version":3,"file":"getBundleManifest.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/getBundleManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAG,aAAa,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,SAAS,OAAO,EAAE,EACrD,MAAM,EACN,UAAU,GACX,EAAE;IACD,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,eAAe,CAAC;CAC7B,GAAG,GAAG,SAAS,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG;IAChD,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG;QAC7B,MAAM,EAAE,MAAM,CAAC;KAChB,CAAA;CACF,CA6GA"}

package/dist/plugin/helpers/getBundleManifest.js

@@ -32,8 +32,7 @@ function getBundleManifest({
           }
         ];
       }
-      const chunkWithFacade = chunk;
-      const moduleId = chunkWithFacade.facadeModuleId || chunkWithFacade.moduleIds[0] || originalFileName;
+      const moduleId = chunk.facadeModuleId || chunk.moduleIds[0] || originalFileName;
       if (moduleId.includes("commonjsHelpers")) {
         return [
           moduleId,
@@ -92,4 +91,4 @@ function getBundleManifest({
 }
 
 export { getBundleManifest };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"getBundleManifest.js","sources":["../../../plugin/helpers/getBundleManifest.ts"],"sourcesContent":["import type {\n  OutputBundle,\n  OutputChunk,\n} from \"rollup\";\nimport type {  ManifestChunk } from \"vite\";\nimport type { InputNormalizer } from \"../types.js\";\n\n\n/**\n * Get the bundle manifest from the plugin context. Will only work during production build\n * @param pluginContext - The plugin context\n * @param bundle - The bundle\n * @param preserveModulesRoot - The preserve modules root\n * @returns The bundle manifest\n */\nexport function getBundleManifest<SSR extends boolean>({\n  bundle,\n  normalizer,\n}: {\n  bundle: OutputBundle,\n  normalizer: InputNormalizer,\n}): SSR extends true ? Record<string, string[]> : {\n  [key: string]: ManifestChunk & {\n    source: string,\n  }\n} {\n\n  if (!bundle) return {};\n\n  // Track virtual modules to prevent duplicates\n  const virtualModules = new Map<string, string>();\n\n  const bundleManifest = Object.fromEntries(\n    Object.entries(bundle)\n      .map(([originalFileName, chunk]) => {\n        if(!originalFileName && 'file' in chunk) {\n          return [\n            chunk.file,\n            {\n              file: chunk.file,\n              source: 'source' in chunk ? chunk.source : undefined,\n            }\n          ]\n        }\n        if (chunk.type === \"asset\") {\n          return [\n            originalFileName,\n            {\n              file: chunk.fileName,\n              name: chunk.names[0],\n              src: originalFileName,\n              source: chunk.source,\n              isEntry: chunk.needsCodeReference,\n            }\n          ]\n        }\n        const chunkWithFacade = chunk as OutputChunk;\n        \n        // Get the module ID, preferring facadeModuleId\n        const moduleId = chunkWithFacade.facadeModuleId || chunkWithFacade.moduleIds[0] || originalFileName;\n        \n        // Handle commonjs helpers specially - must be done before normalization\n        if (moduleId.includes('commonjsHelpers')) {\n          return [\n            moduleId,\n            {\n              file: 'commonjs-runtime.js',\n              name: 'commonjsHelpers',\n              src: moduleId,\n              isEntry: false\n            }\n          ];\n        }\n        \n        // Normalize both paths, removing the root prefix\n        let [normalizedId, sourcePath] = normalizer(moduleId);\n\n        // For virtual modules, use a consistent naming scheme\n        let finalFileName = originalFileName;\n        if (moduleId.includes('?')) {\n          const [basePath, query] = moduleId.split('?');\n          const virtualPath = basePath.includes('node_modules') \n            ? basePath.split('node_modules/')[1] \n            : basePath;\n          \n          // Create a unique key for this virtual module\n          const virtualKey = `${virtualPath}?${query}`;\n          \n          if (!virtualModules.has(virtualKey)) {\n            // First time seeing this virtual module\n            let virtualFileName;\n            if (query === 'inline') {\n              virtualFileName = virtualPath;\n            } else if (virtualPath.endsWith('.css')) {\n              // Preserve CSS extension for CSS files\n              virtualFileName = virtualPath;\n            } else {\n              // Add .js extension for other files\n              virtualFileName = `${virtualPath}.${query}.js`;\n            }\n            virtualModules.set(virtualKey, virtualFileName);\n          }\n          \n          finalFileName = virtualModules.get(virtualKey)!;\n        }\n\n        // handle preserveModulesRoot\n        if(normalizedId.startsWith('\\x00')){\n          normalizedId = normalizedId.slice(1);\n        }\n        if(sourcePath.startsWith('/')){\n          sourcePath = sourcePath.slice(1);\n        }\n\n        \n        const withCss = chunk.viteMetadata?.importedCss?.size ? {\n          css: Array.from(chunk.viteMetadata.importedCss),\n        } : {};\n        const bundleManifestEntry = [\n          sourcePath,\n          {\n            file: finalFileName,\n            name: normalizedId,\n            src: sourcePath,\n            isEntry: chunk.isEntry,\n            ...(chunk.imports?.length > 0 ? { imports: chunk.imports } : {}),\n            ...(chunk.dynamicImports?.length > 0 ? { dynamicImports: chunk.dynamicImports } : {}),\n            ...withCss,\n          },\n        ];\n        return bundleManifestEntry;\n      })\n      .filter(Boolean)\n  );\n  return bundleManifest;\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"getBundleManifest.js","sources":["../../../plugin/helpers/getBundleManifest.ts"],"sourcesContent":["import type {\n  OutputBundle,\n  // OutputChunk - removed unused import\n} from \"rollup\";\nimport type {  ManifestChunk } from \"vite\";\nimport type { InputNormalizer } from \"../types.js\";\n\n\n/**\n * Get the bundle manifest from the plugin context. Will only work during production build\n * @param pluginContext - The plugin context\n * @param bundle - The bundle\n * @param preserveModulesRoot - The preserve modules root\n * @returns The bundle manifest\n */\nexport function getBundleManifest<SSR extends boolean>({\n  bundle,\n  normalizer,\n}: {\n  bundle: OutputBundle,\n  normalizer: InputNormalizer,\n}): SSR extends true ? Record<string, string[]> : {\n  [key: string]: ManifestChunk & {\n    source: string,\n  }\n} {\n\n  if (!bundle) return {};\n\n  // Track virtual modules to prevent duplicates\n  const virtualModules = new Map<string, string>();\n\n  const bundleManifest = Object.fromEntries(\n    Object.entries(bundle)\n      .map(([originalFileName, chunk]) => {\n        if(!originalFileName && 'file' in chunk) {\n          return [\n            chunk.file,\n            {\n              file: chunk.file,\n              source: 'source' in chunk ? chunk.source : undefined,\n            }\n          ]\n        }\n        if (chunk.type === \"asset\") {\n          return [\n            originalFileName,\n            {\n              file: chunk.fileName,\n              name: chunk.names[0],\n              src: originalFileName,\n              source: chunk.source,\n              isEntry: chunk.needsCodeReference,\n            }\n          ]\n        }\n        \n        // Get the module ID, preferring facadeModuleId\n        const moduleId = chunk.facadeModuleId || chunk.moduleIds[0] || originalFileName;\n        \n        // Handle commonjs helpers specially - must be done before normalization\n        if (moduleId.includes('commonjsHelpers')) {\n          return [\n            moduleId,\n            {\n              file: 'commonjs-runtime.js',\n              name: 'commonjsHelpers',\n              src: moduleId,\n              isEntry: false\n            }\n          ];\n        }\n        \n        // Normalize both paths, removing the root prefix\n        let [normalizedId, sourcePath] = normalizer(moduleId);\n\n        // For virtual modules, use a consistent naming scheme\n        let finalFileName = originalFileName;\n        if (moduleId.includes('?')) {\n          const [basePath, query] = moduleId.split('?');\n          const virtualPath = basePath.includes('node_modules') \n            ? basePath.split('node_modules/')[1] \n            : basePath;\n          \n          // Create a unique key for this virtual module\n          const virtualKey = `${virtualPath}?${query}`;\n          \n          if (!virtualModules.has(virtualKey)) {\n            // First time seeing this virtual module\n            let virtualFileName;\n            if (query === 'inline') {\n              virtualFileName = virtualPath;\n            } else if (virtualPath.endsWith('.css')) {\n              // Preserve CSS extension for CSS files\n              virtualFileName = virtualPath;\n            } else {\n              // Add .js extension for other files\n              virtualFileName = `${virtualPath}.${query}.js`;\n            }\n            virtualModules.set(virtualKey, virtualFileName);\n          }\n          \n          finalFileName = virtualModules.get(virtualKey)!;\n        }\n\n        // handle preserveModulesRoot\n        if(normalizedId.startsWith('\\x00')){\n          normalizedId = normalizedId.slice(1);\n        }\n        if(sourcePath.startsWith('/')){\n          sourcePath = sourcePath.slice(1);\n        }\n\n        \n        const withCss = chunk.viteMetadata?.importedCss?.size ? {\n          css: Array.from(chunk.viteMetadata.importedCss),\n        } : {};\n        const bundleManifestEntry = [\n          sourcePath,\n          {\n            file: finalFileName,\n            name: normalizedId,\n            src: sourcePath,\n            isEntry: chunk.isEntry,\n            ...(chunk.imports?.length > 0 ? { imports: chunk.imports } : {}),\n            ...(chunk.dynamicImports?.length > 0 ? { dynamicImports: chunk.dynamicImports } : {}),\n            ...withCss,\n          },\n        ];\n        return bundleManifestEntry;\n      })\n      .filter(Boolean)\n  );\n  return bundleManifest;\n}\n"],"names":[],"mappings":";;;;;AAeO,SAAS,iBAAuC,CAAA;AAAA,EACrD,MAAA;AAAA,EACA;AACF,CAOE,EAAA;AAEA,EAAI,IAAA,CAAC,MAAQ,EAAA,OAAO,EAAC;AAGrB,EAAM,MAAA,cAAA,uBAAqB,GAAoB,EAAA;AAE/C,EAAA,MAAM,iBAAiB,MAAO,CAAA,WAAA;AAAA,IAC5B,MAAA,CAAO,QAAQ,MAAM,CAAA,CAClB,IAAI,CAAC,CAAC,gBAAkB,EAAA,KAAK,CAAM,KAAA;AAClC,MAAG,IAAA,CAAC,gBAAoB,IAAA,MAAA,IAAU,KAAO,EAAA;AACvC,QAAO,OAAA;AAAA,UACL,KAAM,CAAA,IAAA;AAAA,UACN;AAAA,YACE,MAAM,KAAM,CAAA,IAAA;AAAA,YACZ,MAAQ,EAAA,QAAA,IAAY,KAAQ,GAAA,KAAA,CAAM,MAAS,GAAA;AAAA;AAC7C,SACF;AAAA;AAEF,MAAI,IAAA,KAAA,CAAM,SAAS,OAAS,EAAA;AAC1B,QAAO,OAAA;AAAA,UACL,gBAAA;AAAA,UACA;AAAA,YACE,MAAM,KAAM,CAAA,QAAA;AAAA,YACZ,IAAA,EAAM,KAAM,CAAA,KAAA,CAAM,CAAC,CAAA;AAAA,YACnB,GAAK,EAAA,gBAAA;AAAA,YACL,QAAQ,KAAM,CAAA,MAAA;AAAA,YACd,SAAS,KAAM,CAAA;AAAA;AACjB,SACF;AAAA;AAIF,MAAA,MAAM,WAAW,KAAM,CAAA,cAAA,IAAkB,KAAM,CAAA,SAAA,CAAU,CAAC,CAAK,IAAA,gBAAA;AAG/D,MAAI,IAAA,QAAA,CAAS,QAAS,CAAA,iBAAiB,CAAG,EAAA;AACxC,QAAO,OAAA;AAAA,UACL,QAAA;AAAA,UACA;AAAA,YACE,IAAM,EAAA,qBAAA;AAAA,YACN,IAAM,EAAA,iBAAA;AAAA,YACN,GAAK,EAAA,QAAA;AAAA,YACL,OAAS,EAAA;AAAA;AACX,SACF;AAAA;AAIF,MAAA,IAAI,CAAC,YAAA,EAAc,UAAU,CAAA,GAAI,WAAW,QAAQ,CAAA;AAGpD,MAAA,IAAI,aAAgB,GAAA,gBAAA;AACpB,MAAI,IAAA,QAAA,CAAS,QAAS,CAAA,GAAG,CAAG,EAAA;AAC1B,QAAA,MAAM,CAAC,QAAU,EAAA,KAAK,CAAI,GAAA,QAAA,CAAS,MAAM,GAAG,CAAA;AAC5C,QAAM,MAAA,WAAA,GAAc,QAAS,CAAA,QAAA,CAAS,cAAc,CAAA,GAChD,SAAS,KAAM,CAAA,eAAe,CAAE,CAAA,CAAC,CACjC,GAAA,QAAA;AAGJ,QAAA,MAAM,UAAa,GAAA,CAAA,EAAG,WAAW,CAAA,CAAA,EAAI,KAAK,CAAA,CAAA;AAE1C,QAAA,IAAI,CAAC,cAAA,CAAe,GAAI,CAAA,UAAU,CAAG,EAAA;AAEnC,UAAI,IAAA,eAAA;AACJ,UAAA,IAAI,UAAU,QAAU,EAAA;AACtB,YAAkB,eAAA,GAAA,WAAA;AAAA,WACT,MAAA,IAAA,WAAA,CAAY,QAAS,CAAA,MAAM,CAAG,EAAA;AAEvC,YAAkB,eAAA,GAAA,WAAA;AAAA,WACb,MAAA;AAEL,YAAkB,eAAA,GAAA,CAAA,EAAG,WAAW,CAAA,CAAA,EAAI,KAAK,CAAA,GAAA,CAAA;AAAA;AAE3C,UAAe,cAAA,CAAA,GAAA,CAAI,YAAY,eAAe,CAAA;AAAA;AAGhD,QAAgB,aAAA,GAAA,cAAA,CAAe,IAAI,UAAU,CAAA;AAAA;AAI/C,MAAG,IAAA,YAAA,CAAa,UAAW,CAAA,IAAM,CAAE,EAAA;AACjC,QAAe,YAAA,GAAA,YAAA,CAAa,MAAM,CAAC,CAAA;AAAA;AAErC,MAAG,IAAA,UAAA,CAAW,UAAW,CAAA,GAAG,CAAE,EAAA;AAC5B,QAAa,UAAA,GAAA,UAAA,CAAW,MAAM,CAAC,CAAA;AAAA;AAIjC,MAAA,MAAM,OAAU,GAAA,KAAA,CAAM,YAAc,EAAA,WAAA,EAAa,IAAO,GAAA;AAAA,QACtD,GAAK,EAAA,KAAA,CAAM,IAAK,CAAA,KAAA,CAAM,aAAa,WAAW;AAAA,UAC5C,EAAC;AACL,MAAA,MAAM,mBAAsB,GAAA;AAAA,QAC1B,UAAA;AAAA,QACA;AAAA,UACE,IAAM,EAAA,aAAA;AAAA,UACN,IAAM,EAAA,YAAA;AAAA,UACN,GAAK,EAAA,UAAA;AAAA,UACL,SAAS,KAAM,CAAA,OAAA;AAAA,UACf,GAAI,KAAM,CAAA,OAAA,EAAS,MAAS,GAAA,CAAA,GAAI,EAAE,OAAS,EAAA,KAAA,CAAM,OAAQ,EAAA,GAAI,EAAC;AAAA,UAC9D,GAAI,KAAM,CAAA,cAAA,EAAgB,MAAS,GAAA,CAAA,GAAI,EAAE,cAAgB,EAAA,KAAA,CAAM,cAAe,EAAA,GAAI,EAAC;AAAA,UACnF,GAAG;AAAA;AACL,OACF;AACA,MAAO,OAAA,mBAAA;AAAA,KACR,CACA,CAAA,MAAA,CAAO,OAAO;AAAA,GACnB;AACA,EAAO,OAAA,cAAA;AACT;;;;"}

package/dist/plugin/helpers/getRouteFiles.d.ts

@@ -9,7 +9,7 @@ type GetRouteFilesSuccess = {
 };
 type GetRouteFilesError = {
     type: "error";
-    error: Error;
+    error: unknown;
 };
 /**
  * Gets page and props file paths for a route using cached discovery + dynamic fallback.

package/dist/plugin/helpers/getRouteFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRouteFiles.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/getRouteFiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAG5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAIvD,KAAK,oBAAoB,GAAG;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,qBAAqB,mBAAmB,EACxC,aAAa,IAAI,CACf,mBAAmB,EACjB,QAAQ,GACR,SAAS,GACT,MAAM,GACN,MAAM,GACN,gBAAgB,GAChB,SAAS,GACT,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,GAChB,gBAAgB,CACnB,EACD,8BAAuB,KACtB,OAAO,CAAC,oBAAoB,GAAG,kBAAkB,CAkInD,CAAC"}
+{"version":3,"file":"getRouteFiles.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/getRouteFiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAG5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,KAAK,oBAAoB,GAAG;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,qBAAqB,mBAAmB,EACxC,aAAa,IAAI,CACf,mBAAmB,EACjB,QAAQ,GACR,SAAS,GACT,MAAM,GACN,MAAM,GACN,gBAAgB,GAChB,SAAS,GACT,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,GAChB,gBAAgB,CACnB,EACD,8BAAuB,KACtB,OAAO,CAAC,oBAAoB,GAAG,kBAAkB,CAwInD,CAAC"}

package/dist/plugin/helpers/getRouteFiles.js

@@ -5,7 +5,6 @@
  */
 import { resolveUrlOption } from '../config/resolveUrlOption.js';
 import { createLogger } from 'vite';
-import { logError } from '../error/logError.js';
 
 const getRouteFiles = async (route, autoDiscoveredFiles, userOptions, logger = createLogger()) => {
   if (autoDiscoveredFiles.urlMap.has(route)) {
@@ -13,44 +12,53 @@ const getRouteFiles = async (route, autoDiscoveredFiles, userOptions, logger = c
     const { page, props: props2 } = cached;
     let { root: root2, html: html2 } = cached;
     if (userOptions.verbose) {
-      if (page && page !== "") {
-        logger.info(`[getRouteFiles] Page: "${page}"`);
-      }
-      if (props2 && props2 !== "") {
-        logger.info(`[getRouteFiles] Props: "${props2}"`);
+      logger.info(`[getRouteFiles] Found cached route: ${route}, page: "${page}", props: "${props2}"`);
+    }
+    if (!page) {
+      if (userOptions.verbose) {
+        logger.info("[getRouteFiles] Cached page is undefined, falling back to resolveUrlOption");
       }
-      if (root2 && root2 !== "") {
-        logger.info(`[getRouteFiles] Root: "${root2}"`);
+    } else {
+      if (userOptions.verbose) {
+        if (page && page !== "") {
+          logger.info(`[getRouteFiles] Page: "${page}"`);
+        }
+        if (props2 && props2 !== "") {
+          logger.info(`[getRouteFiles] Props: "${props2}"`);
+        }
+        if (root2 && root2 !== "") {
+          logger.info(`[getRouteFiles] Root: "${root2}"`);
+        }
+        if (html2 && html2 !== "") {
+          logger.info(`[getRouteFiles] Html: "${html2}"`);
+        }
       }
-      if (html2 && html2 !== "") {
-        logger.info(`[getRouteFiles] Html: "${html2}"`);
+      if (!root2 && userOptions.Root) {
+        const {
+          type: rootType,
+          error: rootError,
+          Root
+        } = await resolveUrlOption(userOptions, "Root", route);
+        if (rootType === "error") {
+          return { type: "error", error: rootError };
+        }
+        root2 = Root;
+        autoDiscoveredFiles.urlMap.set(route, { page, props: props2, root: root2, html: html2 });
       }
-    }
-    if (!root2 && userOptions.Root) {
-      const {
-        type: rootType,
-        error: rootError,
-        Root
-      } = await resolveUrlOption(userOptions, "Root", route);
-      if (rootType === "error") {
-        return { type: "error", error: rootError };
-      }
-      root2 = Root;
-      autoDiscoveredFiles.urlMap.set(route, { page, props: props2, root: root2, html: html2 });
-    }
-    if (!html2 && userOptions.Html) {
-      const {
-        type: htmlType,
-        error: htmlError,
-        Html
-      } = await resolveUrlOption(userOptions, "Html", route);
-      if (htmlType === "error") {
-        return { type: "error", error: htmlError };
+      if (!html2 && userOptions.Html) {
+        const {
+          type: htmlType,
+          error: htmlError,
+          Html
+        } = await resolveUrlOption(userOptions, "Html", route);
+        if (htmlType === "error") {
+          return { type: "error", error: htmlError };
+        }
+        html2 = Html;
+        autoDiscoveredFiles.urlMap.set(route, { page, props: props2, root: root2, html: html2 });
       }
-      html2 = Html;
-      autoDiscoveredFiles.urlMap.set(route, { page, props: props2, root: root2, html: html2 });
+      return { type: "success", page, props: props2, root: root2, html: html2 };
     }
-    return { type: "success", page, props: props2, root: root2, html: html2 };
   }
   if (userOptions.verbose) {
     logger.info("[getRouteFiles] Not in urlMap, resolving Page option");
@@ -61,9 +69,6 @@ const getRouteFiles = async (route, autoDiscoveredFiles, userOptions, logger = c
     route
   );
   if (type === "error") {
-    if (userOptions.verbose) {
-      logError(error, logger);
-    }
     return { type: "error", error };
   }
   if (userOptions.verbose) {
@@ -114,9 +119,6 @@ const getRouteFiles = async (route, autoDiscoveredFiles, userOptions, logger = c
     props
   } = await resolveUrlOption(userOptions, "props", route);
   if (propsType === "error") {
-    if (userOptions.verbose) {
-      logError(propsError, logger);
-    }
     return { type: "error", error: propsError };
   }
   if (userOptions.verbose) {
@@ -127,4 +129,4 @@ const getRouteFiles = async (route, autoDiscoveredFiles, userOptions, logger = c
 };
 
 export { getRouteFiles };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"getRouteFiles.js","sources":["../../../plugin/helpers/getRouteFiles.ts"],"sourcesContent":["import type { PageName, PropsName, ResolvedUserOptions } from \"../types.js\";\n\nimport { resolveUrlOption } from \"../config/resolveUrlOption.js\";\nimport type { AutoDiscoveredFiles } from \"../types.js\";\nimport { createLogger } from \"vite\";\nimport { logError } from \"../error/logError.js\";\n\ntype GetRouteFilesSuccess = {\n  type: \"success\";\n  page: string;\n  props?: string | undefined;\n  root?: string | undefined;\n  html?: string | undefined;\n};\n\ntype GetRouteFilesError = {\n  type: \"error\";\n  error: Error;\n};\n\n/**\n * Gets page and props file paths for a route using cached discovery + dynamic fallback.\n *\n * ## RUNTIME RESOLUTION STRATEGY\n * This function implements a two-tier lookup strategy:\n *\n * 1. **FAST PATH**: Check auto-discovered urlMap cache first\n *    - Built by resolveBuildPages.ts from build.pages array\n *    - O(1) lookup, no I/O, very fast\n *    - Used for routes that were pre-discovered at build time\n *\n * 2. **FALLBACK PATH**: Dynamic resolution via resolveUrlOption\n *    - Only when route not found in urlMap cache\n *    - Calls Page/props resolver functions with the route URL\n *    - Enables dynamic routing beyond what's in build.pages\n *    - Slower due to function calls + potential I/O\n *\n * ## Auto-Discovery Integration:\n * Results from dynamic resolution are cached back into autoDiscoveredFiles.urlMap\n * for future requests, so each route is only resolved dynamically once.\n *\n * ## Function Resolver Support:\n * This is where router functions like `(url) => \"./src/pages/\" + url + \".tsx\"`\n * are actually called. The dynamic nature allows runtime route resolution but\n * creates complexity for static analysis and build-time discovery.\n */\nexport const getRouteFiles = async (\n  route: string,\n  autoDiscoveredFiles: AutoDiscoveredFiles,\n  userOptions: Pick<\n    ResolvedUserOptions,\n    | PageName\n    | PropsName\n    | \"Root\"\n    | \"Html\"\n    | \"moduleBasePath\"\n    | \"verbose\"\n    | \"pageExportName\"\n    | \"propsExportName\"\n    | \"rootExportName\"\n    | \"htmlExportName\"\n  >,\n  logger = createLogger()\n): Promise<GetRouteFilesSuccess | GetRouteFilesError> => {\n  if (autoDiscoveredFiles.urlMap.has(route)) {\n    const cached = autoDiscoveredFiles.urlMap.get(route)!;\n    const { page, props } = cached;\n    let { root, html } = cached;\n\n    if (userOptions.verbose) {\n      if (page && page !== \"\") {\n        logger.info(`[getRouteFiles] Page: \\\"${page}\\\"`);\n      }\n      if (props && props !== \"\") {\n        logger.info(`[getRouteFiles] Props: \\\"${props}\\\"`);\n      }\n      if (root && root !== \"\") {\n        logger.info(`[getRouteFiles] Root: \\\"${root}\\\"`);\n      }\n      if (html && html !== \"\") {\n        logger.info(`[getRouteFiles] Html: \\\"${html}\\\"`);\n      }\n    }\n\n    // For cached routes, we still need to resolve Root and Html dynamically if they are functions\n    // and not already cached\n    if (!root && userOptions.Root) {\n      const {\n        type: rootType,\n        error: rootError,\n        Root,\n      } = await resolveUrlOption(userOptions, \"Root\", route);\n      if (rootType === \"error\") {\n        return { type: \"error\", error: rootError };\n      }\n      root = Root;\n      // Update cache with resolved root path\n      autoDiscoveredFiles.urlMap.set(route, { page, props, root, html });\n    }\n\n    if (!html && userOptions.Html) {\n      const {\n        type: htmlType,\n        error: htmlError,\n        Html,\n      } = await resolveUrlOption(userOptions, \"Html\", route);\n      if (htmlType === \"error\") {\n        return { type: \"error\", error: htmlError };\n      }\n      html = Html;\n      // Update cache with resolved html path\n      autoDiscoveredFiles.urlMap.set(route, { page, props, root, html });\n    }\n\n    return { type: \"success\", page, props, root, html };\n  }\n  if (userOptions.verbose) {\n    logger.info(\"[getRouteFiles] Not in urlMap, resolving Page option\");\n  }\n  const { type, error, Page } = await resolveUrlOption(\n    userOptions,\n    \"Page\",\n    route\n  );\n  if (type === \"error\") {\n    if (userOptions.verbose) {\n      logError(error, logger);\n    }\n    return { type: \"error\", error };\n  }\n  if (userOptions.verbose) {\n    logger.info(`[getRouteFiles] Page resolved to: ${Page}`);\n  }\n  // Resolve Root and Html components\n  let root: string | undefined;\n  let html: string | undefined;\n\n  if (userOptions.Root) {\n    const {\n      type: rootType,\n      error: rootError,\n      Root,\n    } = await resolveUrlOption(userOptions, \"Root\", route);\n    if (rootType === \"error\") {\n      return { type: \"error\", error: rootError };\n    }\n    root = Root;\n  }\n\n  if (userOptions.Html) {\n    const {\n      type: htmlType,\n      error: htmlError,\n      Html,\n    } = await resolveUrlOption(userOptions, \"Html\", route);\n    if (htmlType === \"error\") {\n      return { type: \"error\", error: htmlError };\n    }\n    html = Html;\n  }\n\n  if (!userOptions.props) {\n    if (userOptions.verbose) {\n      logger.info(\"[getRouteFiles] No props option, returning page only\");\n    }\n    autoDiscoveredFiles.urlMap.set(route, {\n      page: Page,\n      props: undefined,\n      root,\n      html,\n    });\n    return { type: \"success\", page: Page, props: undefined, root, html };\n  }\n  if (userOptions.verbose) {\n    logger.info(\"[getRouteFiles] Resolving props option\");\n  }\n  const {\n    type: propsType,\n    error: propsError,\n    props,\n  } = await resolveUrlOption(userOptions, \"props\", route);\n\n  if (propsType === \"error\") {\n    if (userOptions.verbose) {\n      logError(propsError, logger);\n    }\n    return { type: \"error\", error: propsError };\n  }\n  if (userOptions.verbose) {\n    logger.info(`[getRouteFiles] Props resolved to: ${props}`);\n  }\n  autoDiscoveredFiles.urlMap.set(route, { page: Page, props, root, html });\n  return { type: \"success\", page: Page, props, root, html };\n};\n"],"names":["props","root","html"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"getRouteFiles.js","sources":["../../../plugin/helpers/getRouteFiles.ts"],"sourcesContent":["import type { PageName, PropsName, ResolvedUserOptions } from \"../types.js\";\n\nimport { resolveUrlOption } from \"../config/resolveUrlOption.js\";\nimport type { AutoDiscoveredFiles } from \"../types.js\";\nimport { createLogger } from \"vite\";\n\ntype GetRouteFilesSuccess = {\n  type: \"success\";\n  page: string;\n  props?: string | undefined;\n  root?: string | undefined;\n  html?: string | undefined;\n};\n\ntype GetRouteFilesError = {\n  type: \"error\";\n  error: unknown;\n};\n\n/**\n * Gets page and props file paths for a route using cached discovery + dynamic fallback.\n *\n * ## RUNTIME RESOLUTION STRATEGY\n * This function implements a two-tier lookup strategy:\n *\n * 1. **FAST PATH**: Check auto-discovered urlMap cache first\n *    - Built by resolveBuildPages.ts from build.pages array\n *    - O(1) lookup, no I/O, very fast\n *    - Used for routes that were pre-discovered at build time\n *\n * 2. **FALLBACK PATH**: Dynamic resolution via resolveUrlOption\n *    - Only when route not found in urlMap cache\n *    - Calls Page/props resolver functions with the route URL\n *    - Enables dynamic routing beyond what's in build.pages\n *    - Slower due to function calls + potential I/O\n *\n * ## Auto-Discovery Integration:\n * Results from dynamic resolution are cached back into autoDiscoveredFiles.urlMap\n * for future requests, so each route is only resolved dynamically once.\n *\n * ## Function Resolver Support:\n * This is where router functions like `(url) => \"./src/pages/\" + url + \".tsx\"`\n * are actually called. The dynamic nature allows runtime route resolution but\n * creates complexity for static analysis and build-time discovery.\n */\nexport const getRouteFiles = async (\n  route: string,\n  autoDiscoveredFiles: AutoDiscoveredFiles,\n  userOptions: Pick<\n    ResolvedUserOptions,\n    | PageName\n    | PropsName\n    | \"Root\"\n    | \"Html\"\n    | \"moduleBasePath\"\n    | \"verbose\"\n    | \"pageExportName\"\n    | \"propsExportName\"\n    | \"rootExportName\"\n    | \"htmlExportName\"\n  >,\n  logger = createLogger()\n): Promise<GetRouteFilesSuccess | GetRouteFilesError> => {\n  if (autoDiscoveredFiles.urlMap.has(route)) {\n    const cached = autoDiscoveredFiles.urlMap.get(route)!;\n    const { page, props } = cached;\n    let { root, html } = cached;\n\n    if (userOptions.verbose) {\n      logger.info(`[getRouteFiles] Found cached route: ${route}, page: \"${page}\", props: \"${props}\"`);\n    }\n\n    // If the cached page is undefined, fall back to resolveUrlOption\n    if (!page) {\n      if (userOptions.verbose) {\n        logger.info(\"[getRouteFiles] Cached page is undefined, falling back to resolveUrlOption\");\n      }\n      // Fall through to the resolveUrlOption logic below\n    } else {\n      if (userOptions.verbose) {\n        if (page && page !== \"\") {\n          logger.info(`[getRouteFiles] Page: \\\"${page}\\\"`);\n        }\n        if (props && props !== \"\") {\n          logger.info(`[getRouteFiles] Props: \\\"${props}\\\"`);\n        }\n        if (root && root !== \"\") {\n          logger.info(`[getRouteFiles] Root: \\\"${root}\\\"`);\n        }\n        if (html && html !== \"\") {\n          logger.info(`[getRouteFiles] Html: \\\"${html}\\\"`);\n        }\n      }\n\n      // For cached routes, we still need to resolve Root and Html dynamically if they are functions\n      // and not already cached\n      if (!root && userOptions.Root) {\n      const {\n        type: rootType,\n        error: rootError,\n        Root,\n      } = await resolveUrlOption(userOptions, \"Root\", route);\n      if (rootType === \"error\") {\n        return { type: \"error\", error: rootError };\n      }\n      root = Root;\n      // Update cache with resolved root path\n      autoDiscoveredFiles.urlMap.set(route, { page, props, root, html });\n    }\n\n    if (!html && userOptions.Html) {\n      const {\n        type: htmlType,\n        error: htmlError,\n        Html,\n      } = await resolveUrlOption(userOptions, \"Html\", route);\n      if (htmlType === \"error\") {\n        return { type: \"error\", error: htmlError };\n      }\n      html = Html;\n      // Update cache with resolved html path\n      autoDiscoveredFiles.urlMap.set(route, { page, props, root, html });\n    }\n\n      return { type: \"success\", page, props, root, html };\n    }\n  }\n  if (userOptions.verbose) {\n    logger.info(\"[getRouteFiles] Not in urlMap, resolving Page option\");\n  }\n  const { type, error, Page } = await resolveUrlOption(\n    userOptions,\n    \"Page\",\n    route\n  );\n  if (type === \"error\") {\n    return { type: \"error\", error };\n  }\n  if (userOptions.verbose) {\n    logger.info(`[getRouteFiles] Page resolved to: ${Page}`);\n  }\n  // Resolve Root and Html components\n  let root: string | undefined;\n  let html: string | undefined;\n\n  if (userOptions.Root) {\n    const {\n      type: rootType,\n      error: rootError,\n      Root,\n    } = await resolveUrlOption(userOptions, \"Root\", route);\n    if (rootType === \"error\") {\n      return { type: \"error\", error: rootError };\n    }\n    root = Root;\n  }\n\n  if (userOptions.Html) {\n    const {\n      type: htmlType,\n      error: htmlError,\n      Html,\n    } = await resolveUrlOption(userOptions, \"Html\", route);\n    if (htmlType === \"error\") {\n      return { type: \"error\", error: htmlError };\n    }\n    html = Html;\n  }\n\n  if (!userOptions.props) {\n    if (userOptions.verbose) {\n      logger.info(\"[getRouteFiles] No props option, returning page only\");\n    }\n    autoDiscoveredFiles.urlMap.set(route, {\n      page: Page,\n      props: undefined,\n      root,\n      html,\n    });\n    return { type: \"success\", page: Page, props: undefined, root, html };\n  }\n  if (userOptions.verbose) {\n    logger.info(\"[getRouteFiles] Resolving props option\");\n  }\n  const {\n    type: propsType,\n    error: propsError,\n    props,\n  } = await resolveUrlOption(userOptions, \"props\", route);\n\n  if (propsType === \"error\") {\n    return { type: \"error\", error: propsError };\n  }\n  if (userOptions.verbose) {\n    logger.info(`[getRouteFiles] Props resolved to: ${props}`);\n  }\n  autoDiscoveredFiles.urlMap.set(route, { page: Page, props, root, html });\n  return { type: \"success\", page: Page, props, root, html };\n};\n"],"names":["props","root","html"],"mappings":"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"}

package/dist/plugin/helpers/handleServerAction.client.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from "vite";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Worker } from "node:worker_threads";
+import { PassThrough } from "node:stream";
+import type { ServerActionHandlerOptions } from "./handleServerActionHelper.js";
+/**
+ * Creates a pass-through stream for server action responses.
+ */
+export declare function createServerActionStream(res: ServerResponse): PassThrough;
+/**
+ * Handles errors in server action processing.
+ */
+export declare function handleServerActionError(error: unknown, res: ServerResponse, logger?: Logger): void;
+/**
+ * Client-side server action handler that delegates to worker
+ */
+export declare function handleServerAction(req: IncomingMessage, res: ServerResponse, options: ServerActionHandlerOptions & {
+    worker?: Worker;
+}): Promise<void>;
+/**
+ * Client-side ViteDevServer-specific handler that delegates to worker
+ */
+export declare function handleServerActionWithViteServer(req: IncomingMessage, res: ServerResponse, server: any, handlerOptions: {
+    verbose?: boolean;
+    projectRoot: string;
+    worker?: Worker;
+}): Promise<void>;
+export { parseServerActionRequest, parseServerActionRequestBody, createServerActionResponse, setupServerActionHeaders } from "./handleServerActionHelper.js";
+//# sourceMappingURL=handleServerAction.client.d.ts.map

package/dist/plugin/helpers/handleServerAction.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleServerAction.client.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/handleServerAction.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAKlD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EACV,0BAA0B,EAC3B,MAAM,+BAA+B,CAAC;AAOvC;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,GAAG,WAAW,CAOzE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,MAAM,QAK3F;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,0BAA0B,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxD,OAAO,CAAC,IAAI,CAAC,CAqEf;AAED;;GAEG;AACH,wBAAsB,gCAAgC,CACpD,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,GAAG,EACX,cAAc,EAAE;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,OAAO,CAAC,IAAI,CAAC,CAOf;AAGD,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,0BAA0B,EAC1B,wBAAwB,EACzB,MAAM,+BAA+B,CAAC"}

package/dist/plugin/helpers/handleServerAction.client.js

@@ -0,0 +1,93 @@
+import { cleanupServerAction } from "../dev-server/cleanupServerAction.client.js";
+import { logError, toError } from "../error/index.js";
+import { PassThrough } from "node:stream";
+import { parseServerActionRequestBody, createServerActionResponse, setupServerActionHeaders } from "./handleServerActionHelper.js";
+// Use shared helper instead of duplicating logic
+// Use shared helper instead of duplicating logic
+/**
+ * Creates a pass-through stream for server action responses.
+ */
+export function createServerActionStream(res) {
+    const passThrough = new PassThrough();
+    passThrough.pipe(res, { end: true });
+    passThrough.on('end', () => {
+        res.end();
+    });
+    return passThrough;
+}
+/**
+ * Handles errors in server action processing.
+ */
+export function handleServerActionError(error, res, logger) {
+    const err = toError(error);
+    logError(err, logger);
+    res.statusCode = 500;
+    res.end(JSON.stringify(createServerActionResponse(undefined, err.message)));
+}
+/**
+ * Client-side server action handler that delegates to worker
+ */
+export async function handleServerAction(req, res, options) {
+    if (!options.worker) {
+        throw new Error("Worker is required for client-side server actions");
+    }
+    let messageHandler = null;
+    const passThrough = createServerActionStream(res);
+    try {
+        // Read request body
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(chunk);
+        }
+        const body = Buffer.concat(chunks).toString();
+        // Parse the server action request
+        const { id, args } = parseServerActionRequestBody(body, req.url);
+        // Set up response headers
+        setupServerActionHeaders(res);
+        // Send server action request to worker
+        options.worker.postMessage({
+            type: "SERVER_ACTION",
+            id,
+            args,
+        });
+        // Handle worker messages
+        messageHandler = (message) => {
+            if (message.type === "RSC_CHUNK") {
+                passThrough.write(message.chunk);
+            }
+            else if (message.type === "RSC_END") {
+                if (messageHandler) {
+                    cleanupServerAction(passThrough, options.worker, messageHandler, res);
+                }
+            }
+            else if (message.type === "ERROR") {
+                if (messageHandler) {
+                    cleanupServerAction(passThrough, options.worker, messageHandler, res, message.error, options.logger);
+                }
+            }
+        };
+        options.worker.on("message", messageHandler);
+        // Handle errors
+        passThrough.on("error", (error) => {
+            if (messageHandler) {
+                cleanupServerAction(passThrough, options.worker, messageHandler, res, error, options.logger);
+            }
+        });
+    }
+    catch (error) {
+        handleServerActionError(error, res, options.logger);
+    }
+}
+/**
+ * Client-side ViteDevServer-specific handler that delegates to worker
+ */
+export async function handleServerActionWithViteServer(req, res, server, handlerOptions) {
+    return handleServerAction(req, res, {
+        projectRoot: handlerOptions.projectRoot,
+        verbose: handlerOptions.verbose,
+        logger: server.config.customLogger || server.config.logger,
+        worker: handlerOptions.worker,
+    });
+}
+// Re-export helper functions for the entry point
+export { parseServerActionRequest, parseServerActionRequestBody, createServerActionResponse, setupServerActionHeaders } from "./handleServerActionHelper.js";

package/dist/plugin/helpers/handleServerAction.d.ts

@@ -1,35 +1,3 @@
-import type { Logger } from "vite";
-import { PassThrough } from "node:stream";
-import type { ServerResponse } from "node:http";
-export type ServerActionRequest = {
-    id: string;
-    args: unknown[];
-};
-export type ServerActionResponse = {
-    type: "server-action-response";
-    returnValue: unknown;
-};
-/**
- * Parses a server action request from the request body.
- * Supports two formats:
- * 1. Direct args array: [arg1, arg2, ...]
- * 2. Object with id and args: { id: string, args: unknown[] }
- */
-export declare function parseServerActionRequest(body: string, url?: string): ServerActionRequest;
-/**
- * Creates a server action response with the given result or error.
- */
-export declare function createServerActionResponse(result?: unknown, error?: string): ServerActionResponse;
-/**
- * Handles errors in server action processing.
- */
-export declare function handleServerActionError(error: unknown, res: ServerResponse, logger: Logger): void;
-/**
- * Sets up common response headers for server actions.
- */
-export declare function setupServerActionHeaders(res: ServerResponse): void;
-/**
- * Creates a pass-through stream for server action responses.
- */
-export declare function createServerActionStream(res: ServerResponse): PassThrough;
+export declare const handleServerAction: any, handleServerActionWithViteServer: any, parseServerActionRequest: any, parseServerActionRequestBody: any, createServerActionResponse: any, setupServerActionHeaders: any, createServerActionStream: any, handleServerActionError: any;
+export type { ServerActionRequest, ServerActionHandlerOptions, } from "./handleServerActionHelper.js";
 //# sourceMappingURL=handleServerAction.d.ts.map

package/dist/plugin/helpers/handleServerAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handleServerAction.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/handleServerAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,WAAW,EAAE,OAAO,CAAC;CACtB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAkBxF;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,oBAAoB,CAOjG;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,QAK1F;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,QAI3D;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,cAAc,GAAG,WAAW,CAOzE"}
+{"version":3,"file":"handleServerAction.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/handleServerAction.ts"],"names":[],"mappings":"AAOA,eAAO,MACL,kBAAkB,OAClB,gCAAgC,OAChC,wBAAwB,OACxB,4BAA4B,OAC5B,0BAA0B,OAC1B,wBAAwB,OACxB,wBAAwB,OACxB,uBAAuB,KACwC,CAAC;AAIlE,YAAY,EACV,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,+BAA+B,CAAC"}