@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.12 → 3.9.0-ultramodern.14

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',
@@ -39,8 +71,11 @@ export interface CloudflareBuilderNormalizedConfig {
 }
 
 export interface CloudflareBuilderAppContext {
+  apiOnly?: boolean;
   apiDirectory: string;
   appDirectory: string;
+  entrypoints?: ReadonlyArray<{ entryName: string }>;
+  internalDirectory?: string;
 }
 
 export interface CloudflareBuilderEnvironmentsOptions {
@@ -190,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();
@@ -282,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],
 ) {
@@ -397,18 +769,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,
@@ -476,6 +902,7 @@ const createCloudflareBundlerChain = (
 
   return chain => {
     applyCloudflareWorkerRspackConfig(chain, entryNames);
+    removeCloudflareWorkerDataLoaderClientTransform(chain);
     chain.output
       .module(true)
       .library({ type: 'module' })
@@ -489,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) {
@@ -595,7 +1033,14 @@ export function getCloudflareBuilderEnvironments({
     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;
   }
@@ -625,6 +1070,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,

package/src/cloudflare-output-contract.ts

@@ -10,29 +10,60 @@ 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',
   'fs/promises',
   'http',
   'http2',
+  'https',
   'inspector',
+  'inspector/promises',
   'module',
   'net',
   'os',
   'path',
+  'path/posix',
+  'path/win32',
+  'perf_hooks',
   'process',
+  'punycode',
+  'querystring',
   'readline',
   'readline/promises',
   'repl',
@@ -42,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/identity.ts

@@ -51,6 +51,10 @@ export const verifyDeliveryUnitIdentity = (
       const marker = stamped.surfaces[surface];
       const expected = declared?.surfaces?.[surface];
 
+      if (!expected && !marker) {
+        continue;
+      }
+
       if (declared?.surfaces && !expected) {
         if (marker) {
           addIssue(issues, {

package/src/cloudflare-output-verifier/index.ts

@@ -174,6 +174,26 @@ export const verifyCloudflareOutput = async (
   }
 
   if (wrangler) {
+    if (
+      typeof wrangler.name !== 'string' ||
+      wrangler.name.trim().length === 0
+    ) {
+      addIssue(issues, {
+        code: 'invalid-wrangler',
+        message: 'wrangler.json name must be a non-empty worker name.',
+        path: wranglerPath,
+      });
+    }
+    if (
+      typeof wrangler.compatibility_date !== 'string' ||
+      !/^\d{4}-\d{2}-\d{2}$/u.test(wrangler.compatibility_date)
+    ) {
+      addIssue(issues, {
+        code: 'invalid-wrangler',
+        message: 'wrangler.json compatibility_date must use YYYY-MM-DD.',
+        path: wranglerPath,
+      });
+    }
     assertEqual(issues, wrangler.main, outputPlan.wrangler.main, {
       code: 'invalid-wrangler',
       message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,