deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -29,7 +29,7 @@ import type {
 } from '../artifact-types';
 import { buildPlayContractCompatibility } from '../contracts';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
-import { MAX_ESM_WORKERS_BUNDLE_BYTES, MAX_PLAY_BUNDLE_BYTES } from './limits';
+import { MAX_PLAY_BUNDLE_BYTES } from './limits';
 
 const PLAY_BUNDLE_CACHE_VERSION = 25;
 const PLAY_ARTIFACT_CACHE_DIR = join(
@@ -48,7 +48,6 @@ const SOURCE_EXTENSIONS = [
   '.cjs',
   '.json',
 ];
-const WORKERS_PLAY_ENTRY_VIRTUAL = 'deepline-play-entry';
 const PLAY_SOURCE_FILE_PATTERN = /\.play\.(?:[cm]?[jt]sx?)$/i;
 const NODE_BUILTIN_SET = new Set(
   builtinModules.flatMap((name) =>
@@ -96,10 +95,6 @@ export type PlayBundlingAdapter = {
   sdkPackageJson: string;
   sdkEntryFile: string;
   sdkTypesEntryFile?: string;
-  sdkWorkersEntryFile: string;
-  workersHarnessEntryFile: string;
-  workersHarnessFilesDir: string;
-  workersRuntimeFingerprintDirs?: string[];
   discoverPackagedLocalFiles(
     filePath: string,
   ): Promise<PlayLocalFileDiscoveryResult>;
@@ -1014,106 +1009,6 @@ function extractDefinedPlayMetadata(
   return null;
 }
 
-function canonicalizeRootPlayNameForWorkersRuntimeHash(
-  sourceCode: string,
-): string {
-  const source = stripCommentsToSpaces(sourceCode);
-  const callPattern =
-    /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
-  const match = callPattern.exec(source);
-  if (!match) return sourceCode;
-
-  const openParen = match.index + match[0].length - 1;
-  const firstArgStart = openParen + 1;
-  const firstNonSpace = source.slice(firstArgStart).search(/\S/);
-  if (firstNonSpace < 0) return sourceCode;
-
-  const argIndex = firstArgStart + firstNonSpace;
-  const quote = source[argIndex];
-  if (quote === '"' || quote === "'") {
-    const literalMatch = source
-      .slice(argIndex)
-      .match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
-    if (!literalMatch) return sourceCode;
-    const replacement = `${quote}__deepline_runtime_play_name__${quote}`;
-    return `${sourceCode.slice(0, argIndex)}${replacement}${sourceCode.slice(argIndex + literalMatch[0].length)}`;
-  }
-
-  if (quote !== '{') return sourceCode;
-  const closeBrace = findMatchingBrace(source, argIndex);
-  if (closeBrace < 0) return sourceCode;
-  const objectSource = source.slice(argIndex + 1, closeBrace);
-  const idMatch = objectSource.match(
-    /(^|[,{\s])((?:id|['"]id['"])\s*:\s*)(['"])([\s\S]*?)\3/,
-  );
-  if (!idMatch || idMatch.index === undefined) return sourceCode;
-  const idValueStart =
-    argIndex +
-    1 +
-    idMatch.index +
-    idMatch[1]!.length +
-    idMatch[2]!.length +
-    idMatch[3]!.length;
-  return `${sourceCode.slice(0, idValueStart)}__deepline_runtime_play_name__${sourceCode.slice(idValueStart + idMatch[4]!.length)}`;
-}
-
-function workersRuntimeGraphFilePath(input: {
-  entryFile: string;
-  filePath: string;
-  adapter: PlayBundlingAdapter;
-}): string {
-  if (input.filePath === input.entryFile) return '<entry>';
-  const entryRelative = relative(dirname(input.entryFile), input.filePath);
-  if (entryRelative && !entryRelative.startsWith('..')) {
-    return entryRelative.replaceAll('\\', '/');
-  }
-  return `<project>/${relative(input.adapter.projectRoot, input.filePath).replaceAll('\\', '/')}`;
-}
-
-function buildWorkersRuntimeGraphHash(input: {
-  analysis: SourceGraphAnalysis;
-  entryFile: string;
-  adapter: PlayBundlingAdapter;
-  exportName: string;
-}): string {
-  const sourceFiles = Object.entries(input.analysis.sourceFiles)
-    .map(([filePath, contents]) => ({
-      filePath: workersRuntimeGraphFilePath({
-        entryFile: input.entryFile,
-        filePath,
-        adapter: input.adapter,
-      }),
-      hash: sha256(
-        filePath === input.entryFile
-          ? canonicalizeRootPlayNameForWorkersRuntimeHash(contents)
-          : contents,
-      ),
-    }))
-    .sort((left, right) => left.filePath.localeCompare(right.filePath));
-
-  return sha256(
-    JSON.stringify({
-      entryFile: '<entry>',
-      entryExport: input.exportName,
-      localFiles: sourceFiles,
-      nodeBuiltins: [...input.analysis.importPolicy.nodeBuiltins].sort(),
-      packages: input.analysis.importPolicy.packages
-        .map(({ name, version }) => ({ name, version }))
-        .sort((left, right) => left.name.localeCompare(right.name)),
-      importedPlayDependencies: input.analysis.importedPlayDependencies
-        .map((dependency) => ({
-          filePath: workersRuntimeGraphFilePath({
-            entryFile: input.entryFile,
-            filePath: dependency.filePath,
-            adapter: input.adapter,
-          }),
-          playName: dependency.playName,
-        }))
-        .sort((left, right) => left.filePath.localeCompare(right.filePath)),
-    }),
-  );
-}
-
 function readPackageVersionFromPackageJson(
   packageJsonPath: string,
   packageName: string,
@@ -1193,13 +1088,8 @@ function findPackageJsonPath(
     : null;
 }
 
-function localSdkAliasPlugin(
-  adapter: PlayBundlingAdapter,
-  options?: { workersRuntime?: boolean },
-): Plugin | null {
-  const entryFile = options?.workersRuntime
-    ? adapter.sdkWorkersEntryFile
-    : adapter.sdkEntryFile;
+function localSdkAliasPlugin(adapter: PlayBundlingAdapter): Plugin | null {
+  const entryFile = adapter.sdkEntryFile;
   if (!existsSync(entryFile)) {
     return null;
   }
@@ -1217,308 +1107,6 @@ function localSdkAliasPlugin(
   };
 }
 
-/**
- * Resolves the virtual `deepline-play-entry` import (used by the Workers
- * harness) to the user's play source file. Lets the harness statically import
- * the play without the bundler needing to know its path ahead of time.
- */
-function workersPlayEntryAliasPlugin(playFilePath: string): Plugin {
-  return {
-    name: 'deepline-workers-play-entry-alias',
-    setup(buildContext) {
-      buildContext.onResolve(
-        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
-        () => ({ path: playFilePath }),
-      );
-    },
-  };
-}
-
-const CUSTOMER_CONSOLE_CAPTURE_GLOBAL = '__deeplineCaptureCustomerConsole';
-
-function sourceLoaderForPath(path: string): 'ts' | 'tsx' | 'js' | 'jsx' {
-  const extension = extname(path).toLowerCase();
-  if (extension === '.tsx') return 'tsx';
-  if (extension === '.jsx') return 'jsx';
-  if (extension === '.js' || extension === '.mjs' || extension === '.cjs') {
-    return 'js';
-  }
-  return 'ts';
-}
-
-/**
- * Give the customer's entry module a lexical console without replacing the
- * Worker's process-wide console. Runtime diagnostics therefore keep flowing
- * to Cloudflare while console.* calls authored in the play join its Run Log
- * Stream. The lazy global lookup is required because ESM dependencies are
- * evaluated before the harness installs the request-scoped capture function.
- */
-function workersCustomerConsolePlugin(
-  customerSourceFilePaths: readonly string[],
-): Plugin {
-  const customerSourceFiles = new Set(
-    customerSourceFilePaths
-      .filter((path) => extname(path).toLowerCase() !== '.json')
-      .map((path) => resolve(path)),
-  );
-  return {
-    name: 'deepline-workers-customer-console',
-    setup(buildContext) {
-      buildContext.onLoad({ filter: /./ }, (args) => {
-        if (!customerSourceFiles.has(resolve(args.path))) return undefined;
-        const source = readFileSync(args.path, 'utf8');
-        const declaresOwnConsole =
-          /(?:^|\n)\s*(?:(?:const|let|var|class|function)\s+console\b|import[^\n]*\bconsole\b)/m.test(
-            source,
-          );
-        if (declaresOwnConsole) {
-          return {
-            contents: source,
-            loader: sourceLoaderForPath(args.path),
-            resolveDir: dirname(args.path),
-          };
-        }
-        const prelude = `
-const console = new Proxy(globalThis.console, {
-  get(target, property) {
-    const capture = globalThis.${CUSTOMER_CONSOLE_CAPTURE_GLOBAL};
-    if (typeof capture === 'function') {
-      return (...args) => capture(String(property), args);
-    }
-    const value = Reflect.get(target, property);
-    return typeof value === 'function' ? value.bind(target) : value;
-  },
-});
-`;
-        return {
-          contents: `${prelude}\n${source}`,
-          loader: sourceLoaderForPath(args.path),
-          resolveDir: dirname(args.path),
-        };
-      });
-    },
-  };
-}
-
-function workersNamedPlayEntryAliasPlugin(
-  playFilePath: string,
-  exportName: string,
-): Plugin {
-  return {
-    name: 'deepline-workers-named-play-entry-alias',
-    setup(buildContext) {
-      buildContext.onResolve(
-        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
-        () => ({
-          path: `${playFilePath}.${exportName}.entry.ts`,
-          namespace: 'deepline-named-play-entry',
-        }),
-      );
-      buildContext.onLoad(
-        { filter: /.*/, namespace: 'deepline-named-play-entry' },
-        () => ({
-          contents: `export { ${exportName} as default } from ${JSON.stringify(playFilePath)};\n`,
-          loader: 'ts',
-          resolveDir: dirname(playFilePath),
-        }),
-      );
-    },
-  };
-}
-
-/**
- * Cloudflare Workers' `nodejs_compat` flag covers most node builtins (path,
- * crypto, buffer, async_hooks, ...) but NOT `node:fs` / `node:fs/promises` /
- * `node:os` (no filesystem, no OS in a V8 isolate). The SDK's config-loading
- * and tool-output utilities reference these even when the play never invokes
- * them — which is the case for plays that don't read CLI config at runtime.
- *
- * This plugin substitutes those specific imports with a tiny stub module that
- * has no top-level side effects and throws clearly if anything actually calls
- * into them. That lets the deploy validation pass while still surfacing a
- * loud error if a play unexpectedly depends on a node-only API.
- */
-function workersNodeBuiltinStubPlugin(): Plugin {
-  // These are the node builtins NOT exposed by Cloudflare's nodejs_compat.
-  // Keep this list narrow — anything supported (path, crypto, etc.) should
-  // pass through as `external: ['node:*']` in the build config.
-  const UNSUPPORTED = new Set([
-    'node:fs',
-    'node:fs/promises',
-    'node:os',
-    'node:child_process',
-  ]);
-  return {
-    name: 'deepline-workers-node-builtin-stub',
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /^node:/ }, (args) => {
-        if (!UNSUPPORTED.has(args.path)) return null;
-        return { path: args.path, namespace: 'deepline-workers-node-stub' };
-      });
-      buildContext.onLoad(
-        { filter: /.*/, namespace: 'deepline-workers-node-stub' },
-        (args) => {
-          const builtinName = args.path;
-          // CommonJS module.exports = Proxy. esbuild's CJS↔ESM interop maps
-          // any named import (e.g. `import { readFileSync } from 'node:fs'`)
-          // to a property access on this Proxy. Property access returns a
-          // function-like Proxy that throws on call. So:
-          //   - import resolves at bundle time (deploy validation passes)
-          //   - import binding evaluates to a no-arg-throw function
-          //   - calling it gives a clear error
-          const stubSource = `
-const message = ${JSON.stringify(
-            `Workers backend: ${builtinName} is not available in Cloudflare Workers ` +
-              '(no filesystem / no OS). Run this play on Daytona or local-process backend ' +
-              'if it needs node builtins.',
-          )};
-function makeThrower(name) {
-  return new Proxy(function() { throw new Error(message + ' (called: ' + name + ')'); }, {
-    get(_t, prop) {
-      if (prop === '__esModule') return true;
-      if (typeof prop === 'symbol') return undefined;
-      return makeThrower(name + '.' + String(prop));
-    },
-    apply() { throw new Error(message + ' (called: ' + name + ')'); },
-    construct() { throw new Error(message + ' (constructed: ' + name + ')'); },
-  });
-}
-module.exports = makeThrower(${JSON.stringify(builtinName)});
-`;
-          return { contents: stubSource, loader: 'js' };
-        },
-      );
-    },
-  };
-}
-
-/**
- * Stub every `zod/v4/locales/<lang>.js` module EXCEPT English with an
- * empty default export so non-English locale strings don't get bundled
- * into per-play Workers.
- *
- * Why this exists:
- *   `zod/v4/core/index.js` does `export * as locales from "../locales/index.js"`
- *   and `zod/v4/locales/index.js` re-exports every individual locale
- *   module (he, ru, ta, th, be, km, ka, uk, hy, bg, ur, ar, mk, fa, ps,
- *   lt, …). esbuild follows the static re-exports and bundles every
- *   locale, ~5–9 KB each. A bundle audit (`scripts/audit-play-bundle.ts`)
- *   on `03-tool-basic.play.ts` showed ~22 of these locale modules
- *   present, totaling ~150–200 KB of dead weight.
- *
- *   Plays only ever surface English error messages to user/CLI. The
- *   non-English locale data is unreachable in our codepath, but
- *   esbuild's tree-shaking can't prove that across `export * as`
- *   re-exports. So we stub each non-English locale at load time with
- *   an empty default export. zod's runtime falls back to its built-in
- *   English messages when a requested locale's data is missing or
- *   empty.
- *
- * What this saves (measured, fresh per-play bundle):
- *   ~150–200 KB → cold V8 compile time drops proportionally
- *   (~50–70 ms on CF edge per cold play).
- *
- * Safety:
- *   - English (`en.js`) is NEVER stubbed — that's the language zod
- *     and our error surfaces actually use.
- *   - The locales/index.js wrapper is left intact; its re-exports
- *     resolve to empty `{}` modules but the import shape stays
- *     stable for any code that does `import { locales } from "zod"`.
- *   - If a future codepath needs a non-English locale, this plugin
- *     would silently swallow the data; that would be a real bug, so
- *     we log a one-time warning at bundle time when a non-English
- *     locale is stubbed (only emitted to stderr in dev to keep CI
- *     output clean).
- */
-function zodNonEnglishLocaleStubPlugin(): Plugin {
-  // Match any zod v4 locale module path EXCEPT en + en variants.
-  // The filter uses a coarse regex; the namespace handler then
-  // double-checks with a precise basename test before stubbing.
-  const LOCALE_PATH_FILTER =
-    /[\\/]zod[\\/]v4[\\/]locales[\\/][^\\/]+\.(?:c?js|mjs)$/;
-  const NAMESPACE = 'deepline-zod-locale-stub';
-  return {
-    name: 'deepline-zod-non-english-locale-stub',
-    setup(buildContext) {
-      buildContext.onResolve({ filter: LOCALE_PATH_FILTER }, (args) => {
-        // Resolve relatively first (esbuild needs an absolute path), then
-        // decide whether to stub. We do this in onResolve so we can check
-        // the filename and let `en` flow through unmodified.
-        const norm = args.path.replace(/\\/g, '/');
-        const file = norm.slice(norm.lastIndexOf('/') + 1);
-        // Allow English variants — `en.js`, `en.cjs`, future `en-US.js`, etc.
-        if (/^en(?:[-_][A-Za-z]+)?\.(?:c?js|mjs)$/.test(file)) {
-          return null;
-        }
-        // Anything else: stub with an empty default export.
-        return { path: args.path, namespace: NAMESPACE };
-      });
-      buildContext.onLoad({ filter: /.*/, namespace: NAMESPACE }, () => ({
-        // zod locales export a default object literal. Empty object is
-        // structurally compatible — accessing any locale key returns
-        // undefined and zod falls back to its built-in English.
-        contents: 'export default {};',
-        loader: 'js',
-      }));
-    },
-  };
-}
-
-/**
- * Hard banlist of `node:*` modules whose presence in a workers_edge bundle
- * would either escape the V8 isolate boundary (filesystem, network sockets,
- * subprocess control) or open up confused-deputy paths (vm/repl/worker
- * threads). These are blocked at bundle time so the per-graphHash CF Worker
- * never sees code that could attempt to call them.
- *
- * `nodejs_compat` covers the supported subset (crypto, stream, buffer, util,
- * path, url, http, https) — those imports continue to pass through and
- * resolve to workerd-shimmed implementations.
- */
-const WORKERS_BANNED_NODE_MODULES = new Set([
-  'node:fs',
-  'node:fs/promises',
-  'node:net',
-  'node:child_process',
-  'node:cluster',
-  'node:tls',
-  'node:dgram',
-  'node:dns',
-  'node:dns/promises',
-  'node:repl',
-  'node:vm',
-  'node:worker_threads',
-]);
-
-function workersNodeImportBanlistPlugin(adapter: PlayBundlingAdapter): Plugin {
-  return {
-    name: 'deepline-workers-node-import-banlist',
-    setup(buildContext) {
-      buildContext.onResolve({ filter: /^node:/ }, (args) => {
-        if (!WORKERS_BANNED_NODE_MODULES.has(args.path)) return null;
-        // SDK internals (sdk/src/*.ts) intentionally reference a small set
-        // of node builtins (e.g. config loaders, tool-output writers) that
-        // never run in the V8 isolate path; they're substituted by the
-        // workersNodeBuiltinStubPlugin's throwing stub. Only reject when
-        // the import comes from outside the SDK source tree -- i.e. user
-        // play code or third-party deps that the play pulls in.
-        const importer = args.importer ?? '';
-        if (importer.startsWith(adapter.sdkSourceRoot)) {
-          return null;
-        }
-        return {
-          errors: [
-            {
-              text: `Module "${args.path}" is not allowed in workers_edge plays. See AGENTS.md for the V8 isolate boundary.`,
-              detail: { importer: args.importer, kind: args.kind },
-            },
-          ],
-        };
-      });
-    },
-  };
-}
-
 function buildImportedPlayProxyModule(playName: string): string {
   const serializedName = JSON.stringify(playName);
   return `
@@ -1842,99 +1430,11 @@ async function analyzeSourceGraph(
   };
 }
 
-/**
- * Fingerprint of Worker runtime sources bundled into every esm_workers play
- * artifact. Harness, shared runtime, or provider-owned batching edits must
- * invalidate the bundle cache and force a fresh CF deploy. Computed fresh on
- * every bundle call so dev edits are picked up on the next `play run` without
- * restarting the dev server. No caching: that's deliberate — caching the
- * fingerprint is exactly the stale-state bug this exists to prevent.
- */
-async function computeWorkersHarnessFingerprintWithAdapter(
-  adapter: PlayBundlingAdapter,
-): Promise<string> {
-  const { readdir } = await import('node:fs/promises');
-  const addFilePart = async (
-    parts: Array<{ name: string; hash: string }>,
-    rootDir: string,
-    filePath: string,
-  ) => {
-    const contents = await readFile(filePath, 'utf-8');
-    parts.push({
-      name: `${basename(rootDir)}:${filePath.slice(rootDir.length + 1)}`,
-      hash: sha256(contents),
-    });
-  };
-  const collectTsFilesRecursive = async (
-    rootDir: string,
-    parts: Array<{ name: string; hash: string }>,
-  ) => {
-    if (!(await fileExists(rootDir))) return;
-    const filePaths: string[] = [];
-    const visitDir = async (dir: string) => {
-      const entries = await readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const childPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await visitDir(childPath);
-          continue;
-        }
-        if (entry.isFile() && /\.[cm]?ts$/.test(entry.name)) {
-          filePaths.push(childPath);
-        }
-      }
-    };
-    await visitDir(rootDir);
-    for (const filePath of filePaths.sort()) {
-      await addFilePart(parts, rootDir, filePath);
-    }
-  };
-  const collectIntegrationBatchingFiles = async (
-    rootDir: string,
-    parts: Array<{ name: string; hash: string }>,
-  ) => {
-    if (!(await fileExists(rootDir))) return;
-    const entries = await readdir(rootDir, { withFileTypes: true });
-    const filePaths: string[] = [];
-    for (const entry of entries) {
-      if (
-        entry.isFile() &&
-        (entry.name === 'play-runtime-batching-registry.ts' ||
-          /^batching.*\.ts$/.test(entry.name))
-      ) {
-        filePaths.push(join(rootDir, entry.name));
-      }
-      if (entry.isDirectory()) {
-        const batchingFile = join(rootDir, entry.name, 'batching.ts');
-        if (await fileExists(batchingFile)) {
-          filePaths.push(batchingFile);
-        }
-      }
-    }
-    for (const filePath of filePaths.sort()) {
-      await addFilePart(parts, rootDir, filePath);
-    }
-  };
-
-  const parts: Array<{ name: string; hash: string }> = [];
-  await collectTsFilesRecursive(adapter.workersHarnessFilesDir, parts);
-  for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
-    if (basename(dir) === 'integrations') {
-      await collectIntegrationBatchingFiles(dir, parts);
-    } else {
-      await collectTsFilesRecursive(dir, parts);
-    }
-  }
-  return sha256(JSON.stringify(parts));
-}
-
 function artifactCachePath(
   graphHash: string,
   artifactKind: PlayArtifactKind,
   adapter: PlayBundlingAdapter,
 ): string {
-  // Cache key includes artifactKind so a play can have both cjs_node20 and
-  // esm_workers builds cached side-by-side without one stomping on the other.
   return join(
     adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR,
     `${graphHash}.${artifactKind}.json`,
@@ -2003,25 +1503,11 @@ function normalizeSourceMapForRuntime(
 export function getBundleSizeErrorForBytes(
   filePath: string,
   bundleBytes: number,
-  artifactKind: PlayArtifactKind,
+  _artifactKind: PlayArtifactKind,
 ): string | null {
   if (bundleBytes > MAX_PLAY_BUNDLE_BYTES) {
     return `${filePath} Play bundle exceeds the 30 MiB limit (${bundleBytes} bytes > ${MAX_PLAY_BUNDLE_BYTES} bytes).`;
   }
-  if (
-    artifactKind === PLAY_ARTIFACT_KINDS.esmWorkers &&
-    bundleBytes > MAX_ESM_WORKERS_BUNDLE_BYTES
-  ) {
-    const mib = (bundleBytes / 1024 / 1024).toFixed(2);
-    const limitMib = (MAX_ESM_WORKERS_BUNDLE_BYTES / 1024 / 1024).toFixed(2);
-    return (
-      `${filePath} Cloudflare Workers bundle is ${mib} MiB, above the workerd ` +
-      `local-mode threshold of ${limitMib} MiB. Bundles past this size silently ` +
-      `hang without executing the workflow body. Reduce dependencies (top ` +
-      `offenders are usually date-fns, lodash, large schema libs) or split the ` +
-      `play into smaller pieces with ctx.runPlay.`
-    );
-  }
   return null;
 }
 
@@ -2038,14 +1524,7 @@ function getBundleSizeError(
 }
 
 export type BundlePlayFileOptions = {
-  /**
-   * Which artifact to produce. Defaults to `cjs_node20` (Daytona / local-process
-   * runner). Pass `esm_workers` to produce a Cloudflare Worker bundle that
-   * combines the play with the Workers harness.
-   *
-   * The CLI selects this from the execution profile or an explicit flag. Each
-   * kind is cached independently on disk.
-   */
+  /** Must be `cjs_node20`; retained as an explicit compile-contract assertion. */
   target?: PlayArtifactKind;
   exportName?: string;
 };
@@ -2057,20 +1536,7 @@ export type BundlePlayFileCoreOptions = BundlePlayFileOptions & {
 type EsbuildBundleOutput = {
   bundledCode: string;
   sourceMapText: string;
-  outputExtension: 'cjs' | 'mjs';
-};
-
-type PlayArtifactTargetAdapter = {
-  artifactKind: PlayArtifactKind;
-  codeFormat: PlayBundleArtifact['codeFormat'];
-  includeWorkersHarnessInGraphHash: boolean;
-  runEsbuild(input: {
-    entryFile: string;
-    customerSourceFilePaths: string[];
-    importedPlayDependencies: ImportedPlayDependency[];
-    adapter: PlayBundlingAdapter;
-    exportName: string;
-  }): Promise<EsbuildBundleOutput | string[]>;
+  outputExtension: 'cjs';
 };
 
 async function runEsbuildForCjsNode(
@@ -2125,141 +1591,6 @@ async function runEsbuildForCjsNode(
   };
 }
 
-async function runEsbuildForEsmWorkers(
-  playEntryFile: string,
-  customerSourceFilePaths: string[],
-  importedPlayDependencies: ImportedPlayDependency[],
-  adapter: PlayBundlingAdapter,
-  exportName: string,
-): Promise<EsbuildBundleOutput | string[]> {
-  const sdkAliasPlugin = localSdkAliasPlugin(adapter, { workersRuntime: true });
-  const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
-  const playEntryAlias =
-    exportName === 'default'
-      ? workersPlayEntryAliasPlugin(playEntryFile)
-      : workersNamedPlayEntryAliasPlugin(playEntryFile, exportName);
-  const customerConsolePlugin = workersCustomerConsolePlugin(
-    customerSourceFilePaths,
-  );
-  const result = await build({
-    // Entry is the Workers harness; it imports the play via the virtual
-    // `deepline-play-entry` alias resolved by workersPlayEntryAliasPlugin.
-    entryPoints: [adapter.workersHarnessEntryFile],
-    absWorkingDir: adapter.projectRoot,
-    bundle: true,
-    format: 'esm',
-    nodePaths: [adapter.nodeModulesDir],
-    // Browser platform with workerd + worker conditions matches Cloudflare's
-    // V8-isolate runtime. Avoids accidentally pulling node-only branches of
-    // dual-publish packages.
-    platform: 'browser',
-    conditions: ['workerd', 'worker', 'browser', 'import', 'default'],
-    mainFields: ['module', 'main'],
-    target: ['es2022'],
-    outfile: 'play-worker.mjs',
-    write: false,
-    sourcemap: 'external',
-    sourcesContent: false,
-    logLevel: 'silent',
-    legalComments: 'none',
-    // Aggressive minify + treeshake: a tiny play (<1KB source) was producing
-    // an ~870KB bundle, dominated by zod's locale files (~260KB unused) and
-    // dead-code branches across `shared_libs/play-runtime/*` and the SDK.
-    // Both DCE on with these flags. workerd compiles each unique-graphHash
-    // bundle on first dispatch, so bundle bytes translate ~linearly into
-    // per-play cold latency on workers_edge. External sourcemap remains
-    // unchanged (`sourcemap: 'external'`), so debugging is unaffected.
-    minify: true,
-    treeShaking: true,
-    // Most node:* builtins are provided by Cloudflare's `nodejs_compat` flag.
-    // The unsupported subset (fs, fs/promises, os, child_process) gets
-    // replaced with throwing stubs by workersNodeBuiltinStubPlugin so deploy
-    // validation passes; anything supported (path, crypto, buffer, etc.) is
-    // marked external and resolved at runtime by the Workers runtime.
-    external: ['node:*', 'cloudflare:workers'],
-    plugins: [
-      // Banlist runs first so a forbidden import errors out before any other
-      // resolver (esp. the workersNodeBuiltinStubPlugin which would silently
-      // turn it into a throwing-stub).
-      workersNodeImportBanlistPlugin(adapter),
-      sdkAliasPlugin,
-      playProxyPlugin,
-      playEntryAlias,
-      customerConsolePlugin,
-      workersNodeBuiltinStubPlugin(),
-      // Strip non-English zod locale data from the bundle. zod's locales
-      // are re-exported as a static namespace from `zod/v4/core`, so
-      // tree-shaking can't drop them; this plugin replaces each
-      // non-English locale module with an empty default export at bundle
-      // time. ~150–200 KB savings on every per-play bundle, with no
-      // behavior change (we only surface English messages anyway).
-      // If the bundle suddenly grows back, check whether a new dep added
-      // its own zod copy or whether zod's locale layout changed.
-      zodNonEnglishLocaleStubPlugin(),
-    ].filter((plugin): plugin is Plugin => plugin != null),
-  });
-  const codeFile = result.outputFiles?.find((f) => f.path.endsWith('.mjs'));
-  const mapFile = result.outputFiles?.find((f) => f.path.endsWith('.mjs.map'));
-  if (!codeFile?.text || !mapFile?.text) {
-    return ['Workers play bundling produced incomplete output.'];
-  }
-  return {
-    bundledCode: codeFile.text,
-    sourceMapText: mapFile.text,
-    outputExtension: 'mjs',
-  };
-}
-
-const PLAY_ARTIFACT_TARGET_ADAPTERS: Record<
-  PlayArtifactKind,
-  PlayArtifactTargetAdapter
-> = {
-  [PLAY_ARTIFACT_KINDS.cjsNode20]: {
-    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    codeFormat: 'cjs_module',
-    includeWorkersHarnessInGraphHash: false,
-    runEsbuild: ({
-      entryFile,
-      customerSourceFilePaths,
-      importedPlayDependencies,
-      adapter,
-      exportName,
-    }) =>
-      runEsbuildForCjsNode(
-        entryFile,
-        customerSourceFilePaths,
-        importedPlayDependencies,
-        adapter,
-        exportName,
-      ),
-  },
-  [PLAY_ARTIFACT_KINDS.esmWorkers]: {
-    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
-    codeFormat: 'esm_module',
-    includeWorkersHarnessInGraphHash: true,
-    runEsbuild: ({
-      entryFile,
-      customerSourceFilePaths,
-      importedPlayDependencies,
-      adapter,
-      exportName,
-    }) =>
-      runEsbuildForEsmWorkers(
-        entryFile,
-        customerSourceFilePaths,
-        importedPlayDependencies,
-        adapter,
-        exportName,
-      ),
-  },
-};
-
-function resolvePlayArtifactTargetAdapter(
-  artifactKind: PlayArtifactKind,
-): PlayArtifactTargetAdapter {
-  return PLAY_ARTIFACT_TARGET_ADAPTERS[artifactKind];
-}
-
 export async function bundlePlayFile(
   filePath: string,
   options: BundlePlayFileCoreOptions,
@@ -2267,7 +1598,6 @@ export async function bundlePlayFile(
   const adapter = options.adapter;
   const target: PlayArtifactKind =
     options.target ?? PLAY_ARTIFACT_KINDS.cjsNode20;
-  const targetAdapter = resolvePlayArtifactTargetAdapter(target);
   const exportName = options.exportName?.trim() || 'default';
   assertValidExportName(exportName);
   const absolutePath = await normalizeLocalPath(filePath);
@@ -2279,29 +1609,9 @@ export async function bundlePlayFile(
       adapter,
       exportName,
     );
-    analysis.graphHash =
-      target === PLAY_ARTIFACT_KINDS.esmWorkers
-        ? buildWorkersRuntimeGraphHash({
-            analysis,
-            entryFile: absolutePath,
-            adapter,
-            exportName,
-          })
-        : sha256(`${analysis.graphHash}\nentry-export:${exportName}`);
-    // For esm_workers builds, the harness source files (entry.ts +
-    // peer DO/coordinator types it imports) are bundled INTO every play
-    // artifact. So any harness edit must produce a different graphHash so
-    // (a) the bundle cache misses, (b) the per-graphHash CF Worker name
-    // changes and gets a fresh deploy. This is the file-watcher-equivalent
-    // for hot-reload of the harness: editing entry.ts → next play run
-    // re-bundles + redeploys automatically.
-    if (targetAdapter.includeWorkersHarnessInGraphHash) {
-      const harnessFingerprint =
-        await computeWorkersHarnessFingerprintWithAdapter(adapter);
-      analysis.graphHash = sha256(
-        `${analysis.graphHash}\nworkers-harness:${harnessFingerprint}`,
-      );
-    }
+    analysis.graphHash = sha256(
+      `${analysis.graphHash}\nentry-export:${exportName}`,
+    );
     try {
       validatePlaySourceFilesHaveNoInlineSecrets(analysis.sourceFiles);
     } catch (error) {
@@ -2334,10 +1644,11 @@ export async function bundlePlayFile(
     // Cache lookup happens after validation because a bundle cache hit is keyed
     // by source and target, while cloud descriptor typecheck results also depend
     // on generated tool metadata.
-    const canUseArtifactCache = target !== PLAY_ARTIFACT_KINDS.esmWorkers;
-    const cachedArtifact = canUseArtifactCache
-      ? await readArtifactCache(analysis.graphHash, target, adapter)
-      : null;
+    const cachedArtifact = await readArtifactCache(
+      analysis.graphHash,
+      target,
+      adapter,
+    );
     const discoveredFiles =
       await adapter.discoverPackagedLocalFiles(absolutePath);
     if (cachedArtifact) {
@@ -2374,13 +1685,13 @@ export async function bundlePlayFile(
       };
     }
 
-    const buildOutcome = await targetAdapter.runEsbuild({
-      entryFile: absolutePath,
-      customerSourceFilePaths: analysis.importPolicy.localFiles,
-      importedPlayDependencies: analysis.importedPlayDependencies,
+    const buildOutcome = await runEsbuildForCjsNode(
+      absolutePath,
+      analysis.importPolicy.localFiles,
+      analysis.importedPlayDependencies,
       adapter,
       exportName,
-    });
+    );
     if (Array.isArray(buildOutcome)) {
       return {
         success: false,
@@ -2414,7 +1725,7 @@ export async function bundlePlayFile(
     }
 
     const artifact: PlayBundleArtifact = {
-      codeFormat: targetAdapter.codeFormat,
+      codeFormat: 'cjs_module',
       artifactKind: target,
       entryFile: absolutePath,
       virtualFilename,
@@ -2430,9 +1741,7 @@ export async function bundlePlayFile(
       cacheHit: false,
     };
 
-    if (canUseArtifactCache) {
-      await writeArtifactCache(artifact, adapter);
-    }
+    await writeArtifactCache(artifact, adapter);
 
     return {
       success: true,