rsbuild-plugin-react-router 0.3.0 → 0.3.1

package/dist/lazy-compilation-prewarm.d.ts

@@ -0,0 +1,25 @@
+import * as Effect from 'effect/Effect';
+import type { ReactRouterManifestForDev } from './manifest.js';
+type LazyCompilationPrewarmConfig = {
+    entry: boolean;
+    routeLimit: number;
+    delayMs: number;
+};
+type LazyCompilationPrewarmController = {
+    setServerOrigin(origin: string): void;
+    setManifest(manifest: ReactRouterManifestForDev | null): void;
+    schedule(): void;
+    cancelEffect(): Effect.Effect<void, Error, never>;
+};
+export type RspackLazyCompilationTriggerClient = {
+    extractModuleKeys(source: string): string[];
+    trigger(origin: string, keys: readonly string[]): Effect.Effect<void, Error, never>;
+};
+export declare const normalizeLazyCompilationPrewarmOptions: (options: boolean | undefined) => LazyCompilationPrewarmConfig | null;
+export declare const collectLazyCompilationPrewarmAssets: (manifest: ReactRouterManifestForDev, config: LazyCompilationPrewarmConfig) => string[];
+export declare const createRspackLazyCompilationTriggerClient: (triggerPrefix?: string) => RspackLazyCompilationTriggerClient;
+export declare const createLazyCompilationPrewarmController: ({ config, onError, }: {
+    config: LazyCompilationPrewarmConfig;
+    onError: (error: Error) => void;
+}) => LazyCompilationPrewarmController;
+export {};

package/dist/lazy-compilation.d.ts

@@ -1,5 +1,6 @@
 import type { PluginOptions } from './types.js';
