deepline 0.1.119 → 0.1.121

package/dist/plays/bundle-play-file.mjs

@@ -0,0 +1,1830 @@
+// src/plays/bundle-play-file.ts
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+
+// ../shared_libs/plays/bundling/index.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  relative,
+  resolve
+} from "path";
+import { builtinModules } from "module";
+import { build } from "esbuild";
+
+// ../shared_libs/play-runtime/backend.ts
+var PLAY_RUNTIME_BACKENDS = {
+  localProcess: "local_process",
+  daytona: "daytona",
+  // Artifact/runtime contract for Cloudflare Dynamic Workers. This is no
+  // longer a standalone runner backend; use profile=workers_edge so the
+  // cf-workflows scheduler owns loading and execution.
+  cloudflareWorkers: "cloudflare_workers"
+};
+var PLAY_ARTIFACT_KINDS = {
+  cjsNode20: "cjs_node20",
+  esmWorkers: "esm_workers"
+};
+var PLAY_BACKEND_DESCRIPTORS = {
+  [PLAY_RUNTIME_BACKENDS.localProcess]: {
+    id: PLAY_RUNTIME_BACKENDS.localProcess,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Local node subprocess"
+  },
+  [PLAY_RUNTIME_BACKENDS.daytona]: {
+    id: PLAY_RUNTIME_BACKENDS.daytona,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Daytona sandbox"
+  },
+  [PLAY_RUNTIME_BACKENDS.cloudflareWorkers]: {
+    id: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
+    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
+    label: "Cloudflare Dynamic Workers"
+  }
+};
+
+// ../shared_libs/plays/contracts.ts
+var PLAY_PUBLIC_API_VERSION = 1;
+var PLAY_ARTIFACT_VERSION = 1;
+var PLAY_MIN_RUNNER_VERSION = 1;
+var PLAY_RUNTIME_FEATURES = [
+  "artifact_storage",
+  "checkpoint_resume",
+  "durable_sleep",
+  "packaged_files"
+];
+function buildPlayContractCompatibility(input) {
+  return {
+    apiVersion: PLAY_PUBLIC_API_VERSION,
+    artifactVersion: PLAY_ARTIFACT_VERSION,
+    minRunnerVersion: PLAY_MIN_RUNNER_VERSION,
+    runtimeFeatures: [...PLAY_RUNTIME_FEATURES],
+    runtimeBackend: input?.runtimeBackend ?? null
+  };
+}
+
+// ../shared_libs/plays/secret-guardrails.ts
+var SECRET_ENV_PATTERN = /\bprocess(?:\.env|\[['"]env['"]\])(?:\.|\[['"])([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PRIVATE[_-]?KEY|ACCESS[_-]?KEY)[A-Z0-9_]*)(?:['"]\])?/g;
+var PRIVATE_KEY_PATTERN = /-----BEGIN (?:RSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/;
+var BEARER_LITERAL_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/i;
+var ASSIGNMENT_SECRET_LITERAL_PATTERN = /\b(?:api[_-]?key|token|secret|password)\b\s*[:=]\s*['"][^'"]{12,}['"]/i;
+var HIGH_ENTROPY_LITERAL_PATTERN = /['"]([A-Za-z0-9+/=_-]{32,})['"]/g;
+function shannonEntropy(value) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
+  return [...counts.values()].reduce((entropy, count) => {
+    const p = count / value.length;
+    return entropy - p * Math.log2(p);
+  }, 0);
+}
+function collectInlineSecretFindings(sourceCode) {
+  const findings = [];
+  for (const match of sourceCode.matchAll(SECRET_ENV_PATTERN)) {
+    findings.push(`process.env.${match[1]}`);
+  }
+  if (PRIVATE_KEY_PATTERN.test(sourceCode)) findings.push("private key block");
+  if (BEARER_LITERAL_PATTERN.test(sourceCode))
+    findings.push("bearer token literal");
+  if (ASSIGNMENT_SECRET_LITERAL_PATTERN.test(sourceCode)) {
+    findings.push("secret-looking assignment literal");
+  }
+  for (const match of sourceCode.matchAll(HIGH_ENTROPY_LITERAL_PATTERN)) {
+    const literal = match[1] ?? "";
+    if (literal.length >= 40 && shannonEntropy(literal) >= 4.2) {
+      findings.push("high-entropy string literal");
+      break;
+    }
+  }
+  return [...new Set(findings)];
+}
+function validatePlaySourceHasNoInlineSecrets(input) {
+  const findings = collectInlineSecretFindings(input.sourceCode);
+  if (!findings.length) return;
+  throw new Error(
+    [
+      `Play source ${input.filePath} appears to contain inline secret material: ${[
+        ...new Set(findings)
+      ].join(", ")}.`,
+      'Author secrets in the dashboard and use ctx.secrets.get("NAME") with an approved helper such as ctx.secrets.bearer(handle).'
+    ].join(" ")
+  );
+}
+function validatePlaySourceFilesHaveNoInlineSecrets(sourceFiles) {
+  for (const [filePath, sourceCode] of Object.entries(sourceFiles)) {
+    validatePlaySourceHasNoInlineSecrets({ filePath, sourceCode });
+  }
+}
+
+// ../shared_libs/plays/bundling/limits.ts
+var MAX_PLAY_BUNDLE_BYTES = 30 * 1024 * 1024;
+var MAX_ESM_WORKERS_BUNDLE_BYTES = 115e4;
+
+// ../shared_libs/plays/bundling/index.ts
+var PLAY_BUNDLE_CACHE_VERSION = 24;
+var PLAY_ARTIFACT_CACHE_DIR = join(
+  tmpdir(),
+  `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION}`
+);
+var PLAY_PROXY_NAMESPACE = "deepline-play-runtime-ref";
+var SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+var WORKERS_PLAY_ENTRY_VIRTUAL = "deepline-play-entry";
+var PLAY_SOURCE_FILE_PATTERN = /\.play\.(?:[cm]?[jt]sx?)$/i;
+var NODE_BUILTIN_SET = new Set(
+  builtinModules.flatMap(
+    (name) => name.startsWith("node:") ? [name, name.slice(5)] : [name, `node:${name}`]
+  )
+);
+function assertValidExportName(exportName) {
+  if (exportName === "default") return;
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
+    throw new Error(
+      `Invalid play export name "${exportName}". Named prebuilt exports must be valid JavaScript identifiers.`
+    );
+  }
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function formatEsbuildMessage(message) {
+  const location = message.location ? `${message.location.file}:${message.location.line}:${message.location.column}` : null;
+  return location ? `${location} ${message.text}` : message.text;
+}
+function isLocalSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("file:");
+}
+async function normalizeLocalPath(filePath) {
+  try {
+    return await realpath(filePath);
+  } catch {
+    return resolve(filePath);
+  }
+}
+function createPlayWorkspace(entryFile) {
+  return {
+    entryFile,
+    rootDir: dirname(entryFile)
+  };
+}
+function isPathInsideDirectory(filePath, directory) {
+  return filePath === directory || filePath.startsWith(`${directory}/`);
+}
+function assertWithinPlayWorkspace(input) {
+  if (isPathInsideDirectory(input.resolvedPath, input.workspace.rootDir)) {
+    return;
+  }
+  throw new Error(
+    `${input.importer}:${input.line}:${input.column} Local play imports must stay inside the play workspace (${input.workspace.rootDir}). Import "${input.specifier}" resolved to ${input.resolvedPath}, which crosses into app/backend code. Use the public SDK/API surface or move shared helpers into the play workspace.`
+  );
+}
+function getPackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const [scope, name] = specifier.split("/");
+    return scope && name ? `${scope}/${name}` : specifier;
+  }
+  return specifier.split("/")[0] ?? specifier;
+}
+function isPlaySourceFile(filePath) {
+  return PLAY_SOURCE_FILE_PATTERN.test(filePath);
+}
+function stripCommentsToSpaces(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
+    /(^|[^:])\/\/.*$/gm,
+    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+  );
+}
+function lineAndColumnAt(source, index) {
+  const prefix = source.slice(0, index);
+  const lines = prefix.split("\n");
+  return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+}
+function findSourceImportReferences(sourceCode) {
+  const source = stripCommentsToSpaces(sourceCode);
+  const references = [];
+  const addReference = (specifier, specifierIndex, kind) => {
+    if (!specifier) return;
+    const position = lineAndColumnAt(sourceCode, specifierIndex);
+    references.push({
+      specifier,
+      line: position.line,
+      column: position.column,
+      kind
+    });
+  };
+  const staticImportPattern = /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(staticImportPattern)) {
+    addReference(
+      match[2],
+      match.index + match[0].lastIndexOf(match[1]),
+      "static"
+    );
+  }
+  const dynamicImportPattern = /\bimport\s*\(\s*(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(dynamicImportPattern)) {
+    addReference(
+      match[2],
+      match.index + match[0].lastIndexOf(match[1]),
+      "dynamic-import"
+    );
+  }
+  const requirePattern = /\brequire\s*\(\s*(['"])([^'"\n]+)\1/g;
+  for (const match of source.matchAll(requirePattern)) {
+    addReference(
+      match[2],
+      match.index + match[0].lastIndexOf(match[1]),
+      "require"
+    );
+  }
+  const literalDynamicImportIndexes = new Set(
+    [...source.matchAll(dynamicImportPattern)].map((match) => match.index)
+  );
+  for (const match of source.matchAll(/\bimport\s*\(/g)) {
+    if (literalDynamicImportIndexes.has(match.index)) continue;
+    const position = lineAndColumnAt(sourceCode, match.index);
+    throw new Error(
+      `:${position.line}:${position.column} Dynamic import() is not allowed in plays. Use static imports instead.`
+    );
+  }
+  const literalRequireIndexes = new Set(
+    [...source.matchAll(requirePattern)].map((match) => match.index)
+  );
+  for (const match of source.matchAll(/\brequire\s*\(/g)) {
+    if (literalRequireIndexes.has(match.index)) continue;
+    const position = lineAndColumnAt(sourceCode, match.index);
+    throw new Error(
+      `:${position.line}:${position.column} Dynamic require() is not allowed in plays. Use static imports or require("literal") only.`
+    );
+  }
+  return references.sort(
+    (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
+  );
+}
+function unquoteStringLiteral(literal) {
+  const trimmed = literal.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
+    );
+  } catch {
+    return trimmed.slice(1, -1);
+  }
+}
+function findMatchingBrace(source, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function extractDefinedPlayName(sourceCode) {
+  const source = stripCommentsToSpaces(sourceCode);
+  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
+  for (const match of source.matchAll(callPattern)) {
+    const openParen = match.index + match[0].length - 1;
+    const firstArgStart = openParen + 1;
+    const firstNonSpace = source.slice(firstArgStart).search(/\S/);
+    if (firstNonSpace < 0) continue;
+    const argIndex = firstArgStart + firstNonSpace;
+    const quote = source[argIndex];
+    if (quote === '"' || quote === "'") {
+      const literalMatch = source.slice(argIndex).match(/^(['"])(?:\\.|(?!\1)[\s\S])*\1/);
+      const value = literalMatch ? unquoteStringLiteral(literalMatch[0]) : null;
+      if (value?.trim()) return value.trim();
+    }
+    if (quote === "{") {
+      const closeBrace = findMatchingBrace(source, argIndex);
+      if (closeBrace < 0) continue;
+      const objectSource = source.slice(argIndex + 1, closeBrace);
+      const idMatch = objectSource.match(
+        /(?:^|[,{\s])(?:id|['"]id['"])\s*:\s*(['"])([\s\S]*?)\1/
+      );
+      if (idMatch?.[2]?.trim()) {
+        return idMatch[2].trim();
+      }
+    }
+  }
+  return null;
+}
+function canonicalizeRootPlayNameForWorkersRuntimeHash(sourceCode) {
+  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 === void 0) 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) {
+  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) {
+  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, packageName) {
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.name === packageName && typeof packageJson.version === "string") {
+      return packageJson.version;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function findPackageJsonPathFrom(startDir, packageName) {
+  if (!isAbsolute(startDir)) {
+    throw new Error(
+      `Package resolution requires an absolute start directory, got ${startDir}`
+    );
+  }
+  let current = startDir;
+  while (true) {
+    const packageJsonPath = join(
+      current,
+      "node_modules",
+      packageName,
+      "package.json"
+    );
+    if (existsSync(packageJsonPath)) {
+      return packageJsonPath;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function findPackageJsonPath(packageName, fromFile, adapter) {
+  const startDirs = [
+    resolve(dirname(fromFile)),
+    resolve(adapter.projectRoot),
+    resolve(dirname(adapter.sdkPackageJson))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const startDir of startDirs) {
+    if (seen.has(startDir)) continue;
+    seen.add(startDir);
+    const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
+    if (packageJsonPath) return packageJsonPath;
+  }
+  const adapterNodeModulesPackageJson = join(
+    adapter.nodeModulesDir,
+    packageName,
+    "package.json"
+  );
+  return existsSync(adapterNodeModulesPackageJson) ? adapterNodeModulesPackageJson : null;
+}
+function localSdkAliasPlugin(adapter, options) {
+  const entryFile = options?.workersRuntime ? adapter.sdkWorkersEntryFile : adapter.sdkEntryFile;
+  if (!existsSync(entryFile)) {
+    return null;
+  }
+  return {
+    name: "deepline-sdk-local-alias",
+    setup(buildContext) {
+      buildContext.onResolve({ filter: /^deepline$/ }, () => ({
+        path: entryFile
+      }));
+      buildContext.onResolve({ filter: /^deepline\/helpers$/ }, () => ({
+        path: join(adapter.sdkSourceRoot, "helpers.ts")
+      }));
+    }
+  };
+}
+function workersPlayEntryAliasPlugin(playFilePath) {
+  return {
+    name: "deepline-workers-play-entry-alias",
+    setup(buildContext) {
+      buildContext.onResolve(
+        { filter: new RegExp(`^${WORKERS_PLAY_ENTRY_VIRTUAL}$`) },
+        () => ({ path: playFilePath })
+      );
+    }
+  };
+}
+function workersNamedPlayEntryAliasPlugin(playFilePath, exportName) {
+  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)};
+`,
+          loader: "ts",
+          resolveDir: dirname(playFilePath)
+        })
+      );
+    }
+  };
+}
+function workersNodeBuiltinStubPlugin() {
+  const UNSUPPORTED = /* @__PURE__ */ 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;
+          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" };
+        }
+      );
+    }
+  };
+}
+function zodNonEnglishLocaleStubPlugin() {
+  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) => {
+        const norm = args.path.replace(/\\/g, "/");
+        const file = norm.slice(norm.lastIndexOf("/") + 1);
+        if (/^en(?:[-_][A-Za-z]+)?\.(?:c?js|mjs)$/.test(file)) {
+          return null;
+        }
+        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"
+      }));
+    }
+  };
+}
+var WORKERS_BANNED_NODE_MODULES = /* @__PURE__ */ 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) {
+  return {
+    name: "deepline-workers-node-import-banlist",
+    setup(buildContext) {
+      buildContext.onResolve({ filter: /^node:/ }, (args) => {
+        if (!WORKERS_BANNED_NODE_MODULES.has(args.path)) return null;
+        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) {
+  const serializedName = JSON.stringify(playName);
+  return `
+const PLAY_METADATA_SYMBOL = Symbol.for('deepline.play.metadata');
+const importedPlayRef = async function importedPlayRef(ctx, input) {
+  return ctx.runPlay(${JSON.stringify(`imported_${playName.replace(/[^A-Za-z0-9_]+/g, "_")}`)}, importedPlayRef, input, {
+    description: 'Run the imported Deepline play dependency.',
+  });
+};
+Object.defineProperty(importedPlayRef, 'playName', {
+  value: ${serializedName},
+  enumerable: true,
+  configurable: false,
+  writable: false,
+});
+Object.defineProperty(importedPlayRef, PLAY_METADATA_SYMBOL, {
+  value: { name: ${serializedName} },
+  enumerable: false,
+  configurable: false,
+  writable: false,
+});
+export const playName = ${serializedName};
+export const name = ${serializedName};
+export default importedPlayRef;
+`;
+}
+function importedPlayProxyPlugin(importedPlayDependencies) {
+  if (importedPlayDependencies.length === 0) {
+    return null;
+  }
+  const dependenciesByPath = new Map(
+    importedPlayDependencies.map((dependency) => [
+      dependency.filePath,
+      dependency
+    ])
+  );
+  return {
+    name: "deepline-imported-play-proxy",
+    setup(buildContext) {
+      buildContext.onResolve({ filter: /.*/ }, async (args) => {
+        if (!args.importer || !isLocalSpecifier(args.path)) {
+          return null;
+        }
+        const resolvedPath = await resolveLocalImport(args.importer, args.path);
+        const dependency = dependenciesByPath.get(resolvedPath);
+        if (!dependency) {
+          return null;
+        }
+        return {
+          path: dependency.filePath,
+          namespace: PLAY_PROXY_NAMESPACE,
+          pluginData: dependency
+        };
+      });
+      buildContext.onLoad(
+        { filter: /.*/, namespace: PLAY_PROXY_NAMESPACE },
+        async (args) => {
+          const dependency = args.pluginData ?? dependenciesByPath.get(args.path);
+          if (!dependency) {
+            return null;
+          }
+          return {
+            contents: buildImportedPlayProxyModule(dependency.playName),
+            loader: "ts",
+            resolveDir: dirname(args.path)
+          };
+        }
+      );
+    }
+  };
+}
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveLocalImport(fromFile, specifier) {
+  if (specifier.startsWith("file:")) {
+    return normalizeLocalPath(new URL(specifier).pathname);
+  }
+  const base = isAbsolute(specifier) ? resolve(specifier) : resolve(dirname(fromFile), specifier);
+  const candidates = [base];
+  const explicitExtension = extname(base).toLowerCase();
+  if (!explicitExtension) {
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
+    );
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => join(base, `index${extension}`))
+    );
+  } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
+    const stem = base.slice(0, -explicitExtension.length);
+    candidates.push(
+      ...SOURCE_EXTENSIONS.map((extension) => `${stem}${extension}`)
+    );
+  }
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) {
+      return normalizeLocalPath(candidate);
+    }
+  }
+  throw new Error(
+    `Could not resolve local import "${specifier}" from ${fromFile}`
+  );
+}
+function resolvePackageImport(specifier, fromFile, adapter) {
+  const packageName = getPackageName(specifier);
+  if (packageName === "deepline" && existsSync(adapter.sdkPackageJson)) {
+    const packageJson = JSON.parse(
+      readFileSync(adapter.sdkPackageJson, "utf-8")
+    );
+    return {
+      name: "deepline",
+      version: packageJson.version ?? null
+    };
+  }
+  const packageJsonPath = findPackageJsonPath(packageName, fromFile, adapter);
+  if (!packageJsonPath) {
+    throw new Error(`Could not resolve "${specifier}" from ${fromFile}`);
+  }
+  return {
+    name: packageName,
+    version: readPackageVersionFromPackageJson(packageJsonPath, packageName)
+  };
+}
+async function analyzeSourceGraph(entryFile, adapter) {
+  const absoluteEntryFile = await normalizeLocalPath(entryFile);
+  const workspace = createPlayWorkspace(absoluteEntryFile);
+  const localFiles = /* @__PURE__ */ new Map();
+  const nodeBuiltins = /* @__PURE__ */ new Set();
+  const packages = /* @__PURE__ */ new Map();
+  const importedPlayDependencies = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const visitFile = async (filePath) => {
+    const absolutePath = await normalizeLocalPath(filePath);
+    if (visited.has(absolutePath)) {
+      return;
+    }
+    visited.add(absolutePath);
+    const sourceCode2 = await readFile(absolutePath, "utf-8");
+    localFiles.set(absolutePath, sourceCode2);
+    if (extname(absolutePath).toLowerCase() === ".json") {
+      return;
+    }
+    const handleSpecifier = async (specifier, line, column, kind) => {
+      if (kind === "dynamic-import") {
+        throw new Error(
+          `${absolutePath}:${line}:${column} Dynamic import() is not allowed in plays. Use static imports instead.`
+        );
+      }
+      if (NODE_BUILTIN_SET.has(specifier)) {
+        nodeBuiltins.add(
+          specifier.startsWith("node:") ? specifier : `node:${specifier}`
+        );
+        return;
+      }
+      if (isLocalSpecifier(specifier)) {
+        const resolved = await resolveLocalImport(absolutePath, specifier);
+        assertWithinPlayWorkspace({
+          importer: absolutePath,
+          specifier,
+          resolvedPath: resolved,
+          workspace,
+          line,
+          column
+        });
+        if (resolved !== absoluteEntryFile && isPlaySourceFile(resolved)) {
+          const importedSource = await readFile(resolved, "utf-8");
+          const importedPlayName = extractDefinedPlayName(importedSource);
+          if (!importedPlayName) {
+            throw new Error(
+              `${absolutePath}:${line}:${column} Imported play file "${specifier}" must export definePlay(...) so it can be runtime-composed.`
+            );
+          }
+          importedPlayDependencies.set(resolved, {
+            filePath: resolved,
+            playName: importedPlayName
+          });
+          return;
+        }
+        await visitFile(resolved);
+        return;
+      }
+      if (specifier.includes(":")) {
+        throw new Error(
+          `${absolutePath}:${line}:${column} Unsupported import specifier "${specifier}". Allowed imports are relative files, Node builtins, and installed packages.`
+        );
+      }
+      const packageImport = resolvePackageImport(
+        specifier,
+        absolutePath,
+        adapter
+      );
+      packages.set(packageImport.name, packageImport.version);
+    };
+    try {
+      for (const reference of findSourceImportReferences(sourceCode2)) {
+        await handleSpecifier(
+          reference.specifier,
+          reference.line,
+          reference.column,
+          reference.kind
+        );
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith(":")) {
+        throw new Error(`${absolutePath}${error.message}`);
+      }
+      throw error;
+    }
+  };
+  await visitFile(absoluteEntryFile);
+  const sourceCode = localFiles.get(absoluteEntryFile) ?? "";
+  const sourceHash = sha256(sourceCode);
+  const graphHash = sha256(
+    JSON.stringify({
+      entryFile: absoluteEntryFile,
+      localFiles: [...localFiles.entries()].map(([filePath, contents]) => ({ filePath, hash: sha256(contents) })).sort((left, right) => left.filePath.localeCompare(right.filePath)),
+      nodeBuiltins: [...nodeBuiltins].sort(),
+      packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name)),
+      importedPlayDependencies: [...importedPlayDependencies.values()].map((dependency) => ({
+        filePath: dependency.filePath,
+        playName: dependency.playName
+      })).sort((left, right) => left.filePath.localeCompare(right.filePath))
+    })
+  );
+  const playName = extractDefinedPlayName(sourceCode);
+  return {
+    sourceCode,
+    sourceFiles: Object.fromEntries(
+      [...localFiles.entries()].sort(
+        (left, right) => left[0].localeCompare(right[0])
+      )
+    ),
+    sourceHash,
+    graphHash,
+    importPolicy: {
+      localFiles: [...localFiles.keys()].sort(),
+      nodeBuiltins: [...nodeBuiltins].sort(),
+      packages: [...packages.entries()].map(([name, version]) => ({ name, version })).sort((left, right) => left.name.localeCompare(right.name))
+    },
+    playName,
+    importedPlayDependencies: [...importedPlayDependencies.values()].sort(
+      (left, right) => left.filePath.localeCompare(right.filePath)
+    )
+  };
+}
+async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
+  const { readdir } = await import("fs/promises");
+  const addFilePart = async (parts2, rootDir, filePath) => {
+    const contents = await readFile(filePath, "utf-8");
+    parts2.push({
+      name: `${basename(rootDir)}:${filePath.slice(rootDir.length + 1)}`,
+      hash: sha256(contents)
+    });
+  };
+  const collectTopLevelTsFiles = async (rootDir, parts2) => {
+    if (!await fileExists(rootDir)) return;
+    const entries2 = await readdir(rootDir, { withFileTypes: true });
+    const tsFiles2 = entries2.filter((entry) => entry.isFile() && /\.[cm]?ts$/.test(entry.name)).map((entry) => entry.name).sort();
+    for (const name of tsFiles2) {
+      await addFilePart(parts2, rootDir, join(rootDir, name));
+    }
+  };
+  const collectIntegrationBatchingFiles = async (rootDir, parts2) => {
+    if (!await fileExists(rootDir)) return;
+    const entries2 = await readdir(rootDir, { withFileTypes: true });
+    const filePaths = [];
+    for (const entry of entries2) {
+      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(parts2, rootDir, filePath);
+    }
+  };
+  const entries = await readdir(adapter.workersHarnessFilesDir, {
+    withFileTypes: true
+  });
+  const tsFiles = entries.filter((e) => e.isFile() && /\.[cm]?ts$/.test(e.name)).map((e) => e.name).sort();
+  const parts = [];
+  for (const name of tsFiles) {
+    await addFilePart(
+      parts,
+      adapter.workersHarnessFilesDir,
+      join(adapter.workersHarnessFilesDir, name)
+    );
+  }
+  for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
+    if (basename(dir) === "integrations") {
+      await collectIntegrationBatchingFiles(dir, parts);
+    } else {
+      await collectTopLevelTsFiles(dir, parts);
+    }
+  }
+  return sha256(JSON.stringify(parts));
+}
+function artifactCachePath(graphHash, artifactKind, adapter) {
+  return join(
+    adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR,
+    `${graphHash}.${artifactKind}.json`
+  );
+}
+async function readArtifactCache(graphHash, artifactKind, adapter) {
+  try {
+    const serialized = await readFile(
+      artifactCachePath(graphHash, artifactKind, adapter),
+      "utf-8"
+    );
+    return JSON.parse(serialized);
+  } catch {
+    return null;
+  }
+}
+async function writeArtifactCache(artifact, adapter) {
+  const cacheDir = adapter.cacheDir ?? PLAY_ARTIFACT_CACHE_DIR;
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    artifactCachePath(
+      artifact.graphHash,
+      artifact.artifactKind ?? PLAY_ARTIFACT_KINDS.cjsNode20,
+      adapter
+    ),
+    JSON.stringify(artifact),
+    "utf-8"
+  );
+}
+function normalizeSourceMapForRuntime(sourceMapText, projectRoot) {
+  const parsed = JSON.parse(sourceMapText);
+  parsed.sources = (parsed.sources ?? []).map((sourcePath) => {
+    if (sourcePath.startsWith("data:") || sourcePath.startsWith("node:") || sourcePath.startsWith("/") || /^[a-zA-Z]+:\/\//.test(sourcePath)) {
+      return sourcePath;
+    }
+    return join(projectRoot, sourcePath);
+  });
+  parsed.sourceRoot = void 0;
+  return JSON.stringify(parsed);
+}
+function getBundleSizeErrorForBytes(filePath, bundleBytes, artifactKind) {
+  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;
+}
+function getBundleSizeError(filePath, bundledCode, artifactKind) {
+  return getBundleSizeErrorForBytes(
+    filePath,
+    Buffer.byteLength(bundledCode, "utf8"),
+    artifactKind
+  );
+}
+async function runEsbuildForCjsNode(entryFile, importedPlayDependencies, adapter, exportName) {
+  const sdkAliasPlugin = localSdkAliasPlugin(adapter);
+  const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
+  const namedExportShim = exportName === "default" ? null : `export { ${exportName} as default } from ${JSON.stringify(entryFile)};
+`;
+  const result = await build({
+    ...namedExportShim ? {
+      stdin: {
+        contents: namedExportShim,
+        resolveDir: dirname(entryFile),
+        sourcefile: `${basename(entryFile)}.${exportName}.entry.ts`,
+        loader: "ts"
+      }
+    } : { entryPoints: [entryFile] },
+    absWorkingDir: adapter.projectRoot,
+    bundle: true,
+    format: "cjs",
+    nodePaths: [adapter.nodeModulesDir],
+    platform: "node",
+    target: ["node20"],
+    outfile: "play-artifact.cjs",
+    write: false,
+    sourcemap: "external",
+    sourcesContent: false,
+    logLevel: "silent",
+    legalComments: "none",
+    plugins: [sdkAliasPlugin, playProxyPlugin].filter(
+      (plugin) => plugin != null
+    )
+  });
+  const codeFile = result.outputFiles?.find((f) => f.path.endsWith(".cjs"));
+  const mapFile = result.outputFiles?.find((f) => f.path.endsWith(".cjs.map"));
+  if (!codeFile?.text || !mapFile?.text) {
+    return ["Play bundling produced incomplete output."];
+  }
+  return {
+    bundledCode: codeFile.text,
+    sourceMapText: mapFile.text,
+    outputExtension: "cjs"
+  };
+}
+async function runEsbuildForEsmWorkers(playEntryFile, importedPlayDependencies, adapter, exportName) {
+  const sdkAliasPlugin = localSdkAliasPlugin(adapter, { workersRuntime: true });
+  const playProxyPlugin = importedPlayProxyPlugin(importedPlayDependencies);
+  const playEntryAlias = exportName === "default" ? workersPlayEntryAliasPlugin(playEntryFile) : workersNamedPlayEntryAliasPlugin(playEntryFile, exportName);
+  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,
+      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 != 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"
+  };
+}
+var PLAY_ARTIFACT_TARGET_ADAPTERS = {
+  [PLAY_ARTIFACT_KINDS.cjsNode20]: {
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    codeFormat: "cjs_module",
+    includeWorkersHarnessInGraphHash: false,
+    runEsbuild: ({
+      entryFile,
+      importedPlayDependencies,
+      adapter,
+      exportName
+    }) => runEsbuildForCjsNode(
+      entryFile,
+      importedPlayDependencies,
+      adapter,
+      exportName
+    )
+  },
+  [PLAY_ARTIFACT_KINDS.esmWorkers]: {
+    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
+    codeFormat: "esm_module",
+    includeWorkersHarnessInGraphHash: true,
+    runEsbuild: ({
+      entryFile,
+      importedPlayDependencies,
+      adapter,
+      exportName
+    }) => runEsbuildForEsmWorkers(
+      entryFile,
+      importedPlayDependencies,
+      adapter,
+      exportName
+    )
+  }
+};
+function resolvePlayArtifactTargetAdapter(artifactKind) {
+  return PLAY_ARTIFACT_TARGET_ADAPTERS[artifactKind];
+}
+async function bundlePlayFile(filePath, options) {
+  const adapter = options.adapter;
+  const target = options.target ?? PLAY_ARTIFACT_KINDS.cjsNode20;
+  const targetAdapter = resolvePlayArtifactTargetAdapter(target);
+  const exportName = options.exportName?.trim() || "default";
+  assertValidExportName(exportName);
+  const absolutePath = await normalizeLocalPath(filePath);
+  adapter.warnAboutNonDevelopmentBundling?.(absolutePath);
+  try {
+    const analysis = await analyzeSourceGraph(absolutePath, adapter);
+    analysis.graphHash = target === PLAY_ARTIFACT_KINDS.esmWorkers ? buildWorkersRuntimeGraphHash({
+      analysis,
+      entryFile: absolutePath,
+      adapter,
+      exportName
+    }) : sha256(`${analysis.graphHash}
+entry-export:${exportName}`);
+    if (targetAdapter.includeWorkersHarnessInGraphHash) {
+      const harnessFingerprint = await computeWorkersHarnessFingerprintWithAdapter(adapter);
+      analysis.graphHash = sha256(
+        `${analysis.graphHash}
+workers-harness:${harnessFingerprint}`
+      );
+    }
+    try {
+      validatePlaySourceFilesHaveNoInlineSecrets(analysis.sourceFiles);
+    } catch (error) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+    const typecheckErrors = [
+      ...await adapter.typecheckPlaySource?.({
+        sourceCode: analysis.sourceCode,
+        sourcePath: absolutePath,
+        importedFilePaths: [
+          ...analysis.importPolicy.localFiles,
+          ...analysis.importedPlayDependencies.map(
+            (dependency) => dependency.filePath
+          )
+        ]
+      }) ?? []
+    ];
+    if (typecheckErrors.length > 0) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: typecheckErrors
+      };
+    }
+    const canUseArtifactCache = target !== PLAY_ARTIFACT_KINDS.esmWorkers;
+    const cachedArtifact = canUseArtifactCache ? await readArtifactCache(analysis.graphHash, target, adapter) : null;
+    const discoveredFiles = await adapter.discoverPackagedLocalFiles(absolutePath);
+    if (cachedArtifact) {
+      const cachedArtifactSizeError = getBundleSizeError(
+        absolutePath,
+        cachedArtifact.bundledCode,
+        target
+      );
+      if (cachedArtifactSizeError) {
+        return {
+          success: false,
+          filePath: absolutePath,
+          errors: [cachedArtifactSizeError]
+        };
+      }
+      return {
+        success: true,
+        artifact: {
+          ...cachedArtifact,
+          entryFile: absolutePath,
+          sourceHash: analysis.sourceHash,
+          importPolicy: analysis.importPolicy,
+          cacheHit: true
+        },
+        sourceCode: analysis.sourceCode,
+        sourceFiles: analysis.sourceFiles,
+        filePath: absolutePath,
+        playName: analysis.playName,
+        packagedFiles: discoveredFiles.files,
+        unresolvedFileReferences: discoveredFiles.unresolved,
+        importedPlayDependencies: analysis.importedPlayDependencies
+      };
+    }
+    const buildOutcome = await targetAdapter.runEsbuild({
+      entryFile: absolutePath,
+      importedPlayDependencies: analysis.importedPlayDependencies,
+      adapter,
+      exportName
+    });
+    if (Array.isArray(buildOutcome)) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: buildOutcome
+      };
+    }
+    const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
+    const normalizedSourceMap = normalizeSourceMapForRuntime(
+      sourceMapText,
+      resolve(adapter.projectRoot)
+    );
+    const virtualBaseName = exportName === "default" ? basename(absolutePath).replace(/\.[^.]+$/, "") : `${basename(absolutePath).replace(/\.[^.]+$/, "")}.${exportName}`;
+    const virtualFilename = `/virtual/deepline-plays/${analysis.graphHash}/${virtualBaseName}.${outputExtension}`;
+    const executableCode = `${bundledCode}
+//# sourceMappingURL=${basename(virtualFilename)}.map
+`;
+    const bundleSizeError = getBundleSizeError(
+      absolutePath,
+      executableCode,
+      target
+    );
+    if (bundleSizeError) {
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors: [bundleSizeError]
+      };
+    }
+    const artifact = {
+      codeFormat: targetAdapter.codeFormat,
+      artifactKind: target,
+      entryFile: absolutePath,
+      virtualFilename,
+      sourceHash: analysis.sourceHash,
+      graphHash: analysis.graphHash,
+      artifactHash: sha256(executableCode),
+      sourceMapHash: sha256(normalizedSourceMap),
+      bundledCode: executableCode,
+      sourceMap: normalizedSourceMap,
+      importPolicy: analysis.importPolicy,
+      compatibility: buildPlayContractCompatibility(),
+      generatedAt: Date.now(),
+      cacheHit: false
+    };
+    if (canUseArtifactCache) {
+      await writeArtifactCache(artifact, adapter);
+    }
+    return {
+      success: true,
+      artifact,
+      sourceCode: analysis.sourceCode,
+      sourceFiles: analysis.sourceFiles,
+      filePath: absolutePath,
+      playName: analysis.playName,
+      packagedFiles: discoveredFiles.files,
+      unresolvedFileReferences: discoveredFiles.unresolved,
+      importedPlayDependencies: analysis.importedPlayDependencies
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && "errors" in error) {
+      const errors = Array.isArray(error.errors) ? error.errors.map(formatEsbuildMessage) : ["Play bundling failed."];
+      return {
+        success: false,
+        filePath: absolutePath,
+        errors
+      };
+    }
+    return {
+      success: false,
+      filePath: absolutePath,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+
+// ../shared_libs/play-runtime/dedup-backend.ts
+var PLAY_DEDUP_BACKENDS = {
+  inMemory: "in_memory",
+  neonTable: "neon_table",
+  durableObject: "durable_object"
+};
+
+// ../shared_libs/play-runtime/scheduler-backend.ts
+var PLAY_SCHEDULER_BACKENDS = {
+  temporal: "temporal",
+  cfWorkflows: "cf-workflows",
+  /**
+   * Private legacy id retained only so old persisted rows can be interpreted.
+   * It is not a selectable scheduler backend after the Hatchet hard cutover.
+   */
+  postgres: "postgres",
+  hatchet: "hatchet",
+  inProcess: "in-process"
+};
+
+// ../shared_libs/play-runtime/providers.ts
+var PLAY_RUNTIME_PROVIDER_IDS = {
+  workersEdge: "workers_edge",
+  hatchet: "hatchet",
+  local: "local"
+};
+var PLAY_RUNTIME_PROVIDERS = {
+  workers_edge: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.workersEdge,
+    scheduler: PLAY_SCHEDULER_BACKENDS.cfWorkflows,
+    runner: PLAY_RUNTIME_BACKENDS.cloudflareWorkers,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.esmWorkers,
+    label: "Cloudflare Dynamic Workflows + Dynamic Workers + DO dedup"
+  },
+  hatchet: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.hatchet,
+    scheduler: PLAY_SCHEDULER_BACKENDS.hatchet,
+    runner: PLAY_RUNTIME_BACKENDS.daytona,
+    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Hatchet scheduler + one-shot Daytona runner + DO dedup"
+  },
+  local: {
+    id: PLAY_RUNTIME_PROVIDER_IDS.local,
+    scheduler: PLAY_SCHEDULER_BACKENDS.temporal,
+    runner: PLAY_RUNTIME_BACKENDS.localProcess,
+    dedup: PLAY_DEDUP_BACKENDS.inMemory,
+    artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
+    label: "Local Temporal scheduler + local subprocess runner (tests)"
+  }
+};
+function defaultPlayRuntimeProvider() {
+  return PLAY_RUNTIME_PROVIDERS.workers_edge;
+}
+function resolvePlayRuntimeProvider(override) {
+  if (override?.trim()) {
+    const id = override.trim();
+    if (id in PLAY_RUNTIME_PROVIDERS) {
+      return PLAY_RUNTIME_PROVIDERS[id];
+    }
+    throw new Error(
+      `Unknown play runtime provider "${id}". Expected one of: ${Object.keys(
+        PLAY_RUNTIME_PROVIDERS
+      ).join(", ")}.`
+    );
+  }
+  return defaultPlayRuntimeProvider();
+}
+
+// ../shared_libs/play-runtime/profiles.ts
+var PLAY_EXECUTION_PROFILE_IDS = {
+  ...PLAY_RUNTIME_PROVIDER_IDS
+};
+var PLAY_EXECUTION_PROFILES = PLAY_RUNTIME_PROVIDERS;
+function resolveExecutionProfile(override) {
+  try {
+    return resolvePlayRuntimeProvider(override);
+  } catch (error) {
+    if (override?.trim()) {
+      throw new Error(
+        `Unknown execution profile "${override.trim()}". Expected one of: ${Object.keys(
+          PLAY_EXECUTION_PROFILES
+        ).join(", ")}.`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/plays/local-file-discovery.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import {
+  basename as basename2,
+  dirname as dirname2,
+  extname as extname2,
+  isAbsolute as isAbsolute2,
+  join as join2,
+  relative as relative2,
+  resolve as resolve2
+} from "path";
+var SOURCE_EXTENSIONS2 = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+function sha2562(buffer) {
+  return createHash2("sha256").update(buffer).digest("hex");
+}
+function contentTypeForFile(filePath) {
+  const extension = extname2(filePath).toLowerCase();
+  if (extension === ".csv") return "text/csv";
+  if (extension === ".json") return "application/json";
+  if (extension === ".txt") return "text/plain";
+  return "application/octet-stream";
+}
+function stripCommentsToSpaces2(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, " ")).replace(
+    /(^|[^:])\/\/.*$/gm,
+    (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
+  );
+}
+function unquoteStringLiteral2(literal) {
+  const trimmed = literal.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
+    );
+  } catch {
+    return trimmed.slice(1, -1);
+  }
+}
+function splitTopLevelPlus(expression) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < expression.length; index += 1) {
+    const char = expression[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
+    if (char === "+" && depth === 0) {
+      parts.push(expression.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (parts.length === 0) return null;
+  parts.push(expression.slice(start));
+  return parts;
+}
+function stripOuterParens(expression) {
+  let value = expression.trim();
+  while (value.startsWith("(") && value.endsWith(")")) {
+    value = value.slice(1, -1).trim();
+  }
+  return value;
+}
+function isRuntimeInputExpression(expression) {
+  return /(^|[^\w$])input([^\w$]|$)/.test(expression);
+}
+function resolveStringExpression(expression, constants) {
+  const value = stripOuterParens(expression);
+  if (/^(['"])(?:\\.|(?!\1)[\s\S])*\1$/.test(value)) {
+    return unquoteStringLiteral2(value);
+  }
+  if (/^`(?:\\.|[^`$]|\$(?!\{))*`$/.test(value)) {
+    return value.slice(1, -1);
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(value)) {
+    return constants.get(value) ?? null;
+  }
+  const parts = splitTopLevelPlus(value);
+  if (parts) {
+    const resolved = parts.map(
+      (part) => resolveStringExpression(part, constants)
+    );
+    return resolved.every((part) => part != null) ? resolved.join("") : null;
+  }
+  return null;
+}
+function collectTopLevelStringConstants(sourceCode) {
+  const constants = /* @__PURE__ */ new Map();
+  const source = stripCommentsToSpaces2(sourceCode);
+  for (const match of source.matchAll(
+    /(?:^|\n)\s*const\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/g
+  )) {
+    const resolved = resolveStringExpression(match[2], constants);
+    if (resolved != null) {
+      constants.set(match[1], resolved);
+    }
+  }
+  return constants;
+}
+function findMatchingGenericEnd(source, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "<") depth += 1;
+    if (char === ">") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function findCallOpenParen(source, afterCsvIndex) {
+  let index = afterCsvIndex;
+  while (/\s/.test(source[index] ?? "")) index += 1;
+  if (source[index] === "<") {
+    const genericEnd = findMatchingGenericEnd(source, index);
+    if (genericEnd < 0) return -1;
+    index = genericEnd + 1;
+    while (/\s/.test(source[index] ?? "")) index += 1;
+  }
+  return source[index] === "(" ? index : -1;
+}
+function firstCallArgument(source, openParen) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  const start = openParen + 1;
+  for (let index = start; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") depth += 1;
+    if (char === ")" && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
+    }
+    if (char === "," && depth === 0) {
+      const text = source.slice(start, index).trim();
+      return text ? { text, start, end: index } : null;
+    }
+    if (char === ")" || char === "]" || char === "}") depth -= 1;
+  }
+  return null;
+}
+function localImportSpecifiers(sourceCode) {
+  const source = stripCommentsToSpaces2(sourceCode);
+  const specifiers = [];
+  for (const match of source.matchAll(
+    /\b(?:import|export)\s+(?!type\b)(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]/g
+  )) {
+    if (match[1]?.startsWith(".")) specifiers.push(match[1]);
+  }
+  for (const match of source.matchAll(
+    /\brequire\s*\(\s*(['"])(\.[^'"]*)\1\s*\)/g
+  )) {
+    specifiers.push(match[2]);
+  }
+  return specifiers;
+}
+async function fileExists2(filePath) {
+  try {
+    await stat2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPathInsideDirectory2(filePath, directory) {
+  const relativePath = relative2(directory, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute2(relativePath);
+}
+async function resolveLocalImport2(fromFile, specifier) {
+  const base = isAbsolute2(specifier) ? resolve2(specifier) : resolve2(dirname2(fromFile), specifier);
+  const candidates = [base];
+  const explicitExtension = extname2(base).toLowerCase();
+  if (!explicitExtension) {
+    candidates.push(
+      ...SOURCE_EXTENSIONS2.map((extension) => `${base}${extension}`)
+    );
+    candidates.push(
+      ...SOURCE_EXTENSIONS2.map((extension) => join2(base, `index${extension}`))
+    );
+  } else if ([".js", ".jsx", ".mjs", ".cjs"].includes(explicitExtension)) {
+    const stem = base.slice(0, -explicitExtension.length);
+    candidates.push(
+      ...SOURCE_EXTENSIONS2.map((extension) => `${stem}${extension}`)
+    );
+  }
+  for (const candidate of candidates) {
+    if (await fileExists2(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Could not resolve local import "${specifier}" from ${fromFile}`
+  );
+}
+async function discoverPackagedLocalFiles(entryFile) {
+  const absoluteEntryFile = resolve2(entryFile);
+  const packagingRoot = dirname2(absoluteEntryFile);
+  const files = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  const visitedFiles = /* @__PURE__ */ new Set();
+  const visitSourceFile = async (filePath) => {
+    const absolutePath = resolve2(filePath);
+    if (visitedFiles.has(absolutePath)) {
+      return;
+    }
+    visitedFiles.add(absolutePath);
+    const sourceCode = await readFile2(absolutePath, "utf-8");
+    const scanSource = stripCommentsToSpaces2(sourceCode);
+    const constants = collectTopLevelStringConstants(sourceCode);
+    const childVisits = [];
+    for (const match of scanSource.matchAll(
+      /\b([A-Za-z_$][\w$]*)\s*\.\s*csv\b/g
+    )) {
+      const target = match[1];
+      if (target !== "ctx" && !target.endsWith("Ctx")) {
+        continue;
+      }
+      const openParen = findCallOpenParen(
+        scanSource,
+        match.index + match[0].length
+      );
+      if (openParen < 0) {
+        continue;
+      }
+      const argument = firstCallArgument(scanSource, openParen);
+      if (!argument) {
+        unresolved.push({
+          sourceFragment: "ctx.csv()",
+          message: "ctx.csv() requires a file path string or input reference."
+        });
+      } else if (!isRuntimeInputExpression(argument.text)) {
+        const resolvedPath = resolveStringExpression(argument.text, constants);
+        if (resolvedPath == null) {
+          unresolved.push({
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            message: "Could not resolve this ctx.csv(...) path at submit time. Use a string literal, a top-level const string, or pass a runtime input like input.file."
+          });
+        } else {
+          const absoluteCsvPath = resolve2(dirname2(absolutePath), resolvedPath);
+          if (isAbsolute2(resolvedPath) || !isPathInsideDirectory2(absoluteCsvPath, packagingRoot)) {
+            unresolved.push({
+              sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+              message: "ctx.csv(...) packaged file paths must be relative paths inside the play directory. Pass external files at runtime with input.file instead."
+            });
+            continue;
+          }
+          const buffer = await readFile2(absoluteCsvPath);
+          const stats = await stat2(absoluteCsvPath);
+          files.set(absoluteCsvPath, {
+            sourceFragment: sourceCode.slice(argument.start, argument.end).trim(),
+            logicalPath: resolvedPath,
+            absolutePath: absoluteCsvPath,
+            bytes: stats.size,
+            contentHash: sha2562(buffer),
+            contentType: contentTypeForFile(absoluteCsvPath)
+          });
+        }
+      }
+    }
+    for (const specifier of localImportSpecifiers(sourceCode)) {
+      childVisits.push(
+        resolveLocalImport2(absolutePath, specifier).then(
+          (resolvedImport) => visitSourceFile(resolvedImport)
+        )
+      );
+    }
+    await Promise.all(childVisits);
+  };
+  await visitSourceFile(absoluteEntryFile);
+  return {
+    files: [...files.values()],
+    unresolved
+  };
+}
+
+// src/plays/bundle-play-file.ts
+var PLAY_BUNDLE_CACHE_VERSION2 = 30;
+var MODULE_DIR = dirname3(fileURLToPath(import.meta.url));
+var SDK_PACKAGE_ROOT = resolve3(MODULE_DIR, "..", "..");
+var SOURCE_REPO_ROOT = resolve3(SDK_PACKAGE_ROOT, "..");
+var HAS_SOURCE_BUNDLING_SOURCES = existsSync2(
+  resolve3(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
+);
+var PACKAGED_BUNDLING_SOURCE_ROOT = resolve3(
+  SDK_PACKAGE_ROOT,
+  "dist",
+  "bundling-sources"
+);
+var HAS_PACKAGED_BUNDLING_SOURCES = existsSync2(
+  resolve3(
+    PACKAGED_BUNDLING_SOURCE_ROOT,
+    "apps",
+    "play-runner-workers",
+    "src",
+    "entry.ts"
+  )
+);
+var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_BUNDLING_SOURCE_ROOT : resolve3(SDK_PACKAGE_ROOT, "..");
+var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? resolve3(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? resolve3(PACKAGED_BUNDLING_SOURCE_ROOT, "sdk", "src") : resolve3(SDK_PACKAGE_ROOT, "src");
+var SDK_PACKAGE_JSON = resolve3(SDK_PACKAGE_ROOT, "package.json");
+var SDK_ENTRY_FILE = resolve3(SDK_SOURCE_ROOT, "index.ts");
+var SDK_TYPES_ENTRY_FILE = HAS_SOURCE_BUNDLING_SOURCES ? SDK_ENTRY_FILE : resolve3(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
+var SDK_WORKERS_ENTRY_FILE = resolve3(SDK_SOURCE_ROOT, "worker-play-entry.ts");
+var WORKERS_HARNESS_ENTRY_FILE = resolve3(
+  PROJECT_ROOT,
+  "apps",
+  "play-runner-workers",
+  "src",
+  "entry.ts"
+);
+var WORKERS_HARNESS_FILES_DIR = resolve3(
+  PROJECT_ROOT,
+  "apps",
+  "play-runner-workers",
+  "src"
+);
+var hasWarnedAboutNonDevelopmentBundling = false;
+function warnAboutNonDevelopmentBundling(filePath) {
+  if (hasWarnedAboutNonDevelopmentBundling) {
+    return;
+  }
+  const nodeEnv = String(process.env.NODE_ENV ?? "").trim().toLowerCase();
+  if (!nodeEnv || nodeEnv === "development" || nodeEnv === "test") {
+    return;
+  }
+  hasWarnedAboutNonDevelopmentBundling = true;
+  console.warn(
+    `[deepline] Warning: live play bundling was invoked while NODE_ENV=${nodeEnv} for ${filePath}. This source-first SDK path is intended for local development. For preview/production, run a published or prebuilt play reference instead of bundling source at runtime.`
+  );
+  console.warn(
+    '[deepline] Preferred production call pattern: client.play("person-to-email").run(...) or run a previously registered/published org play.'
+  );
+}
+function defaultPlayBundleTarget() {
+  return resolveExecutionProfile(null).artifactKind;
+}
+function createSdkPlayBundlingAdapter() {
+  return {
+    projectRoot: PROJECT_ROOT,
+    nodeModulesDir: HAS_PACKAGED_BUNDLING_SOURCES ? resolve3(SDK_PACKAGE_ROOT, "node_modules") : resolve3(PROJECT_ROOT, "node_modules"),
+    cacheDir: join3(
+      tmpdir2(),
+      `deepline-play-artifacts-v${PLAY_BUNDLE_CACHE_VERSION2}`
+    ),
+    sdkSourceRoot: SDK_SOURCE_ROOT,
+    sdkPackageJson: SDK_PACKAGE_JSON,
+    sdkEntryFile: SDK_ENTRY_FILE,
+    sdkTypesEntryFile: HAS_SOURCE_BUNDLING_SOURCES || !existsSync2(SDK_TYPES_ENTRY_FILE) ? SDK_ENTRY_FILE : SDK_TYPES_ENTRY_FILE,
+    sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
+    workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
+    workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
+    workersRuntimeFingerprintDirs: [
+      resolve3(PROJECT_ROOT, "shared_libs", "play-runtime")
+    ],
+    discoverPackagedLocalFiles,
+    warnAboutNonDevelopmentBundling
+  };
+}
+async function bundlePlayFile2(filePath, options = {}) {
+  const result = await bundlePlayFile(filePath, {
+    target: options.target ?? defaultPlayBundleTarget(),
+    exportName: options.exportName,
+    adapter: createSdkPlayBundlingAdapter()
+  });
+  if (result.success)
+    validatePlaySourceFilesHaveNoInlineSecrets(result.sourceFiles);
+  return result;
+}
+export {
+  PLAY_ARTIFACT_KINDS,
+  bundlePlayFile2 as bundlePlayFile,
+  createSdkPlayBundlingAdapter,
+  extractDefinedPlayName
+};