@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.13 → 3.9.0-ultramodern.15

package/src/cloudflare-builder.ts

@@ -1,5 +1,5 @@
 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';
@@ -10,18 +10,50 @@ import type {
   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 { 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';
+// 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;
 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';
+// 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',
@@ -42,6 +74,8 @@ export interface CloudflareBuilderAppContext {
   apiOnly?: boolean;
   apiDirectory: string;
   appDirectory: string;
+  entrypoints?: ReadonlyArray<{ entryName: string }>;
+  internalDirectory?: string;
 }
 
 export interface CloudflareBuilderEnvironmentsOptions {
@@ -191,16 +225,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();
@@ -283,6 +630,30 @@ export function applyCloudflareWorkerRspackConfig(
   chain.optimization.splitChunks(config.optimization.splitChunks);
 }
 
+/**
+ * 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],
+) {
+  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);
+    }
+  }
+}
+
 export function applyCloudflareWorkerMfRuntimeBoundary(
   chain: Parameters<ModifyBundlerChainFn>[0],
 ) {
@@ -398,6 +769,55 @@ 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,
@@ -410,7 +830,10 @@ const getWorkerEntries = (
   }
 
   const entries = configuredEntries
-    ? rewriteWorkerEntries(configuredEntries)
+    ? {
+        ...rewriteWorkerEntries(configuredEntries),
+        ...getWorkerRouteDataEntries(appContext),
+      }
     : {};
   return effectApiEntry
     ? {
@@ -479,6 +902,7 @@ const createCloudflareBundlerChain = (
 
   return chain => {
     applyCloudflareWorkerRspackConfig(chain, entryNames);
+    removeCloudflareWorkerDataLoaderClientTransform(chain);
     chain.output
       .module(true)
       .library({ type: 'module' })
@@ -492,12 +916,23 @@ const createCloudflareBundlerChain = (
       'worker',
       'webpack',
       isProd() ? 'production' : 'development',
-      'import',
-      'require',
       'module',
     ]) {
       chain.resolve.conditionNames.add(condition);
     }
+    // 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);
 
     applyCloudflareWorkerMfRuntimeBoundary(chain);
     if (tanstackRouterSsrServerFile) {

package/src/cloudflare-output-contract.ts

@@ -10,17 +10,41 @@ export const CLOUDFLARE_RUNTIME_TYPE = 'cloudflare-module-worker';
 export const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
 export const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
 export const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
-// Import availability for the default 2026-06-02 nodejs_compat target.
-// Some modules are runtime-provided stubs whose unsupported operations throw.
+// Each SSR entry with route data loaders gets a worker bundle that answers
+// `?__loader=` route data requests through this export.
+export const CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT = 'handleRouteDataRequest';
+export const getCloudflareWorkerRouteDataEntryName = (entryName: string) =>
+  `${entryName}-server-loaders`;
+// Every Node.js built-in that workerd resolves for the default 2026-06-02
+// nodejs_compat target (tests/cloudflare-worker-node-builtins.test.ts probes
+// workerd against Node's own `builtinModules`). Names are listed without the
+// `node:` scheme; bare-name imports are only valid where Node itself accepts
+// them (`isBuiltin`), so prefix-only modules such as `sqlite` and `test` are
+// externalized solely as `node:sqlite` and `node:test`. Some modules are
+// runtime-provided stubs whose unsupported operations throw. Earlier
+// compatibility dates are rejected when the Wrangler config is generated.
 export const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+  '_http_agent',
+  '_http_client',
+  '_http_common',
+  '_http_incoming',
+  '_http_outgoing',
+  '_http_server',
+  '_tls_common',
+  '_tls_wrap',
   'assert',
   'assert/strict',
   'async_hooks',
   'buffer',
   'child_process',
+  'cluster',
+  'console',
+  'constants',
   'crypto',
   'dgram',
+  'diagnostics_channel',
   'dns',
+  'dns/promises',
   'domain',
   'events',
   'fs',
@@ -29,11 +53,17 @@ export const CLOUDFLARE_WORKER_NODE_BUILTINS = [
   'http2',
   'https',
   'inspector',
+  'inspector/promises',
   'module',
   'net',
   'os',
   'path',
+  'path/posix',
+  'path/win32',
+  'perf_hooks',
   'process',
+  'punycode',
+  'querystring',
   'readline',
   'readline/promises',
   'repl',
@@ -43,6 +73,8 @@ export const CLOUDFLARE_WORKER_NODE_BUILTINS = [
   'stream/promises',
   'stream/web',
   'string_decoder',
+  'sys',
+  'test',
   'timers',
   'timers/promises',
   'tls',

package/src/cloudflare-output-verifier/worker-bundles.ts

@@ -5,6 +5,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { parse } from '@babel/parser';
 import traverse, { type NodePath } from '@babel/traverse';
 import {
+  CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
   CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
   CLOUDFLARE_WORKER_NODE_BUILTINS,
   CLOUDFLARE_WORKER_PLATFORM_MODULES,
@@ -14,7 +15,7 @@ import { addIssue } from './issues';
 
 interface WorkerBundleReference {
   dispatcherExport?: string;
-  kind: 'effect-bff' | 'route';
+  kind: 'effect-bff' | 'route' | 'route-data';
   reference: string;
 }
 
@@ -22,12 +23,15 @@ interface ResolvedWorkerBundleReference extends WorkerBundleReference {
   path: string;
 }
 
-const getReferencedRouteWorkers = (manifest: JsonObject) =>
+const getReferencedRouteWorkers = (
+  manifest: JsonObject,
+  field: 'routeDataWorker' | 'worker',
+) =>
   Array.isArray(manifest?.routeSpec?.routes)
     ? manifest.routeSpec.routes
         .map((route: any) =>
-          typeof route?.worker === 'string' && route.worker.length > 0
-            ? route.worker
+          typeof route?.[field] === 'string' && route[field].length > 0
+            ? route[field]
             : undefined,
         )
         .filter(
@@ -58,10 +62,19 @@ export const getWorkerBundleReferences = (
           },
         ]
       : []),
-    ...getReferencedRouteWorkers(manifest).map((reference: string) => ({
-      kind: 'route' as const,
-      reference,
-    })),
+    ...getReferencedRouteWorkers(manifest, 'worker').map(
+      (reference: string) => ({
+        kind: 'route' as const,
+        reference,
+      }),
+    ),
+    ...getReferencedRouteWorkers(manifest, 'routeDataWorker').map(
+      (reference: string) => ({
+        dispatcherExport: CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
+        kind: 'route-data' as const,
+        reference,
+      }),
+    ),
   ];
 };
 
@@ -101,7 +114,9 @@ export const resolveWorkerBundleReference = (
 export const missingWorkerBundleMessage = (reference: WorkerBundleReference) =>
   reference.kind === 'effect-bff'
     ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.'
-    : 'Cloudflare route worker manifest points to a missing worker bundle.';
+    : reference.kind === 'route-data'
+      ? 'Cloudflare route data worker manifest points to a missing worker bundle.'
+      : 'Cloudflare route worker manifest points to a missing worker bundle.';
 
 interface AstNode {
   type: string;
@@ -611,14 +626,15 @@ export const verifyWorkerBundleReferences = async (
     contract,
   );
   if (
-    worker.kind === 'effect-bff' &&
     typeof worker.dispatcherExport === 'string' &&
     !entryAnalysis?.exports.has(worker.dispatcherExport)
   ) {
     addIssue(issues, {
       code: 'invalid-worker-bundle',
       message:
-        'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        worker.kind === 'route-data'
+          ? `Cloudflare route data worker bundle must expose ${worker.dispatcherExport}.`
+          : 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
       path: worker.path,
     });
   }