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

package/plugin/config/resolveOptions.ts

@@ -1,5 +1,4 @@
-import type { PreRenderedAsset } from "rollup";
-import type { PreRenderedChunk } from "rollup";
+import type { PreRenderedAsset, PreRenderedChunk } from "rollup";
 import type {
   StreamPluginOptions,
   ResolvedUserOptions,
@@ -13,13 +12,20 @@ import {
   DEFAULT_CONFIG,
   DEFAULT_LOADER_CONFIG,
 } from "./defaults.js";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { pluginRoot } from "../root.js";
 import { createInputNormalizer } from "../helpers/inputNormalizer.js";
 import { resolveDirectiveMatcher } from "./resolveDirectiveMatcher.js";
 import { resolveAllowedDirectives } from "./resolveAllowedDirectives.js";
 import { resolveRegExp } from "./resolveRegExp.js";
 import type { LoaderConfig } from "../loader/types.js";
+import { handleError } from "../error/handleError.js";
+import { createLogger, type Logger } from "vite";
+import { getCondition } from "./getCondition.js";
+import { getNodeEnv } from "./getNodeEnv.js";
+import { stashUserOptions, getStashedUserOptions, getEnvironmentId } from "./stashedOptionsState.js";
+import { createHash } from "node:crypto";
+import { readFileSync, existsSync } from "node:fs";
 
 export type ResolveOptionsReturn =
   | {
@@ -27,10 +33,12 @@ export type ResolveOptionsReturn =
       userOptions: ResolvedUserOptions;
       error?: never;
     }
-  | { type: "error"; error: Error; userOptions?: never };
+  | { type: "error"; error: unknown; userOptions?: never };
 
 export type ResolveOptionsFn = (
-  options: StreamPluginOptions
+  options: StreamPluginOptions,
+  forceResolve?: boolean,
+  logger?: Logger
 ) => ResolveOptionsReturn;
 
 // /**
@@ -77,8 +85,7 @@ const registerPath = (path: string, pattern?: RegExp, ext?: string) => {
 // Main Options Resolver
 // ============================================================================
 
-const stashedUserOptions: Record<string, ResolvedUserOptions | null> = {};
-
+let originalOptions: any | null = null;
 /**
  * Resolves the user options for the plugin.
  *
@@ -86,15 +93,42 @@ const stashedUserOptions: Record<string, ResolvedUserOptions | null> = {};
  * @returns The resolved options.
  */
 export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
-  options
+  options = {} as StreamPluginOptions,
+  forceResolve = false,
+  logger = createLogger(!options.verbose ? "error" : "info", {
+    prefix: "vite:plugin-react-server/config#resolveOptions",
+  })
 ) {
-  const envId = process.env.NODE_ENV ?? "development";
+  if (!forceResolve && originalOptions == null) {
+    originalOptions = options;
+  } else if (originalOptions != null && options !== originalOptions) {
+    if (options.verbose) {
+      logger.info("options changed, forcing re-resolve");
+    }
+    forceResolve = true;
+  }
+  
+  // Force re-resolve if projectRoot changed
+  if (originalOptions != null && originalOptions.projectRoot !== options.projectRoot) {
+    if (options.verbose) {
+      logger.info(`projectRoot changed from ${originalOptions.projectRoot} to ${options.projectRoot}, forcing re-resolve`);
+    }
+    forceResolve = true;
+  }
+  
+  const panicThreshold =
+    typeof options.panicThreshold === "string"
+      ? options.panicThreshold
+      : DEFAULT_CONFIG.PANIC_THRESHOLD;
+  // since panicThreshold affects the behavior of the plugin, we need to re-resolve the options if it changes
+  const envId = getEnvironmentId(getCondition(), process.env.NODE_ENV ?? "production");
 
   // Return stashed options if available
-  if (stashedUserOptions[envId]) {
+  const stashedOptions = getStashedUserOptions(envId);
+  if (stashedOptions && !forceResolve) {
     return {
       type: "success",
-      userOptions: stashedUserOptions[envId] as never,
+      userOptions: stashedOptions as never,
     };
   }
 
@@ -105,20 +139,30 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       ? options.moduleBase
       : DEFAULT_CONFIG.MODULE_BASE;
 
-  // Basic configuration
-  const projectRoot = options.projectRoot ?? process.cwd();
+  // Basic configuration - use the first projectRoot that was provided, or fall back to current options
+  const projectRoot = options.projectRoot ?? originalOptions?.projectRoot ?? process.cwd();
+  
+  if (options.verbose && options.projectRoot != originalOptions?.projectRoot) {
+    logger.info(`[resolveOptions] new projectRoot: ${projectRoot}`);
+  }
 
   // Build options
   const preserveModulesRoot =
     options.build?.preserveModulesRoot ??
     DEFAULT_CONFIG.BUILD.preserveModulesRoot;
-  
+
+  // Get current mode to check if we're in development
+  const currentMode = getNodeEnv(process.env.NODE_ENV);
+  const isDevelopment = currentMode === "development";
+
   // Rollup's preserveModulesRoot works in reverse of what you'd expect:
   // - When user wants preservation (true): pass undefined to Rollup (don't strip anything)
   // - When user wants stripping (false): pass moduleBase to Rollup (strip this path)
-  const preserveModulesRootString = preserveModulesRoot === false
-    ? moduleBase  // Strip src/ from output paths
-    : undefined;  // Keep src/ in output paths
+  // CRITICAL: In development mode, NEVER strip moduleBase (src/) because Vite serves from source locations
+  const preserveModulesRootString =
+    !isDevelopment && preserveModulesRoot === false
+      ? moduleBase // Strip src/ from output paths (production only)
+      : undefined; // Keep src/ in output paths
 
   const client =
     typeof options.build?.client === "string"
@@ -151,23 +195,21 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       ? options.publicOrigin
       : DEFAULT_CONFIG.PUBLIC_ORIGIN;
 
-  // Worker and loader paths
+
   const rscWorkerPath =
     typeof options.rscWorkerPath === "string"
-      ? join(projectRoot, options.rscWorkerPath)
-      : join(pluginRoot, DEFAULT_CONFIG.RSC_WORKER_PATH);
+      ? resolve(projectRoot, options.rscWorkerPath)
+      : resolve(pluginRoot, DEFAULT_CONFIG.RSC_WORKER_PATH);
 
   const htmlWorkerPath =
     typeof options.htmlWorkerPath === "string"
-      ? join(projectRoot, options.htmlWorkerPath)
-      : join(pluginRoot, DEFAULT_CONFIG.HTML_WORKER_PATH);
+      ? resolve(projectRoot, options.htmlWorkerPath)
+      : resolve(pluginRoot, DEFAULT_CONFIG.HTML_WORKER_PATH);
 
   const loaderPath =
     typeof options.loaderPath === "string"
-      ? join(projectRoot, options.loaderPath)
-      : join(pluginRoot, DEFAULT_CONFIG.LOADER_PATH);
-
-
+      ? resolve(projectRoot, options.loaderPath)
+      : resolve(pluginRoot, DEFAULT_CONFIG.LOADER_PATH);
 
   const jsExtension =
     typeof options.build?.jsExtension === "string"
@@ -298,46 +340,143 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       false
   );
 
-  const hashOption =
-    typeof options.build?.hash === "string"
-      ? options.build.hash
-      : DEFAULT_CONFIG.BUILD.hash;
-
-  const hashString = hashOption === "" ? "" : `-[${hashOption}]`;
-  // const addModuleExtension = (path: string) => {
-  //   const isAsset =
-  //     autoDiscover.cssPattern(path) || autoDiscover.jsonPattern(path);
-  //   if (isAsset) {
-  //     return path;
-  //   }
-  //   return addExtension(path);
-  // };
-
-  // File naming and hashing
-  const hash = (n: string | null, ssr: boolean) => {
-    if (!n) return "";
-    if (ssr) return n;
-    if (hashString === "" || new RegExp(BASE_PATTERNS.EXT.NODE).test(n)) {
-      return n;
+  const isClientComponentByCode = resolveDirectiveMatcher(
+    clientDirective,
+    (code: string) => code.match(clientDirective) != null || false
+  );
+
+  const isClientComponentByName = (moduleId: string, _transformedModuleId?: string) => 
+    (typeof moduleId === "string" && clientPattern.test(moduleId)) || false;
+
+  const hashOption = options.build?.hash ?? DEFAULT_CONFIG.BUILD.hash;
+
+  // Clean hash API that mimics Rollup's behavior but allows control over input
+  const createRollupLikeHash = (content: string, hashCharacters: 'base36' | 'base64' | 'hex' = 'base36') => {
+    const hash = createHash('sha1');
+    hash.update(content);
+    const fullHash = hash.digest('hex');
+    
+    // Apply the same character set logic as Rollup
+    switch (hashCharacters) {
+      case 'base36':
+        // Convert hex to base36 (0-9, a-z)
+        return parseInt(fullHash.substring(0, 8), 16).toString(36);
+      case 'base64':
+        // Convert to base64-like format (A-Z, a-z, 0-9, -, _)
+        return Buffer.from(fullHash.substring(0, 8), 'hex').toString('base64')
+          .replace(/\+/g, '-')
+          .replace(/\//g, '_')
+          .replace(/=/g, '');
+      case 'hex':
+      default:
+        // Return hex format
+        return fullHash.substring(0, 8);
     }
-    const extensionIndex = n.lastIndexOf(".");
+  };
+
+  // User-facing hash function that can take source content or filename
+  const hash = (input: string | null, _ssr: boolean, sourceContent?: string) => {
+    if (!input) return "";
+    if (new RegExp(BASE_PATTERNS.EXT.NODE).test(input)) {
+      return input;
+    }
+    
+    // CRITICAL: Never hash node_modules files - Vite/Rollup handles those
+    if (input.includes("node_modules")) {
+      return input;
+    }
+    
+    // CRITICAL: Never hash virtual modules (_virtual or matching virtualPattern) - Vite handles those
+    const virtualPattern = resolveRegExp(
+      options.autoDiscover?.virtualPattern,
+      DEFAULT_CONFIG.AUTO_DISCOVER.virtualPattern
+    );
+    if (input.includes("_virtual") || (virtualPattern && virtualPattern.test(input))) {
+      return input;
+    }
+    
+    // Check if hashing is disabled
+    if (hashOption === "false") {
+      return input;
+    }
+    
+    // Only hash client components - server files should not be hashed
+    const isClientComponent = clientPattern.test(input);
+    if (!isClientComponent) {
+      return input;
+    }
+    
+    // Determine what to hash based on available input
+    let contentToHash: string;
+    
+    if (sourceContent) {
+      // Use provided source content (preferred)
+      contentToHash = sourceContent;
+    } else {
+           // Try to read source file content
+     try {
+       const sourcePath = resolve(projectRoot, input);
+       if (existsSync(sourcePath)) {
+         contentToHash = readFileSync(sourcePath, 'utf-8');
+         // Debug logging
+         if (options.verbose) {
+           logger.info(`[hash] Reading source: ${sourcePath} (${contentToHash.length} chars)`);
+         }
+       } else {
+         // Fallback to filename
+         contentToHash = input;
+         if (options.verbose) {
+           logger.warn(`[hash] File not found: ${sourcePath}, using filename: ${input}`);
+         }
+       }
+     } catch (error) {
+       // Fallback to filename
+       contentToHash = input;
+       if (options.verbose) {
+         logger.warn(`[hash] Error reading ${input}: ${error}`);
+       }
+     }
+    }
+    
+    // Generate hash using Rollup-like algorithm
+    const hashCharacters = typeof hashOption === 'object' && hashOption?.format === 'hex' ? 'hex' : 'base36';
+    const contentHash = createRollupLikeHash(contentToHash, hashCharacters);
+    
+    // Apply naming logic
+    const extensionIndex = input.lastIndexOf(".");
     if (extensionIndex !== -1) {
-      const extension = n.slice(extensionIndex);
-      const filename = n.slice(0, extensionIndex);
-      return filename + hashString + extension;
+      const extension = input.slice(extensionIndex);
+      const filename = input.slice(0, extensionIndex);
+      return filename + "-" + contentHash + extension;
     } else {
-      return n + hashString;
+      return input + "-" + contentHash;
     }
   };
 
   // Output path resolution
-  const getOutputPath = (n: string | null) => {
+  const getOutputPath = (n: string | null, isAsset: boolean = false) => {
     if (!n) return "";
     let path = handleSearchQuery(n);
     path = path.startsWith(moduleBase + moduleBasePath)
       ? path.slice(moduleBase.length + moduleBasePath.length)
       : path;
 
+    // For assets that are not modules, preserve the original extension
+    // Only apply module transformations if the file actually matches module patterns
+    if (isAsset) {
+      // Check if this is a module file (JS/TS/JSX/TSX) - if so, apply module transformations
+      const isModuleFile = modulePattern.test(path) || 
+                          clientPattern.test(path) || 
+                          serverPattern.test(path) ||
+                          propsPattern.test(path) ||
+                          pagePattern.test(path);
+      
+      // If it's not a module file, preserve the original extension
+      if (!isModuleFile) {
+        return path;
+      }
+    }
+
     if (vendorPattern.test(path))
       return registerPath(path, vendorPattern, jsExtension);
     if (cssModulePattern.test(path))
@@ -358,6 +497,9 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       return registerPath(path, serverPattern, jsExtension);
     if (modulePattern.test(path))
       return registerPath(path, modulePattern, jsExtension);
+    
+    // Fallback: only apply module pattern if we're sure it's a module
+    // For assets, we've already returned above, so this is safe
     return registerPath(path, modulePattern, jsExtension);
   };
 
@@ -370,19 +512,48 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       moduleBasePath,
       moduleBaseURL,
     });
-  // File naming functions
-  const entryFile = (n: PreRenderedChunk, ssr: boolean) => {
-    return hash(getOutputPath(normalizer(n.name)[0]), ssr);
-  };
+  // File naming functions - defined as regular functions to avoid closure issues
+  function entryFile(n: PreRenderedChunk, ssr: boolean, sourceContent?: string): string {
+    const normalizedName = normalizer(n.name)[0];
+    let outputPath = getOutputPath(normalizedName);
+    
+    // When preserveModulesRoot is true, preserve the src/ prefix in output paths
+    if (preserveModulesRoot && n.name.startsWith("src/")) {
+      // If the normalized name doesn't have src/, add it back
+      if (!outputPath.startsWith("src/")) {
+        // Handle the case where outputPath starts with a slash
+        if (outputPath.startsWith("/")) {
+          outputPath = "src" + outputPath;
+        } else {
+          outputPath = "src/" + outputPath;
+        }
+      }
+    }
+    
+    return hash(outputPath, ssr, sourceContent);
+  }
 
-  const chunkFile = (n: PreRenderedChunk, ssr: boolean) => {
-    return hash(getOutputPath(normalizer(n.name)[0]), ssr);
-  };
+  function chunkFile(n: PreRenderedChunk, ssr: boolean, sourceContent?: string): string {
+    const normalizedName = normalizer(n.name)[0];
+    let outputPath = getOutputPath(normalizedName);
+    
+    // When preserveModulesRoot is true, preserve the src/ prefix in output paths
+    if (preserveModulesRoot && n.name.startsWith("src/")) {
+      // If the normalized name doesn't have src/, add it back
+      if (!outputPath.startsWith("src/")) {
+        // Handle the case where outputPath starts with a slash
+        if (outputPath.startsWith("/")) {
+          outputPath = "src" + outputPath;
+        } else {
+          outputPath = "src/" + outputPath;
+        }
+      }
+    }
+    
+    return hash(outputPath, ssr, sourceContent);
+  }
 
-  const assetFile: (n: PreRenderedAsset, ssr?: boolean) => string = (
-    n: PreRenderedAsset,
-    ssr = false
-  ) => {
+  function assetFile(n: PreRenderedAsset, ssr: boolean = false): string {
     if (n.names.length > 1) {
       return n.names.map((name) => hash(name, ssr)).join(",");
     }
@@ -413,14 +584,19 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       firstName = firstName.slice(moduleBase.length + 1);
     }
 
-    // For CSS files, make sure we preserve the .css extension and don't apply JS extension mapping
+    // For CSS files, ensure they go into the assets directory
     if (firstName.endsWith(".css")) {
+      // Add assets directory prefix if not already present
+      if (!firstName.startsWith(assetsDir + "/")) {
+        firstName = assetsDir + "/" + firstName;
+      }
       return hash(firstName, false);
     }
 
     // For other assets, apply the extension mapping if needed
-    return hash(getOutputPath(firstName), false);
-  };
+    // Pass isAsset=true to preserve extensions for non-module assets
+    return hash(getOutputPath(firstName, true), false);
+  }
 
   /**
    * pages
@@ -488,10 +664,25 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
     rscExtension: rscExtension,
     cssModuleExtension: cssModuleExtension,
     nodeExtension: DEFAULT_CONFIG.BUILD.nodeExtension,
+    useRscWorker: options.build?.useRscWorker ?? DEFAULT_CONFIG.BUILD.useRscWorker,
+    useHtmlWorker: options.build?.useHtmlWorker ?? 
+      // Force useHtmlWorker to true when build.pages is explicitly configured, regardless of default logic
+      (options.build?.pages && (Array.isArray(options.build.pages) || typeof options.build.pages === 'function')) ? true : DEFAULT_CONFIG.BUILD.useHtmlWorker,
   } satisfies ResolvedUserOptions["build"];
 
+  // Development configuration
+  const dev = {
+    useHtmlWorker: options.dev?.useHtmlWorker ?? DEFAULT_CONFIG.DEV.useHtmlWorker,
+    useRscWorker: options.dev?.useRscWorker ?? DEFAULT_CONFIG.DEV.useRscWorker,
+  } satisfies ResolvedUserOptions["dev"];
+
   // Auto-discovery configuration
   const autoDiscover = {
+    clientEntry: options.autoDiscover?.clientEntry ?? DEFAULT_CONFIG.AUTO_DISCOVER.clientEntry,
+    serverEntry: options.autoDiscover?.serverEntry ?? DEFAULT_CONFIG.AUTO_DISCOVER.serverEntry,
+    cssEntry: options.autoDiscover?.cssEntry ?? DEFAULT_CONFIG.AUTO_DISCOVER.cssEntry,
+    jsonEntry: options.autoDiscover?.jsonEntry ?? DEFAULT_CONFIG.AUTO_DISCOVER.jsonEntry,
+    htmlEntry: options.autoDiscover?.htmlEntry ?? DEFAULT_CONFIG.AUTO_DISCOVER.htmlEntry,
     modulePattern,
     jsonPattern,
     cssPattern,
@@ -561,7 +752,10 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
           DEFAULT_CONFIG.RSC_LOADER[loaderMode].registerServerReferenceName,
         isServerFunctionCode,
         isClientComponentCode,
-        parse: DEFAULT_LOADER_CONFIG.parse,
+        isClientComponentByCode,
+        isClientComponentByName,
+        parse: options?.loader?.parse ?? DEFAULT_LOADER_CONFIG.parse,
+        moduleID: options?.loader?.moduleID ?? options?.moduleID,
       } as Required<LoaderConfig>)
     : undefined;
 
@@ -579,9 +773,18 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
       moduleRootPath,
       publicOrigin,
       build: build,
+      dev: dev,
       verbose: options.verbose ?? DEFAULT_CONFIG.VERBOSE,
-      onMetrics: options.onMetrics ?? DEFAULT_CONFIG.ON_METRICS,
-      onEvent: options.onEvent,
+      availableEnvironments: (options as any).availableEnvironments,
+      strategy: (options as any).strategy,
+      onMetrics:
+        typeof options.onMetrics === "function"
+          ? options.onMetrics
+          : DEFAULT_CONFIG.ON_METRICS,
+      onEvent:
+        typeof options.onEvent === "function"
+          ? options.onEvent
+          : DEFAULT_CONFIG.ON_EVENT,
       Page: options.Page,
       props: options.props,
       Html: options.Html ?? DEFAULT_CONFIG.HTML,
@@ -623,6 +826,10 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
         typeof options.rscTimeout === "number"
           ? options.rscTimeout
           : DEFAULT_CONFIG.RSC_TIMEOUT,
+      htmlTimeout:
+        typeof options.htmlTimeout === "number"
+          ? options.htmlTimeout
+          : DEFAULT_CONFIG.HTML_TIMEOUT,
       htmlWorkerStartupTimeout:
         typeof options.htmlWorkerStartupTimeout === "number"
           ? options.htmlWorkerStartupTimeout
@@ -631,14 +838,19 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
         typeof options.rscWorkerStartupTimeout === "number"
           ? options.rscWorkerStartupTimeout
           : DEFAULT_CONFIG.RSC_WORKER_STARTUP_TIMEOUT,
-      panicThreshold:
-        typeof options.panicThreshold === "string"
-          ? options.panicThreshold
-          : DEFAULT_CONFIG.PANIC_THRESHOLD,
+      fileWriteTimeout:
+        typeof options.fileWriteTimeout === "number"
+          ? options.fileWriteTimeout
+          : DEFAULT_CONFIG.FILE_WRITE_TIMEOUT,
+      workerShutdownTimeout:
+        typeof options.workerShutdownTimeout === "number"
+          ? options.workerShutdownTimeout
+          : DEFAULT_CONFIG.WORKER_SHUTDOWN_TIMEOUT,
+      panicThreshold: panicThreshold,
     };
 
     // Stash the resolved options
-    stashedUserOptions[envId] = userOptions;
+    stashUserOptions(envId, userOptions);
 
     return {
       type: "success",
@@ -647,8 +859,14 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
   } catch (error) {
     return {
       type: "error",
-      error:
-        error instanceof Error ? error : new Error("Failed to resolve options"),
+      error: handleError({
+        error,
+        logger: logger,
+        panicThreshold,
+        context: "config(resolveOptions)",
+      }),
     };
   }
 };
+
+

package/plugin/config/resolvePages.ts

@@ -2,7 +2,7 @@ import type { ResolvedUserOptions } from '../types.js';
 
 export async function resolvePages(
   pages: ResolvedUserOptions["build"]["pages"]
-): Promise<{ type: "success"; error?:never; pages: string[] } | { type: "error"; error: Error; pages?:never }> {
+): Promise<{ type: "success"; error?:never; pages: string[] } | { type: "error"; error: unknown; pages?:never }> {
   if (!pages) {
     return { type: "success", pages: [] };
   }

package/plugin/config/resolvePatternWithValues.ts

@@ -1,7 +1,5 @@
 import type { RegExpOpt } from "../types.js";
-import { interpolatePattern } from "./interpolatePattern.js";
-import { parsePattern } from "./parsePattern.js";
-
+import { createPatternMatcher } from "../helpers/createPatternMatcher.js";
 
 /**
  * Resolves a pattern with values, handling string, RegExp, and function inputs.
@@ -44,27 +42,9 @@ export function resolvePatternWithValues(
   defaultPattern?: RegExpOpt | ((path: string) => boolean),
   values: Record<string, string> = {}
 ): (path: string, moduleId?: string) => boolean {
-  if (pattern instanceof RegExp) {
-    return (path: string) => pattern.test(path);
-  }
-  if (typeof pattern === "function") {
-    return pattern;
-  }
-  if (typeof pattern === "string") {
-    const interpolatedPattern = interpolatePattern(pattern, values);
-    const regex = parsePattern(interpolatedPattern);
-    return (path: string) => regex.test(path);
-  }
-  if (defaultPattern instanceof RegExp) {
-    return (path: string) => defaultPattern.test(path);
-  }
-  if (typeof defaultPattern === "function") {
-    return defaultPattern;
-  }
-  if (typeof defaultPattern === "string") {
-    const interpolatedPattern = interpolatePattern(defaultPattern, values);
-    const regex = parsePattern(interpolatedPattern);
-    return (path: string) => regex.test(path);
-  }
-  throw new Error("No valid pattern provided");
+  return createPatternMatcher(pattern, defaultPattern, {
+    values,
+    handleDeserialized: false,
+    throwOnInvalid: true
+  });
 }

package/plugin/config/resolveUrlOption.ts

@@ -8,7 +8,7 @@ type ResolvePageAndPropsOptionsSuccess<N extends SupportedOptionNames> = {
 
 type ResolvePageAndPropsOptionsError<N extends SupportedOptionNames> = {
   [optionName in N]?: never;
-} & { type: "error"; error: Error };
+} & { type: "error"; error: unknown };
 
 export type ResolvePageAndPropsReturn<N extends SupportedOptionNames> =
   | ResolvePageAndPropsOptionsSuccess<N>
@@ -112,7 +112,7 @@ export const resolveUrlOption: ResolvePageAndPropsOptionsFn = async function _re
       default:
         break;
     }
-    return { type: "error", error: new Error(`${configName} must return a string`) };
+    return { type: "error", error: new Error(`${configName} must be string or function that returns a string`) };
   } catch (error) {
     return { type: "error", error: error as Error };
   }