@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/src/cloudflare-builder.ts

@@ -1,26 +1,55 @@
 import fs from 'node:fs';
-import { createRequire } from 'node:module';
+import { createRequire, isBuiltin } from 'node:module';
 import path from 'node:path';
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from '@modern-js/builder';
 import type { BffUserConfig } from '@modern-js/server-core';
+import type {} from '@modern-js/server-runtime-extensions/server-config';
 import { isProd } from '@modern-js/utils';
 import type {
   EnvironmentConfig,
   ModifyBundlerChainFn,
   RsbuildEntry,
   RsbuildEntryDescription,
+  Rspack,
 } from '@rsbuild/core';
-import { provider } from 'std-env';
-import { CLOUDFLARE_WORKER_NODE_BUILTINS } from './cloudflare-output-contract';
+import {
+  CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
+  CLOUDFLARE_WORKER_NODE_BUILTINS,
+  CLOUDFLARE_WORKER_PLATFORM_MODULES,
+  getCloudflareWorkerRouteDataEntryName,
+} from './cloudflare-output-contract';
+import type { ResolvedDeployTarget } from './deploy-output/target';
 import { getTemplatePath } from './read-template';
 
 const moduleRequire = createRequire(import.meta.url);
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
-const MF_SSR_DATA_FETCH_RUNTIME_PLUGIN =
-  '@module-federation/modern-js-v3/ssr-inject-data-fetch-function-plugin';
-const MF_SSR_DEV_RUNTIME_PLUGIN =
-  '@module-federation/modern-js-v3/ssr-dev-plugin';
+// Generated by the router code generator for SSR entries with nested route
+// data loaders; the Node server loads this module as its loader bundle. It
+// re-exports the data loader runtime next to the entry's route loaders.
+const SERVER_LOADER_COMBINED_FILE = 'server-loader-combined.js';
+// The entry's route loaders (`routes`), which the loader bundle re-exports.
+const ROUTE_SERVER_LOADERS_FILE = 'route-server-loaders.js';
+const WORKER_ROUTE_DATA_FILE = 'cloudflare-worker-route-data.js';
+const WORKER_ROUTE_DATA_TEMPLATE = 'cloudflare-worker-route-data.mjs';
+// Client builds rewrite `*.data.*` modules into `?__loader=` fetch clients
+// through the data loader plugin's webpack loader. The worker is a server
+// runtime and must execute route loaders in-process. The rule is matched by
+// that loader module, not by the rule name the SSR adapter registers, in both
+// the workspace package and the published `@bleedingdev/modern-js-*` name.
+const DATA_LOADER_CLIENT_TRANSFORM =
+  /plugin-data-loader[\\/](?:.+[\\/])?loader\.[cm]?js$/u;
+// Rspack's default dependency-type conditions (`resolve.byDependency`).
+const WORKER_DEPENDENCY_CONDITIONS = [
+  ['esm', 'import'],
+  ['wasm', 'import'],
+  ['loaderImport', 'import'],
+  ['worker', 'import'],
+  ['commonjs', 'require'],
+  ['amd', 'require'],
+  ['loader', 'require'],
+  ['unknown', 'require'],
+] as const;
 const JS_OR_TS_EXTENSIONS = new Set([
   '.js',
   '.jsx',
@@ -34,23 +63,23 @@ const JS_OR_TS_EXTENSIONS = new Set([
 
 export interface CloudflareBuilderNormalizedConfig {
   bff?: BffUserConfig;
-  deploy?: { target?: string };
 }
 
 export interface CloudflareBuilderAppContext {
+  apiOnly?: boolean;
+  deployTarget?: ResolvedDeployTarget;
   apiDirectory: string;
   appDirectory: string;
+  entrypoints?: ReadonlyArray<{ entryName: string }>;
+  internalDirectory?: string;
 }
 
 export interface CloudflareBuilderEnvironmentsOptions {
   appContext: CloudflareBuilderAppContext;
   environments: Record<string, EnvironmentConfig>;
   normalizedConfig: CloudflareBuilderNormalizedConfig;
-  resolveDeployProvider?: ResolveCloudflareDeployProvider;
 }
 
-export type ResolveCloudflareDeployProvider = () => string | undefined;
-
 export interface CloudflareWorkerRspackConfig {
   externals: Record<string, string>;
   externalsType: 'module-import';
@@ -189,16 +218,329 @@ const setAliasIfPresent = (
   }
 };
 
+// Node accepts a bare specifier only for built-ins that are not prefix-only
+// (`sqlite` and `test` are ordinary npm package names without `node:`).
 const getCloudflareWorkerNodeExternals = () =>
-  Object.fromEntries(
-    CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap(builtin => {
+  Object.fromEntries([
+    ...CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap(builtin => {
       const nodeBuiltin = `node:${builtin}`;
-      return [
-        [builtin, `module-import ${nodeBuiltin}`],
-        [nodeBuiltin, `module-import ${nodeBuiltin}`],
-      ];
+      const external = `module-import ${nodeBuiltin}`;
+      return isBuiltin(builtin)
+        ? [
+            [builtin, external],
+            [nodeBuiltin, external],
+          ]
+        : [[nodeBuiltin, external]];
     }),
-  );
+    ...CLOUDFLARE_WORKER_PLATFORM_MODULES.map(platformModule => [
+      platformModule,
+      `module-import ${platformModule}`,
+    ]),
+  ]);
+
+const getPackageNameFromRequest = (request: string) => {
+  if (
+    request.startsWith('.') ||
+    request.startsWith('/') ||
+    request.includes(':') ||
+    path.isAbsolute(request)
+  ) {
+    return undefined;
+  }
+  const segments = request.split('/');
+  return request.startsWith('@')
+    ? segments.length > 1
+      ? `${segments[0]}/${segments[1]}`
+      : undefined
+    : segments[0];
+};
+
+interface OptionalDependencyManifest {
+  optionalDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
+  [field: string]: unknown;
+}
+
+type AliasField = string | readonly string[];
+
+// Mirrors the resolver's `resolve.aliasFields` lookup: a field is a key or a
+// nested key path into the importing package's manifest whose object maps
+// exact requests to replacements (or to `false` for an empty module); an
+// entry for a package name does not cover its subpaths.
+const isRedirectedByAliasField = (
+  manifest: OptionalDependencyManifest,
+  aliasFields: readonly AliasField[],
+  request: string,
+) =>
+  aliasFields.some(field => {
+    let value: unknown = manifest;
+    for (const key of typeof field === 'string' ? [field] : field) {
+      value =
+        value && typeof value === 'object'
+          ? (value as Record<string, unknown>)[key]
+          : undefined;
+    }
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      Object.hasOwn(value, request)
+    );
+  });
+
+const findOwningPackageManifest = (
+  directory: string,
+  cache: Map<string, OptionalDependencyManifest | undefined>,
+): OptionalDependencyManifest | undefined => {
+  if (cache.has(directory)) {
+    return cache.get(directory);
+  }
+  let manifest: OptionalDependencyManifest | undefined;
+  const packageJsonPath = path.join(directory, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      manifest = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    } catch {
+      manifest = undefined;
+    }
+  } else if (path.dirname(directory) !== directory) {
+    manifest = findOwningPackageManifest(path.dirname(directory), cache);
+  }
+  cache.set(directory, manifest);
+  return manifest;
+};
+
+// Mirrors the resolver's `resolve.modules` lookup: absolute entries are
+// searched directly, named entries in the context directory and each ancestor.
+const isPackageInstalled = (
+  packageName: string,
+  directory: string,
+  moduleDirectories: readonly string[],
+) =>
+  moduleDirectories.some(moduleDirectory => {
+    if (path.isAbsolute(moduleDirectory)) {
+      return fs.existsSync(path.join(moduleDirectory, packageName));
+    }
+    let current = directory;
+    while (true) {
+      if (fs.existsSync(path.join(current, moduleDirectory, packageName))) {
+        return true;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) {
+        return false;
+      }
+      current = parent;
+    }
+  });
+
+/**
+ * Leaves an absent optional dependency missing at runtime, exactly as Node
+ * does, instead of failing the worker build. It applies only when the
+ * importing package itself declares the request as an optional peer
+ * (`peerDependenciesMeta.<name>.optional`) or an `optionalDependencies`
+ * entry, the package is not found in any `resolve.modules` directory, and
+ * neither the app (`resolve.alias`, `resolve.fallback`, `externals`) nor the
+ * importing package (an enabled `resolve.aliasFields` entry such as
+ * `browser`) redirects the request. The import
+ * then rejects with "Cannot find module" so the library's own fallback
+ * handles it (for example `@redis/client` guards `import('@node-rs/xxhash')`).
+ */
+export const createAbsentOptionalDependencyFilter = (
+  isRedirected: (request: string) => boolean = () => false,
+  moduleDirectories: readonly string[] = ['node_modules'],
+  aliasFields: readonly AliasField[] = [],
+) => {
+  const manifests = new Map<string, OptionalDependencyManifest | undefined>();
+  return (request: string, context: string) => {
+    const packageName = getPackageNameFromRequest(request);
+    if (!packageName || !context || isRedirected(request)) {
+      return false;
+    }
+    const manifest = findOwningPackageManifest(context, manifests);
+    if (!manifest) {
+      return false;
+    }
+    const optional =
+      manifest.peerDependenciesMeta?.[packageName]?.optional === true ||
+      Object.hasOwn(manifest.optionalDependencies ?? {}, packageName);
+    return (
+      optional &&
+      !isRedirectedByAliasField(manifest, aliasFields, request) &&
+      !isPackageInstalled(packageName, context, moduleDirectories)
+    );
+  };
+};
+
+type AliasOption =
+  | Record<string, unknown>
+  | { name: string; onlyModule?: boolean }[]
+  | false
+  | undefined;
+
+const getAliasNames = (alias: AliasOption) =>
+  !alias
+    ? []
+    : Array.isArray(alias)
+      ? alias.map(entry => (entry.onlyModule ? `${entry.name}$` : entry.name))
+      : Object.keys(alias);
+
+type ExternalMatcher = (request: string) => boolean;
+
+// String, RegExp and object-key externals are matched synchronously; function
+// externals are consulted per request by `claimsByFunctionExternal`.
+// An object entry mapped to `false` keeps the request bundled, so it is not
+// a redirect.
+const getExternalMatchers = (externals: unknown): ExternalMatcher[] => {
+  if (Array.isArray(externals)) {
+    return externals.flatMap(getExternalMatchers);
+  }
+  if (typeof externals === 'string') {
+    return [request => request === externals];
+  }
+  if (externals instanceof RegExp) {
+    return [
+      request => {
+        externals.lastIndex = 0;
+        return externals.test(request);
+      },
+    ];
+  }
+  if (externals && typeof externals === 'object') {
+    const names = new Set(
+      Object.entries(externals)
+        .filter(([, value]) => value !== false)
+        .map(([name]) => name),
+    );
+    return [request => names.has(request)];
+  }
+  return [];
+};
+
+/**
+ * Reads the final resolved `resolve.alias`, `resolve.fallback` and
+ * `externals` so an app's own
+ * replacement for an optional package still wins over the absent-module
+ * fallback (the fallback runs before resolution).
+ */
+export const createRequestRedirectMatcher = (options: {
+  externals?: unknown;
+  resolve?: { alias?: AliasOption; fallback?: AliasOption };
+}) => {
+  const aliasNames = [
+    ...getAliasNames(options.resolve?.alias),
+    ...getAliasNames(options.resolve?.fallback),
+  ];
+  const externalMatchers = getExternalMatchers(options.externals);
+  return (request: string) =>
+    externalMatchers.some(matches => matches(request)) ||
+    aliasNames.some(name =>
+      name.endsWith('$')
+        ? request === name.slice(0, -1)
+        : request === name || request.startsWith(`${name}/`),
+    );
+};
+
+type FunctionExternal = (
+  data: Rspack.ExternalItemFunctionData,
+  callback: (error?: Error | null, result?: unknown) => void,
+) => unknown;
+
+const getFunctionExternals = (externals: unknown): FunctionExternal[] =>
+  Array.isArray(externals)
+    ? externals.flatMap(getFunctionExternals)
+    : typeof externals === 'function'
+      ? [externals as FunctionExternal]
+      : [];
+
+// Calls a function external with the same callback, promise and synchronous
+// return forms Rspack accepts. `undefined`, `null` and `false` decline.
+const callFunctionExternal = (
+  external: FunctionExternal,
+  data: Rspack.ExternalItemFunctionData,
+) =>
+  new Promise<unknown>((resolve, reject) => {
+    const returned = external(data, (error, result) =>
+      error ? reject(error) : resolve(result),
+    );
+    if (
+      returned !== null &&
+      typeof returned === 'object' &&
+      typeof (returned as PromiseLike<unknown>).then === 'function'
+    ) {
+      (returned as PromiseLike<unknown>).then(resolve, reject);
+    } else if (external.length === 1) {
+      resolve(returned);
+    }
+  });
+
+/**
+ * Reports whether any function external claims the request. A function that
+ * throws is treated as claiming it, so the request goes through ordinary
+ * external processing and surfaces that error instead of being ignored.
+ */
+export const claimsByFunctionExternal = async (
+  externals: readonly FunctionExternal[],
+  data: Rspack.ExternalItemFunctionData,
+) => {
+  for (const external of externals) {
+    try {
+      const result = await callFunctionExternal(external, data);
+      if (result !== undefined && result !== null && result !== false) {
+        return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  return false;
+};
+
+const PLUGIN_NAME = 'AbsentOptionalDependencyPlugin';
+
+class AbsentOptionalDependencyPlugin {
+  apply(compiler: Rspack.Compiler) {
+    const isAbsent = createAbsentOptionalDependencyFilter(
+      createRequestRedirectMatcher(compiler.options),
+      compiler.options.resolve.modules,
+      compiler.options.resolve.aliasFields,
+    );
+    const functionExternals = getFunctionExternals(compiler.options.externals);
+    compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, factory => {
+      factory.hooks.beforeResolve.tapPromise(PLUGIN_NAME, async data => {
+        if (!isAbsent(data.request, data.context)) {
+          return undefined;
+        }
+        const claimed = await claimsByFunctionExternal(functionExternals, {
+          context: data.context,
+          contextInfo: {
+            issuer: data.contextInfo.issuer,
+            issuerLayer: data.contextInfo.issuerLayer ?? null,
+          },
+          getResolve: options => {
+            const resolver = factory.getResolver('normal', options ?? {});
+            return (
+              context: string,
+              request: string,
+              callback?: Parameters<typeof resolver.resolve>[4],
+            ) => {
+              if (callback) {
+                resolver.resolve({}, context, request, {}, callback);
+                return undefined;
+              }
+              return new Promise<string | undefined>((resolve, reject) => {
+                resolver.resolve({}, context, request, {}, (error, result) =>
+                  error ? reject(error) : resolve(result || undefined),
+                );
+              });
+            };
+          },
+          request: data.request,
+        });
+        return claimed ? undefined : false;
+      });
+    });
+  }
+}
 
 const normalizeWorkerOutputName = (name: string) =>
   path.posix.normalize(name.replace(/\\/gu, '/')).toLowerCase();
@@ -281,18 +623,28 @@ export function applyCloudflareWorkerRspackConfig(
   chain.optimization.splitChunks(config.optimization.splitChunks);
 }
 
-export function applyCloudflareWorkerMfRuntimeBoundary(
+/**
+ * The worker environment uses Rspack's web target for ESM output, which the
+ * data loader transform treats as a browser bundle. Remove every module rule
+ * that applies it, so SSR runs route loaders in-process as the Node server
+ * does instead of fetching the worker's own `?__loader=` URL.
+ */
+function removeCloudflareWorkerDataLoaderClientTransform(
   chain: Parameters<ModifyBundlerChainFn>[0],
 ) {
-  const runtimePlugin = getTemplatePath(
-    'cloudflare-worker-mf-ssr-runtime-plugin.mjs',
-  );
-  chain.plugins.delete('plugin-module-federation');
-  chain.resolve.alias.set(
-    `${MF_SSR_DATA_FETCH_RUNTIME_PLUGIN}$`,
-    runtimePlugin,
-  );
-  chain.resolve.alias.set(`${MF_SSR_DEV_RUNTIME_PLUGIN}$`, runtimePlugin);
+  for (const [name, rule] of Object.entries(
+    chain.module.rules.entries() ?? {},
+  )) {
+    if (
+      rule.uses
+        .values()
+        .some(use =>
+          DATA_LOADER_CLIENT_TRANSFORM.test(String(use.get('loader'))),
+        )
+    ) {
+      chain.module.rules.delete(name);
+    }
+  }
 }
 
 const getEffectBffEntry = (
@@ -317,31 +669,6 @@ const getEffectBffEntry = (
   return resolveJsOrTsEntry(path.resolve(appContext.apiDirectory, 'index'));
 };
 
-const CLOUDFLARE_DEPLOY_PROVIDERS = new Set([
-  'cloudflare',
-  'cloudflare_pages',
-  'cloudflare_workers',
-]);
-
-const resolveStdEnvDeployProvider: ResolveCloudflareDeployProvider = () =>
-  provider;
-
-const isCloudflareWorkerDeploy = (
-  normalizedConfig: CloudflareBuilderNormalizedConfig,
-  resolveDeployProvider: ResolveCloudflareDeployProvider,
-) => {
-  const explicitTarget =
-    normalizedConfig.deploy?.target || process.env.MODERNJS_DEPLOY;
-  if (explicitTarget) {
-    return explicitTarget === 'cloudflare';
-  }
-
-  const detectedProvider = resolveDeployProvider();
-  return detectedProvider
-    ? CLOUDFLARE_DEPLOY_PROVIDERS.has(detectedProvider)
-    : false;
-};
-
 const rewriteWorkerEntryPath = (entry: string) =>
   entry
     .replace('index.jsx', 'index.server.jsx')
@@ -396,18 +723,72 @@ const prependBundlerChain = (
   };
 };
 
+const createWorkerRouteDataModule = () =>
+  [
+    `import { routes } from './${ROUTE_SERVER_LOADERS_FILE}';`,
+    `import { createRouteDataRequestHandler } from ${JSON.stringify(
+      getTemplatePath(WORKER_ROUTE_DATA_TEMPLATE),
+    )};`,
+    '',
+    `export const ${CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT} =`,
+    '  createRouteDataRequestHandler(routes);',
+    '',
+  ].join('\n');
+
+/**
+ * Route data requests reach the worker whenever the browser navigates to a
+ * route with a data loader. Bundle the route loaders of each entry that has a
+ * Node server loader bundle behind the worker route data handler, so the
+ * worker answers them instead of rendering the page. The worker imports the
+ * route loaders without the loader bundle's data loader runtime, which is
+ * built on react-router.
+ */
+const getWorkerRouteDataEntries = (
+  appContext: CloudflareBuilderAppContext,
+): Record<string, string[]> => {
+  const { entrypoints, internalDirectory } = appContext;
+  if (!entrypoints || !internalDirectory) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    entrypoints.flatMap(({ entryName }) => {
+      const entryDirectory = path.join(internalDirectory, entryName);
+      if (
+        !fs.existsSync(
+          path.join(entryDirectory, SERVER_LOADER_COMBINED_FILE),
+        ) ||
+        !fs.existsSync(path.join(entryDirectory, ROUTE_SERVER_LOADERS_FILE))
+      ) {
+        return [];
+      }
+
+      const routeDataFile = path.join(entryDirectory, WORKER_ROUTE_DATA_FILE);
+      fs.writeFileSync(routeDataFile, createWorkerRouteDataModule());
+      return [
+        [getCloudflareWorkerRouteDataEntryName(entryName), [routeDataFile]],
+      ];
+    }),
+  );
+};
+
 const getWorkerEntries = (
   environment: EnvironmentConfig,
   normalizedConfig: CloudflareBuilderNormalizedConfig,
   appContext: CloudflareBuilderAppContext,
 ) => {
   const configuredEntries = environment.source?.entry;
-  if (!configuredEntries) {
+  const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
+  if (!configuredEntries && !effectApiEntry) {
     return undefined;
   }
 
-  const entries = rewriteWorkerEntries(configuredEntries);
-  const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
+  const entries = configuredEntries
+    ? {
+        ...rewriteWorkerEntries(configuredEntries),
+        ...getWorkerRouteDataEntries(appContext),
+      }
+    : {};
   return effectApiEntry
     ? {
         ...entries,
@@ -423,21 +804,6 @@ const createCloudflareBundlerChain = (
   workerEntryNames: Iterable<string>,
 ): ModifyBundlerChainFn => {
   const resolvePaths = [appContext.appDirectory, process.cwd()];
-  const tanstackRouterSsrServerFile = resolvePackageFile(
-    '@tanstack/router-core',
-    'dist/esm/ssr/ssr-server.js',
-    resolvePaths,
-  );
-  const runtimeRscWorkerFile = resolvePackageFile(
-    '@modern-js/runtime',
-    'dist/esm/rsc/server.worker.mjs',
-    resolvePaths,
-  );
-  const renderRscWorkerFile = resolvePackageFile(
-    '@modern-js/render',
-    'dist/esm/rscWorker.mjs',
-    resolvePaths,
-  );
   const reactFile = resolvePackageFile('react', 'index.js', resolvePaths);
   const reactJsxRuntimeFile = resolvePackageFile(
     'react',
@@ -464,17 +830,11 @@ const createCloudflareBundlerChain = (
     'dist/esm/loadable.esm.mjs',
     [...resolvePaths, getTemplatePath('')],
   );
-  const loadableServerWorkerFile = getTemplatePath(
-    'cloudflare-worker-loadable-server.mjs',
-  );
-  const fsPromisesWorkerFile = getTemplatePath(
-    'cloudflare-worker-fs-promises.mjs',
-  );
-  const pathWorkerFile = getTemplatePath('cloudflare-worker-path.mjs');
   const entryNames = [...workerEntryNames];
 
   return chain => {
     applyCloudflareWorkerRspackConfig(chain, entryNames);
+    removeCloudflareWorkerDataLoaderClientTransform(chain);
     chain.output
       .module(true)
       .library({ type: 'module' })
@@ -488,42 +848,31 @@ const createCloudflareBundlerChain = (
       'worker',
       'webpack',
       isProd() ? 'production' : 'development',
-      'import',
-      'require',
       'module',
     ]) {
       chain.resolve.conditionNames.add(condition);
     }
-
-    applyCloudflareWorkerMfRuntimeBoundary(chain);
-    if (tanstackRouterSsrServerFile) {
-      chain.resolve.alias.set(
-        '@tanstack/router-core/ssr/server$',
-        tanstackRouterSsrServerFile,
-      );
-      chain.resolve.alias.set(
-        '@tanstack/router-core/ssr/server',
-        tanstackRouterSsrServerFile,
-      );
-    }
-    if (runtimeRscWorkerFile) {
-      chain.resolve.alias.set(
-        '@modern-js/runtime/rsc/server$',
-        runtimeRscWorkerFile,
-      );
-      chain.resolve.alias.set(
-        '@modern-js/runtime/rsc/server',
-        runtimeRscWorkerFile,
-      );
-    }
-    if (renderRscWorkerFile) {
-      chain.resolve.alias.set('@modern-js/render/rsc$', renderRscWorkerFile);
-      chain.resolve.alias.set('@modern-js/render/rsc', renderRscWorkerFile);
-      chain.resolve.alias.set(
-        '@modern-js/render/rsc-worker$',
-        renderRscWorkerFile,
-      );
+    // Setting base conditions drops Rspack's per-dependency `import` /
+    // `require` defaults, and adding both globally lets a dual package's
+    // first-listed `import` branch win for `require()` (so `pg` received an
+    // ES module namespace for `pg-pool` and missed `pg-cloudflare`'s
+    // `workerd.require` entry). Restore Rspack's own per-dependency split.
+    for (const [dependencyType, condition] of WORKER_DEPENDENCY_CONDITIONS) {
+      chain.resolve.byDependency.set(dependencyType, {
+        conditionNames: [condition, '...'],
+      });
     }
+    chain
+      .plugin('cloudflare-worker-absent-optional-dependencies')
+      .use(AbsentOptionalDependencyPlugin);
+
+    // The worker environment still uses the web target, so
+    // @module-federation/modern-js-v3 registers its browser federation plugin
+    // on it; Cloudflare workers load no native remotes. The `worker` export
+    // condition keeps MF's SSR runtime plugins out of the bundle
+    // (module-federation/core#5155). This deletion goes with the web-worker
+    // target, which needs @rsbuild/core 2.2.10 (web-infra-dev/rsbuild#8557).
+    chain.plugins.delete('plugin-module-federation');
     setAliasIfPresent(chain.resolve.alias, 'react$', reactFile);
     setAliasIfPresent(
       chain.resolve.alias,
@@ -546,41 +895,6 @@ const createCloudflareBundlerChain = (
       '@loadable/component$',
       loadableComponentFile,
     );
-    setAliasIfPresent(
-      chain.resolve.alias,
-      '@loadable/server$',
-      loadableServerWorkerFile,
-    );
-    setAliasIfPresent(
-      chain.resolve.alias,
-      'fs/promises$',
-      fsPromisesWorkerFile,
-    );
-    setAliasIfPresent(
-      chain.resolve.alias,
-      'node:fs/promises$',
-      fsPromisesWorkerFile,
-    );
-    setAliasIfPresent(chain.resolve.alias, 'path$', pathWorkerFile);
-    setAliasIfPresent(chain.resolve.alias, 'node:path$', pathWorkerFile);
-    chain.resolve.alias.set(
-      'react-server-dom-rspack/server.node$',
-      'react-server-dom-rspack/server.edge',
-    );
-    chain.resolve.alias.set(
-      'react-server-dom-rspack/server.node',
-      'react-server-dom-rspack/server.edge',
-    );
-    chain.resolve.alias.set(
-      'react-server-dom-rspack/client.node$',
-      'react-server-dom-rspack/client.edge',
-    );
-    chain.resolve.alias.set(
-      'react-server-dom-rspack/client.node',
-      'react-server-dom-rspack/client.edge',
-    );
-    chain.resolve.fallback.set('fs', false);
-    chain.resolve.fallback.set('node:fs', false);
   };
 };
 
@@ -588,13 +902,19 @@ export function getCloudflareBuilderEnvironments({
   appContext,
   environments,
   normalizedConfig,
-  resolveDeployProvider = resolveStdEnvDeployProvider,
 }: CloudflareBuilderEnvironmentsOptions): Record<string, EnvironmentConfig> {
-  if (!isCloudflareWorkerDeploy(normalizedConfig, resolveDeployProvider)) {
+  if (appContext.deployTarget?.target !== 'cloudflare') {
     return environments;
   }
 
-  const workerEnvironment = environments[SERVICE_WORKER_ENVIRONMENT_NAME];
+  const workerEnvironment =
+    environments[SERVICE_WORKER_ENVIRONMENT_NAME] ??
+    (appContext.apiOnly
+      ? {
+          output: { target: 'web-worker' as const },
+          source: { entry: {} },
+        }
+      : undefined);
   if (!workerEnvironment) {
     return environments;
   }
@@ -624,6 +944,10 @@ export function getCloudflareBuilderEnvironments({
     createCloudflareBundlerChain(appContext, Object.keys(workerEntries)),
   );
 
+  if (appContext.apiOnly) {
+    return { [SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment };
+  }
+
   return {
     ...environments,
     [SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment,
@@ -636,9 +960,7 @@ export function applyCloudflareBuilderEnvironments(
   return { environments: getCloudflareBuilderEnvironments(options) };
 }
 
-export const createCloudflareBuilderPlugin = (
-  resolveDeployProvider = resolveStdEnvDeployProvider,
-): CloudflareBuilderPlugin => ({
+export const createCloudflareBuilderPlugin = (): CloudflareBuilderPlugin => ({
   name: '@modern-js/cloudflare-builder',
   setup(api) {
     api.modifyBuilderEnvironments(({ environments }) =>
@@ -646,7 +968,6 @@ export const createCloudflareBuilderPlugin = (
         appContext: api.getAppContext(),
         environments,
         normalizedConfig: api.getNormalizedConfig(),
-        resolveDeployProvider,
       }),
     );
   },