-export declare const guardReactRouterLazyCompilation: ({ lazyCompilation, entryClientPath, }: {
+export declare const guardReactRouterLazyCompilation: ({ lazyCompilation, entryClientPath, prewarmReactRouterModules, }: {
     lazyCompilation: PluginOptions["lazyCompilation"] | undefined;
     entryClientPath: string;
+    prewarmReactRouterModules?: boolean;
 }) => PluginOptions["lazyCompilation"] | undefined;

package/dist/manifest.d.ts

@@ -1,6 +1,18 @@
 import type { Route, PluginOptions, RouteManifestItem } from './types.js';
-import type { RouteConfigEntry } from '@react-router/dev/routes';
 import { type RouteChunkCache } from './route-chunks.js';
+/**
+ * Structural equivalent of `RouteConfigEntry` from `@react-router/dev/routes`,
+ * inlined so the public declaration files do not reference a devDependency
+ * (which would fail to resolve for consumers with `skipLibCheck: false`).
+ */
+export interface RouteConfigEntry {
+    id?: string;
+    path?: string;
+    index?: boolean;
+    caseSensitive?: boolean;
+    file: string;
+    children?: RouteConfigEntry[];
+}
 export declare function configRoutesToRouteManifest(appDirectory: string, routes: RouteConfigEntry[], rootId?: string): Record<string, Route>;
 export declare function configRoutesToRouteManifestEntries(appDirectory: string, routes: RouteConfigEntry[], rootId?: string): Array<[string, Route]>;
 type RouteChunkManifestOptions = {
@@ -33,9 +45,12 @@ type ReactRouterManifestStatsChunk = {
 type ReactRouterManifestStatsEntrypoint = {
     getFiles?: () => Iterable<string>;
 };
+type ReactRouterManifestStatsLookup<T> = Iterable<[string, T]> & {
+    get?: (name: string) => T | undefined;
+};
 type ReactRouterManifestStatsCompilation = {
-    namedChunks: Iterable<[string, ReactRouterManifestStatsChunk]>;
-    entrypoints?: Iterable<[string, ReactRouterManifestStatsEntrypoint]>;
+    namedChunks: ReactRouterManifestStatsLookup<ReactRouterManifestStatsChunk>;
+    entrypoints?: ReactRouterManifestStatsLookup<ReactRouterManifestStatsEntrypoint>;
 };
 export declare const createReactRouterManifestStats: (compilation: ReactRouterManifestStatsCompilation | undefined, chunkNames?: ReadonlySet<string>) => ReactRouterManifestStats | undefined;
 export type RouteManifestModuleExports = Record<string, readonly string[]>;
@@ -49,6 +64,6 @@ export declare const getReactRouterManifestPath: ({ version, isBuild, entryModul
     entryModulePath?: string;
 }) => string;
 export declare const getReactRouterManifestChunkNames: (routes: Record<string, Route>, splitRouteModules?: boolean | "enforce") => Set<string>;
-export declare function generateReactRouterManifestForDev(routes: Record<string, Route>, _options: PluginOptions, clientStats: ReactRouterManifestStats | undefined, context: string, assetPrefix?: string, routeChunkOptions?: RouteChunkManifestOptions): Promise<ReactRouterManifestGenerationResult>;
+export declare function generateReactRouterManifestForDev(routes: Record<string, Route>, options: PluginOptions, clientStats: ReactRouterManifestStats | undefined, context: string, assetPrefix?: string, routeChunkOptions?: RouteChunkManifestOptions): Promise<ReactRouterManifestGenerationResult>;
 export declare function getReactRouterManifestForDev(...args: Parameters<typeof generateReactRouterManifestForDev>): Promise<ReactRouterManifestForDev>;
 export {};

package/dist/parallel-route-transforms.d.ts

@@ -1,14 +1,29 @@
 import { type RouteTransformResult, type RouteTransformTask, type RouteTransformTaskOptions } from './route-transform-tasks.js';
 import type { PluginOptions } from './types.js';
+import type { WorkerRequest, WorkerResponse } from './parallel-route-transform-protocol.js';
 export type ParallelRouteTransformConfig = NonNullable<PluginOptions['parallelRouteTransform']> extends infer Config ? Exclude<Config, false> : never;
 export type RouteTransformExecutorOptions = RouteTransformTaskOptions & {
     parallelRouteTransform?: PluginOptions['parallelRouteTransform'];
     splitRouteModules?: boolean;
+    isBuild?: boolean;
 };
 export type RouteTransformExecutor = {
     run: (task: RouteTransformTask) => Promise<RouteTransformResult>;
+    prewarm: () => void;
     close: () => Promise<void>;
 };
-export declare const getDefaultWorkerCount: (cpuCount?: number) => number;
+type RouteTransformWorker = {
+    on(event: 'message', handler: (response: WorkerResponse) => void): unknown;
+    on(event: 'error', handler: (error: Error) => void): unknown;
+    on(event: 'exit', handler: (code: number) => void): unknown;
+    postMessage(message: WorkerRequest): void;
+    terminate(): Promise<number> | number;
+};
+type RouteTransformWorkerFactory = () => RouteTransformWorker;
+export declare const getDefaultWorkerCount: (cpuCount?: number, { isBuild }?: {
+    isBuild?: boolean;
+}) => number;
 export declare const shouldParallelizeRouteTransforms: (routeCount: number) => boolean;
-export declare const createRouteTransformExecutor: ({ parallelRouteTransform, routeChunkCache, splitRouteModules, }?: RouteTransformExecutorOptions) => RouteTransformExecutor;
+export declare const createRouteTransformExecutor: ({ parallelRouteTransform, routeChunkCache, splitRouteModules, isBuild, }?: RouteTransformExecutorOptions) => RouteTransformExecutor;
+export declare const createRouteTransformExecutorForTesting: (options: RouteTransformExecutorOptions, createWorker: RouteTransformWorkerFactory) => RouteTransformExecutor;
+export {};

package/dist/prerender-build.d.ts

@@ -1,3 +1,4 @@
+import * as Effect from 'effect/Effect';
 import type { RsbuildPluginAPI } from '@rsbuild/core';
 import { getBuildManifest } from './build-manifest.js';
 import { getReactRouterManifestForDev, type ReactRouterManifestStats, type RouteManifestModuleExports } from './manifest.js';
@@ -28,5 +29,8 @@ type RunReactRouterPrerenderBuildOptions = {
     resolvedConfigWithRoutes: ResolvedReactRouterConfig;
     buildEnd: Config['buildEnd'];
 };
+export declare const createBuildRequestEffect: <T>(input: string | URL, init: RequestInit | undefined, handle: (request: Request) => Promise<T>) => Effect.Effect<T, Error, never>;
+export declare const withBuildRequest: <T>(input: string | URL, init: RequestInit | undefined, handle: (request: Request) => Promise<T>) => Promise<T>;
+export declare const createBoundedPrerenderTasksEffect: (prerenderPaths: string[], concurrency: number, renderPath: (path: string) => Effect.Effect<void, Error, never>) => Effect.Effect<void, Error, never>;
 export declare const runReactRouterPrerenderBuild: (options: RunReactRouterPrerenderBuildOptions) => Promise<void>;
 export {};

package/dist/prerender.d.ts

@@ -33,7 +33,6 @@ type SsrFalsePrerenderExportOptions = {
 };
 export declare const createPrerenderRoutes: (manifest: Record<string, any>, parentId?: string, grouped?: Record<string, any[]>) => MatchRouteObject[];
 export declare const normalizePrerenderMatchPath: (path: string) => string;
-export declare const withBuildRequest: <T>(input: string | URL, init: RequestInit | undefined, handle: (request: Request) => Promise<T>) => Promise<T>;
 export declare const getSsrFalsePrerenderExportErrors: ({ routes, manifestRoutes, routeExports, prerenderPaths, }: SsrFalsePrerenderExportOptions) => string[];
 export declare const getStaticPrerenderPaths: (routes: RouteConfigEntry[]) => StaticPrerenderPaths;
 export declare const resolvePrerenderPaths: (prerender: PrerenderConfig, ssr: boolean, routes: RouteConfigEntry[], options?: PrerenderResolveOptions) => Promise<string[]>;

package/dist/react-router-config.d.ts

@@ -1,6 +1,7 @@
 import type { BuildManifest as ReactRouterBuildManifest, Config as ReactRouterConfig } from '@react-router/dev/config';
 import type { NormalizedConfig } from '@rsbuild/core';
 import type { RouteConfigEntry } from '@react-router/dev/routes';
+import * as Effect from 'effect/Effect';
 export type BuildEndHook = {
     bivarianceHack(args: {
         buildManifest: ReactRouterBuildManifest | undefined;
@@ -32,6 +33,11 @@ type RouteManifestEntry = {
     file: string;
 };
 type RouteManifest = Record<string, RouteManifestEntry>;
+type ResolveReactRouterConfigResult = {
+    resolved: ResolvedReactRouterConfig;
+    presets: NonNullable<Config['presets']>;
+    hasConfiguredServerModuleFormat: boolean;
+};
 export type ResolvedReactRouterConfig = Readonly<{
     appDirectory: string;
     basename: string;
@@ -50,9 +56,6 @@ export type ResolvedReactRouterConfig = Readonly<{
     allowedActionOrigins: string[] | false;
     unstable_routeConfig: RouteConfigEntry[];
 }>;
-export declare const resolveReactRouterConfig: (reactRouterUserConfig: Config) => Promise<{
-    resolved: ResolvedReactRouterConfig;
-    presets: NonNullable<Config["presets"]>;
-    hasConfiguredServerModuleFormat: boolean;
-}>;
+export declare const resolveReactRouterConfigEffect: (reactRouterUserConfig: Config) => Effect.Effect<ResolveReactRouterConfigResult, Error, never>;
+export declare const resolveReactRouterConfig: (reactRouterUserConfig: Config) => Promise<ResolveReactRouterConfigResult>;
 export {};

package/dist/server-build-resolution.d.ts

@@ -0,0 +1,3 @@
+import * as Effect from 'effect/Effect';
+import type { ServerBuild } from 'react-router';
+export declare function resolveServerBuildModuleEffect(buildModule: unknown, source: string): Effect.Effect<ServerBuild, Error, never>;

package/dist/ssr-externals.d.ts

@@ -1 +1,2 @@
+export declare function resolvePackageJson(name: string, rootDirectory: string): string | null;
 export declare function getSsrExternals(rootDirectory: string): string[];

package/dist/typegen.d.ts

@@ -1,2 +1,15 @@
 import type { RsbuildPluginAPI } from '@rsbuild/core';
-export declare const registerReactRouterTypegen: (api: RsbuildPluginAPI) => void;
+type Execa = typeof import('execa').execa;
+type LoadExeca = () => Promise<Execa>;
+export type ReactRouterTypegenRunner = {
+    startWatch(): Promise<void>;
+    closeWatch(): Promise<void>;
+    runBuild(): Promise<void>;
+};
+export declare const createReactRouterTypegenRunner: (loadExeca?: LoadExeca, appDirectory?: string) => ReactRouterTypegenRunner;
+export declare const registerReactRouterTypegen: (api: RsbuildPluginAPI, { runner, devWatchDelayMs, appDirectory, }?: {
+    runner?: ReactRouterTypegenRunner;
+    devWatchDelayMs?: number;
+    appDirectory?: string;
+}) => void;
+export {};

package/dist/types.d.ts

@@ -17,8 +17,8 @@ export type PluginOptions = {
     customServer?: boolean;
     /**
      * The output format for server builds.
-     * When set to "module", no package.json will be emitted.
-     * @default "module"
+     * When omitted, React Router's `serverModuleFormat` selects the emitted
+     * Rsbuild format (`"esm"` -> `"module"`, `"cjs"` -> `"commonjs"`).
      */
     serverOutput?: 'module' | 'commonjs';
     /**
@@ -26,14 +26,23 @@ export type PluginOptions = {
      */
     federation?: boolean;
     /**
-     * Opt in to Rsbuild's dev-only lazy compilation behavior.
+     * Rsbuild dev-only lazy compilation behavior.
      *
-     * React Router hydration modules remain eager so initial dev requests can
-     * load the browser manifest and route modules without lazy proxy delays.
+     * React Router's browser manifest remains eager so initial dev requests can
+     * discover browser assets without lazy proxy delays.
      *
-     * @default undefined
+     * Pass `false` to disable.
+     * @default true
      */
     lazyCompilation?: NonNullable<RsbuildConfig['dev']>['lazyCompilation'];
+    /**
+     * Prewarm Rspack lazy-compilation proxy modules after dev compiles.
+     * This depends on Rspack's generated lazy-compilation client shape and should
+     * be treated as experimental.
+     *
+     * @default false
+     */
+    unstableLazyCompilationPrewarm?: boolean;
     /**
      * Emit structured React Router plugin timing logs.
      * @default false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsbuild-plugin-react-router",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "React Router plugin for Rsbuild",
   "repository": {
     "type": "git",
@@ -78,6 +78,7 @@
     "@types/node": "^25.0.10",
     "@types/react": "^19.2.10",
     "@types/react-dom": "^19.2.3",
+    "effect": "^3.21.4",
     "es-module-lexer": "1.7.0",
     "kill-port": "^2.0.1",
     "pkg-pr-new": "^0.0.75",
@@ -100,13 +101,14 @@
   },
   "scripts": {
     "build": "rslib build",
-    "bench": "node scripts/bench-builds.mjs",
-    "bench:ci-report": "node scripts/report-benchmark-ci.mjs",
-    "bench:compare": "node scripts/compare-benchmarks.mjs",
-    "bench:smoke": "node scripts/bench-builds.mjs --profile smoke --iterations 1 --warmup 0 --format both --out .benchmark/results/smoke",
-    "bench:baseline": "node scripts/bench-builds.mjs --profile default --iterations 5 --warmup 1 --clean build --format both --out .benchmark/results/baseline",
-    "bench:full": "node scripts/bench-builds.mjs --profile full --iterations 5 --warmup 1 --clean build --format both --out .benchmark/results/full",
-    "bench:large": "node scripts/bench-builds.mjs --profile large --iterations 1 --warmup 0 --clean cold --format both --out .benchmark/results/large",
+    "bench": "node scripts/bench-builds.mts",
+    "bench:ci-report": "node scripts/report-benchmark-ci.mts",
+    "bench:compare": "node scripts/compare-benchmarks.mts",
+    "bench:smoke": "node scripts/bench-builds.mts --profile smoke --iterations 1 --warmup 0 --format both --out .benchmark/results/smoke",
+    "bench:baseline": "node scripts/bench-builds.mts --profile default --iterations 5 --warmup 1 --clean build --format both --out .benchmark/results/baseline",
+    "bench:full": "node scripts/bench-builds.mts --profile full --iterations 5 --warmup 1 --clean build --format both --out .benchmark/results/full",
+    "bench:large": "node scripts/bench-builds.mts --profile large --iterations 1 --warmup 0 --clean cold --format both --out .benchmark/results/large",
+    "bench:synthetic-app": "node scripts/bench-synthetic-app.mjs",
     "e2e": "pnpm build && pnpm test:package-interop && pnpm --filter './examples/{default-template,spa-mode,prerender,custom-node-server,cloudflare,client-only}' test:e2e",
     "dev": "rslib build --watch",
     "test": "rstest run",
@@ -114,7 +116,7 @@
     "test:coverage": "rstest run --coverage",
     "test:core": "rstest run -c ./rstest.config.ts",
     "test:core:watch": "rstest watch -c ./rstest.config.ts",
-    "test:package-interop": "node scripts/test-package-interop.mjs",
+    "test:package-interop": "node scripts/test-package-interop.mts",
     "format": "prettier --write \"src/**/*.{js,jsx,ts,tsx}\"",
     "format:check": "prettier --check \"src/**/*.{js,jsx,ts,tsx}\"",
     "changeset": "changeset",

package/src/build-manifest.ts

@@ -1,4 +1,7 @@
 import { relative, resolve } from 'pathe';
+import * as Effect from 'effect/Effect';
+import { getCappedPluginConcurrency } from './concurrency.js';
+import { runPluginEffect, tryPluginPromise } from './effect-runtime.js';
 import type { Config } from './react-router-config.js';
 import type { Route } from './types.js';
 
@@ -57,11 +60,26 @@ const configRouteToBranchRoute = (route: Route) => ({
   index: route.index,
 });
 
-export const getBuildManifest = async ({
-  reactRouterConfig,
-  routes,
-  rootDirectory,
-}: {
+const validateServerBundleId = (
+  serverBundleId: string,
+  future: Required<Config>['future']
+): Error | undefined => {
+  if (future?.v8_viteEnvironmentApi) {
+    return /^[a-zA-Z0-9_]+$/.test(serverBundleId)
+      ? undefined
+      : new Error(
+          'The "serverBundles" function must only return strings containing alphanumeric characters and underscores.'
+        );
+  }
+
+  return /^[a-zA-Z0-9-_]+$/.test(serverBundleId)
+    ? undefined
+    : new Error(
+        'The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.'
+      );
+};
+
+type GetBuildManifestOptions = {
   reactRouterConfig: Required<
     Pick<
       Config,
@@ -71,80 +89,99 @@ export const getBuildManifest = async ({
     Pick<Config, 'serverBundles'>;
   routes: Record<string, Route>;
   rootDirectory: string;
-}): Promise<BuildManifest | undefined> => {
-  const {
-    serverBundles,
-    appDirectory,
-    buildDirectory,
-    serverBuildFile,
-    future,
-  } = reactRouterConfig;
-
-  if (!serverBundles) {
-    return { routes };
-  }
+};
 
-  const rootRelativeRoutes = Object.fromEntries(
-    Object.entries(routes).map(([id, route]) => {
-      const filePath = resolve(appDirectory, route.file);
-      return [
-        id,
-        { ...route, file: normalizePath(relative(rootDirectory, filePath)) },
-      ];
-    })
-  );
+export const getBuildManifestEffect = ({
+  reactRouterConfig,
+  routes,
+  rootDirectory,
+}: GetBuildManifestOptions): Effect.Effect<
+  BuildManifest | undefined,
+  Error,
+  never
+> =>
+  Effect.gen(function* () {
+    const {
+      serverBundles,
+      appDirectory,
+      buildDirectory,
+      serverBuildFile,
+      future,
+    } = reactRouterConfig;
+
+    if (!serverBundles) {
+      return { routes };
+    }
 
-  const serverBuildDirectory = resolve(buildDirectory, 'server');
-
-  const buildManifest: BuildManifest = {
-    routes: rootRelativeRoutes,
-    serverBundles: {},
-    routeIdToServerBundleId: {},
-  };
-
-  await Promise.all(
-    getAddressableRoutes(routes).map(async route => {
-      const branch = getRouteBranch(routes, route.id);
-      const serverBundleId = await serverBundles({
-        branch: branch.map(branchRoute =>
-          configRouteToBranchRoute({
-            ...branchRoute,
-            file: resolve(appDirectory, branchRoute.file),
-          })
-        ),
-      });
-
-      if (typeof serverBundleId !== 'string') {
-        throw new Error('The "serverBundles" function must return a string');
-      }
+    const rootRelativeRoutes = Object.fromEntries(
+      Object.entries(routes).map(([id, route]) => {
+        const filePath = resolve(appDirectory, route.file);
+        return [
+          id,
+          { ...route, file: normalizePath(relative(rootDirectory, filePath)) },
+        ];
+      })
+    );
+
+    const serverBuildDirectory = resolve(buildDirectory, 'server');
+
+    const buildManifest: BuildManifest = {
+      routes: rootRelativeRoutes,
+      serverBundles: {},
+      routeIdToServerBundleId: {},
+    };
 
-      if (future?.v8_viteEnvironmentApi) {
-        if (!/^[a-zA-Z0-9_]+$/.test(serverBundleId)) {
-          throw new Error(
-            'The "serverBundles" function must only return strings containing alphanumeric characters and underscores.'
+    yield* Effect.forEach(
+      getAddressableRoutes(routes),
+      route =>
+        Effect.gen(function* () {
+          const branch = getRouteBranch(routes, route.id);
+          const serverBundleId = yield* tryPluginPromise(() =>
+            serverBundles({
+              branch: branch.map(branchRoute =>
+                configRouteToBranchRoute({
+                  ...branchRoute,
+                  file: resolve(appDirectory, branchRoute.file),
+                })
+              ),
+            })
           );
-        }
-      } else if (!/^[a-zA-Z0-9-_]+$/.test(serverBundleId)) {
-        throw new Error(
-          'The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.'
-        );
-      }
 
-      buildManifest.routeIdToServerBundleId![route.id] = serverBundleId;
-      buildManifest.serverBundles![serverBundleId] ??= {
-        id: serverBundleId,
-        file: normalizePath(
-          relative(
-            rootDirectory,
-            resolve(serverBuildDirectory, serverBundleId, serverBuildFile)
-          )
-        ),
-      };
-    })
-  );
+          if (typeof serverBundleId !== 'string') {
+            return yield* Effect.fail(
+              new Error('The "serverBundles" function must return a string')
+            );
+          }
 
-  return buildManifest;
-};
+          const validationError = validateServerBundleId(
+            serverBundleId,
+            future
+          );
+          if (validationError) {
+            return yield* Effect.fail(validationError);
+          }
+
+          buildManifest.routeIdToServerBundleId![route.id] = serverBundleId;
+          buildManifest.serverBundles![serverBundleId] ??= {
+            id: serverBundleId,
+            file: normalizePath(
+              relative(
+                rootDirectory,
+                resolve(serverBuildDirectory, serverBundleId, serverBuildFile)
+              )
+            ),
+          };
+        }),
+      { concurrency: getCappedPluginConcurrency(), discard: true }
+    );
+
+    return buildManifest;
+  });
+
+export const getBuildManifest = (
+  options: GetBuildManifestOptions
+): Promise<BuildManifest | undefined> =>
+  runPluginEffect(getBuildManifestEffect(options));
 
 export const getRoutesByServerBundleId = (
   buildManifest: BuildManifest | undefined,

package/src/concurrency.ts

@@ -2,7 +2,7 @@ import { availableParallelism, cpus } from 'node:os';
 
 const DEFAULT_RESERVED_CORES = 2;
 
-const getAvailableCpuCount = (): number =>
+export const getAvailableCpuCount = (): number =>
   typeof availableParallelism === 'function'
     ? availableParallelism()
     : cpus().length;
@@ -11,24 +11,5 @@ export const getDefaultConcurrency = (
   cpuCount: number = getAvailableCpuCount()
 ): number => Math.max(0, Math.floor(cpuCount) - DEFAULT_RESERVED_CORES);
 
-export const mapWithConcurrency = async <Item, Result>(
-  items: readonly Item[],
-  concurrency: number,
-  worker: (item: Item, index: number) => Promise<Result>
-): Promise<Result[]> => {
-  const results = new Array<Result>(items.length);
-  let nextIndex = 0;
-  const workerCount = Math.max(1, Math.min(concurrency, items.length));
-  await Promise.all(
-    Array.from({ length: workerCount }, async () => {
-      while (true) {
-        const index = nextIndex++;
-        if (index >= items.length) {
-          return;
-        }
-        results[index] = await worker(items[index], index);
-      }
-    })
-  );
-  return results;
-};
+export const getCappedPluginConcurrency = (cap = 16): number =>
+  Math.max(1, Math.min(cap, getDefaultConcurrency() || 1));

package/src/config-imports.ts

@@ -1,6 +1,9 @@
 import type { ModuleCache } from 'jiti';
+import { createJiti } from 'jiti';
 import { resolve } from 'pathe';
 
+type ConfigImporter = Pick<ReturnType<typeof createJiti>, 'import'>;
+
 const normalizePath = (filePath: string): string => resolve(filePath);
 
 const isNodeModulePath = (filePath: string): boolean =>
@@ -43,3 +46,38 @@ export const clearConfigImportCache = (
     }
   }
 };
+
+export const importConfigWithWatchPaths = async <T>(
+  configPath: string,
+  load: (importer: ConfigImporter) => PromiseLike<T> | T = async importer =>
+    importer.import<T>(configPath, { default: true })
+): Promise<{ value: Awaited<T>; watchPaths: string | string[] }> => {
+  const jiti = createJiti(process.cwd(), {
+    moduleCache: true,
+  });
+  const previousCacheKeys = new Set(Object.keys(jiti.cache));
+  let importPaths: string[] = [];
+
+  try {
+    const value = await load(jiti);
+    importPaths = collectConfigImportWatchPaths(
+      configPath,
+      jiti.cache,
+      previousCacheKeys
+    );
+    return {
+      value,
+      watchPaths:
+        importPaths.length > 0 ? [configPath, ...importPaths] : configPath,
+    };
+  } finally {
+    if (importPaths.length === 0) {
+      importPaths = collectConfigImportWatchPaths(
+        configPath,
+        jiti.cache,
+        previousCacheKeys
+      );
+    }
+    clearConfigImportCache(jiti.cache, [configPath, ...importPaths]);
+  }
+};